fix: replace registry.npmmirror.com with registry.npmjs.org in package-lock.json

Co-authored-by: catlog22 <28037070+catlog22@users.noreply.github.com>

.ccw/personal/coding-style.md

@@ -1,27 +0,0 @@
----
-title: "Personal Coding Style"
-dimension: personal
-category: general
-keywords:
-  - style
-  - preference
-readMode: optional
-priority: medium
----
-
-# Personal Coding Style
-
-## Preferences
-
-- Describe your preferred coding style here
-- Example: verbose variable names vs terse, functional vs imperative
-
-## Patterns I Prefer
-
-- List patterns you reach for most often
-- Example: builder pattern, factory functions, tagged unions
-
-## Things I Avoid
-
-- List anti-patterns or approaches you dislike
-- Example: deep inheritance hierarchies, magic strings

.ccw/personal/tool-preferences.md

@@ -1,25 +0,0 @@
----
-title: "Tool Preferences"
-dimension: personal
-category: general
-keywords:
-  - tool
-  - cli
-  - editor
-readMode: optional
-priority: low
----
-
-# Tool Preferences
-
-## Editor
-
-- Preferred editor and key extensions/plugins
-
-## CLI Tools
-
-- Preferred shell, package manager, build tools
-
-## Debugging
-
-- Preferred debugging approach and tools

.ccw/specs/architecture-constraints.md

@@ -1,21 +0,0 @@
----
-title: Architecture Constraints
-readMode: optional
-priority: medium
-category: general
-scope: project
-dimension: specs
-keywords: [architecture, constraint, schema, compatibility, portability, design, arch]
----
-
-# Architecture Constraints
-
-## Schema Evolution
-
-- [compatibility] When enhancing existing schemas, use optional fields and additionalProperties rather than creating new schemas. Avoid breaking changes.
-- [portability] Use relative paths for cross-artifact navigation to ensure portability across different environments and installations.
-
-## Skill Design
-
-- [decision:skills] All skills must follow Completion Status Protocol (DONE/DONE_WITH_CONCERNS/BLOCKED/NEEDS_CONTEXT) defined in SKILL-DESIGN-SPEC.md sections 13-14. New skills created via skill-generator auto-include the protocol reference. (2026-03-29)
-- [decision:hooks] Hook safety guardrails use TypeScript HookTemplate pattern (not standalone bash scripts) for integration with CCW hook endpoint system. Templates: careful-destructive-guard, freeze-edit-boundary. (2026-03-29)

.ccw/specs/coding-conventions.md

@@ -1,28 +0,0 @@
----
-title: Coding Conventions
-readMode: optional
-priority: medium
-category: general
-scope: project
-dimension: specs
-keywords: [coding, convention, style, naming, pattern, navigation, schema, error-handling, implementation, validation, clarity, doc]
----
-
-# Coding Conventions
-
-## Navigation & Path Handling
-
-- [navigation] When creating navigation links between artifacts, always compute relative paths from the artifact's actual location, not from an assumed location. Test path resolution before committing. (learned: 2026-03-07)
-- [schema] Always include schema_version field in index/registry files to enable safe evolution and migration detection. (learned: 2026-03-07)
-- [error-handling] When adding version checks or validation, always continue with degraded functionality rather than failing hard. Log warnings but don't block execution. (learned: 2026-03-07)
-
-## Document Generation
-
-- [architecture] For document generation systems, adopt Layer 3→2→1 pattern (components → features → indexes) for efficient incremental updates. (learned: 2026-03-07)
-- [tools] When commands need to generate files with deterministic paths and frontmatter, use dedicated ccw tool endpoints (`ccw tool exec`) instead of raw `ccw cli -p` calls. Endpoints control output path, file naming, and structural metadata; CLI tools only generate prose content. (learned: 2026-03-09)
-
-## Implementation Quality
-
-- [validation] Path calculation errors are subtle and hard to spot in static review. Always verify path resolution from the actual file location, not from documentation. (learned: 2026-03-07)
-- [implementation] Declaring "add X to Y" in documentation is not enough - the actual logic must be implemented in the target files. (learned: 2026-03-07)
-- [clarity] Explicit instructions are better than implicit ones. Vague instructions like "Update _index.md files" should be made explicit (e.g., "Update sessions/_index.md"). (learned: 2026-03-07)

.ccw/workflows/cli-templates/planning-roles/synthesis-role.md

@@ -301,7 +301,7 @@ Document known constraints that affect planning:
 
 [Continue for all major feature groups]
 
-**Note**: Detailed task breakdown into executable work items is handled by `/workflow-plan` → `IMPL_PLAN.md`
+**Note**: Detailed task breakdown into executable work items is handled by `/workflow:plan` → `IMPL_PLAN.md`
 
 ---
 

.ccw/workflows/cli-templates/prompts/workflow-impl-plan-template.txt

@@ -43,7 +43,7 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
 
 **Quality Gates**:
 - concept-verify: ✅ Passed (0 ambiguities remaining) | ⏭️ Skipped (user decision) | ⏳ Pending
-- plan-verify: ⏳ Pending (recommended before /workflow-execute)
+- plan-verify: ⏳ Pending (recommended before /workflow:execute)
 
 **Context Package Summary**:
 - **Focus Paths**: {list key directories from context-package.json}

.ccw/workflows/cli-templates/protocols/analysis-protocol.md

@@ -30,7 +30,6 @@ RULES: [templates | additional constraints]
 
 ## Execution Flow
 
-0. **Load Project Specs** - MANDATORY first step: run `ccw spec load` to retrieve project specifications and constraints before any analysis. Adapt analysis scope and standards based on loaded specs
 1. **Parse** all 6 fields (PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES)
 2. **Read** and analyze CONTEXT files thoroughly
 3. **Identify** patterns, issues, and dependencies
@@ -41,7 +40,6 @@ RULES: [templates | additional constraints]
 ## Core Requirements
 
 **ALWAYS**:
-- Run `ccw spec load` FIRST to obtain project specifications before starting any work
 - Analyze ALL CONTEXT files completely
 - Apply RULES (templates + constraints) exactly
 - Provide code evidence with `file:line` references

.ccw/workflows/cli-templates/protocols/write-protocol.md

@@ -24,7 +24,6 @@ RULES: [templates | additional constraints]
 ## Execution Flow
 
 ### MODE: write
-0. **Load Project Specs** - MANDATORY first step: run `ccw spec load` to retrieve project specifications and constraints before any implementation. Apply loaded specs to guide coding standards, architecture decisions, and quality gates
 1. **Parse** all 6 fields (PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES)
 2. **Read** CONTEXT files, find 3+ similar patterns
 3. **Plan** implementation following RULES
@@ -35,7 +34,6 @@ RULES: [templates | additional constraints]
 ## Core Requirements
 
 **ALWAYS**:
-- Run `ccw spec load` FIRST to obtain project specifications before starting any work
 - Study CONTEXT files - find 3+ similar patterns before implementing
 - Apply RULES exactly
 - Test continuously (auto mode)

.ccw/workflows/cli-templates/schemas/explore-json-schema.json

@@ -63,35 +63,6 @@
             "type": "array",
             "items": {"type": "string"},
             "description": "Key symbols (functions, classes, types) in this file relevant to the task. Example: ['AuthService', 'login', 'TokenPayload']"
-          },
-          "key_code": {
-            "type": "array",
-            "items": {
-              "type": "object",
-              "required": ["symbol", "description"],
-              "properties": {
-                "symbol": {
-                  "type": "string",
-                  "description": "Symbol identifier (function, class, method, type). Example: 'AuthService.login()'"
-                },
-                "location": {
-                  "type": "string",
-                  "description": "Line range in file. Example: 'L45-L78'"
-                },
-                "description": {
-                  "type": "string",
-                  "minLength": 10,
-                  "description": "What this code does and why it matters. Example: 'JWT token generation with bcrypt verification, returns {token, refreshToken} pair'"
-                }
-              },
-              "additionalProperties": false
-            },
-            "description": "Key code constructs with descriptions. Richer complement to key_symbols. Populate for files with relevance >= 0.7."
-          },
-          "topic_relation": {
-            "type": "string",
-            "minLength": 15,
-            "description": "How this file relates to the exploration ANGLE/TOPIC. Must reference the angle explicitly. Example: 'Security exploration targets this file because JWT generation lacks token rotation'. Distinct from rationale (WHY selected) - topic_relation explains the CONNECTION to the exploration perspective."
           }
         },
         "additionalProperties": false

.ccw/workflows/cli-templates/schemas/project-guidelines-schema.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Project Guidelines Schema",
-  "description": "Legacy schema - project guidelines now managed by spec system (`ccw spec load --dimension specs`)",
+  "description": "Schema for project-guidelines.json - user-maintained rules and constraints",
   "type": "object",
   "required": ["conventions", "constraints", "_metadata"],
   "properties": {

.ccw/workflows/cli-templates/schemas/project-tech-schema.json

@@ -155,7 +155,7 @@
     },
     "development_index": {
       "type": "object",
-      "description": "Categorized development history (lite-planex sessions)",
+      "description": "Categorized development history (lite-plan/lite-execute)",
       "properties": {
         "feature": { "type": "array", "items": { "$ref": "#/$defs/devIndexEntry" } },
         "enhancement": { "type": "array", "items": { "$ref": "#/$defs/devIndexEntry" } },

.ccw/workflows/cli-templates/schemas/team-tasks-schema.json

@@ -1,255 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "team-tasks-schema",
-  "title": "Team Tasks State",
-  "description": "Universal tasks.json schema for all Codex team skills. Single source of truth for task state management, replacing Claude Code TaskCreate/TaskUpdate API.",
-
-  "type": "object",
-  "required": ["session_id", "skill", "pipeline", "requirement", "created_at", "tasks"],
-  "properties": {
-    "session_id": {
-      "type": "string",
-      "description": "Unique session identifier. Format: <skill-prefix>-<slug>-<YYYYMMDD>",
-      "pattern": "^[a-zA-Z0-9]+-[a-z0-9-]+-\\d{8}$",
-      "examples": ["tlv4-auth-system-20260324", "brs-product-strategy-20260324", "ao-api-perf-20260324"]
-    },
-    "skill": {
-      "type": "string",
-      "description": "Source team skill name (e.g., team-lifecycle-v4, team-brainstorm, team-arch-opt)"
-    },
-    "pipeline": {
-      "type": "string",
-      "description": "Selected pipeline name from the skill's specs/pipelines.md or specs/team-config.json"
-    },
-    "requirement": {
-      "type": "string",
-      "description": "Original user requirement text, verbatim"
-    },
-    "created_at": {
-      "type": "string",
-      "format": "date-time",
-      "description": "ISO 8601 creation timestamp with timezone"
-    },
-    "supervision": {
-      "type": "boolean",
-      "default": true,
-      "description": "Whether CHECKPOINT tasks are active"
-    },
-    "completed_waves": {
-      "type": "array",
-      "items": { "type": "integer", "minimum": 1 },
-      "default": [],
-      "description": "List of completed wave numbers"
-    },
-    "active_agents": {
-      "type": "object",
-      "additionalProperties": { "type": "string" },
-      "default": {},
-      "description": "Runtime tracking: { task_id: agent_id } for currently running agents"
-    },
-    "gc_rounds": {
-      "type": "integer",
-      "minimum": 0,
-      "default": 0,
-      "description": "Generator-Critic / Fix-Verify loop iteration count (skills with GC loops)"
-    },
-    "tasks": {
-      "type": "object",
-      "additionalProperties": { "$ref": "#/$defs/TaskEntry" },
-      "description": "Task registry: { TASK-ID: TaskEntry }"
-    }
-  },
-
-  "$defs": {
-    "TaskEntry": {
-      "type": "object",
-      "required": ["title", "description", "role", "deps", "wave", "status"],
-      "properties": {
-        "title": {
-          "type": "string",
-          "description": "Human-readable task name"
-        },
-        "description": {
-          "type": "string",
-          "description": "What the task should accomplish"
-        },
-        "role": {
-          "type": "string",
-          "description": "Role name matching roles/<role>/role.md in the skill directory"
-        },
-        "pipeline_phase": {
-          "type": "string",
-          "description": "Phase from the skill's pipelines.md Task Metadata Registry (skill-specific)"
-        },
-        "deps": {
-          "type": "array",
-          "items": { "type": "string" },
-          "default": [],
-          "description": "Task IDs that must complete before this task starts. All must be 'completed'"
-        },
-        "context_from": {
-          "type": "array",
-          "items": { "type": "string" },
-          "default": [],
-          "description": "Task IDs whose discoveries to load as upstream context"
-        },
-        "wave": {
-          "type": "integer",
-          "minimum": 1,
-          "description": "Execution wave number (1-based). Tasks in the same wave run in parallel"
-        },
-        "status": {
-          "type": "string",
-          "enum": ["pending", "in_progress", "completed", "failed", "skipped"],
-          "default": "pending",
-          "description": "Current task state"
-        },
-        "findings": {
-          "type": ["string", "null"],
-          "maxLength": 500,
-          "default": null,
-          "description": "Summary of task output (max 500 chars). Required when status=completed"
-        },
-        "quality_score": {
-          "type": ["number", "null"],
-          "minimum": 0,
-          "maximum": 100,
-          "default": null,
-          "description": "0-100, set by reviewer/evaluator roles only"
-        },
-        "supervision_verdict": {
-          "type": ["string", "null"],
-          "enum": ["pass", "warn", "block", null],
-          "default": null,
-          "description": "Set by CHECKPOINT/supervisor tasks only"
-        },
-        "error": {
-          "type": ["string", "null"],
-          "default": null,
-          "description": "Error description. Required when status=failed or status=skipped"
-        }
-      }
-    },
-
-    "DiscoveryEntry": {
-      "type": "object",
-      "required": ["task_id", "timestamp", "status", "findings", "data"],
-      "description": "Schema for discoveries/{task_id}.json — each task writes one on completion",
-      "properties": {
-        "task_id": {
-          "type": "string",
-          "description": "Matches the task key in tasks.json"
-        },
-        "worker": {
-          "type": "string",
-          "description": "Same as task_id (identifies the producing agent)"
-        },
-        "timestamp": {
-          "type": "string",
-          "format": "date-time",
-          "description": "ISO 8601 completion timestamp"
-        },
-        "type": {
-          "type": "string",
-          "description": "Same as pipeline_phase"
-        },
-        "status": {
-          "type": "string",
-          "enum": ["completed", "failed"]
-        },
-        "findings": {
-          "type": "string",
-          "maxLength": 500
-        },
-        "quality_score": {
-          "type": ["number", "null"]
-        },
-        "supervision_verdict": {
-          "type": ["string", "null"],
-          "enum": ["pass", "warn", "block", null]
-        },
-        "error": {
-          "type": ["string", "null"]
-        },
-        "data": {
-          "type": "object",
-          "properties": {
-            "key_findings": {
-              "type": "array",
-              "items": { "type": "string", "maxLength": 100 },
-              "maxItems": 5
-            },
-            "decisions": {
-              "type": "array",
-              "items": { "type": "string" },
-              "description": "Include rationale, not just choice"
-            },
-            "files_modified": {
-              "type": "array",
-              "items": { "type": "string" },
-              "description": "Only for implementation tasks"
-            },
-            "verification": {
-              "type": "string",
-              "enum": ["self-validated", "peer-reviewed", "tested"]
-            },
-            "risks_logged": {
-              "type": "integer",
-              "description": "CHECKPOINT only: count of risks"
-            },
-            "blocks_detected": {
-              "type": "integer",
-              "description": "CHECKPOINT only: count of blocking issues"
-            }
-          }
-        },
-        "artifacts_produced": {
-          "type": "array",
-          "items": { "type": "string" },
-          "description": "Paths to generated artifact files"
-        }
-      }
-    }
-  },
-
-  "$comment_validation_rules": {
-    "structural": [
-      "Unique IDs: every key in tasks must be unique",
-      "Valid deps: every entry in deps must reference an existing task ID",
-      "Valid context_from: every entry in context_from must reference an existing task ID",
-      "No cycles: dependency graph must be a DAG",
-      "Wave ordering: if task A depends on task B, then A.wave > B.wave",
-      "Role exists: role must match a directory in the skill's roles/"
-    ],
-    "runtime": [
-      "Status transitions: pending->in_progress, in_progress->completed|failed, pending->skipped",
-      "Dependency check: task can only move to in_progress if all deps are completed",
-      "Skip propagation: if any dep is failed|skipped, task is automatically skipped",
-      "Discovery required: completed task MUST have discoveries/{task_id}.json",
-      "Findings required: completed task MUST have non-null findings",
-      "Error required: failed|skipped task MUST have non-null error",
-      "Supervision fields: CHECKPOINT tasks MUST set supervision_verdict on completion"
-    ]
-  },
-
-  "$comment_claude_code_mapping": {
-    "TaskCreate": {
-      "title": "tasks[id].title",
-      "description": "tasks[id].description",
-      "assignee": "tasks[id].role",
-      "status_open": "tasks[id].status = pending",
-      "metadata.deps": "tasks[id].deps",
-      "metadata.wave": "tasks[id].wave"
-    },
-    "TaskUpdate": {
-      "status_in_progress": "Write tasks[id].status = in_progress",
-      "status_completed": "Write tasks[id].status = completed + Write discoveries/{id}.json",
-      "status_failed": "Write tasks[id].status = failed + tasks[id].error"
-    },
-    "team_msg": {
-      "get_state": "Read tasks.json + Read discoveries/{upstream_id}.json",
-      "state_update": "Write discoveries/{task_id}.json",
-      "broadcast": "Write to wisdom/*.md"
-    }
-  }
-}

.ccw/workflows/cli-tools-usage.md

@@ -1,203 +1,538 @@
 # CLI Tools Execution Specification
 
-Unified reference for `ccw cli` — runs agent tools (gemini, qwen, codex, claude, opencode) with a shared interface for prompt, mode, model, directory, templates, and session resume.
-
-**References**: `~/.claude/cli-tools.json` (tool config), `~/.ccw/templates/cli/` (protocol + prompt templates)
+## Table of Contents
+1. [Configuration Reference](#configuration-reference)
+2. [Tool Selection](#tool-selection)
+3. [Prompt Template](#prompt-template)
+4. [CLI Execution](#cli-execution)
+5. [Auto-Invoke Triggers](#auto-invoke-triggers)
+6. [Best Practices](#best-practices)
 
 ---
 
-## 1. Quick Reference
+## Configuration Reference
 
-### Command Syntax
+### Configuration File
 
-```bash
-ccw cli -p "<PROMPT>" [options]
-```
+**Path**: `~/.claude/cli-tools.json`
 
-### Options
+All tool availability, model selection, and routing are defined in this configuration file.
 
-| Option | Description | Default |
-|--------|-------------|---------|
-| `-p, --prompt` | **Required**. Prompt text | — |
-| `--tool <name>` | Tool: gemini, qwen, codex, claude, opencode | First enabled in config |
-| `--mode <mode>` | `analysis` (read-only), `write` (create/modify/delete), `review` (codex-only) | `analysis` |
-| `--model <model>` | Model override | Tool's `primaryModel` |
-| `--cd <dir>` | Working directory | Current directory |
-| `--includeDirs <dirs>` | Additional directories (comma-separated) | — |
-| `--rule <template>` | Load protocol + prompt template | — (optional) |
-| `--id <id>` | Execution ID | Auto: `{prefix}-{HHmmss}-{rand4}` |
-| `--resume [id]` | Resume session (last if no id, comma-separated for merge) | — |
-
-### Mode Definition (Authoritative)
-
-| Mode | Permission | Auto-Invoke Safe | Use For |
-|------|-----------|------------------|---------|
-| `analysis` | Read-only | Yes | Review, exploration, diagnosis, architecture analysis |
-| `write` | Create/Modify/Delete | No — requires explicit intent | Implementation, bug fixes, refactoring |
-| `review` | Read-only (git-aware) | Yes | **Codex only**. Uncommitted changes, branch diffs, specific commits |
-
-> `--mode` is the **authoritative** permission control for ccw cli. The `MODE:` field inside prompt text is a hint for the agent — both should be consistent, but `--mode` governs actual behavior.
-
-**Codex review mode**: Target flags (`--uncommitted`, `--base`, `--commit`) are codex-only and mutually exclusive with `-p`.
-
----
-
-## 2. Configuration
-
-### Config File: `~/.claude/cli-tools.json`
+### Configuration Fields
 
 | Field | Description |
 |-------|-------------|
-| `enabled` | Tool availability |
-| `primaryModel` | Default model |
+| `enabled` | Tool availability status |
+| `primaryModel` | Default model for the tool |
 | `secondaryModel` | Fallback model |
-| `tags` | Capability tags (for caller-side routing) |
+| `tags` | Capability tags for routing |
 
 ### Tool Types
 
 | Type | Usage | Capabilities |
 |------|-------|--------------|
-| `builtin` | `--tool gemini` | Full (analysis + write) |
-| `cli-wrapper` | `--tool doubao` | Full (analysis + write) |
-| `api-endpoint` | `--tool g25` | **Analysis only** (no file write) |
+| `builtin` | `--tool gemini` | Full (analysis + write tools) |
+| `cli-wrapper` | `--tool doubao` | Full (analysis + write tools) |
+| `api-endpoint` | `--tool g25` | **Analysis only** (no file write tools) |
 
-### Tool Selection
-
-1. Explicit `--tool` specified → use it (validate enabled)
-2. No `--tool` → first enabled tool in config order
-
-### Fallback Chain
-
-Primary model fails → `secondaryModel` → next enabled tool → first enabled (default).
+> **Note**: `api-endpoint` tools only support analysis and code generation responses. They cannot create, modify, or delete files.
 
 ---
 
-## 3. Prompt Construction
+## Tool Selection
 
-### Assembly Order
+### Tag-Based Routing
 
-`ccw cli` builds the final prompt as:
+Tools are selected based on **tags** defined in the configuration. Use tags to match task requirements to tool capabilities.
 
-1. **Mode protocol** — loaded based on `--mode` (analysis-protocol.md / write-protocol.md)
-2. **User prompt** — the `-p` value
-3. **Rule template** — loaded from `--rule` template name (if specified)
+#### Common Tags
 
-### Prompt Template (6 Fields)
+| Tag | Use Case |
+|-----|----------|
+| `analysis` | Code review, architecture analysis, exploration |
+| `implementation` | Feature development, bug fixes |
+| `documentation` | Doc generation, comments |
+| `testing` | Test creation, coverage analysis |
+| `refactoring` | Code restructuring |
+| `security` | Security audits, vulnerability scanning |
+
+### Selection Algorithm
 
 ```
-PURPOSE: [goal] + [why] + [success criteria]
-TASK: [step 1] | [step 2] | [step 3]
-MODE: analysis|write
-CONTEXT: @[file patterns] | Memory: [prior work context]
-EXPECTED: [output format] + [quality criteria]
-CONSTRAINTS: [scope limits] | [special requirements]
+1. Parse task intent → extract required capabilities
+2. Load cli-tools.json → get enabled tools with tags
+3. Match tags → filter tools supporting required capabilities
+4. Select tool → choose by priority (explicit > tag-match > default)
+5. Select model → use primaryModel, fallback to secondaryModel
 ```
 
-- **PURPOSE**: What + Why + Success. Not "Analyze code" but "Identify auth vulnerabilities; success = OWASP Top 10 covered"
-- **TASK**: Specific verbs. Not "Review code" but "Scan for SQL injection | Check XSS | Verify CSRF"
-- **MODE**: Must match `--mode` flag
-- **CONTEXT**: File scope + memory from prior work
-- **EXPECTED**: Deliverable format, not just "Report"
-- **CONSTRAINTS**: Task-specific limits (vs `--rule` which loads generic templates)
+### Selection Decision Tree
 
-### CONTEXT: File Patterns + Directory
+```
+┌─ Explicit --tool specified?
+│  └─→ YES: Use specified tool (validate enabled)
+│
+└─ NO: Tag-based selection
+   ├─ Task requires tags?
+   │  └─→ Match tools with matching tags
+   │     └─→ Multiple matches? Use first enabled
+   │
+   └─ No tag match?
+      └─→ Use default tool (first enabled in config)
+```
 
-- `@**/*` — all files in working directory (default)
-- `@src/**/*.ts` — scoped pattern
-- `@../shared/**/*` — sibling directory (**requires `--includeDirs`**)
-
-**Rule**: If CONTEXT uses `@../dir/**/*`, must add `--includeDirs ../dir`.
+### Command Structure
 
 ```bash
-# Cross-directory example
-ccw cli -p "<PROMPT>" --tool gemini --mode analysis \
-  --cd "src/auth" --includeDirs "../shared"
+# Explicit tool selection
+ccw cli -p "<PROMPT>" --tool <tool-id> --mode <analysis|write|review>
+
+# Model override
+ccw cli -p "<PROMPT>" --tool <tool-id> --model <model-id> --mode <analysis|write>
+
+# Code review (codex only)
+ccw cli -p "<PROMPT>" --tool codex --mode review
+
+# Tag-based auto-selection (future)
+ccw cli -p "<PROMPT>" --tags <tag1,tag2> --mode <analysis|write>
 ```
 
-### CONTEXT: Memory
+### Tool Fallback Chain
+
+When primary tool fails or is unavailable:
+1. Check `secondaryModel` for same tool
+2. Try next enabled tool with matching tags
+3. Fall back to default enabled tool
+
+---
+
+## Prompt Template
+
+### Universal Prompt Template
+
+```bash
+ccw cli -p "PURPOSE: [what] + [why] + [success criteria] + [constraints/scope]
+TASK: • [step 1: specific action] • [step 2: specific action] • [step 3: specific action]
+MODE: [analysis|write]
+CONTEXT: @[file patterns] | Memory: [session/tech/module context]
+EXPECTED: [deliverable format] + [quality criteria] + [structure requirements]
+CONSTRAINTS: [domain constraints]" --tool <tool-id> --mode <analysis|write> --rule <category-template>
+```
+
+### Intent Capture Checklist (Before CLI Execution)
+
+**⚠️ CRITICAL**: Before executing any CLI command, verify these intent dimensions:
+
+**Intent Validation Questions**:
+- [ ] Is the objective specific and measurable?
+- [ ] Are success criteria defined?
+- [ ] Is the scope clearly bounded?
+- [ ] Are constraints and limitations stated?
+- [ ] Is the expected output format clear?
+- [ ] Is the action level (read/write) explicit?
+
+### Template Structure
+
+Every command MUST include these fields:
+
+- **PURPOSE**
+  - Purpose: Goal + motivation + success
+  - Components: What + Why + Success Criteria + Constraints
+  - Bad Example: "Analyze code"
+  - Good Example: "Identify security vulnerabilities in auth module to pass compliance audit; success = all OWASP Top 10 addressed; scope = src/auth/** only"
+
+- **TASK**
+  - Purpose: Actionable steps
+  - Components: Specific verbs + targets
+  - Bad Example: "• Review code • Find issues"
+  - Good Example: "• Scan for SQL injection in query builders • Check XSS in template rendering • Verify CSRF token validation"
+
+- **MODE**
+  - Purpose: Permission level
+  - Components: analysis / write / auto
+  - Bad Example: (missing)
+  - Good Example: "analysis" or "write"
+
+- **CONTEXT**
+  - Purpose: File scope + history
+  - Components: File patterns + Memory
+  - Bad Example: "@**/*"
+  - Good Example: "@src/auth/**/*.ts @shared/utils/security.ts \| Memory: Previous auth refactoring (WFS-001)"
+
+- **EXPECTED**
+  - Purpose: Output specification
+  - Components: Format + Quality + Structure
+  - Bad Example: "Report"
+  - Good Example: "Markdown report with: severity levels (Critical/High/Medium/Low), file:line references, remediation code snippets, priority ranking"
+
+- **CONSTRAINTS**
+  - Purpose: Domain-specific constraints
+  - Components: Scope limits, special requirements, focus areas
+  - Bad Example: (missing or too vague)
+  - Good Example: "Focus on authentication | Ignore test files | No breaking changes"
+
+### CONTEXT Configuration
+
+**Format**: `CONTEXT: [file patterns] | Memory: [memory context]`
+
+#### File Patterns
+
+- **`@**/*`**: All files (default)
+- **`@src/**/*.ts`**: TypeScript in src
+- **`@../shared/**/*`**: Sibling directory (requires `--includeDirs`)
+- **`@CLAUDE.md`**: Specific file
+
+#### Memory Context
 
 Include when building on previous work:
 
-```
+```bash
+# Cross-task reference
 Memory: Building on auth refactoring (commit abc123), implementing refresh tokens
-Memory: Integration with auth module, using shared error patterns
+
+# Cross-module integration
+Memory: Integration with auth module, using shared error patterns from @shared/utils/errors.ts
 ```
 
-### --rule Templates
+**Memory Sources**:
+- **Related Tasks**: Previous refactoring, extensions, conflict resolution
+- **Tech Stack Patterns**: Framework conventions, security guidelines
+- **Cross-Module References**: Integration points, shared utilities, type dependencies
 
-**Universal**: `universal-rigorous-style`, `universal-creative-style`
+#### Pattern Discovery Workflow
 
-**Analysis**: `analysis-trace-code-execution`, `analysis-diagnose-bug-root-cause`, `analysis-analyze-code-patterns`, `analysis-analyze-technical-document`, `analysis-review-architecture`, `analysis-review-code-quality`, `analysis-analyze-performance`, `analysis-assess-security-risks`
-
-**Planning**: `planning-plan-architecture-design`, `planning-breakdown-task-steps`, `planning-design-component-spec`, `planning-plan-migration-strategy`
-
-**Development**: `development-implement-feature`, `development-refactor-codebase`, `development-generate-tests`, `development-implement-component-ui`, `development-debug-runtime-issues`
-
-### Complete Example
+For complex requirements, discover files BEFORE CLI execution:
 
 ```bash
-ccw cli -p "PURPOSE: Identify OWASP Top 10 vulnerabilities in auth module; success = all critical/high documented with remediation
-TASK: Scan for injection flaws | Check auth bypass vectors | Evaluate session management | Assess data exposure
-MODE: analysis
-CONTEXT: @src/auth/**/* @src/middleware/auth.ts | Memory: Using bcrypt + JWT
-EXPECTED: Severity matrix, file:line references, remediation snippets, priority ranking
-CONSTRAINTS: Focus on authentication | Ignore test files
-" --tool gemini --mode analysis --rule analysis-assess-security-risks --cd "src/auth"
+# Step 1: Discover files (choose one method)
+# Method A: ACE semantic search (recommended)
+mcp__ace-tool__search_context(project_root_path="/path", query="React components with export")
+
+# Method B: Ripgrep pattern search
+rg "export.*Component" --files-with-matches --type ts
+
+# Step 2: Build CONTEXT
+CONTEXT: @components/Auth.tsx @types/auth.d.ts | Memory: Previous type refactoring
+
+# Step 3: Execute CLI
+ccw cli -p "..." --tool <tool-id> --mode analysis --cd src
 ```
 
+### --rule Configuration
+
+**Use `--rule` option to auto-load templates**:
+
+```bash
+ccw cli -p "..." --tool gemini --mode analysis --rule analysis-review-architecture
+```
+
+### Mode Protocol References
+
+**`--rule` auto-loads Protocol based on mode**:
+- `--mode analysis` → analysis-protocol.md
+- `--mode write` → write-protocol.md
+
+**Protocol Mapping**:
+
+- **`analysis`** mode
+  - Permission: Read-only
+  - Constraint: No file create/modify/delete
+
+- **`write`** mode
+  - Permission: Create/Modify/Delete files
+  - Constraint: Full workflow execution
+
+### Template System
+
+**Available `--rule` template names**:
+
+**Universal**:
+- `universal-rigorous-style` - Precise tasks
+- `universal-creative-style` - Exploratory tasks
+
+**Analysis**:
+- `analysis-trace-code-execution` - Execution tracing
+- `analysis-diagnose-bug-root-cause` - Bug diagnosis
+- `analysis-analyze-code-patterns` - Code patterns
+- `analysis-analyze-technical-document` - Document analysis
+- `analysis-review-architecture` - Architecture review
+- `analysis-review-code-quality` - Code review
+- `analysis-analyze-performance` - Performance analysis
+- `analysis-assess-security-risks` - Security assessment
+
+**Planning**:
+- `planning-plan-architecture-design` - Architecture design
+- `planning-breakdown-task-steps` - Task breakdown
+- `planning-design-component-spec` - Component design
+- `planning-plan-migration-strategy` - Migration strategy
+
+**Development**:
+- `development-implement-feature` - Feature implementation
+- `development-refactor-codebase` - Code refactoring
+- `development-generate-tests` - Test generation
+- `development-implement-component-ui` - UI component
+- `development-debug-runtime-issues` - Runtime debugging
+
 ---
 
-## 4. Execution
+## CLI Execution
 
-### Execution ID
+### MODE Options
 
-ID prefix: gemini→`gem`, qwen→`qwn`, codex→`cdx`, claude→`cld`, opencode→`opc`
+- **`analysis`**
+  - Permission: Read-only
+  - Use For: Code review, architecture analysis, pattern discovery, exploration
+  - Specification: Safe for all tools
 
-Output to stderr: `[CCW_EXEC_ID=<id>]`
+- **`write`**
+  - Permission: Create/Modify/Delete
+  - Use For: Feature implementation, bug fixes, documentation, code creation, file modifications
+  - Specification: Requires explicit `--mode write`
+
+- **`review`**
+  - Permission: Read-only (code review output)
+  - Use For: Git-aware code review of uncommitted changes, branch diffs, specific commits
+  - Specification: **codex only** - uses `codex review` subcommand
+  - Tool Behavior:
+    - `codex`: Executes `codex review` for structured code review
+    - Other tools (gemini/qwen/claude): Accept mode but no operation change (treated as analysis)
+  - **Constraint**: Target flags (`--uncommitted`, `--base`, `--commit`) and prompt are mutually exclusive
+    - With prompt only: `ccw cli -p "Focus on security" --tool codex --mode review` (reviews uncommitted by default)
+    - With target flag only: `ccw cli --tool codex --mode review --commit abc123` (no prompt allowed)
+
+### Command Options
+
+- **`--tool <tool>`**
+  - Description: Tool from config (e.g., gemini, qwen, codex)
+  - Default: First enabled tool in config
+
+- **`--mode <mode>`**
+  - Description: **REQUIRED**: analysis, write, review
+  - Default: **NONE** (must specify)
+  - Note: `review` mode triggers `codex review` subcommand for codex tool only
+
+- **`--model <model>`**
+  - Description: Model override
+  - Default: Tool's primaryModel from config
+
+- **`--cd <path>`**
+  - Description: Working directory
+  - Default: current
+
+- **`--includeDirs <dirs>`**
+  - Description: Additional directories (comma-separated)
+  - Default: none
+
+- **`--resume [id]`**
+  - Description: Resume previous session
+  - Default: -
+
+- **`--rule <template>`**
+  - Description: Template name, auto-loads protocol + template appended to prompt
+  - Default: universal-rigorous-style
+  - Auto-selects protocol based on --mode
+
+### Directory Configuration
+
+#### Working Directory (`--cd`)
+
+When using `--cd`:
+- `@**/*` = Files within working directory tree only
+- CANNOT reference parent/sibling via @ alone
+- Must use `--includeDirs` for external directories
+
+#### Include Directories (`--includeDirs`)
+
+**TWO-STEP requirement for external files**:
+1. Add `--includeDirs` parameter
+2. Reference in CONTEXT with @ patterns
 
 ```bash
-ccw cli -p "<PROMPT>" --tool gemini --mode analysis    # auto-ID: gem-143022-a7f2
-ccw cli -p "<PROMPT>" --tool gemini --mode write --id my-task-1  # custom ID
+# Single directory
+ccw cli -p "CONTEXT: @**/* @../shared/**/*" --tool <tool-id> --mode analysis --cd src/auth --includeDirs ../shared
+
+# Multiple directories
+ccw cli -p "..." --tool <tool-id> --mode analysis --cd src/auth --includeDirs ../shared,../types,../utils
 ```
 
+**Rule**: If CONTEXT contains `@../dir/**/*`, MUST include `--includeDirs ../dir`
+
+**Benefits**: Excludes unrelated directories, reduces token usage
+
 ### Session Resume
 
+**When to Use**:
+- Multi-round planning (analysis → planning → implementation)
+- Multi-model collaboration (tool A → tool B on same topic)
+- Topic continuity (building on previous findings)
+
+**Usage**:
+
 ```bash
-ccw cli -p "<PROMPT>" --tool gemini --resume              # last session
-ccw cli -p "<PROMPT>" --tool gemini --mode write --resume <id>  # specific
-ccw cli -p "<PROMPT>" --tool gemini --resume <id1>,<id2>     # merge multiple
+ccw cli -p "Continue analyzing" --tool <tool-id> --mode analysis --resume              # Resume last
+ccw cli -p "Fix issues found" --tool <tool-id> --mode write --resume <id>              # Resume specific
+ccw cli -p "Merge findings" --tool <tool-id> --mode analysis --resume <id1>,<id2>      # Merge multiple
 ```
 
-Resume auto-assembles previous conversation context. Warning emitted when context exceeds 32KB.
+- **`--resume`**: Last session
+- **`--resume <id>`**: Specific session
+- **`--resume <id1>,<id2>`**: Merge sessions (comma-separated)
 
-### Subcommands
+**Context Assembly** (automatic):
+```
+=== PREVIOUS CONVERSATION ===
+USER PROMPT: [Previous prompt]
+ASSISTANT RESPONSE: [Previous output]
+=== CONTINUATION ===
+[Your new prompt]
+```
+
+### Command Examples
+
+#### Task-Type Specific Templates
+
+**Analysis Task** (Security Audit):
+```bash
+ccw cli -p "PURPOSE: Identify OWASP Top 10 vulnerabilities in authentication module to pass security audit; success = all critical/high issues documented with remediation
+TASK: • Scan for injection flaws (SQL, command, LDAP) • Check authentication bypass vectors • Evaluate session management • Assess sensitive data exposure
+MODE: analysis
+CONTEXT: @src/auth/**/* @src/middleware/auth.ts | Memory: Using bcrypt for passwords, JWT for sessions
+EXPECTED: Security report with: severity matrix, file:line references, CVE mappings where applicable, remediation code snippets prioritized by risk
+CONSTRAINTS: Focus on authentication | Ignore test files
+" --tool gemini --mode analysis --rule analysis-assess-security-risks --cd src/auth
+```
+
+**Implementation Task** (New Feature):
+```bash
+ccw cli -p "PURPOSE: Implement rate limiting for API endpoints to prevent abuse; must be configurable per-endpoint; backward compatible with existing clients
+TASK: • Create rate limiter middleware with sliding window • Implement per-route configuration • Add Redis backend for distributed state • Include bypass for internal services
+MODE: write
+CONTEXT: @src/middleware/**/* @src/config/**/* | Memory: Using Express.js, Redis already configured, existing middleware pattern in auth.ts
+EXPECTED: Production-ready code with: TypeScript types, unit tests, integration test, configuration example, migration guide
+CONSTRAINTS: Follow existing middleware patterns | No breaking changes
+" --tool gemini --mode write --rule development-implement-feature
+```
+
+**Bug Fix Task**:
+```bash
+ccw cli -p "PURPOSE: Fix memory leak in WebSocket connection handler causing server OOM after 24h; root cause must be identified before any fix
+TASK: • Trace connection lifecycle from open to close • Identify event listener accumulation • Check cleanup on disconnect • Verify garbage collection eligibility
+MODE: analysis
+CONTEXT: @src/websocket/**/* @src/services/connection-manager.ts | Memory: Using ws library, ~5000 concurrent connections in production
+EXPECTED: Root cause analysis with: memory profile, leak source (file:line), fix recommendation with code, verification steps
+CONSTRAINTS: Focus on resource cleanup
+" --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause --cd src
+```
+
+**Refactoring Task**:
+```bash
+ccw cli -p "PURPOSE: Refactor payment processing to use strategy pattern for multi-gateway support; no functional changes; all existing tests must pass
+TASK: • Extract gateway interface from current implementation • Create strategy classes for Stripe, PayPal • Implement factory for gateway selection • Migrate existing code to use strategies
+MODE: write
+CONTEXT: @src/payments/**/* @src/types/payment.ts | Memory: Currently only Stripe, adding PayPal next sprint, must support future gateways
+EXPECTED: Refactored code with: strategy interface, concrete implementations, factory class, updated tests, migration checklist
+CONSTRAINTS: Preserve all existing behavior | Tests must pass
+" --tool gemini --mode write --rule development-refactor-codebase
+```
+
+**Code Review Task** (codex review mode):
+```bash
+# Option 1: Custom prompt (reviews uncommitted changes by default)
+ccw cli -p "Focus on security vulnerabilities and error handling" --tool codex --mode review
+
+# Option 2: Target flag only (no prompt allowed with target flags)
+ccw cli --tool codex --mode review --uncommitted
+ccw cli --tool codex --mode review --base main
+ccw cli --tool codex --mode review --commit abc123
+```
+
+> **Note**: `--mode review` only triggers special behavior for `codex` tool. Target flags (`--uncommitted`, `--base`, `--commit`) and prompt are **mutually exclusive** - use one or the other, not both.
+
+---
+
+### Permission Framework
+
+**Single-Use Authorization**: Each execution requires explicit user instruction. Previous authorization does NOT carry over.
+
+**Mode Hierarchy**:
+- `analysis`: Read-only, safe for auto-execution
+- `write`: Create/Modify/Delete files, full operations - requires explicit `--mode write`
+- `review`: Git-aware code review (codex only), read-only output - requires explicit `--mode review`
+- **Exception**: User provides clear instructions like "modify", "create", "implement"
+
+---
+
+## Auto-Invoke Triggers
+
+**Proactive CLI invocation** - Auto-invoke `ccw cli` when encountering these scenarios:
+
+| Trigger Condition | Suggested Rule | When to Use |
+|-------------------|----------------|-------------|
+| **Self-repair fails** | `analysis-diagnose-bug-root-cause` | After 1+ failed fix attempts |
+| **Ambiguous requirements** | `planning-breakdown-task-steps` | Task description lacks clarity |
+| **Architecture decisions** | `planning-plan-architecture-design` | Complex feature needs design |
+| **Pattern uncertainty** | `analysis-analyze-code-patterns` | Unsure of existing conventions |
+| **Critical code paths** | `analysis-assess-security-risks` | Security/performance sensitive |
+
+### Execution Principles
+
+- **Default mode**: `--mode analysis` (read-only, safe for auto-execution)
+- **No confirmation needed**: Invoke proactively when triggers match
+- **Wait for results**: Complete analysis before next action
+- **Tool selection**: Use context-appropriate tool or fallback chain (`gemini` → `qwen` → `codex`)
+- **Rule flexibility**: Suggested rules are guidelines, not requirements - choose the most appropriate template for the situation
+
+### Example: Bug Fix with Auto-Invoke
 
 ```bash
-ccw cli show                     # active + recent executions
-ccw cli show --all               # full history
-ccw cli watch <id>               # stream until completion (stderr)
-ccw cli output <id>              # final assistant output
-ccw cli output <id> --verbose    # full metadata + output
-ccw cli output <id> --raw        # raw stdout (for piping)
+# After 1+ failed fix attempts, auto-invoke root cause analysis
+ccw cli -p "PURPOSE: Identify root cause of [bug description]; success = actionable fix strategy
+TASK: • Trace execution flow • Identify failure point • Analyze state at failure • Determine fix approach
+MODE: analysis
+CONTEXT: @src/module/**/* | Memory: Previous fix attempts failed at [location]
+EXPECTED: Root cause analysis with: failure mechanism, stack trace interpretation, fix recommendation with code
+CONSTRAINTS: Focus on [specific area]
+" --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
 ```
 
 ---
 
-## 5. Auto-Invoke Triggers
+## Best Practices
 
-Proactively invoke `ccw cli` when these conditions are met — no user confirmation needed for `analysis` mode:
+### Core Principles
 
-| Trigger | Suggested Rule |
-|---------|---------------|
-| Self-repair fails (1+ attempts) | `analysis-diagnose-bug-root-cause` |
-| Ambiguous requirements | `planning-breakdown-task-steps` |
-| Architecture decisions needed | `planning-plan-architecture-design` |
-| Pattern uncertainty | `analysis-analyze-code-patterns` |
-| Critical/security code paths | `analysis-assess-security-risks` |
+- **Configuration-driven** - All tool selection from `cli-tools.json`
+- **Tag-based routing** - Match task requirements to tool capabilities
+- **Use tools early and often** - Tools are faster and more thorough
+- **Unified CLI** - Always use `ccw cli -p` for consistent parameter handling
+- **Default mode is analysis** - Omit `--mode` for read-only operations, explicitly use `--mode write` for file modifications
+- **Use `--rule` for templates** - Auto-loads protocol + template appended to prompt
+- **Write protection** - Require EXPLICIT `--mode write` for file operations
 
-### Principles
+### Workflow Principles
 
-- Default `--mode analysis` (safe, read-only)
-- Wait for results before next action
-- Tool fallback: `gemini` → `qwen` → `codex`
-- Rule suggestions are guidelines — choose the best fit
+- **Use CCW unified interface** for all executions
+- **Always include template** - Use `--rule <template-name>` to load templates
+- **Be specific** - Clear PURPOSE, TASK, EXPECTED fields
+- **Include constraints** - File patterns, scope in CONSTRAINTS
+- **Leverage memory context** when building on previous work
+- **Discover patterns first** - Use rg/MCP before CLI execution
+- **Default to full context** - Use `@**/*` unless specific files needed
+
+### Planning Checklist
+
+- [ ] **Purpose defined** - Clear goal and intent
+- [ ] **Mode selected** - `--mode analysis|write|review`
+- [ ] **Context gathered** - File references + memory (default `@**/*`)
+- [ ] **Directory navigation** - `--cd` and/or `--includeDirs`
+- [ ] **Tool selected** - Explicit `--tool` or tag-based auto-selection
+- [ ] **Rule template** - `--rule <template-name>` loads template
+- [ ] **Constraints** - Domain constraints in CONSTRAINTS field
+
+### Execution Workflow
+
+1. **Load configuration** - Read `cli-tools.json` for available tools
+2. **Match by tags** - Select tool based on task requirements
+3. **Validate enabled** - Ensure selected tool is enabled
+4. **Execute with mode** - Always specify `--mode analysis|write|review`
+5. **Fallback gracefully** - Use secondary model or next matching tool on failure

.ccw/workflows/context-tools.md

@@ -0,0 +1,76 @@
+## Context Acquisition (MCP Tools Priority)
+
+**For task context gathering and analysis, ALWAYS prefer MCP tools**:
+
+1. **mcp__ace-tool__search_context** - HIGHEST PRIORITY for code discovery
+   - Semantic search with real-time codebase index
+   - Use for: finding implementations, understanding architecture, locating patterns
+   - Example: `mcp__ace-tool__search_context(project_root_path="/path", query="authentication logic")`
+
+2. **smart_search** - Fallback for structured search
+   - Use `smart_search(query="...")` for keyword/regex search
+   - Use `smart_search(action="find_files", pattern="*.ts")` for file discovery
+   - Supports modes: `auto`, `hybrid`, `exact`, `ripgrep`
+
+3. **read_file** - Batch file reading
+   - Read multiple files in parallel: `read_file(path="file1.ts")`, `read_file(path="file2.ts")`
+   - Supports glob patterns: `read_file(path="src/**/*.config.ts")`
+
+**Priority Order**:
+```
+ACE search_context (semantic) → smart_search (structured) → read_file (batch read) → shell commands (fallback)
+```
+
+**NEVER** use shell commands (`cat`, `find`, `grep`) when MCP tools are available.
+### read_file - Read File Contents
+
+**When**: Read files found by smart_search
+
+**How**:
+```javascript
+read_file(path="/path/to/file.ts")                   // Single file
+read_file(path="/src/**/*.config.ts")                // Pattern matching
+```
+
+---
+
+### edit_file - Modify Files
+
+**When**: Built-in Edit tool fails or need advanced features
+
+**How**:
+```javascript
+edit_file(path="/file.ts", old_string="...", new_string="...", mode="update")
+edit_file(path="/file.ts", line=10, content="...", mode="insert_after")
+```
+
+**Modes**: `update` (replace text), `insert_after`, `insert_before`, `delete_line`
+
+---
+
+### write_file - Create/Overwrite Files
+
+**When**: Create new files or completely replace content
+
+**How**:
+```javascript
+write_file(path="/new-file.ts", content="...")
+```
+
+---
+
+### Exa - External Search
+
+**When**: Find documentation/examples outside codebase
+
+**How**:
+```javascript
+mcp__exa__search(query="React hooks 2025 documentation")
+mcp__exa__search(query="FastAPI auth example", numResults=10)
+mcp__exa__search(query="latest API docs", livecrawl="always")
+```
+
+**Parameters**:
+- `query` (required): Search query string
+- `numResults` (optional): Number of results to return (default: 5)
+- `livecrawl` (optional): `"always"` or `"fallback"` for live crawling

.ccw/workflows/file-modification.md

@@ -0,0 +1,64 @@
+# File Modification
+
+Before modifying files, always:
+- Try built-in Edit tool first
+- Escalate to MCP tools when built-ins fail
+- Use write_file only as last resort
+
+## MCP Tools Usage
+
+### edit_file - Modify Files
+
+**When**: Built-in Edit fails, need dry-run preview, or need line-based operations
+
+**How**:
+```javascript
+edit_file(path="/file.ts", oldText="old", newText="new")              // Replace text
+edit_file(path="/file.ts", oldText="old", newText="new", dryRun=true) // Preview diff
+edit_file(path="/file.ts", oldText="old", newText="new", replaceAll=true) // Replace all
+edit_file(path="/file.ts", mode="line", operation="insert_after", line=10, text="new line")
+edit_file(path="/file.ts", mode="line", operation="delete", line=5, end_line=8)
+```
+
+**Modes**: `update` (replace text, default), `line` (line-based operations)
+
+**Operations** (line mode): `insert_before`, `insert_after`, `replace`, `delete`
+
+---
+
+### write_file - Create/Overwrite Files
+
+**When**: Create new files, completely replace content, or edit_file still fails
+
+**How**:
+```javascript
+write_file(path="/new-file.ts", content="file content here")
+write_file(path="/existing.ts", content="...", backup=true)  // Create backup first
+```
+
+---
+
+## Priority Logic
+
+> **Note**: Search priority is defined in `context-tools.md` - smart_search has HIGHEST PRIORITY for all discovery tasks.
+
+**Search & Discovery** (defer to context-tools.md):
+1. **smart_search FIRST** for any code/file discovery
+2. Built-in Grep only for single-file exact line search (location already confirmed)
+3. Exa for external/public knowledge
+
+**File Reading**:
+1. Unknown location → **smart_search first**, then Read
+2. Known confirmed file → Built-in Read directly
+3. Pattern matching → smart_search (action="find_files")
+
+**File Editing**:
+1. Always try built-in Edit first
+2. Fails 1+ times → edit_file (MCP)
+3. Still fails → write_file (MCP)
+
+## Decision Triggers
+
+**Search tasks** → Always start with smart_search (per context-tools.md)
+**Known file edits** → Start with built-in Edit, escalate to MCP if fails
+**External knowledge** → Use Exa

.ccw/workflows/review-directory-specification.md

@@ -0,0 +1,336 @@
+# Review Directory Specification
+
+## Overview
+
+Unified directory structure for all review commands (session-based and module-based) within workflow sessions.
+
+## Core Principles
+
+1. **Session-Based**: All reviews run within a workflow session context
+2. **Unified Structure**: Same directory layout for all review types
+3. **Type Differentiation**: Review type indicated by metadata, not directory structure
+4. **Progressive Creation**: Directories created on-demand during review execution
+5. **Archive Support**: Reviews archived with their parent session
+
+## Directory Structure
+
+### Base Location
+```
+.workflow/active/WFS-{session-id}/.review/
+```
+
+### Complete Structure
+```
+.workflow/active/WFS-{session-id}/.review/
+├── review-state.json              # Review orchestrator state machine
+├── review-progress.json           # Real-time progress for dashboard polling
+├── review-metadata.json           # Review configuration and scope
+├── dimensions/                    # Per-dimension analysis results
+│   ├── security.json
+│   ├── architecture.json
+│   ├── quality.json
+│   ├── action-items.json
+│   ├── performance.json
+│   ├── maintainability.json
+│   └── best-practices.json
+├── iterations/                    # Deep-dive iteration results
+│   ├── iteration-1-finding-{uuid}.json
+│   ├── iteration-2-finding-{uuid}.json
+│   └── ...
+├── reports/                       # Human-readable reports
+│   ├── security-analysis.md
+│   ├── security-cli-output.txt
+│   ├── architecture-analysis.md
+│   ├── architecture-cli-output.txt
+│   ├── ...
+│   ├── deep-dive-1-{uuid}.md
+│   └── deep-dive-2-{uuid}.md
+├── REVIEW-SUMMARY.md              # Final consolidated summary
+└── dashboard.html                 # Interactive review dashboard
+```
+
+## Review Metadata Schema
+
+**File**: `review-metadata.json`
+
+```json
+{
+  "review_id": "review-20250125-143022",
+  "review_type": "module|session",
+  "session_id": "WFS-auth-system",
+  "created_at": "2025-01-25T14:30:22Z",
+  "scope": {
+    "type": "module|session",
+    "module_scope": {
+      "target_pattern": "src/auth/**",
+      "resolved_files": [
+        "src/auth/service.ts",
+        "src/auth/validator.ts"
+      ],
+      "file_count": 2
+    },
+    "session_scope": {
+      "commit_range": "abc123..def456",
+      "changed_files": [
+        "src/auth/service.ts",
+        "src/payment/processor.ts"
+      ],
+      "file_count": 2
+    }
+  },
+  "dimensions": ["security", "architecture", "quality", "action-items", "performance", "maintainability", "best-practices"],
+  "max_iterations": 3,
+  "cli_tools": {
+    "primary": "gemini",
+    "fallback": ["qwen", "codex"]
+  }
+}
+```
+
+## Review State Schema
+
+**File**: `review-state.json`
+
+```json
+{
+  "review_id": "review-20250125-143022",
+  "phase": "init|parallel|aggregate|iterate|complete",
+  "current_iteration": 1,
+  "dimensions_status": {
+    "security": "pending|in_progress|completed|failed",
+    "architecture": "completed",
+    "quality": "in_progress",
+    "action-items": "pending",
+    "performance": "pending",
+    "maintainability": "pending",
+    "best-practices": "pending"
+  },
+  "severity_distribution": {
+    "critical": 2,
+    "high": 5,
+    "medium": 12,
+    "low": 8
+  },
+  "critical_files": [
+    "src/auth/service.ts",
+    "src/payment/processor.ts"
+  ],
+  "iterations": [
+    {
+      "iteration": 1,
+      "findings_selected": ["uuid-1", "uuid-2", "uuid-3"],
+      "completed_at": "2025-01-25T15:30:00Z"
+    }
+  ],
+  "completion_criteria": {
+    "critical_count": 0,
+    "high_count_threshold": 5,
+    "max_iterations": 3
+  },
+  "next_action": "execute_parallel_reviews|aggregate_findings|execute_deep_dive|generate_final_report|complete"
+}
+```
+
+## Session Integration
+
+### Session Discovery
+
+**review-session-cycle** (auto-discover):
+```bash
+# Auto-detect active session
+/workflow:review-session-cycle
+
+# Or specify session explicitly
+/workflow:review-session-cycle WFS-auth-system
+```
+
+**review-module-cycle** (require session):
+```bash
+# Must have active session or specify one
+/workflow:review-module-cycle src/auth/** --session WFS-auth-system
+
+# Or use active session
+/workflow:review-module-cycle src/auth/**
+```
+
+### Session Creation Logic
+
+**For review-module-cycle**:
+
+1. **Check Active Session**: Search `.workflow/active/WFS-*`
+2. **If Found**: Use active session's `.review/` directory
+3. **If Not Found**:
+   - **Option A** (Recommended): Prompt user to create session first
+   - **Option B**: Auto-create review-only session: `WFS-review-{pattern-hash}`
+
+**Recommended Flow**:
+```bash
+# Step 1: Start session
+/workflow:session:start --new "Review auth module"
+# Creates: .workflow/active/WFS-review-auth-module/
+
+# Step 2: Run review
+/workflow:review-module-cycle src/auth/**
+# Creates: .workflow/active/WFS-review-auth-module/.review/
+```
+
+## Command Phase 1 Requirements
+
+### Both Commands Must:
+
+1. **Session Discovery**:
+   ```javascript
+   // Check for active session
+   const sessions = Glob('.workflow/active/WFS-*');
+   if (sessions.length === 0) {
+     // Prompt user to create session first
+     error("No active session found. Please run /workflow:session:start first");
+   }
+   const sessionId = sessions[0].match(/WFS-[^/]+/)[0];
+   ```
+
+2. **Create .review/ Structure**:
+   ```javascript
+   const reviewDir = `.workflow/active/${sessionId}/.review/`;
+
+   // Create directory structure
+   Bash(`mkdir -p ${reviewDir}/dimensions`);
+   Bash(`mkdir -p ${reviewDir}/iterations`);
+   Bash(`mkdir -p ${reviewDir}/reports`);
+   ```
+
+3. **Initialize Metadata**:
+   ```javascript
+   // Write review-metadata.json
+   Write(`${reviewDir}/review-metadata.json`, JSON.stringify({
+     review_id: `review-${timestamp}`,
+     review_type: "module|session",
+     session_id: sessionId,
+     created_at: new Date().toISOString(),
+     scope: {...},
+     dimensions: [...],
+     max_iterations: 3,
+     cli_tools: {...}
+   }));
+
+   // Write review-state.json
+   Write(`${reviewDir}/review-state.json`, JSON.stringify({
+     review_id: `review-${timestamp}`,
+     phase: "init",
+     current_iteration: 0,
+     dimensions_status: {},
+     severity_distribution: {},
+     critical_files: [],
+     iterations: [],
+     completion_criteria: {},
+     next_action: "execute_parallel_reviews"
+   }));
+   ```
+
+4. **Generate Dashboard**:
+   ```javascript
+   const template = Read('~/.claude/templates/review-cycle-dashboard.html');
+   const dashboard = template
+     .replace('{{SESSION_ID}}', sessionId)
+     .replace('{{REVIEW_TYPE}}', reviewType)
+     .replace('{{REVIEW_DIR}}', reviewDir);
+   Write(`${reviewDir}/dashboard.html`, dashboard);
+
+   // Output to user
+   console.log(`📊 Review Dashboard: file://${absolutePath(reviewDir)}/dashboard.html`);
+   console.log(`📂 Review Output: ${reviewDir}`);
+   ```
+
+## Archive Strategy
+
+### On Session Completion
+
+When `/workflow:session:complete` is called:
+
+1. **Preserve Review Directory**:
+   ```javascript
+   // Move entire session including .review/
+   Bash(`mv .workflow/active/${sessionId} .workflow/archives/${sessionId}`);
+   ```
+
+2. **Review Archive Structure**:
+   ```
+   .workflow/archives/WFS-auth-system/
+   ├── workflow-session.json
+   ├── IMPL_PLAN.md
+   ├── TODO_LIST.md
+   ├── .task/
+   ├── .summaries/
+   └── .review/                    # Review results preserved
+       ├── review-metadata.json
+       ├── REVIEW-SUMMARY.md
+       └── dashboard.html
+   ```
+
+3. **Access Archived Reviews**:
+   ```bash
+   # Open archived dashboard
+   start .workflow/archives/WFS-auth-system/.review/dashboard.html
+   ```
+
+## Benefits
+
+### 1. Unified Structure
+- Same directory layout for all review types
+- Consistent file naming and schemas
+- Easier maintenance and tooling
+
+### 2. Session Integration
+- Review history tracked with implementation
+- Easy correlation between code changes and reviews
+- Simplified archiving and retrieval
+
+### 3. Progressive Creation
+- Directories created only when needed
+- No upfront overhead
+- Clean session initialization
+
+### 4. Type Flexibility
+- Module-based and session-based reviews in same structure
+- Type indicated by metadata, not directory layout
+- Easy to add new review types
+
+### 5. Dashboard Consistency
+- Same dashboard template for both types
+- Unified progress tracking
+- Consistent user experience
+
+## Migration Path
+
+### For Existing Commands
+
+**review-session-cycle**:
+1. Change output from `.workflow/.reviews/session-{id}/` to `.workflow/active/{session-id}/.review/`
+2. Update Phase 1 to use session discovery
+3. Add review-metadata.json creation
+
+**review-module-cycle**:
+1. Add session requirement (or auto-create)
+2. Change output from `.workflow/.reviews/module-{hash}/` to `.workflow/active/{session-id}/.review/`
+3. Update Phase 1 to use session discovery
+4. Add review-metadata.json creation
+
+### Backward Compatibility
+
+**For existing standalone reviews** in `.workflow/.reviews/`:
+- Keep for reference
+- Document migration in README
+- Provide migration script if needed
+
+## Implementation Checklist
+
+- [ ] Update workflow-architecture.md with .review/ structure
+- [ ] Update review-session-cycle.md command specification
+- [ ] Update review-module-cycle.md command specification
+- [ ] Update review-cycle-dashboard.html template
+- [ ] Create review-metadata.json schema validation
+- [ ] Update /workflow:session:complete to preserve .review/
+- [ ] Update documentation examples
+- [ ] Test both review types with new structure
+- [ ] Validate dashboard compatibility
+- [ ] Document migration path for existing reviews

.ccw/workflows/task-core.md

@@ -0,0 +1,214 @@
+# Task System Core Reference
+
+## Overview
+Task commands provide single-execution workflow capabilities with full context awareness, hierarchical organization, and agent orchestration.
+
+## Task JSON Schema
+All task files use this simplified 5-field schema:
+
+```json
+{
+  "id": "IMPL-1.2",
+  "title": "Implement JWT authentication",
+  "status": "pending|active|completed|blocked|container",
+
+  "meta": {
+    "type": "feature|bugfix|refactor|test-gen|test-fix|docs",
+    "agent": "@code-developer|@action-planning-agent|@test-fix-agent|@universal-executor"
+  },
+
+  "context": {
+    "requirements": ["JWT authentication", "OAuth2 support"],
+    "focus_paths": ["src/auth", "tests/auth", "config/auth.json"],
+    "acceptance": ["JWT validation works", "OAuth flow complete"],
+    "parent": "IMPL-1",
+    "depends_on": ["IMPL-1.1"],
+    "inherited": {
+      "from": "IMPL-1",
+      "context": ["Authentication system design completed"]
+    },
+    "shared_context": {
+      "auth_strategy": "JWT with refresh tokens"
+    }
+  },
+
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "gather_context",
+        "action": "Read dependency summaries",
+        "command": "bash(cat .workflow/*/summaries/IMPL-1.1-summary.md)",
+        "output_to": "auth_design_context",
+        "on_error": "skip_optional"
+      }
+    ],
+    "implementation_approach": [
+      {
+        "step": 1,
+        "title": "Implement JWT authentication system",
+        "description": "Implement comprehensive JWT authentication system with token generation, validation, and refresh logic",
+        "modification_points": ["Add JWT token generation", "Implement token validation middleware", "Create refresh token logic"],
+        "logic_flow": ["User login request → validate credentials", "Generate JWT access and refresh tokens", "Store refresh token securely", "Return tokens to client"],
+        "depends_on": [],
+        "output": "jwt_implementation"
+      }
+    ],
+    "target_files": [
+      "src/auth/login.ts:handleLogin:75-120",
+      "src/middleware/auth.ts:validateToken",
+      "src/auth/PasswordReset.ts"
+    ]
+  }
+}
+```
+
+## Field Structure Details
+
+### focus_paths Field (within context)
+**Purpose**: Specifies concrete project paths relevant to task implementation
+
+**Format**:
+- **Array of strings**: `["folder1", "folder2", "specific_file.ts"]`
+- **Concrete paths**: Use actual directory/file names without wildcards
+- **Mixed types**: Can include both directories and specific files
+- **Relative paths**: From project root (e.g., `src/auth`, not `./src/auth`)
+
+**Examples**:
+```json
+// Authentication system task
+"focus_paths": ["src/auth", "tests/auth", "config/auth.json", "src/middleware/auth.ts"]
+
+// UI component task
+"focus_paths": ["src/components/Button", "src/styles", "tests/components"]
+```
+
+### flow_control Field Structure
+**Purpose**: Universal process manager for task execution
+
+**Components**:
+- **pre_analysis**: Array of sequential process steps
+- **implementation_approach**: Task execution strategy
+- **target_files**: Files to modify/create - existing files in `file:function:lines` format, new files as `file` only
+
+**Step Structure**:
+```json
+{
+  "step": "gather_context",
+  "action": "Human-readable description",
+  "command": "bash(executable command with [variables])",
+  "output_to": "variable_name",
+  "on_error": "skip_optional|fail|retry_once|manual_intervention"
+}
+```
+
+## Hierarchical System
+
+### Task Hierarchy Rules
+- **Format**: IMPL-N (main), IMPL-N.M (subtasks) - uppercase required
+- **Maximum Depth**: 2 levels only
+- **10-Task Limit**: Hard limit enforced across all tasks
+- **Container Tasks**: Parents with subtasks (not executable)
+- **Leaf Tasks**: No subtasks (executable)
+- **File Cohesion**: Related files must stay in same task
+
+### Task Complexity Classifications
+- **Simple**: ≤5 tasks, single-level tasks, direct execution
+- **Medium**: 6-10 tasks, two-level hierarchy, context coordination
+- **Over-scope**: >10 tasks requires project re-scoping into iterations
+
+### Complexity Assessment Rules
+- **Creation**: System evaluates and assigns complexity
+- **10-task limit**: Hard limit enforced - exceeding requires re-scoping
+- **Execution**: Can upgrade (Simple→Medium→Over-scope), triggers re-scoping
+- **Override**: Users can manually specify complexity within 10-task limit
+
+### Status Rules
+- **pending**: Ready for execution
+- **active**: Currently being executed
+- **completed**: Successfully finished
+- **blocked**: Waiting for dependencies
+- **container**: Has subtasks (parent only)
+
+## Session Integration
+
+### Active Session Detection
+```bash
+# Check for active session in sessions directory
+active_session=$(find .workflow/active/ -name 'WFS-*' -type d 2>/dev/null | head -1)
+```
+
+### Workflow Context Inheritance
+Tasks inherit from:
+1. `workflow-session.json` - Session metadata
+2. Parent task context (for subtasks)
+3. `IMPL_PLAN.md` - Planning document
+
+### File Locations
+- **Task JSON**: `.workflow/active/WFS-[topic]/.task/IMPL-*.json` (uppercase required)
+- **Session State**: `.workflow/active/WFS-[topic]/workflow-session.json`
+- **Planning Doc**: `.workflow/active/WFS-[topic]/IMPL_PLAN.md`
+- **Progress**: `.workflow/active/WFS-[topic]/TODO_LIST.md`
+
+## Agent Mapping
+
+### Automatic Agent Selection
+- **@code-developer**: Implementation tasks, coding, test writing
+- **@action-planning-agent**: Design, architecture planning
+- **@test-fix-agent**: Test execution, failure diagnosis, code fixing
+- **@universal-executor**: Optional manual review (only when explicitly requested)
+
+### Agent Context Filtering
+Each agent receives tailored context:
+- **@code-developer**: Complete implementation details, test requirements
+- **@action-planning-agent**: High-level requirements, risks, architecture
+- **@test-fix-agent**: Test execution, failure diagnosis, code fixing
+- **@universal-executor**: Quality standards, security considerations (when requested)
+
+## Deprecated Fields
+
+### Legacy paths Field
+**Deprecated**: The semicolon-separated `paths` field has been replaced by `context.focus_paths` array.
+
+**Old Format** (no longer used):
+```json
+"paths": "src/auth;tests/auth;config/auth.json;src/middleware/auth.ts"
+```
+
+**New Format** (use this instead):
+```json
+"context": {
+  "focus_paths": ["src/auth", "tests/auth", "config/auth.json", "src/middleware/auth.ts"]
+}
+```
+
+## Validation Rules
+
+### Pre-execution Checks
+1. Task exists and is valid JSON
+2. Task status allows operation
+3. Dependencies are met
+4. Active workflow session exists
+5. All 5 core fields present (id, title, status, meta, context, flow_control)
+6. Total task count ≤ 10 (hard limit)
+7. File cohesion maintained in focus_paths
+
+### Hierarchy Validation
+- Parent-child relationships valid
+- Maximum depth not exceeded
+- Container tasks have subtasks
+- No circular dependencies
+
+## Error Handling Patterns
+
+### Common Errors
+- **Task not found**: Check ID format and session
+- **Invalid status**: Verify task can be operated on
+- **Missing session**: Ensure active workflow exists
+- **Max depth exceeded**: Restructure hierarchy
+- **Missing implementation**: Complete required fields
+
+### Recovery Strategies
+- Session validation with clear guidance
+- Automatic ID correction suggestions
+- Implementation field completion prompts
+- Hierarchy restructuring options

.ccw/workflows/tool-strategy.md

@@ -0,0 +1,216 @@
+# Tool Strategy - When to Use What
+
+> **Focus**: Decision triggers and selection logic, NOT syntax (already registered with Claude)
+
+## Quick Decision Tree
+
+```
+Need context?
+├─ Exa available? → Use Exa (fastest, most comprehensive)
+├─ Large codebase (>500 files)? → codex_lens
+├─ Known files (<5)? → Read tool
+└─ Unknown files? → smart_search → Read tool
+
+Need to modify files?
+├─ Built-in Edit fails? → mcp__ccw-tools__edit_file
+└─ Still fails? → mcp__ccw-tools__write_file
+
+Need to search?
+├─ Semantic/concept search? → smart_search (mode=semantic)
+├─ Exact pattern match? → Grep tool
+└─ Multiple search modes needed? → smart_search (mode=auto)
+```
+
+---
+
+## 1. Context Gathering Tools
+
+### Exa (`mcp__exa__get_code_context_exa`)
+
+**Use When**:
+- ✅ Researching external APIs, libraries, frameworks
+- ✅ Need recent documentation (post-cutoff knowledge)
+- ✅ Looking for implementation examples in public repos
+- ✅ Comparing architectural patterns across projects
+
+**Don't Use When**:
+- ❌ Searching internal codebase (use smart_search/codex_lens)
+- ❌ Files already in working directory (use Read)
+
+**Trigger Indicators**:
+- User mentions specific library/framework names
+- Questions about "best practices", "how does X work"
+- Need to verify current API signatures
+
+---
+
+### read_file (`mcp__ccw-tools__read_file`)
+
+**Use When**:
+- ✅ Reading multiple related files at once (batch reading)
+- ✅ Need directory traversal with pattern matching
+- ✅ Searching file content with regex (`contentPattern`)
+- ✅ Want to limit depth/file count for large directories
+
+**Don't Use When**:
+- ❌ Single file read → Use built-in Read tool (faster)
+- ❌ Unknown file locations → Use smart_search first
+- ❌ Need semantic search → Use smart_search or codex_lens
+
+**Trigger Indicators**:
+- Need to read "all TypeScript files in src/"
+- Need to find "files containing TODO comments"
+- Want to read "up to 20 config files"
+
+**Advantages over Built-in Read**:
+- Batch operation (multiple files in one call)
+- Pattern-based filtering (glob + content regex)
+- Directory traversal with depth control
+
+---
+
+### codex_lens (`mcp__ccw-tools__codex_lens`)
+
+**Use When**:
+- ✅ Large codebase (>500 files) requiring repeated searches
+- ✅ Need semantic understanding of code relationships
+- ✅ Working across multiple sessions (persistent index)
+- ✅ Symbol-level navigation needed
+
+**Don't Use When**:
+- ❌ Small project (<100 files) → Use smart_search (no indexing overhead)
+- ❌ One-time search → Use smart_search or Grep
+- ❌ Files change frequently → Indexing overhead not worth it
+
+**Trigger Indicators**:
+- "Find all implementations of interface X"
+- "What calls this function across the codebase?"
+- Multi-session workflow on same codebase
+
+**Action Selection**:
+- `init`: First time in new codebase
+- `search`: Find code patterns
+- `search_files`: Find files by path/name pattern
+- `symbol`: Get symbols in specific file
+- `status`: Check if index exists/is stale
+- `clean`: Remove stale index
+
+---
+
+### smart_search (`mcp__ccw-tools__smart_search`)
+
+**Use When**:
+- ✅ Don't know exact file locations
+- ✅ Need concept/semantic search ("authentication logic")
+- ✅ Medium-sized codebase (100-500 files)
+- ✅ One-time or infrequent searches
+
+**Don't Use When**:
+- ❌ Known exact file path → Use Read directly
+- ❌ Large codebase + repeated searches → Use codex_lens
+- ❌ Exact pattern match → Use Grep (faster)
+
+**Mode Selection**:
+- `auto`: Let tool decide (default, safest)
+- `exact`: Know exact pattern, need fast results
+- `fuzzy`: Typo-tolerant file/symbol names
+- `semantic`: Concept-based ("error handling", "data validation")
+- `graph`: Dependency/relationship analysis
+
+**Trigger Indicators**:
+- "Find files related to user authentication"
+- "Where is the payment processing logic?"
+- "Locate database connection setup"
+
+---
+
+## 2. File Modification Tools
+
+### edit_file (`mcp__ccw-tools__edit_file`)
+
+**Use When**:
+- ✅ Built-in Edit tool failed 1+ times
+- ✅ Need dry-run preview before applying
+- ✅ Need line-based operations (insert_after, insert_before)
+- ✅ Need to replace all occurrences
+
+**Don't Use When**:
+- ❌ Built-in Edit hasn't failed yet → Try built-in first
+- ❌ Need to create new file → Use write_file
+
+**Trigger Indicators**:
+- Built-in Edit returns "old_string not found"
+- Built-in Edit fails due to whitespace/formatting
+- Need to verify changes before applying (dryRun=true)
+
+**Mode Selection**:
+- `mode=update`: Replace text (similar to built-in Edit)
+- `mode=line`: Line-based operations (insert_after, insert_before, delete)
+
+---
+
+### write_file (`mcp__ccw-tools__write_file`)
+
+**Use When**:
+- ✅ Creating brand new files
+- ✅ MCP edit_file still fails (last resort)
+- ✅ Need to completely replace file content
+- ✅ Need backup before overwriting
+
+**Don't Use When**:
+- ❌ File exists + small change → Use Edit tools
+- ❌ Built-in Edit hasn't been tried → Try built-in Edit first
+
+**Trigger Indicators**:
+- All Edit attempts failed
+- Need to create new file with specific content
+- User explicitly asks to "recreate file"
+
+---
+
+## 3. Decision Logic
+
+### File Reading Priority
+
+```
+1. Known single file? → Built-in Read
+2. Multiple files OR pattern matching? → mcp__ccw-tools__read_file
+3. Unknown location? → smart_search, then Read
+4. Large codebase + repeated access? → codex_lens
+```
+
+### File Editing Priority
+
+```
+1. Always try built-in Edit first
+2. Fails 1+ times? → mcp__ccw-tools__edit_file
+3. Still fails? → mcp__ccw-tools__write_file (last resort)
+```
+
+### Search Tool Priority
+
+```
+1. External knowledge? → Exa
+2. Exact pattern in small codebase? → Built-in Grep
+3. Semantic/unknown location? → smart_search
+4. Large codebase + repeated searches? → codex_lens
+```
+
+---
+
+## 4. Anti-Patterns
+
+**Don't**:
+- Use codex_lens for one-time searches in small projects
+- Use smart_search when file path is already known
+- Use write_file before trying Edit tools
+- Use Exa for internal codebase searches
+- Use read_file for single file when Read tool works
+
+**Do**:
+- Start with simplest tool (Read, Edit, Grep)
+- Escalate to MCP tools when built-ins fail
+- Use semantic search (smart_search) for exploratory tasks
+- Use indexed search (codex_lens) for large, stable codebases
+- Use Exa for external/public knowledge
+

.ccw/workflows/workflow-architecture.md

@@ -0,0 +1,942 @@
+# Workflow Architecture
+
+## Overview
+
+This document defines the complete workflow system architecture using a **JSON-only data model**, **marker-based session management**, and **unified file structure** with dynamic task decomposition.
+
+## Core Architecture
+
+### JSON-Only Data Model
+**JSON files (.task/IMPL-*.json) are the only authoritative source of task state. All markdown documents are read-only generated views.**
+
+- **Task State**: Stored exclusively in JSON files
+- **Documents**: Generated on-demand from JSON data
+- **No Synchronization**: Eliminates bidirectional sync complexity
+- **Performance**: Direct JSON access without parsing overhead
+
+### Key Design Decisions
+- **JSON files are the single source of truth** - All markdown documents are read-only generated views
+- **Marker files for session tracking** - Ultra-simple active session management
+- **Unified file structure definition** - Same structure template for all workflows, created on-demand
+- **Dynamic task decomposition** - Subtasks created as needed during execution
+- **On-demand file creation** - Directories and files created only when required
+- **Agent-agnostic task definitions** - Complete context preserved for autonomous execution
+
+## Session Management
+
+### Directory-Based Session Management
+**Simple Location-Based Tracking**: Sessions in `.workflow/active/` directory
+
+```bash
+.workflow/
+├── active/
+│   ├── WFS-oauth-integration/         # Active session directory
+│   ├── WFS-user-profile/             # Active session directory
+│   └── WFS-bug-fix-123/              # Active session directory
+└── archives/
+    └── WFS-old-feature/              # Archived session (completed)
+```
+
+
+### Session Operations
+
+#### Detect Active Session(s)
+```bash
+active_sessions=$(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null)
+count=$(echo "$active_sessions" | wc -l)
+
+if [ -z "$active_sessions" ]; then
+  echo "No active session"
+elif [ "$count" -eq 1 ]; then
+  session_name=$(basename "$active_sessions")
+  echo "Active session: $session_name"
+else
+  echo "Multiple sessions found:"
+  echo "$active_sessions" | while read session_dir; do
+    session=$(basename "$session_dir")
+    echo "  - $session"
+  done
+  echo "Please specify which session to work with"
+fi
+```
+
+#### Archive Session
+```bash
+mv .workflow/active/WFS-feature .workflow/archives/WFS-feature
+```
+
+### Session State Tracking
+Each session directory contains `workflow-session.json`:
+
+```json
+{
+  "session_id": "WFS-[topic-slug]",
+  "project": "feature description",
+  "type": "simple|medium|complex",
+  "current_phase": "PLAN|IMPLEMENT|REVIEW",
+  "status": "active|paused|completed",
+  "progress": {
+    "completed_phases": ["PLAN"],
+    "current_tasks": ["IMPL-1", "IMPL-2"]
+  }
+}
+```
+
+## Task System
+
+### Hierarchical Task Structure
+**Maximum Depth**: 2 levels (IMPL-N.M format)
+
+```
+IMPL-1              # Main task
+IMPL-1.1            # Subtask of IMPL-1 (dynamically created)
+IMPL-1.2            # Another subtask of IMPL-1
+IMPL-2              # Another main task
+IMPL-2.1            # Subtask of IMPL-2 (dynamically created)
+```
+
+**Task Status Rules**:
+- **Container tasks**: Parent tasks with subtasks (cannot be directly executed)
+- **Leaf tasks**: Only these can be executed directly
+- **Status inheritance**: Parent status derived from subtask completion
+
+### Enhanced Task JSON Schema
+All task files use this unified 6-field schema with optional artifacts enhancement:
+
+```json
+{
+  "id": "IMPL-1.2",
+  "title": "Implement JWT authentication",
+  "status": "pending|active|completed|blocked|container",
+  "context_package_path": ".workflow/WFS-session/.process/context-package.json",
+
+  "meta": {
+    "type": "feature|bugfix|refactor|test-gen|test-fix|docs",
+    "agent": "@code-developer|@action-planning-agent|@test-fix-agent|@universal-executor"
+  },
+
+  "context": {
+    "requirements": ["JWT authentication", "OAuth2 support"],
+    "focus_paths": ["src/auth", "tests/auth", "config/auth.json"],
+    "acceptance": ["JWT validation works", "OAuth flow complete"],
+    "parent": "IMPL-1",
+    "depends_on": ["IMPL-1.1"],
+    "inherited": {
+      "from": "IMPL-1",
+      "context": ["Authentication system design completed"]
+    },
+    "shared_context": {
+      "auth_strategy": "JWT with refresh tokens"
+    },
+    "artifacts": [
+      {
+        "type": "role_analyses",
+        "source": "brainstorm_clarification",
+        "path": ".workflow/WFS-session/.brainstorming/*/analysis*.md",
+        "priority": "highest",
+        "contains": "role_specific_requirements_and_design"
+      }
+    ]
+  },
+
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "check_patterns",
+        "action": "Analyze existing patterns",
+        "command": "bash(rg 'auth' [focus_paths] | head -10)",
+        "output_to": "patterns"
+      },
+      {
+        "step": "analyze_architecture",
+        "action": "Review system architecture",
+        "command": "gemini \"analyze patterns: [patterns]\"",
+        "output_to": "design"
+      },
+      {
+        "step": "check_deps",
+        "action": "Check dependencies",
+        "command": "bash(echo [depends_on] | xargs cat)",
+        "output_to": "context"
+      }
+    ],
+    "implementation_approach": [
+      {
+        "step": 1,
+        "title": "Set up authentication infrastructure",
+        "description": "Install JWT library and create auth config following [design] patterns from [parent]",
+        "modification_points": [
+          "Add JWT library dependencies to package.json",
+          "Create auth configuration file using [parent] patterns"
+        ],
+        "logic_flow": [
+          "Install jsonwebtoken library via npm",
+          "Configure JWT secret and expiration from [inherited]",
+          "Export auth config for use by [jwt_generator]"
+        ],
+        "depends_on": [],
+        "output": "auth_config"
+      },
+      {
+        "step": 2,
+        "title": "Implement JWT generation",
+        "description": "Create JWT token generation logic using [auth_config] and [inherited] validation patterns",
+        "modification_points": [
+          "Add JWT generation function in auth service",
+          "Implement token signing with [auth_config]"
+        ],
+        "logic_flow": [
+          "User login → validate credentials with [inherited]",
+          "Generate JWT payload with user data",
+          "Sign JWT using secret from [auth_config]",
+          "Return signed token"
+        ],
+        "depends_on": [1],
+        "output": "jwt_generator"
+      },
+      {
+        "step": 3,
+        "title": "Implement JWT validation middleware",
+        "description": "Create middleware to validate JWT tokens using [auth_config] and [shared] rules",
+        "modification_points": [
+          "Create validation middleware using [jwt_generator]",
+          "Add token verification using [shared] rules",
+          "Implement user attachment to request object"
+        ],
+        "logic_flow": [
+          "Protected route → extract JWT from Authorization header",
+          "Validate token signature using [auth_config]",
+          "Check token expiration and [shared] rules",
+          "Decode payload and attach user to request",
+          "Call next() or return 401 error"
+        ],
+        "command": "bash(npm test -- middleware.test.ts)",
+        "depends_on": [1, 2],
+        "output": "auth_middleware"
+      }
+    ],
+    "target_files": [
+      "src/auth/login.ts:handleLogin:75-120",
+      "src/middleware/auth.ts:validateToken",
+      "src/auth/PasswordReset.ts"
+    ]
+  }
+}
+```
+
+### Focus Paths & Context Management
+
+#### Context Package Path (Top-Level Field)
+The **context_package_path** field provides the location of the smart context package:
+- **Location**: Top-level field (not in `artifacts` array)
+- **Path**: `.workflow/WFS-session/.process/context-package.json`
+- **Purpose**: References the comprehensive context package containing project structure, dependencies, and brainstorming artifacts catalog
+- **Usage**: Loaded in `pre_analysis` steps via `Read({{context_package_path}})`
+
+#### Focus Paths Format
+The **focus_paths** field specifies concrete project paths for task implementation:
+- **Array of strings**: `["folder1", "folder2", "specific_file.ts"]`
+- **Concrete paths**: Use actual directory/file names without wildcards
+- **Mixed types**: Can include both directories and specific files
+- **Relative paths**: From project root (e.g., `src/auth`, not `./src/auth`)
+
+#### Artifacts Field ⚠️ NEW FIELD
+Optional field referencing brainstorming outputs for task execution:
+
+```json
+"artifacts": [
+  {
+    "type": "role_analyses|topic_framework|individual_role_analysis",
+    "source": "brainstorm_clarification|brainstorm_framework|brainstorm_roles",
+    "path": ".workflow/WFS-session/.brainstorming/document.md",
+    "priority": "highest|high|medium|low"
+  }
+]
+```
+
+**Types & Priority**: role_analyses (highest) → topic_framework (medium) → individual_role_analysis (low)
+
+#### Flow Control Configuration
+The **flow_control** field manages task execution through structured sequential steps. For complete format specifications and usage guidelines, see [Flow Control Format Guide](#flow-control-format-guide) below.
+
+**Quick Reference**:
+- **pre_analysis**: Context gathering steps (supports multiple command types)
+- **implementation_approach**: Implementation steps array with dependency management
+- **target_files**: Target files for modification (file:function:lines format)
+- **Variable references**: Use `[variable_name]` to reference step outputs
+- **Tool integration**: Supports Gemini, Codex, Bash commands, and MCP tools
+
+## Flow Control Format Guide
+
+The `[FLOW_CONTROL]` marker indicates that a task or prompt contains flow control steps for sequential execution. There are **two distinct formats** used in different scenarios:
+
+### Format Comparison Matrix
+
+| Aspect | Inline Format | JSON Format |
+|--------|--------------|-------------|
+| **Used In** | Brainstorm workflows | Implementation tasks |
+| **Agent** | conceptual-planning-agent | code-developer, test-fix-agent, doc-generator |
+| **Location** | Task() prompt (markdown) | .task/IMPL-*.json file |
+| **Persistence** | Temporary (prompt-only) | Persistent (file storage) |
+| **Complexity** | Simple (3-5 steps) | Complex (10+ steps) |
+| **Dependencies** | None | Full `depends_on` support |
+| **Purpose** | Load brainstorming context | Implement task with preparation |
+
+### Inline Format (Brainstorm)
+
+**Marker**: `[FLOW_CONTROL]` written directly in Task() prompt
+
+**Structure**: Markdown list format
+
+**Used By**: Brainstorm commands (`auto-parallel.md`, role commands)
+
+**Agent**: `conceptual-planning-agent`
+
+**Example**:
+```markdown
+[FLOW_CONTROL]
+
+### Flow Control Steps
+**AGENT RESPONSIBILITY**: Execute these pre_analysis steps sequentially with context accumulation:
+
+1. **load_topic_framework**
+   - Action: Load structured topic discussion framework
+   - Command: Read(.workflow/WFS-{session}/.brainstorming/guidance-specification.md)
+   - Output: topic_framework
+
+2. **load_role_template**
+   - Action: Load role-specific planning template
+   - Command: bash($(cat "~/.ccw/workflows/cli-templates/planning-roles/{role}.md"))
+   - Output: role_template
+
+3. **load_session_metadata**
+   - Action: Load session metadata and topic description
+   - Command: bash(cat .workflow/WFS-{session}/workflow-session.json 2>/dev/null || echo '{}')
+   - Output: session_metadata
+```
+
+**Characteristics**:
+- 3-5 simple context loading steps
+- Written directly in prompt (not persistent)
+- No dependency management between steps
+- Used for temporary context preparation
+- Variables: `[variable_name]` for output references
+
+### JSON Format (Implementation)
+
+**Marker**: `[FLOW_CONTROL]` used in TodoWrite or documentation to indicate task has flow control
+
+**Structure**: Complete JSON structure in task file
+
+**Used By**: Implementation tasks (IMPL-*.json)
+
+**Agents**: `code-developer`, `test-fix-agent`, `doc-generator`
+
+**Example**:
+```json
+"flow_control": {
+  "pre_analysis": [
+    {
+      "step": "load_role_analyses",
+      "action": "Load role analysis documents from brainstorming",
+      "commands": [
+        "bash(ls .workflow/WFS-{session}/.brainstorming/*/analysis*.md 2>/dev/null || echo 'not found')",
+        "Glob(.workflow/WFS-{session}/.brainstorming/*/analysis*.md)",
+        "Read(each discovered role analysis file)"
+      ],
+      "output_to": "role_analyses",
+      "on_error": "skip_optional"
+    },
+    {
+      "step": "local_codebase_exploration",
+      "action": "Explore codebase using local search",
+      "commands": [
+        "bash(rg '^(function|class|interface).*auth' --type ts -n --max-count 15)",
+        "bash(find . -name '*auth*' -type f | grep -v node_modules | head -10)"
+      ],
+      "output_to": "codebase_structure"
+    }
+  ],
+  "implementation_approach": [
+    {
+      "step": 1,
+      "title": "Setup infrastructure",
+      "description": "Install JWT library and create config following [role_analyses]",
+      "modification_points": [
+        "Add JWT library dependencies to package.json",
+        "Create auth configuration file"
+      ],
+      "logic_flow": [
+        "Install jsonwebtoken library via npm",
+        "Configure JWT secret from [role_analyses]",
+        "Export auth config for use by [jwt_generator]"
+      ],
+      "depends_on": [],
+      "output": "auth_config"
+    },
+    {
+      "step": 2,
+      "title": "Implement JWT generation",
+      "description": "Create JWT token generation logic using [auth_config]",
+      "modification_points": [
+        "Add JWT generation function in auth service",
+        "Implement token signing with [auth_config]"
+      ],
+      "logic_flow": [
+        "User login → validate credentials",
+        "Generate JWT payload with user data",
+        "Sign JWT using secret from [auth_config]",
+        "Return signed token"
+      ],
+      "depends_on": [1],
+      "output": "jwt_generator"
+    }
+  ],
+  "target_files": [
+    "src/auth/login.ts:handleLogin:75-120",
+    "src/middleware/auth.ts:validateToken"
+  ]
+}
+```
+
+**Characteristics**:
+- Persistent storage in .task/IMPL-*.json files
+- Complete dependency management (`depends_on` arrays)
+- Two-phase structure: `pre_analysis` + `implementation_approach`
+- Error handling strategies (`on_error` field)
+- Target file specifications
+- Variables: `[variable_name]` for cross-step references
+
+### JSON Format Field Specifications
+
+#### pre_analysis Field
+**Purpose**: Context gathering phase before implementation
+
+**Structure**: Array of step objects with sequential execution
+
+**Step Fields**:
+- **step**: Step identifier (string, e.g., "load_role_analyses")
+- **action**: Human-readable description of the step
+- **command** or **commands**: Single command string or array of command strings
+- **output_to**: Variable name for storing step output
+- **on_error**: Error handling strategy (`skip_optional`, `fail`, `retry_once`, `manual_intervention`)
+
+**Command Types Supported**:
+- **Bash commands**: `bash(command)` - Any shell command
+- **Tool calls**: `Read(file)`, `Glob(pattern)`, `Grep(pattern)`
+- **MCP tools**: `mcp__exa__get_code_context_exa()`, `mcp__exa__web_search_exa()`
+- **CLI commands**: `gemini`, `qwen`, `codex --full-auto exec`
+
+**Example**:
+```json
+{
+  "step": "load_context",
+  "action": "Load project context and patterns",
+  "commands": [
+    "bash(ccw tool exec get_modules_by_depth '{}')",
+    "Read(CLAUDE.md)"
+  ],
+  "output_to": "project_structure",
+  "on_error": "skip_optional"
+}
+```
+
+#### implementation_approach Field
+**Purpose**: Define implementation steps with dependency management
+
+**Structure**: Array of step objects (NOT object format)
+
+**Step Fields (All Required)**:
+- **step**: Unique step number (1, 2, 3, ...) - serves as step identifier
+- **title**: Brief step title
+- **description**: Comprehensive implementation description with context variable references
+- **modification_points**: Array of specific code modification targets
+- **logic_flow**: Array describing business logic execution sequence
+- **depends_on**: Array of step numbers this step depends on (e.g., `[1]`, `[1, 2]`) - empty array `[]` for independent steps
+- **output**: Output variable name that can be referenced by subsequent steps via `[output_name]`
+
+**Optional Fields**:
+- **command**: Command for step execution (supports any shell command or CLI tool)
+  - When omitted: Agent interprets modification_points and logic_flow to execute
+  - When specified: Command executes the step directly
+
+**Execution Modes**:
+- **Default (without command)**: Agent executes based on modification_points and logic_flow
+- **With command**: Specified command handles execution
+
+**Command Field Usage**:
+- **Default approach**: Omit command field - let agent execute autonomously
+- **CLI tools (codex/gemini/qwen)**: Add ONLY when user explicitly requests CLI tool usage
+- **Simple commands**: Can include bash commands, test commands, validation scripts
+- **Complex workflows**: Use command for multi-step operations or tool coordination
+
+**Command Format Examples** (only when explicitly needed):
+```json
+// Simple Bash
+"command": "bash(npm install package)"
+"command": "bash(npm test)"
+
+// Validation
+"command": "bash(test -f config.ts && grep -q 'JWT_SECRET' config.ts)"
+
+// Codex (user requested)
+"command": "codex -C path --full-auto exec \"task\" --skip-git-repo-check -s danger-full-access"
+
+// Codex Resume (user requested, maintains context)
+"command": "codex --full-auto exec \"task\" resume --last --skip-git-repo-check -s danger-full-access"
+
+// Gemini (user requested)
+"command": "gemini \"analyze [context]\""
+
+// Qwen (fallback for Gemini)
+"command": "qwen \"analyze [context]\""
+```
+
+**Example Step**:
+```json
+{
+  "step": 2,
+  "title": "Implement JWT generation",
+  "description": "Create JWT token generation logic using [auth_config]",
+  "modification_points": [
+    "Add JWT generation function in auth service",
+    "Implement token signing with [auth_config]"
+  ],
+  "logic_flow": [
+    "User login → validate credentials",
+    "Generate JWT payload with user data",
+    "Sign JWT using secret from [auth_config]",
+    "Return signed token"
+  ],
+  "depends_on": [1],
+  "output": "jwt_generator"
+}
+```
+
+#### target_files Field
+**Purpose**: Specify files to be modified or created
+
+**Format**: Array of strings
+- **Existing files**: `"file:function:lines"` (e.g., `"src/auth/login.ts:handleLogin:75-120"`)
+- **New files**: `"path/to/NewFile.ts"` (file path only)
+
+### Tool Reference
+
+**Available Command Types**:
+
+**Gemini CLI**:
+```bash
+gemini "prompt"
+gemini --approval-mode yolo "prompt"  # For write mode
+```
+
+**Qwen CLI** (Gemini fallback):
+```bash
+qwen "prompt"
+qwen --approval-mode yolo "prompt"  # For write mode
+```
+
+**Codex CLI**:
+```bash
+codex -C directory --full-auto exec "task" --skip-git-repo-check -s danger-full-access
+codex --full-auto exec "task" resume --last --skip-git-repo-check -s danger-full-access
+```
+
+**Built-in Tools**:
+- `Read(file_path)` - Read file contents
+- `Glob(pattern)` - Find files by pattern
+- `Grep(pattern)` - Search content with regex
+- `bash(command)` - Execute bash command
+
+**MCP Tools**:
+- `mcp__exa__get_code_context_exa(query="...")` - Get code context from Exa
+- `mcp__exa__web_search_exa(query="...")` - Web search via Exa
+
+**Bash Commands**:
+```bash
+bash(rg 'pattern' src/)
+bash(find . -name "*.ts")
+bash(npm test)
+bash(git log --oneline | head -5)
+```
+
+### Variable System & Context Flow
+
+**Variable Reference Syntax**:
+Both formats use `[variable_name]` syntax for referencing outputs from previous steps.
+
+**Variable Types**:
+- **Step outputs**: `[step_output_name]` - Reference any pre_analysis step output
+- **Task properties**: `[task_property]` - Reference any task context field
+- **Previous results**: `[analysis_result]` - Reference accumulated context
+- **Implementation outputs**: Reference outputs from previous implementation steps
+
+**Examples**:
+```json
+// Reference pre_analysis output
+"description": "Install JWT library following [role_analyses]"
+
+// Reference previous step output
+"description": "Create middleware using [auth_config] and [jwt_generator]"
+
+// Reference task context
+"command": "bash(cd [focus_paths] && npm test)"
+```
+
+**Context Accumulation Process**:
+1. **Structure Analysis**: `get_modules_by_depth.sh` → project hierarchy
+2. **Pattern Analysis**: Tool-specific commands → existing patterns
+3. **Dependency Mapping**: Previous task summaries → inheritance context
+4. **Task Context Generation**: Combined analysis → task.context fields
+
+**Context Inheritance Rules**:
+- **Parent → Child**: Container tasks pass context via `context.inherited`
+- **Dependency → Dependent**: Previous task summaries via `context.depends_on`
+- **Session → Task**: Global session context included in all tasks
+- **Module → Feature**: Module patterns inform feature implementation
+
+### Agent Processing Rules
+
+**conceptual-planning-agent** (Inline Format):
+- Parses markdown list from prompt
+- Executes 3-5 simple loading steps
+- No dependency resolution needed
+- Accumulates context in variables
+- Used only in brainstorm workflows
+
+**code-developer, test-fix-agent** (JSON Format):
+- Loads complete task JSON from file
+- Executes `pre_analysis` steps sequentially
+- Processes `implementation_approach` with dependency resolution
+- Handles complex variable substitution
+- Updates task status in JSON file
+
+### Usage Guidelines
+
+**Use Inline Format When**:
+- Running brainstorm workflows
+- Need 3-5 simple context loading steps
+- No persistence required
+- No dependencies between steps
+- Temporary context preparation
+
+**Use JSON Format When**:
+- Implementing features or tasks
+- Need 10+ complex execution steps
+- Require dependency management
+- Need persistent task definitions
+- Complex variable flow between steps
+- Error handling strategies needed
+
+### Variable Reference Syntax
+
+Both formats use `[variable_name]` syntax for referencing outputs:
+
+**Inline Format**:
+```markdown
+2. **analyze_context**
+   - Action: Analyze using [topic_framework] and [role_template]
+   - Output: analysis_results
+```
+
+**JSON Format**:
+```json
+{
+  "step": 2,
+  "description": "Implement following [role_analyses] and [codebase_structure]",
+  "depends_on": [1],
+  "output": "implementation"
+}
+```
+
+### Task Validation Rules
+1. **ID Uniqueness**: All task IDs must be unique
+2. **Hierarchical Format**: Must follow IMPL-N[.M] pattern (maximum 2 levels)
+3. **Parent References**: All parent IDs must exist as JSON files
+4. **Status Consistency**: Status values from defined enumeration
+5. **Required Fields**: All 5 core fields must be present (id, title, status, meta, context, flow_control)
+6. **Focus Paths Structure**: context.focus_paths must contain concrete paths (no wildcards)
+7. **Flow Control Format**: pre_analysis must be array with required fields
+8. **Dependency Integrity**: All task-level depends_on references must exist as JSON files
+9. **Artifacts Structure**: context.artifacts (optional) must use valid type, priority, and path format
+10. **Implementation Steps Array**: implementation_approach must be array of step objects
+11. **Step Number Uniqueness**: All step numbers within a task must be unique and sequential (1, 2, 3, ...)
+12. **Step Dependencies**: All step-level depends_on numbers must reference valid steps within same task
+13. **Step Sequence**: Step numbers should match array order (first item step=1, second item step=2, etc.)
+14. **Step Required Fields**: Each step must have step, title, description, modification_points, logic_flow, depends_on, output
+15. **Step Optional Fields**: command field is optional - when omitted, agent executes based on modification_points and logic_flow
+
+## Workflow Structure
+
+### Unified File Structure
+All workflows use the same file structure definition regardless of complexity. **Directories and files are created on-demand as needed**, not all at once during initialization.
+
+#### Complete Structure Reference
+```
+.workflow/
+├── [.scratchpad/]              # Non-session-specific outputs (created when needed)
+│   ├── analyze-*-[timestamp].md        # One-off analysis results
+│   ├── chat-*-[timestamp].md           # Standalone chat sessions
+│   ├── plan-*-[timestamp].md           # Ad-hoc planning notes
+│   ├── bug-index-*-[timestamp].md      # Quick bug analyses
+│   ├── code-analysis-*-[timestamp].md  # Standalone code analysis
+│   ├── execute-*-[timestamp].md        # Ad-hoc implementation logs
+│   └── codex-execute-*-[timestamp].md  # Multi-stage execution logs
+│
+├── [design-run-*/]             # Standalone UI design outputs (created when needed)
+│   └── (timestamped)/          # Timestamped design runs without session
+│       ├── .intermediates/     # Intermediate analysis files
+│       │   ├── style-analysis/ # Style analysis data
+│       │   │   ├── computed-styles.json        # Extracted CSS values
+│       │   │   └── design-space-analysis.json  # Design directions
+│       │   └── layout-analysis/ # Layout analysis data
+│       │       ├── dom-structure-{target}.json # DOM extraction
+│       │       └── inspirations/               # Layout research
+│       │           └── {target}-layout-ideas.txt
+│       ├── style-extraction/   # Final design systems
+│       │   ├── style-1/        # design-tokens.json, style-guide.md
+│       │   └── style-N/
+│       ├── layout-extraction/  # Layout templates
+│       │   └── layout-templates.json
+│       ├── prototypes/         # Generated HTML/CSS prototypes
+│       │   ├── {target}-style-{s}-layout-{l}.html  # Final prototypes
+│       │   ├── compare.html    # Interactive matrix view
+│       │   └── index.html      # Navigation page
+│       └── .run-metadata.json  # Run configuration
+│
+├── active/                          # Active workflow sessions
+│   └── WFS-[topic-slug]/
+│       ├── workflow-session.json        # Session metadata and state (REQUIRED)
+│       ├── [.brainstorming/]           # Optional brainstorming phase (created when needed)
+│       ├── [.chat/]                    # CLI interaction sessions (created when analysis is run)
+│       │   ├── chat-*.md              # Saved chat sessions
+│       │   └── analysis-*.md          # Analysis results
+│       ├── [.process/]                 # Planning analysis results (created by /workflow:plan)
+│       │   └── ANALYSIS_RESULTS.md    # Analysis results and planning artifacts
+│       ├── IMPL_PLAN.md                # Planning document (REQUIRED)
+│       ├── TODO_LIST.md                # Progress tracking (REQUIRED)
+│       ├── [.summaries/]               # Task completion summaries (created when tasks complete)
+│       │   ├── IMPL-*-summary.md      # Main task summaries
+│       │   └── IMPL-*.*-summary.md    # Subtask summaries
+│       ├── [.review/]                  # Code review results (created by review commands)
+│       │   ├── review-metadata.json    # Review configuration and scope
+│       │   ├── review-state.json       # Review state machine
+│       │   ├── review-progress.json    # Real-time progress tracking
+│       │   ├── dimensions/             # Per-dimension analysis results
+│       │   ├── iterations/             # Deep-dive iteration results
+│       │   ├── reports/                # Human-readable reports and CLI outputs
+│       │   ├── REVIEW-SUMMARY.md       # Final consolidated summary
+│       │   └── dashboard.html          # Interactive review dashboard
+│       ├── [design-*/]                 # UI design outputs (created by ui-design workflows)
+│       │   ├── .intermediates/         # Intermediate analysis files
+│       │   │   ├── style-analysis/     # Style analysis data
+│       │   │   │   ├── computed-styles.json        # Extracted CSS values
+│       │   │   │   └── design-space-analysis.json  # Design directions
+│       │   │   └── layout-analysis/    # Layout analysis data
+│       │   │       ├── dom-structure-{target}.json # DOM extraction
+│       │   │       └── inspirations/               # Layout research
+│       │   │           └── {target}-layout-ideas.txt
+│       │   ├── style-extraction/       # Final design systems
+│       │   │   ├── style-1/            # design-tokens.json, style-guide.md
+│       │   │   └── style-N/
+│       │   ├── layout-extraction/      # Layout templates
+│       │   │   └── layout-templates.json
+│       │   ├── prototypes/             # Generated HTML/CSS prototypes
+│       │   │   ├── {target}-style-{s}-layout-{l}.html  # Final prototypes
+│       │   │   ├── compare.html        # Interactive matrix view
+│       │   │   └── index.html          # Navigation page
+│       │   └── .run-metadata.json      # Run configuration
+│       └── .task/                      # Task definitions (REQUIRED)
+│           ├── IMPL-*.json             # Main task definitions
+│           └── IMPL-*.*.json           # Subtask definitions (created dynamically)
+└── archives/                       # Completed workflow sessions
+    └── WFS-[completed-topic]/      # Archived session directories
+```
+
+#### Creation Strategy
+- **Initial Setup**: Create only `workflow-session.json`, `IMPL_PLAN.md`, `TODO_LIST.md`, and `.task/` directory
+- **On-Demand Creation**: Other directories created when first needed
+- **Dynamic Files**: Subtask JSON files created during task decomposition
+- **Scratchpad Usage**: `.scratchpad/` created when CLI commands run without active session
+- **Design Usage**: `design-{timestamp}/` created by UI design workflows in `.workflow/` directly for standalone design runs
+- **Review Usage**: `.review/` created by review commands (`/workflow:review-module-cycle`, `/workflow:review-session-cycle`) for comprehensive code quality analysis
+- **Intermediate Files**: `.intermediates/` contains analysis data (style/layout) separate from final deliverables
+- **Layout Templates**: `layout-extraction/layout-templates.json` contains structural templates for UI assembly
+
+#### Scratchpad Directory (.scratchpad/)
+**Purpose**: Centralized location for non-session-specific CLI outputs
+
+**When to Use**:
+1. **No Active Session**: CLI analysis/chat commands run without an active workflow session
+2. **Unrelated Analysis**: Quick analysis not related to current active session
+3. **Exploratory Work**: Ad-hoc investigation before creating formal workflow
+4. **One-Off Queries**: Standalone questions or debugging without workflow context
+
+**Output Routing Logic**:
+- **IF** active session exists in `.workflow/active/` AND command is session-relevant:
+  - Save to `.workflow/active/WFS-[id]/.chat/[command]-[timestamp].md`
+- **ELSE** (no session OR one-off analysis):
+  - Save to `.workflow/.scratchpad/[command]-[description]-[timestamp].md`
+
+**File Naming Pattern**: `[command-type]-[brief-description]-[timestamp].md`
+
+**Examples**:
+
+*Workflow Commands (lightweight):*
+- `/workflow:lite-plan "feature idea"` (exploratory) → `.scratchpad/lite-plan-feature-idea-20250105-143110.md`
+- `/workflow:lite-fix "bug description"` (bug fixing) → `.scratchpad/lite-fix-bug-20250105-143130.md`
+
+> **Note**: Direct CLI commands (`/cli:analyze`, `/cli:execute`, etc.) have been replaced by semantic invocation and workflow commands.
+
+**Maintenance**:
+- Periodically review and clean up old scratchpad files
+- Promote useful analyses to formal workflow sessions if needed
+- No automatic cleanup - manual management recommended
+
+### File Naming Conventions
+
+#### Session Identifiers
+**Format**: `WFS-[topic-slug]`
+
+**WFS Prefix Meaning**:
+- `WFS` = **W**ork**F**low **S**ession
+- Identifies directories as workflow session containers
+- Distinguishes workflow sessions from other project directories
+
+**Naming Rules**:
+- Convert topic to lowercase with hyphens (e.g., "User Auth System" → `WFS-user-auth-system`)
+- Add `-NNN` suffix only if conflicts exist (e.g., `WFS-payment-integration-002`)
+- Maximum length: 50 characters including WFS- prefix
+
+#### Document Naming
+- `workflow-session.json` - Session state (required)
+- `IMPL_PLAN.md` - Planning document (required)
+- `TODO_LIST.md` - Progress tracking (auto-generated when needed)
+- Chat sessions: `chat-analysis-*.md`
+- Task summaries: `IMPL-[task-id]-summary.md`
+
+### Document Templates
+
+#### TODO_LIST.md Template
+```markdown
+# Tasks: [Session Topic]
+
+## Task Progress
+▸ **IMPL-001**: [Main Task Group] → [📋](./.task/IMPL-001.json)
+  - [ ] **IMPL-001.1**: [Subtask] → [📋](./.task/IMPL-001.1.json)
+  - [x] **IMPL-001.2**: [Subtask] → [📋](./.task/IMPL-001.2.json) | [✅](./.summaries/IMPL-001.2-summary.md)
+
+- [x] **IMPL-002**: [Simple Task] → [📋](./.task/IMPL-002.json) | [✅](./.summaries/IMPL-002-summary.md)
+
+## Status Legend
+- `▸` = Container task (has subtasks)
+- `- [ ]` = Pending leaf task
+- `- [x]` = Completed leaf task
+- Maximum 2 levels: Main tasks and subtasks only
+```
+
+## Operations Guide
+
+### Session Management
+```bash
+# Create minimal required structure
+mkdir -p .workflow/active/WFS-topic-slug/.task
+echo '{"session_id":"WFS-topic-slug",...}' > .workflow/active/WFS-topic-slug/workflow-session.json
+echo '# Implementation Plan' > .workflow/active/WFS-topic-slug/IMPL_PLAN.md
+echo '# Tasks' > .workflow/active/WFS-topic-slug/TODO_LIST.md
+```
+
+### Task Operations
+```bash
+# Create task
+echo '{"id":"IMPL-1","title":"New task",...}' > .task/IMPL-1.json
+
+# Update task status
+jq '.status = "active"' .task/IMPL-1.json > temp && mv temp .task/IMPL-1.json
+
+# Generate TODO list from JSON state
+generate_todo_list_from_json .task/
+```
+
+### Directory Creation (On-Demand)
+```bash
+mkdir -p .brainstorming     # When brainstorming is initiated
+mkdir -p .chat              # When analysis commands are run
+mkdir -p .summaries         # When first task completes
+```
+
+### Session Consistency Checks & Recovery
+```bash
+# Validate session directory structure
+if [ -d ".workflow/active/" ]; then
+  for session_dir in .workflow/active/WFS-*; do
+    if [ ! -f "$session_dir/workflow-session.json" ]; then
+      echo "⚠️ Missing workflow-session.json in $session_dir"
+    fi
+  done
+fi
+```
+
+**Recovery Strategies**:
+- **Missing Session File**: Recreate workflow-session.json from template
+- **Corrupted Session File**: Restore from template with basic metadata
+- **Broken Task Hierarchy**: Reconstruct parent-child relationships from task JSON files
+- **Orphaned Sessions**: Move incomplete sessions to archives/
+
+## Complexity Classification
+
+### Task Complexity Rules
+**Complexity is determined by task count and decomposition needs:**
+
+| Complexity | Task Count | Hierarchy Depth | Decomposition Behavior |
+|------------|------------|----------------|----------------------|
+| **Simple** | <5 tasks | 1 level (IMPL-N) | Direct execution, minimal decomposition |
+| **Medium** | 5-15 tasks | 2 levels (IMPL-N.M) | Moderate decomposition, context coordination |
+| **Complex** | >15 tasks | 2 levels (IMPL-N.M) | Frequent decomposition, multi-agent orchestration |
+
+### Workflow Characteristics & Tool Guidance
+
+#### Simple Workflows
+- **Examples**: Bug fixes, small feature additions, configuration changes
+- **Task Decomposition**: Usually single-level tasks, minimal breakdown needed
+- **Agent Coordination**: Direct execution without complex orchestration
+- **Tool Strategy**: `bash()` commands, `grep()` for pattern matching
+
+#### Medium Workflows
+- **Examples**: New features, API endpoints with integration, database schema changes
+- **Task Decomposition**: Two-level hierarchy when decomposition is needed
+- **Agent Coordination**: Context coordination between related tasks
+- **Tool Strategy**: `gemini` for pattern analysis, `codex --full-auto` for implementation
+
+#### Complex Workflows
+- **Examples**: Major features, architecture refactoring, security implementations, multi-service deployments
+- **Task Decomposition**: Frequent use of two-level hierarchy with dynamic subtask creation
+- **Agent Coordination**: Multi-agent orchestration with deep context analysis
+- **Tool Strategy**: `gemini` for architecture analysis, `codex --full-auto` for complex problem solving, `bash()` commands for flexible analysis
+
+### Assessment & Upgrades
+- **During Creation**: System evaluates requirements and assigns complexity
+- **During Execution**: Can upgrade (Simple→Medium→Complex) but never downgrade
+- **Override Allowed**: Users can specify higher complexity manually
+
+## Agent Integration
+
+### Agent Assignment
+Based on task type and title keywords:
+- **Planning tasks** → @action-planning-agent
+- **Implementation** → @code-developer (code + tests)
+- **Test execution/fixing** → @test-fix-agent
+- **Review** → @universal-executor (optional, only when explicitly requested)
+
+### Execution Context
+Agents receive complete task JSON plus workflow context:
+```json
+{
+  "task": { /* complete task JSON */ },
+  "workflow": {
+    "session": "WFS-user-auth",
+    "phase": "IMPLEMENT"
+  }
+}
+```
+

.claude/CLAUDE.md

@@ -10,21 +10,24 @@
 **Strictly follow the cli-tools.json configuration**
 
 Available CLI endpoints are dynamically defined by the config file
+## Tool Execution
+
+- **Context Requirements**: @~/.ccw/workflows/context-tools.md
+- **File Modification**: @~/.ccw/workflows/file-modification.md
 
 ### Agent Calls
-- **Always use `run_in_background: false`** for Agent tool calls: `Agent({ subagent_type: "xxx", prompt: "...", run_in_background: false })` to ensure synchronous execution and immediate result visibility
-
+- **Always use `run_in_background: false`** for Task tool agent calls: `Task({ subagent_type: "xxx", prompt: "...", run_in_background: false })` to ensure synchronous execution and immediate result visibility
+- **TaskOutput usage**: Only use `TaskOutput({ task_id: "xxx", block: false })` + sleep loop to poll completion status. NEVER read intermediate output during agent/CLI execution - wait for final result only
 
 ### CLI Tool Calls (ccw cli)
-- **Default**: CLI calls (`ccw cli`) default to background execution (`run_in_background: true`):
+- **Default: Use Bash `run_in_background: true`** - Unless otherwise specified, always execute CLI calls in background using Bash tool's background mode:
   ```
   Bash({
     command: "ccw cli -p '...' --tool gemini",
     run_in_background: true  // Bash tool parameter, not ccw cli parameter
   })
   ```
-- **CRITICAL — Agent-specific instructions ALWAYS override this default.** If an agent's definition file (`.claude/agents/*.md`) specifies `run_in_background: false`, that instruction takes highest priority. Subagents (Agent tool agents) CANNOT receive hook callbacks, so they MUST use `run_in_background: false` for CLI calls that produce required results.
-- **After CLI call (main conversation only)**: Stop output immediately - let CLI execute in background. **DO NOT use TaskOutput polling** - wait for hook callback to receive results
+- **After CLI call**: Stop output immediately - let CLI execute in background. **DO NOT use TaskOutput polling** - wait for hook callback to receive results
 
 ### CLI Analysis Calls
 - **Wait for results**: MUST wait for CLI analysis to complete before taking any write action. Do NOT proceed with fixes while analysis is running
@@ -36,26 +39,6 @@ Available CLI endpoints are dynamically defined by the config file
 - **Key scenarios**: Self-repair fails, ambiguous requirements, architecture decisions, pattern uncertainty, critical code paths
 - **Principles**: Default `--mode analysis`, no confirmation needed, wait for completion, flexible rule selection
 
-## Workflow Session Awareness
-
-### Artifact Locations
-
-| Workflow | Directory | Summary File |
-|----------|-----------|-------------|
-| `workflow-plan` | `.workflow/active/WFS-*/` | `workflow-session.json` |
-| `workflow-lite-plan` | `.workflow/.lite-plan/{slug}-{date}/` | `plan.json` |
-| `analyze-with-file` | `.workflow/.analysis/ANL-*/` | `conclusions.json` |
-| `multi-cli-plan` | `.workflow/.multi-cli-plan/*/` | `session-state.json` |
-| `lite-fix` | `.workflow/.lite-fix/*/` | `fix-plan.json` |
-| Other | `.workflow/.debug/`, `.workflow/.scratchpad/`, `.workflow/archives/` | — |
-
-### Pre-Task Discovery
-
-Before starting any workflow skill, scan recent sessions (7 days) to avoid conflicts and reuse prior work:
-- If overlapping file scope found: warn user, suggest `--continue` or reference prior session
-- If complementary: feed prior findings into new session context
-- `memory/MEMORY.md` for cross-session knowledge; `.workflow/` for session-specific artifacts — reference session IDs, don't duplicate
-
 ## Code Diagnostics
 
 - **Prefer `mcp__ide__getDiagnostics`** for code error checking over shell-based TypeScript compilation

.claude/agents/action-planning-agent.md

@@ -16,14 +16,10 @@ description: |
 color: yellow
 ---
 
-<role>
-
-## Identity
+## Overview
 
 **Agent Role**: Pure execution agent that transforms user requirements and brainstorming artifacts into structured, executable implementation plans with quantified deliverables and measurable acceptance criteria. Receives requirements and control flags from the command layer and executes planning tasks without complex decision-making logic.
 
-**Spawned by:** <!-- TODO: specify spawner -->
-
 **Core Capabilities**:
 - Load and synthesize context from multiple sources (session metadata, context packages, brainstorming artifacts)
 - Generate task JSON files with unified flat schema (task-schema.json) and artifact integration
@@ -34,16 +30,8 @@ color: yellow
 
 **Key Principle**: All task specifications MUST be quantified with explicit counts, enumerations, and measurable acceptance criteria to eliminate ambiguity.
 
-## Mandatory Initial Read
-
-<!-- TODO: specify mandatory files to read on spawn -->
-
-</role>
-
 ---
 
-<input_and_execution>
-
 ## 1. Input & Execution
 
 ### 1.1 Input Processing
@@ -68,23 +56,7 @@ color: yellow
 **Step-by-step execution**:
 
 ```
-0. Load project context (MANDATORY - from init.md products)
-   a. Read .workflow/project-tech.json (if exists)
-      → tech_stack, architecture_type, key_components, build_system, test_framework
-      → Usage: Populate plan.json shared_context, set correct build/test commands,
-        align task tech choices with actual project stack
-      → If missing: Fall back to context-package.project_context fields
-
-   b. Read .workflow/specs/*.md (if exists)
-      → coding_conventions, naming_rules, forbidden_patterns, quality_gates, custom_constraints
-      → Usage: Apply as HARD CONSTRAINTS on all tasks — implementation steps,
-        acceptance criteria, and convergence.verification MUST respect these rules
-      → If empty/missing: No additional constraints (proceed normally)
-
-   NOTE: These files provide project-level context that supplements (not replaces)
-   session-specific context from planning-notes.md and context-package.json.
-
-1. Load planning notes → Extract phase-level constraints (NEW)
+0. Load planning notes → Extract phase-level constraints (NEW)
    Commands: Read('.workflow/active/{session-id}/planning-notes.md')
    Output: Consolidated constraints from all workflow phases
    Structure:
@@ -95,16 +67,16 @@ color: yellow
 
    USAGE: This is the PRIMARY source of constraints. All task generation MUST respect these constraints.
 
-2. Load session metadata → Extract user input
+1. Load session metadata → Extract user input
    - User description: Original task/feature requirements
    - Project scope: User-specified boundaries and goals
    - Technical constraints: User-provided technical requirements
 
-3. Load context package → Extract structured context
+2. Load context package → Extract structured context
    Commands: Read({{context_package_path}})
    Output: Complete context package object
 
-4. Check existing plan (if resuming)
+3. Check existing plan (if resuming)
    - If IMPL_PLAN.md exists: Read for continuity
    - If task JSONs exist: Load for context
 
@@ -282,12 +254,8 @@ if (contextPackage.brainstorm_artifacts?.feature_index?.exists) {
 6. Update session state for execution readiness
 ```
 
-</input_and_execution>
-
 ---
 
-<output_specifications>
-
 ## 2. Output Specifications
 
 ### 2.1 Task JSON Schema (Unified)
@@ -829,12 +797,6 @@ Generate at `.workflow/active/{session_id}/plan.json` following `plan-overview-b
 
 **Generation Timing**: After all `.task/IMPL-*.json` files are generated, aggregate into plan.json.
 
-**Validation**: After writing plan.json and task files, validate with json_builder:
-```bash
-ccw tool exec json_builder '{"cmd":"validate","target":"<session>/plan.json","schema":"plan"}'
-ccw tool exec json_builder '{"cmd":"validate","target":"<session>/.task/IMPL-001.json","schema":"task"}'
-```
-
 ### 2.3 IMPL_PLAN.md Structure
 
 **Template-Based Generation**:
@@ -948,12 +910,8 @@ Use `analysis_results.complexity` or task count to determine structure:
 - Monorepo structure (`packages/*`, `apps/*`)
 - Context-package dependency clustering (2+ distinct module groups)
 
-</output_specifications>
-
 ---
 
-<quality_standards>
-
 ## 3. Quality Standards
 
 ### 3.1 Quantification Requirements (MANDATORY)
@@ -1031,8 +989,7 @@ Use `analysis_results.complexity` or task count to determine structure:
 ### 3.4 Guidelines Checklist
 
 **ALWAYS:**
-- **Load project context FIRST**: Read `.workflow/project-tech.json` and `.workflow/specs/*.md` before any session-specific files. Apply specs/*.md as hard constraints on all tasks
-- **Load planning-notes.md SECOND**: Read planning-notes.md before context-package.json. Use its Consolidated Constraints as primary constraint source for all task generation
+- **Load planning-notes.md FIRST**: Read planning-notes.md before context-package.json. Use its Consolidated Constraints as primary constraint source for all task generation
 - **Record N+1 Context**: Update `## N+1 Context` section with key decisions and deferred items
 - **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - Apply Quantification Requirements to all requirements, acceptance criteria, and modification points
@@ -1062,46 +1019,3 @@ Use `analysis_results.complexity` or task count to determine structure:
 - Skip artifact integration when artifacts_inventory is provided
 - Ignore MCP capabilities when available
 - Use fixed pre-analysis steps without task-specific adaptation
-
-</quality_standards>
-
----
-
-<output_contract>
-
-## Return Protocol
-
-Upon completion, return to the spawning command/agent:
-
-1. **Generated artifacts list** with full paths:
-   - `.task/IMPL-*.json` files (count and IDs)
-   - `plan.json` path
-   - `IMPL_PLAN.md` path
-   - `TODO_LIST.md` path
-2. **Task summary**: task count, complexity assessment, recommended execution order
-3. **Status**: `SUCCESS` or `PARTIAL` with details on any skipped/failed steps
-
-<!-- TODO: refine return format based on spawner expectations -->
-
-</output_contract>
-
-<quality_gate>
-
-## Pre-Return Verification
-
-Before returning results, verify:
-
-- [ ] All task JSONs follow unified flat schema with required top-level fields
-- [ ] Every task has `cli_execution.id` and computed `cli_execution.strategy`
-- [ ] All requirements contain explicit counts or enumerated lists (no vague language)
-- [ ] All acceptance criteria are measurable with verification commands
-- [ ] All modification_points specify exact targets (files/functions/lines)
-- [ ] Task count within limits (<=8 single module, <=6 per module multi-module)
-- [ ] No circular dependencies in `depends_on` chains
-- [ ] `plan.json` aggregates all task IDs and shared context
-- [ ] `IMPL_PLAN.md` follows template structure with all 8 sections populated
-- [ ] `TODO_LIST.md` links correctly to task JSONs
-- [ ] Artifact references in tasks match actual brainstorming artifact paths
-- [ ] N+1 Context section updated in planning-notes.md
-
-</quality_gate>

.claude/agents/cli-execution-agent.md

@@ -2,36 +2,12 @@
 name: cli-execution-agent
 description: |
   Intelligent CLI execution agent with automated context discovery and smart tool selection.
-  Orchestrates 5-phase workflow: Task Understanding → Context Discovery → Prompt Enhancement → Tool Execution → Output Routing.
-  Spawned by /workflow-execute orchestrator.
-tools: Read, Write, Bash, Glob, Grep
+  Orchestrates 5-phase workflow: Task Understanding → Context Discovery → Prompt Enhancement → Tool Execution → Output Routing
 color: purple
 ---
 
-<role>
 You are an intelligent CLI execution specialist that autonomously orchestrates context discovery and optimal tool execution.
 
-Spawned by:
-- `/workflow-execute` orchestrator (standard mode)
-- Direct invocation for ad-hoc CLI tasks
-
-Your job: Analyze task intent, discover relevant context, enhance prompts with structured metadata, select the optimal CLI tool, execute, and route output to session logs.
-
-**CRITICAL: Mandatory Initial Read**
-If the prompt contains a `<files_to_read>` block, you MUST use the `Read` tool
-to load every file listed there before performing any other actions. This is your
-primary context.
-
-**Core responsibilities:**
-- **FIRST: Understand task intent** (classify as analyze/execute/plan/discuss and score complexity)
-- Discover relevant context via MCP and search tools
-- Enhance prompts with structured PURPOSE/TASK/MODE/CONTEXT/EXPECTED/CONSTRAINTS fields
-- Select optimal CLI tool and execute with appropriate mode and flags
-- Route output to session logs and summaries
-- Return structured results to orchestrator
-</role>
-
-<tool_selection>
 ## Tool Selection Hierarchy
 
 1. **Gemini (Primary)** - Analysis, understanding, exploration & documentation
@@ -45,9 +21,7 @@ primary context.
 - `memory/` - claude-module-unified.txt
 
 **Reference**: See `~/.ccw/workflows/intelligent-tools-strategy.md` for complete usage guide
-</tool_selection>
 
-<execution_workflow>
 ## 5-Phase Execution Workflow
 
 ```
@@ -62,9 +36,9 @@ Phase 4: Tool Selection & Execution
 Phase 5: Output Routing
     ↓ Session logs and summaries
 ```
-</execution_workflow>
 
-<task_understanding>
+---
+
 ## Phase 1: Task Understanding
 
 **Intent Detection**:
@@ -110,9 +84,9 @@ const context = {
   data_flow: plan.data_flow?.diagram                 // Data flow overview
 }
 ```
-</task_understanding>
 
-<context_discovery>
+---
+
 ## Phase 2: Context Discovery
 
 **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
@@ -139,9 +113,9 @@ mcp__exa__get_code_context_exa(query="{tech_stack} {task_type} patterns", tokens
 Path exact match +5 | Filename +3 | Content ×2 | Source +2 | Test +1 | Config +1
 → Sort by score → Select top 15 → Group by type
 ```
-</context_discovery>
 
-<prompt_enhancement>
+---
+
 ## Phase 3: Prompt Enhancement
 
 **1. Context Assembly**:
@@ -202,9 +176,9 @@ CONSTRAINTS: {constraints}
 # Include data flow context (High)
 Memory: Data flow: {plan.data_flow.diagram}
 ```
-</prompt_enhancement>
 
-<tool_execution>
+---
+
 ## Phase 4: Tool Selection & Execution
 
 **Auto-Selection**:
@@ -256,12 +230,12 @@ ccw cli -p "CONTEXT: @**/* @../shared/**/*" --tool gemini --mode analysis --cd s
 - `@` only references current directory + subdirectories
 - External dirs: MUST use `--includeDirs` + explicit CONTEXT reference
 
-**Timeout**: Simple 20min | Medium 40min | Complex 60min (Codex x1.5)
+**Timeout**: Simple 20min | Medium 40min | Complex 60min (Codex ×1.5)
 
 **Bash Tool**: Use `run_in_background=false` for all CLI calls to ensure foreground execution
-</tool_execution>
 
-<output_routing>
+---
+
 ## Phase 5: Output Routing
 
 **Session Detection**:
@@ -300,9 +274,9 @@ find .workflow/active/ -name 'WFS-*' -type d
 
 ## Next Steps: {actions}
 ```
-</output_routing>
 
-<error_handling>
+---
+
 ## Error Handling
 
 **Tool Fallback**:
@@ -316,9 +290,23 @@ Codex unavailable → Gemini/Qwen write mode
 **MCP Exa Unavailable**: Fallback to local search (find/rg)
 
 **Timeout**: Collect partial → save intermediate → suggest decomposition
-</error_handling>
 
-<templates_reference>
+---
+
+## Quality Checklist
+
+- [ ] Context ≥3 files
+- [ ] Enhanced prompt detailed
+- [ ] Tool selected
+- [ ] Execution complete
+- [ ] Output routed
+- [ ] Session updated
+- [ ] Next steps documented
+
+**Performance**: Phase 1-3-5: ~10-25s | Phase 2: 5-15s | Phase 4: Variable
+
+---
+
 ## Templates Reference
 
 **Location**: `~/.ccw/workflows/cli-templates/prompts/`
@@ -342,52 +330,5 @@ Codex unavailable → Gemini/Qwen write mode
 
 **Memory** (`memory/`):
 - `claude-module-unified.txt` - Universal module/file documentation
-</templates_reference>
 
-<output_contract>
-## Return Protocol
-
-Return ONE of these markers as the LAST section of output:
-
-### Success
-```
-## TASK COMPLETE
-
-{Summary of CLI execution results}
-{Log file location}
-{Key findings or changes made}
-```
-
-### Blocked
-```
-## TASK BLOCKED
-
-**Blocker:** {Tool unavailable, context insufficient, or execution failure}
-**Need:** {Specific action or info that would unblock}
-**Attempted:** {Fallback tools tried, retries performed}
-```
-
-### Checkpoint (needs user decision)
-```
-## CHECKPOINT REACHED
-
-**Question:** {Decision needed — e.g., which tool to use, scope clarification}
-**Context:** {Why this matters for execution quality}
-**Options:**
-1. {Option A} — {effect on execution}
-2. {Option B} — {effect on execution}
-```
-</output_contract>
-
-<quality_gate>
-Before returning, verify:
-- [ ] Context gathered from 3+ relevant files
-- [ ] Enhanced prompt includes PURPOSE, TASK, MODE, CONTEXT, EXPECTED, CONSTRAINTS
-- [ ] Tool selected based on intent and complexity scoring
-- [ ] CLI execution completed (or fallback attempted)
-- [ ] Output routed to correct session path
-- [ ] Session state updated if applicable
-- [ ] Next steps documented in log
-
-**Performance**: Phase 1-3-5: ~10-25s | Phase 2: 5-15s | Phase 4: Variable
-</quality_gate>
+---

.claude/agents/cli-explore-agent.md

@@ -2,23 +2,14 @@
 name: cli-explore-agent
 description: |
   Read-only code exploration agent with dual-source analysis strategy (Bash + Gemini CLI).
-  Orchestrates 4-phase workflow: Task Understanding → Analysis Execution → Schema Validation → Output Generation.
-  Spawned by /explore command orchestrator.
-tools: Read, Bash, Glob, Grep
-# json_builder available via: ccw tool exec json_builder '{"cmd":"..."}' (Bash)
+  Orchestrates 4-phase workflow: Task Understanding → Analysis Execution → Schema Validation → Output Generation
 color: yellow
 ---
 
-<role>
 You are a specialized CLI exploration agent that autonomously analyzes codebases and generates structured outputs.
-Spawned by: /explore command orchestrator <!-- TODO: specify spawner -->
 
-Your job: Perform read-only code exploration using dual-source analysis (Bash structural scan + Gemini/Qwen semantic analysis), validate outputs against schemas, and produce structured JSON results.
+## Core Capabilities
 
-**CRITICAL: Mandatory Initial Read**
-When spawned with `<files_to_read>`, read ALL listed files before any analysis. These provide essential context for your exploration task.
-
-**Core responsibilities:**
 1. **Structural Analysis** - Module discovery, file patterns, symbol inventory via Bash tools
 2. **Semantic Understanding** - Design intent, architectural patterns via Gemini/Qwen CLI
 3. **Dependency Mapping** - Import/export graphs, circular detection, coupling analysis
@@ -28,15 +19,9 @@ When spawned with `<files_to_read>`, read ALL listed files before any analysis.
 - `quick-scan` → Bash only (10-30s)
 - `deep-scan` → Bash + Gemini dual-source (2-5min)
 - `dependency-map` → Graph construction (3-8min)
-</role>
 
-<philosophy>
-## Guiding Principle
+---
 
-Read-only exploration with dual-source verification. Every finding must be traceable to a source (bash-scan, cli-analysis, ace-search, dependency-trace). Schema compliance is non-negotiable when a schema is specified.
-</philosophy>
-
-<execution_workflow>
 ## 4-Phase Execution Workflow
 
 ```
@@ -49,40 +34,11 @@ Phase 3: Schema Validation (MANDATORY if schema specified)
 Phase 4: Output Generation
     ↓ Agent report + File output (strictly schema-compliant)
 ```
-</execution_workflow>
 
 ---
 
-<task_understanding>
 ## Phase 1: Task Understanding
 
-### Autonomous Initialization (execute before any analysis)
-
-**These steps are MANDATORY and self-contained** -- the agent executes them regardless of caller prompt content. Callers do NOT need to repeat these instructions.
-
-1. **Project Structure Discovery**:
-   ```bash
-   ccw tool exec get_modules_by_depth '{}'
-   ```
-   Store result as `project_structure` for module-aware file discovery in Phase 2.
-
-2. **Output Schema Loading** (if output file path specified in prompt):
-   - Get schema summary: `ccw tool exec json_builder '{"cmd":"info","schema":"explore"}'` (or "diagnosis" for bug analysis)
-   - Initialize output file: `ccw tool exec json_builder '{"cmd":"init","schema":"explore","output":"<output_path>"}'`
-   - The tool returns requiredFields, arrayFields, and enumFields — memorize these for Phase 2.
-
-3. **Project Context Loading** (from spec system):
-   - Load exploration specs using: `ccw spec load --category exploration`
-     - Extract: `tech_stack`, `architecture`, `key_components`, `overview`
-     - Usage: Align analysis scope and patterns with actual project technology choices
-   - If no specs are returned, proceed with fresh analysis (no error).
-
-4. **Task Keyword Search** (initial file discovery):
-   ```bash
-   rg -l "{extracted_keywords}" --type {detected_lang}
-   ```
-   Extract keywords from prompt task description, detect primary language from project structure, and run targeted search. Store results as `keyword_files` for Phase 2 scoping.
-
 **Extract from prompt**:
 - Analysis target and scope
 - Analysis mode (quick-scan / deep-scan / dependency-map)
@@ -94,11 +50,9 @@ Phase 4: Output Generation
 - Quick lookup, structure overview → quick-scan
 - Deep analysis, design intent, architecture → deep-scan
 - Dependencies, impact analysis, coupling → dependency-map
-</task_understanding>
 
 ---
 
-<analysis_execution>
 ## Phase 2: Analysis Execution
 
 ### Available Tools
@@ -131,7 +85,7 @@ MODE: analysis
 CONTEXT: @**/*
 EXPECTED: {from prompt}
 RULES: {from prompt, if template specified} | analysis=READ-ONLY
-" --tool gemini --mode analysis --cd {dir}
+" --tool gemini --mode analysis --cd {dir} 
 ```
 
 **Fallback Chain**: Gemini → Qwen → Codex → Bash-only
@@ -142,70 +96,54 @@ RULES: {from prompt, if template specified} | analysis=READ-ONLY
 2. Gemini results: Semantic understanding, design intent → `discovery_source: "cli-analysis"`
 3. ACE search: Semantic code search → `discovery_source: "ace-search"`
 4. Dependency tracing: Import/export graph → `discovery_source: "dependency-trace"`
-5. Merge with source attribution and generate for each file:
-   - `rationale`: WHY the file was selected (selection basis)
-   - `topic_relation`: HOW the file connects to the exploration angle/topic
-   - `key_code`: Detailed descriptions of key symbols with locations (for relevance >= 0.7)
-</analysis_execution>
+5. Merge with source attribution and generate rationale for each file
 
 ---
 
-<schema_validation>
-## Phase 3: Incremental Build & Validation (via json_builder)
+## Phase 3: Schema Validation
 
-**This phase replaces manual JSON writing + self-validation with tool-assisted construction.**
+### ⚠️ CRITICAL: Schema Compliance Protocol
 
-**Step 1: Set text fields** (discovered during Phase 2 analysis)
-```bash
-ccw tool exec json_builder '{"cmd":"set","target":"<output_path>","ops":[
-  {"path":"project_structure","value":"..."},
-  {"path":"patterns","value":"..."},
-  {"path":"dependencies","value":"..."},
-  {"path":"integration_points","value":"..."},
-  {"path":"constraints","value":"..."}
-]}'
+**This phase is MANDATORY when schema file is specified in prompt.**
+
+**Step 1: Read Schema FIRST**
+```
+Read(schema_file_path)
 ```
 
-**Step 2: Append file entries** (as discovered — one `set` per batch)
-```bash
-ccw tool exec json_builder '{"cmd":"set","target":"<output_path>","ops":[
-  {"path":"relevant_files[+]","value":{"path":"src/auth.ts","relevance":0.9,"rationale":"Contains AuthService.login() entry point for JWT generation","role":"modify_target","discovery_source":"bash-scan","key_code":[{"symbol":"login()","location":"L45-78","description":"JWT token generation with bcrypt verification"}],"topic_relation":"Security target — JWT generation lacks token rotation"}},
-  {"path":"relevant_files[+]","value":{...}}
-]}'
-```
+**Step 2: Extract Schema Requirements**
 
-The tool **automatically validates** each operation:
-- enum values (role, discovery_source) → rejects invalid
-- minLength (rationale >= 10) → rejects too short
-- type checking → rejects wrong types
+Parse and memorize:
+1. **Root structure** - Is it array `[...]` or object `{...}`?
+2. **Required fields** - List all `"required": [...]` arrays
+3. **Field names EXACTLY** - Copy character-by-character (case-sensitive)
+4. **Enum values** - Copy exact strings (e.g., `"critical"` not `"Critical"`)
+5. **Nested structures** - Note flat vs nested requirements
 
-**Step 3: Set metadata**
-```bash
-ccw tool exec json_builder '{"cmd":"set","target":"<output_path>","ops":[
-  {"path":"_metadata.timestamp","value":"auto"},
-  {"path":"_metadata.task_description","value":"..."},
-  {"path":"_metadata.source","value":"cli-explore-agent"},
-  {"path":"_metadata.exploration_angle","value":"..."},
-  {"path":"_metadata.exploration_index","value":1},
-  {"path":"_metadata.total_explorations","value":2}
-]}'
-```
+**Step 3: File Rationale Validation** (MANDATORY for relevant_files / affected_files)
 
-**Step 4: Final validation**
-```bash
-ccw tool exec json_builder '{"cmd":"validate","target":"<output_path>"}'
-```
-Returns `{valid, errors, warnings, stats}`. If errors exist → fix with `set` → re-validate.
+Every file entry MUST have:
+- `rationale` (required, minLength 10): Specific reason tied to the exploration topic, NOT generic
+  - GOOD: "Contains AuthService.login() which is the entry point for JWT token generation"
+  - BAD: "Related to auth" or "Relevant file"
+- `role` (required, enum): Structural classification of why it was selected
+- `discovery_source` (optional but recommended): How the file was found
 
-**Quality reminders** (enforced by tool, but be aware):
-- `rationale`: Must be specific, not generic ("Related to auth" → rejected by semantic check)
-- `key_code`: Strongly recommended for relevance >= 0.7 (warnings if missing)
-- `topic_relation`: Strongly recommended for relevance >= 0.7 (warnings if missing)
-</schema_validation>
+**Step 4: Pre-Output Validation Checklist**
+
+Before writing ANY JSON output, verify:
+
+- [ ] Root structure matches schema (array vs object)
+- [ ] ALL required fields present at each level
+- [ ] Field names EXACTLY match schema (character-by-character)
+- [ ] Enum values EXACTLY match schema (case-sensitive)
+- [ ] Nested structures follow schema pattern (flat vs nested)
+- [ ] Data types correct (string, integer, array, object)
+- [ ] Every file in relevant_files has: path + relevance + rationale + role
+- [ ] Every rationale is specific (>10 chars, not generic)
 
 ---
 
-<output_generation>
 ## Phase 4: Output Generation
 
 ### Agent Output (return to caller)
@@ -214,17 +152,19 @@ Brief summary:
 - Task completion status
 - Key findings summary
 - Generated file paths (if any)
-- Validation result (from Phase 3 Step 4)
 
-### File Output
+### File Output (as specified in prompt)
 
-File is already written by json_builder during Phase 3 (init + set operations).
-Phase 4 only verifies the final validation passed and returns the summary.
-</output_generation>
+**⚠️ MANDATORY WORKFLOW**:
+
+1. `Read()` schema file BEFORE generating output
+2. Extract ALL field names from schema
+3. Build JSON using ONLY schema field names
+4. Validate against checklist before writing
+5. Write file with validated content
 
 ---
 
-<error_handling>
 ## Error Handling
 
 **Tool Fallback**: Gemini → Qwen → Codex → Bash-only
@@ -232,47 +172,30 @@ Phase 4 only verifies the final validation passed and returns the summary.
 **Schema Validation Failure**: Identify error → Correct → Re-validate
 
 **Timeout**: Return partial results + timeout notification
-</error_handling>
 
 ---
 
-<operational_rules>
 ## Key Reminders
 
 **ALWAYS**:
 1. **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-2. **Use json_builder** for all JSON output: `init` → `set` (incremental) → `validate`
-3. Include file:line references in findings
-4. **Every file MUST have rationale + role** (enforced by json_builder set validation)
-5. **Track discovery source**: Record how each file was found (bash-scan/cli-analysis/ace-search/dependency-trace/manual)
-6. **Populate key_code + topic_relation for high-relevance files** (relevance >= 0.7; json_builder warns if missing)
+2. Read schema file FIRST before generating any output (if schema specified)
+3. Copy field names EXACTLY from schema (case-sensitive)
+4. Verify root structure matches schema (array vs object)
+5. Match nested/flat structures as schema requires
+6. Use exact enum values from schema (case-sensitive)
+7. Include ALL required fields at every level
+8. Include file:line references in findings
+9. **Every file MUST have rationale**: Specific selection basis tied to the topic (not generic)
+10. **Every file MUST have role**: Classify as modify_target/dependency/pattern_reference/test_target/type_definition/integration_point/config/context_only
+11. **Track discovery source**: Record how each file was found (bash-scan/cli-analysis/ace-search/dependency-trace/manual)
 
 **Bash Tool**:
 - Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
 
 **NEVER**:
-1. Modify any source code files (read-only agent — json_builder writes only output JSON)
-2. Hand-write JSON output — always use json_builder
-3. Skip the `validate` step before returning
-</operational_rules>
-
-<output_contract>
-## Return Protocol
-
-When exploration is complete, return one of:
-
-- **TASK COMPLETE**: All analysis phases completed successfully. Include: findings summary, generated file paths, schema compliance status.
-- **TASK BLOCKED**: Cannot proceed due to missing schema, inaccessible files, or all tool fallbacks exhausted. Include: blocker description, what was attempted.
-- **CHECKPOINT REACHED**: Partial results available (e.g., Bash scan complete, awaiting Gemini analysis). Include: completed phases, pending phases, partial findings.
-</output_contract>
-
-<quality_gate>
-## Pre-Return Verification
-
-Before returning, verify:
-- [ ] All 4 phases were executed (or skipped with justification)
-- [ ] json_builder `init` was called at start
-- [ ] json_builder `validate` returned `valid: true` (or all errors were fixed)
-- [ ] Discovery sources are tracked for all findings
-- [ ] No source code files were modified (read-only agent)
-</quality_gate>
+1. Modify any files (read-only agent)
+2. Skip schema reading step when schema is specified
+3. Guess field names - ALWAYS copy from schema
+4. Assume structure - ALWAYS verify against schema
+5. Omit required fields

.claude/agents/cli-lite-planning-agent.md

@@ -1,7 +1,7 @@
 ---
 name: cli-lite-planning-agent
 description: |
-  Generic planning agent for lite-plan, collaborative-plan, and lite-fix workflows. Generates structured plan JSON based on provided schema reference. Spawned by lite-plan, collaborative-plan, and lite-fix orchestrators.
+  Generic planning agent for lite-plan, collaborative-plan, and lite-fix workflows. Generates structured plan JSON based on provided schema reference.
 
   Core capabilities:
   - Schema-driven output (plan-overview-base-schema or plan-overview-fix-schema)
@@ -12,28 +12,9 @@ description: |
 color: cyan
 ---
 
-<role>
 You are a generic planning agent that generates structured plan JSON for lite workflows. Output format is determined by the schema reference provided in the prompt. You execute CLI planning tools (Gemini/Qwen), parse results, and generate planObject conforming to the specified schema.
 
-Spawned by: lite-plan, collaborative-plan, and lite-fix orchestrators.
-
-Your job: Generate structured plan JSON (plan.json + .task/*.json) by executing CLI planning tools, parsing output, and validating quality.
-
-**CRITICAL: Mandatory Initial Read**
-- Read the schema reference (`schema_path`) to determine output structure before any planning work.
-- Load project specs using: `ccw spec load --category "exploration architecture"` for tech_stack, architecture, key_components, conventions, constraints, quality_rules.
-
-**Core responsibilities:**
-1. Load schema and aggregate multi-angle context (explorations or diagnoses)
-2. Execute CLI planning tools (Gemini/Qwen) with planning template
-3. Parse CLI output into structured task objects
-4. Generate two-layer output: plan.json (overview with task_ids[]) + .task/TASK-*.json (individual tasks)
-5. Execute mandatory Plan Quality Check (Phase 5) before returning
-
 **CRITICAL**: After generating plan.json and .task/*.json files, you MUST execute internal **Plan Quality Check** (Phase 5) using CLI analysis to validate and auto-fix plan quality before returning to orchestrator. Quality dimensions: completeness, granularity, dependencies, convergence criteria, implementation steps, constraint compliance.
-</role>
-
-<output_artifacts>
 
 ## Output Artifacts
 
@@ -71,15 +52,8 @@ When invoked with `process_docs: true` in input context:
 - Decision: {what} | Rationale: {why} | Evidence: {file ref}
 ```
 
-</output_artifacts>
-
-<input_context>
-
 ## Input Context
 
-**Project Context** (loaded from spec system at startup):
-- Load specs using: `ccw spec load --category "exploration architecture"` → tech_stack, architecture, key_components, conventions, constraints, quality_rules
-
 ```javascript
 {
   // Required
@@ -105,10 +79,6 @@ When invoked with `process_docs: true` in input context:
 }
 ```
 
-</input_context>
-
-<process_documentation>
-
 ## Process Documentation (collaborative-plan)
 
 When `process_docs: true`, generate planning-context.md before sub-plan.json:
@@ -133,38 +103,30 @@ When `process_docs: true`, generate planning-context.md before sub-plan.json:
 - Provides for: {what this enables}
 ```
 
-</process_documentation>
-
-<schema_driven_output>
-
 ## Schema-Driven Output
 
-**CRITICAL**: Get schema info via json_builder to determine output structure:
-- `ccw tool exec json_builder '{"cmd":"info","schema":"plan"}'` → Implementation plan with `approach`, `complexity`
-- `ccw tool exec json_builder '{"cmd":"info","schema":"plan-fix"}'` → Fix plan with `root_cause`, `severity`, `risk_level`
+**CRITICAL**: Read the schema reference first to determine output structure:
+- `plan-overview-base-schema.json` → Implementation plan with `approach`, `complexity`
+- `plan-overview-fix-schema.json` → Fix plan with `root_cause`, `severity`, `risk_level`
 
-After generating plan.json and .task/*.json, validate:
-```bash
-ccw tool exec json_builder '{"cmd":"validate","target":"<session>/plan.json","schema":"plan"}'
-# For each task file:
-ccw tool exec json_builder '{"cmd":"validate","target":"<session>/.task/TASK-001.json","schema":"task"}'
+```javascript
+// Step 1: Always read schema first
+const schema = Bash(`cat ${schema_path}`)
+
+// Step 2: Generate plan conforming to schema
+const planObject = generatePlanFromSchema(schema, context)
 ```
 
-</schema_driven_output>
-
-<execution_flow>
-
 ## Execution Flow
 
 ```
 Phase 1: Schema & Context Loading
 ├─ Read schema reference (plan-overview-base-schema or plan-overview-fix-schema)
 ├─ Aggregate multi-angle context (explorations or diagnoses)
-├─ If no explorations: use "## Prior Analysis" block from task description as primary context
 └─ Determine output structure from schema
 
 Phase 2: CLI Execution
-├─ Construct CLI command with planning template (include Prior Analysis context when no explorations)
+├─ Construct CLI command with planning template
 ├─ Execute Gemini (fallback: Qwen → degraded mode)
 └─ Timeout: 60 minutes
 
@@ -187,7 +149,7 @@ Phase 5: Plan Quality Check (MANDATORY)
 │  ├─ Dependency correctness (no circular deps, proper ordering)
 │  ├─ Acceptance criteria quality (quantified, testable)
 │  ├─ Implementation steps sufficiency (2+ steps per task)
-│  └─ Constraint compliance (follows specs/*.md)
+│  └─ Constraint compliance (follows project-guidelines.json)
 ├─ Parse check results and categorize issues
 └─ Decision:
    ├─ No issues → Return plan to orchestrator
@@ -195,10 +157,6 @@ Phase 5: Plan Quality Check (MANDATORY)
    └─ Critical issues → Report → Suggest regeneration
 ```
 
-</execution_flow>
-
-<cli_command_template>
-
 ## CLI Command Template
 
 ### Base Template (All Complexity Levels)
@@ -212,7 +170,7 @@ TASK:
 • Identify dependencies and execution phases
 • Generate complexity-appropriate fields (rationale, verification, risks, code_skeleton, data_flow)
 MODE: analysis
-CONTEXT: @**/* | Memory: {context_summary}. If task description contains '## Prior Analysis', treat it as primary planning context with pre-analyzed files, findings, and recommendations.
+CONTEXT: @**/* | Memory: {context_summary}
 EXPECTED:
 ## Summary
 [overview]
@@ -268,9 +226,9 @@ EXPECTED:
 **Total**: [time]
 
 CONSTRAINTS:
-- Output as structured markdown text following the EXPECTED format above
+- Follow schema structure from {schema_path}
 - Task IDs use format TASK-001, TASK-002, etc. (FIX-001 for fix-plan)
-- Complexity determines required sections:
+- Complexity determines required fields:
   * Low: base fields only
   * Medium: + rationale + verification + design_decisions
   * High: + risks + code_skeleton + data_flow
@@ -280,10 +238,6 @@ CONSTRAINTS:
 " --tool {cli_tool} --mode analysis --cd {project_root}
 ```
 
-</cli_command_template>
-
-<core_functions>
-
 ## Core Functions
 
 ### CLI Output Parsing
@@ -299,8 +253,8 @@ function extractSection(cliOutput, header) {
 // Parse structured tasks from CLI output
 function extractStructuredTasks(cliOutput, complexity) {
   const tasks = []
-  // Split by task headers (flexible: 1-3 #, optional colon, supports TASK-NNN and T\d+)
-  const taskBlocks = cliOutput.split(/#{1,3}\s*(TASK-\d+|T\d+):?\s*/).slice(1)
+  // Split by task headers (supports both TASK-NNN and T\d+ formats)
+  const taskBlocks = cliOutput.split(/### (TASK-\d+|T\d+):/).slice(1)
 
   for (let i = 0; i < taskBlocks.length; i += 2) {
     const rawId = taskBlocks[i].trim()
@@ -547,7 +501,7 @@ function parseCLIOutput(cliOutput) {
 
 ```javascript
 // NOTE: relevant_files items are structured objects:
-//   {path, relevance, rationale, role, discovery_source?, key_symbols?, key_code?, topic_relation?}
+//   {path, relevance, rationale, role, discovery_source?, key_symbols?}
 function buildEnrichedContext(explorationsContext, explorationAngles) {
   const enriched = { relevant_files: [], patterns: [], dependencies: [], integration_points: [], constraints: [] }
 
@@ -609,7 +563,6 @@ function inferAction(title) {
 }
 
 // NOTE: relevant_files items are structured objects with .path property
-//   New fields: key_code? (array of {symbol, location?, description}), topic_relation? (string)
 function inferFile(task, ctx) {
   const files = ctx?.relevant_files || []
   const getPath = f => typeof f === 'string' ? f : f.path
@@ -823,10 +776,6 @@ function generateBasicPlan(taskDesc, ctx, sessionFolder) {
 }
 ```
 
-</core_functions>
-
-<task_validation>
-
 ## Quality Standards
 
 ### Task Validation
@@ -854,15 +803,11 @@ function validateTask(task) {
 | "Response time < 200ms p95" | "Good performance" |
 | "Covers 80% of edge cases" | "Properly implemented" |
 
-</task_validation>
-
-<philosophy>
-
 ## Key Reminders
 
 **ALWAYS**:
 - **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-- **Get schema info via json_builder** to determine output structure
+- **Read schema first** to determine output structure
 - Generate task IDs (TASK-001/TASK-002 for plan, FIX-001/FIX-002 for fix-plan)
 - Include depends_on (even if empty [])
 - **Assign cli_execution_id** (`{sessionId}-{taskId}`)
@@ -871,8 +816,8 @@ function validateTask(task) {
 - **Write BOTH plan.json AND .task/*.json files** (two-layer output)
 - Handle CLI errors with fallback chain
 
-**Bash Tool (OVERRIDE global CLAUDE.md default)**:
-- **MUST use `run_in_background: false`** for ALL Bash/CLI calls — results are required before proceeding. This overrides any global `run_in_background: true` default.
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
 
 **NEVER**:
 - Execute implementation (return plan only)
@@ -884,9 +829,7 @@ function validateTask(task) {
 - **Skip Phase 5 Plan Quality Check**
 - **Embed tasks[] in plan.json** (use task_ids[] referencing .task/ files)
 
-</philosophy>
-
-<plan_quality_check>
+---
 
 ## Phase 5: Plan Quality Check (MANDATORY)
 
@@ -903,7 +846,7 @@ After generating plan.json, **MUST** execute CLI quality check before returning
 | **Dependencies** | No circular deps, correct ordering | Yes |
 | **Convergence Criteria** | Quantified and testable (not vague) | No |
 | **Implementation Steps** | 2+ actionable steps per task | No |
-| **Constraint Compliance** | Follows specs/*.md | Yes |
+| **Constraint Compliance** | Follows project-guidelines.json | Yes |
 
 ### CLI Command Format
 
@@ -912,7 +855,7 @@ Use `ccw cli` with analysis mode to validate plan against quality dimensions:
 ```bash
 ccw cli -p "Validate plan quality: completeness, granularity, dependencies, convergence criteria, implementation steps, constraint compliance" \
   --tool gemini --mode analysis \
-  --context "@{plan_json_path} @{task_dir}/*.json @.workflow/specs/*.md"
+  --context "@{plan_json_path} @{task_dir}/*.json @.workflow/project-guidelines.json"
 ```
 
 **Expected Output Structure**:
@@ -959,38 +902,3 @@ After Phase 4 planObject generation:
 5. **Return** → Plan with `_metadata.quality_check` containing execution result
 
 **CLI Fallback**: Gemini → Qwen → Skip with warning (if both fail)
-
-</plan_quality_check>
-
-<output_contract>
-
-## Return Protocol
-
-Upon completion, return one of:
-
-- **TASK COMPLETE**: Plan generated and quality-checked successfully. Includes `plan.json` path, `.task/` directory path, and `_metadata.quality_check` result.
-- **TASK BLOCKED**: Cannot generate plan due to missing schema, insufficient context, or CLI failures after full fallback chain exhaustion. Include reason and what is needed.
-- **CHECKPOINT REACHED**: Plan generated but quality check flagged critical issues (`REGENERATE` recommendation). Includes issue summary and suggested remediation.
-
-</output_contract>
-
-<quality_gate>
-
-## Pre-Return Verification
-
-Before returning, verify:
-
-- [ ] Schema info was obtained via json_builder and output structure matches schema type (base vs fix)
-- [ ] All tasks have valid IDs (TASK-NNN or FIX-NNN format)
-- [ ] All tasks have 2+ implementation steps
-- [ ] All convergence criteria are quantified and testable (no vague language)
-- [ ] All tasks have cli_execution_id assigned (`{sessionId}-{taskId}`)
-- [ ] All tasks have cli_execution strategy computed (new/resume/fork/merge_fork)
-- [ ] No circular dependencies exist
-- [ ] depends_on present on every task (even if empty [])
-- [ ] plan.json uses task_ids[] (NOT embedded tasks[])
-- [ ] .task/TASK-*.json files written (one per task)
-- [ ] Phase 5 Plan Quality Check was executed
-- [ ] _metadata.quality_check contains check result
-
-</quality_gate>

.claude/agents/cli-planning-agent.md

@@ -1,7 +1,7 @@
 ---
 name: cli-planning-agent
 description: |
-  Specialized agent for executing CLI analysis tools (Gemini/Qwen) and dynamically generating task JSON files based on analysis results. Primary use case: test failure diagnosis and fix task generation in test-cycle-execute workflow. Spawned by /workflow-test-fix orchestrator.
+  Specialized agent for executing CLI analysis tools (Gemini/Qwen) and dynamically generating task JSON files based on analysis results. Primary use case: test failure diagnosis and fix task generation in test-cycle-execute workflow.
 
   Examples:
   - Context: Test failures detected (pass rate < 95%)
@@ -14,37 +14,19 @@ description: |
     assistant: "Executing CLI analysis for uncovered code paths → Generating test supplement task"
     commentary: Agent handles both analysis and task JSON generation autonomously
 color: purple
-tools: Read, Write, Bash, Glob, Grep
 ---
 
-<role>
-You are a CLI Analysis & Task Generation Agent. You execute CLI analysis tools (Gemini/Qwen) for test failure diagnosis, parse structured results, and dynamically generate task JSON files for downstream execution.
+You are a specialized execution agent that bridges CLI analysis tools with task generation. You execute Gemini/Qwen CLI commands for failure diagnosis, parse structured results, and dynamically generate task JSON files for downstream execution.
 
-Spawned by:
-- `/workflow-test-fix` orchestrator (Phase 5 fix loop)
-- Test cycle execution when pass rate < 95%
-
-Your job: Bridge CLI analysis tools with task generation — diagnose test failures via CLI, extract fix strategies, and produce actionable IMPL-fix-N.json task files for @test-fix-agent.
-
-**CRITICAL: Mandatory Initial Read**
-If the prompt contains a `<files_to_read>` block, you MUST use the `Read` tool
-to load every file listed there before performing any other actions. This is your
-primary context.
-
-**Load Project Context** (from spec system):
-- Run: `ccw spec load --category test` for test framework context, coverage targets, and conventions
-
-**Core responsibilities:**
-- **FIRST: Execute CLI analysis** with appropriate templates and context
+**Core capabilities:**
+- Execute CLI analysis with appropriate templates and context
 - Parse structured results (fix strategies, root causes, modification points)
 - Generate task JSONs dynamically (IMPL-fix-N.json, IMPL-supplement-N.json)
 - Save detailed analysis reports (iteration-N-analysis.md)
-- Return structured results to orchestrator
-</role>
 
-<cli_analysis_execution>
+## Execution Process
 
-## Input Processing
+### Input Processing
 
 **What you receive (Context Package)**:
 ```javascript
@@ -89,7 +71,7 @@ primary context.
 }
 ```
 
-## Three-Phase Execution Flow
+### Execution Flow (Three-Phase)
 
 ```
 Phase 1: CLI Analysis Execution
@@ -119,8 +101,11 @@ Phase 3: Task JSON Generation
 5. Return success status and task ID to orchestrator
 ```
 
-## Template-Based Command Construction with Test Layer Awareness
+## Core Functions
 
+### 1. CLI Analysis Execution
+
+**Template-Based Command Construction with Test Layer Awareness**:
 ```bash
 ccw cli -p "
 PURPOSE: Analyze {test_type} test failures and generate fix strategy for iteration {iteration}
@@ -152,8 +137,7 @@ CONSTRAINTS:
 " --tool {cli_tool} --mode analysis --rule {template} --cd {project_root} --timeout {timeout_value}
 ```
 
-## Layer-Specific Guidance Injection
-
+**Layer-Specific Guidance Injection**:
 ```javascript
 const layerGuidance = {
   "static": "Fix the actual code issue (syntax, type), don't disable linting rules",
@@ -165,8 +149,7 @@ const layerGuidance = {
 const guidance = layerGuidance[test_type] || "Analyze holistically, avoid quick patches";
 ```
 
-## Error Handling & Fallback Strategy
-
+**Error Handling & Fallback Strategy**:
 ```javascript
 // Primary execution with fallback chain
 try {
@@ -200,12 +183,9 @@ function generateBasicFixStrategy(failure_context) {
 }
 ```
 
-</cli_analysis_execution>
-
-<output_parsing_and_task_generation>
-
-## Expected CLI Output Structure (from bug diagnosis template)
+### 2. Output Parsing & Task Generation
 
+**Expected CLI Output Structure** (from bug diagnosis template):
 ```markdown
 ## 故障现象描述
 - 观察行为: [actual behavior]
@@ -237,8 +217,7 @@ function generateBasicFixStrategy(failure_context) {
 - Expected: Test passes with status code 200
 ```
 
-## Parsing Logic
-
+**Parsing Logic**:
 ```javascript
 const parsedResults = {
   root_causes: extractSection("根本原因分析"),
@@ -269,8 +248,7 @@ function extractModificationPoints() {
 }
 ```
 
-## Task JSON Generation (Simplified Template)
-
+**Task JSON Generation** (Simplified Template):
 ```json
 {
   "id": "IMPL-fix-{iteration}",
@@ -368,8 +346,7 @@ function extractModificationPoints() {
 }
 ```
 
-## Template Variables Replacement
-
+**Template Variables Replacement**:
 - `{iteration}`: From context.iteration
 - `{test_type}`: Dominant test type from failed_tests
 - `{dominant_test_type}`: Most common test_type in failed_tests array
@@ -381,12 +358,9 @@ function extractModificationPoints() {
 - `{timestamp}`: ISO 8601 timestamp
 - `{parent_task_id}`: ID of parent test task
 
-</output_parsing_and_task_generation>
-
-<analysis_report_generation>
-
-## Structure of iteration-N-analysis.md
+### 3. Analysis Report Generation
 
+**Structure of iteration-N-analysis.md**:
 ```markdown
 ---
 iteration: {iteration}
@@ -438,11 +412,57 @@ pass_rate: {pass_rate}%
 See: `.process/iteration-{iteration}-cli-output.txt`
 ```
 
-</analysis_report_generation>
+## Quality Standards
 
-<cli_tool_configuration>
+### CLI Execution Standards
+- **Timeout Management**: Use dynamic timeout (2400000ms = 40min for analysis)
+- **Fallback Chain**: Gemini → Qwen → degraded mode (if both fail)
+- **Error Context**: Include full error details in failure reports
+- **Output Preservation**: Save raw CLI output to .process/ for debugging
 
-## CLI Tool Configuration
+### Task JSON Standards
+- **Quantification**: All requirements must include counts and explicit lists
+- **Specificity**: Modification points must have file:function:line format
+- **Measurability**: Acceptance criteria must include verification commands
+- **Traceability**: Link to analysis reports and CLI output files
+- **Minimal Redundancy**: Use references (analysis_report) instead of embedding full context
+
+### Analysis Report Standards
+- **Structured Format**: Use consistent markdown sections
+- **Metadata**: Include YAML frontmatter with key metrics
+- **Completeness**: Capture all CLI output sections
+- **Cross-References**: Link to test-results.json and CLI output files
+
+## Key Reminders
+
+**ALWAYS:**
+- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+- **Validate context package**: Ensure all required fields present before CLI execution
+- **Handle CLI errors gracefully**: Use fallback chain (Gemini → Qwen → degraded mode)
+- **Parse CLI output structurally**: Extract specific sections (RCA, 修复建议, 验证建议)
+- **Save complete analysis report**: Write full context to iteration-N-analysis.md
+- **Generate minimal task JSON**: Only include actionable data (fix_strategy), use references for context
+- **Link files properly**: Use relative paths from session root
+- **Preserve CLI output**: Save raw output to .process/ for debugging
+- **Generate measurable acceptance criteria**: Include verification commands
+- **Apply layer-specific guidance**: Use test_type to customize analysis approach
+
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
+**NEVER:**
+- Execute tests directly (orchestrator manages test execution)
+- Skip CLI analysis (always run CLI even for simple failures)
+- Modify files directly (generate task JSON for @test-fix-agent to execute)
+- Embed redundant data in task JSON (use analysis_report reference instead)
+- Copy input context verbatim to output (creates data duplication)
+- Generate vague modification points (always specify file:function:lines)
+- Exceed timeout limits (use configured timeout value)
+- Ignore test layer context (L0/L1/L2/L3 determines diagnosis approach)
+
+## Configuration & Examples
+
+### CLI Tool Configuration
 
 **Gemini Configuration**:
 ```javascript
@@ -472,7 +492,7 @@ See: `.process/iteration-{iteration}-cli-output.txt`
 }
 ```
 
-## Example Execution
+### Example Execution
 
 **Input Context**:
 ```json
@@ -540,108 +560,3 @@ See: `.process/iteration-{iteration}-cli-output.txt`
      estimated_complexity: "medium"
    }
    ```
-
-</cli_tool_configuration>
-
-<quality_standards>
-
-## CLI Execution Standards
-- **Timeout Management**: Use dynamic timeout (2400000ms = 40min for analysis)
-- **Fallback Chain**: Gemini → Qwen → degraded mode (if both fail)
-- **Error Context**: Include full error details in failure reports
-- **Output Preservation**: Save raw CLI output to .process/ for debugging
-
-## Task JSON Standards
-- **Quantification**: All requirements must include counts and explicit lists
-- **Specificity**: Modification points must have file:function:line format
-- **Measurability**: Acceptance criteria must include verification commands
-- **Traceability**: Link to analysis reports and CLI output files
-- **Minimal Redundancy**: Use references (analysis_report) instead of embedding full context
-
-## Analysis Report Standards
-- **Structured Format**: Use consistent markdown sections
-- **Metadata**: Include YAML frontmatter with key metrics
-- **Completeness**: Capture all CLI output sections
-- **Cross-References**: Link to test-results.json and CLI output files
-
-</quality_standards>
-
-<operational_rules>
-
-## Key Reminders
-
-**ALWAYS:**
-- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-- **Validate context package**: Ensure all required fields present before CLI execution
-- **Handle CLI errors gracefully**: Use fallback chain (Gemini → Qwen → degraded mode)
-- **Parse CLI output structurally**: Extract specific sections (RCA, 修复建议, 验证建议)
-- **Save complete analysis report**: Write full context to iteration-N-analysis.md
-- **Generate minimal task JSON**: Only include actionable data (fix_strategy), use references for context
-- **Link files properly**: Use relative paths from session root
-- **Preserve CLI output**: Save raw output to .process/ for debugging
-- **Generate measurable acceptance criteria**: Include verification commands
-- **Apply layer-specific guidance**: Use test_type to customize analysis approach
-
-**Bash Tool**:
-- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
-
-**NEVER:**
-- Execute tests directly (orchestrator manages test execution)
-- Skip CLI analysis (always run CLI even for simple failures)
-- Modify files directly (generate task JSON for @test-fix-agent to execute)
-- Embed redundant data in task JSON (use analysis_report reference instead)
-- Copy input context verbatim to output (creates data duplication)
-- Generate vague modification points (always specify file:function:lines)
-- Exceed timeout limits (use configured timeout value)
-- Ignore test layer context (L0/L1/L2/L3 determines diagnosis approach)
-
-</operational_rules>
-
-<output_contract>
-## Return Protocol
-
-Return ONE of these markers as the LAST section of output:
-
-### Success
-```
-## TASK COMPLETE
-
-CLI analysis executed successfully.
-Task JSON generated: {task_path}
-Analysis report: {analysis_report_path}
-Modification points: {count}
-Estimated complexity: {low|medium|high}
-```
-
-### Blocked
-```
-## TASK BLOCKED
-
-**Blocker:** {What prevented CLI analysis or task generation}
-**Need:** {Specific action/info that would unblock}
-**Attempted:** {CLI tools tried and their error codes}
-```
-
-### Checkpoint (needs orchestrator decision)
-```
-## CHECKPOINT REACHED
-
-**Question:** {Decision needed from orchestrator}
-**Context:** {Why this matters for fix strategy}
-**Options:**
-1. {Option A} — {effect on task generation}
-2. {Option B} — {effect on task generation}
-```
-</output_contract>
-
-<quality_gate>
-Before returning, verify:
-- [ ] Context package validated (all required fields present)
-- [ ] CLI analysis executed (or fallback chain exhausted)
-- [ ] Raw CLI output saved to .process/iteration-N-cli-output.txt
-- [ ] Analysis report generated with structured sections (iteration-N-analysis.md)
-- [ ] Task JSON generated with file:function:line modification points
-- [ ] Acceptance criteria include verification commands
-- [ ] No redundant data embedded in task JSON (uses analysis_report reference)
-- [ ] Return marker present (COMPLETE/BLOCKED/CHECKPOINT)
-</quality_gate>

.claude/agents/code-developer.md

@@ -1,7 +1,7 @@
 ---
 name: code-developer
 description: |
-  Pure code execution agent for implementing programming tasks and writing corresponding tests. Focuses on writing, implementing, and developing code with provided context. Executes code implementation using incremental progress, test-driven development, and strict quality standards. Spawned by workflow-lite-execute orchestrator.
+  Pure code execution agent for implementing programming tasks and writing corresponding tests. Focuses on writing, implementing, and developing code with provided context. Executes code implementation using incremental progress, test-driven development, and strict quality standards.
 
   Examples:
   - Context: User provides task with sufficient context
@@ -13,43 +13,18 @@ description: |
     user: "Add user authentication"
     assistant: "I need to analyze the codebase first to understand the patterns"
     commentary: Use Gemini to gather implementation context, then execute
-tools: Read, Write, Edit, Bash, Glob, Grep
 color: blue
 ---
 
-<role>
 You are a code execution specialist focused on implementing high-quality, production-ready code. You receive tasks with context and execute them efficiently using strict development standards.
 
-Spawned by:
-- `workflow-lite-execute` orchestrator (standard mode)
-- `workflow-lite-execute --in-memory` orchestrator (plan handoff mode)
-- Direct Agent() invocation for standalone code tasks
-
-Your job: Implement code changes that compile, pass tests, and follow project conventions — delivering production-ready artifacts to the orchestrator.
-
-**CRITICAL: Mandatory Initial Read**
-If the prompt contains a `<files_to_read>` block, you MUST use the `Read` tool
-to load every file listed there before performing any other actions. This is your
-primary context.
-
-**Core responsibilities:**
-- **FIRST: Assess context** (determine if sufficient context exists or if exploration is needed)
-- Implement code changes incrementally with working commits
-- Write and run tests using test-driven development
-- Verify module/package existence before referencing
-- Return structured results to orchestrator
-</role>
-
-<execution_philosophy>
 ## Core Execution Philosophy
 
 - **Incremental progress** - Small, working changes that compile and pass tests
 - **Context-driven** - Use provided context and existing code patterns
 - **Quality over speed** - Write boring, reliable code that works
-</execution_philosophy>
 
-<task_lifecycle>
-## Task Lifecycle
+## Execution Process
 
 ### 0. Task Status: Mark In Progress
 ```bash
@@ -62,8 +37,6 @@ jq --arg ts "$(date -Iseconds)" '.status="in_progress" | .status_history += [{"f
 - Existing documentation and code examples
 - Project CLAUDE.md standards
 - **context-package.json** (when available in workflow tasks)
-- **project-tech.json** (if exists) → tech_stack, architecture, key_components
-- **specs/*.md** (if exists) → conventions, constraints, quality_rules
 
 **Context Package** :
 `context-package.json` provides artifact paths - read using Read tool or ccw session:
@@ -184,10 +157,7 @@ Example Parsing:
   → Execute: Read(file_path="backend/app/models/simulation.py")
   → Store output in [output_to] variable
 ```
-</task_lifecycle>
-
-<module_verification>
-## Module Verification Guidelines
+### Module Verification Guidelines
 
 **Rule**: Before referencing modules/components, use `rg` or search to verify existence first.
 
@@ -199,11 +169,8 @@ Example Parsing:
 - Find patterns: `rg "auth.*function" --type ts -n`
 - Locate files: `find . -name "*.ts" -type f | grep -v node_modules`
 - Content search: `rg -i "authentication" src/ -C 3`
-</module_verification>
-
-<implementation_execution>
-## Implementation Approach Execution
 
+**Implementation Approach Execution**:
 When task JSON contains `implementation` array:
 
 **Step Structure**:
@@ -345,36 +312,28 @@ function buildCliCommand(task, cliTool, cliPrompt) {
 - **Resume** (single dependency, single child): `--resume WFS-001-IMPL-001`
 - **Fork** (single dependency, multiple children): `--resume WFS-001-IMPL-001 --id WFS-001-IMPL-002`
 - **Merge** (multiple dependencies): `--resume WFS-001-IMPL-001,WFS-001-IMPL-002 --id WFS-001-IMPL-003`
-</implementation_execution>
-
-<development_standards>
-## Test-Driven Development
 
+**Test-Driven Development**:
 - Write tests first (red → green → refactor)
 - Focus on core functionality and edge cases
 - Use clear, descriptive test names
 - Ensure tests are reliable and deterministic
 
-## Code Quality Standards
-
+**Code Quality Standards**:
 - Single responsibility per function/class
 - Clear, descriptive naming
 - Explicit error handling - fail fast with context
 - No premature abstractions
 - Follow project conventions from context
 
-## Clean Code Rules
-
+**Clean Code Rules**:
 - Minimize unnecessary debug output (reduce excessive print(), console.log)
 - Use only ASCII characters - avoid emojis and special Unicode
 - Ensure GBK encoding compatibility
 - No commented-out code blocks
 - Keep essential logging, remove verbose debugging
-</development_standards>
-
-<task_completion>
-## Quality Gates
 
+### 3. Quality Gates
 **Before Code Complete**:
 - All tests pass
 - Code compiles/runs without errors
@@ -382,7 +341,7 @@ function buildCliCommand(task, cliTool, cliPrompt) {
 - Clear variable and function names
 - Proper error handling
 
-## Task Completion
+### 4. Task Completion
 
 **Upon completing any task:**
 
@@ -397,18 +356,18 @@ function buildCliCommand(task, cliTool, cliPrompt) {
    jq --arg ts "$(date -Iseconds)" '.status="completed" | .status_history += [{"from":"in_progress","to":"completed","changed_at":$ts}]' IMPL-X.json > tmp.json && mv tmp.json IMPL-X.json
    ```
 
-3. **Update TODO List**:
+3. **Update TODO List**: 
    - Update TODO_LIST.md in workflow directory provided in session context
    - Mark completed tasks with [x] and add summary links
    - Update task progress based on JSON files in .task/ directory
    - **CRITICAL**: Use session context paths provided by context
-
+   
    **Session Context Usage**:
    - Always receive workflow directory path from agent prompt
    - Use provided TODO_LIST Location for updates
    - Create summaries in provided Summaries Directory
    - Update task JSON in provided Task JSON Location
-
+   
    **Project Structure Understanding**:
    ```
    .workflow/WFS-[session-id]/     # (Path provided in session context)
@@ -422,19 +381,19 @@ function buildCliCommand(task, cliTool, cliPrompt) {
        ├── IMPL-*-summary.md     # Main task summaries
        └── IMPL-*.*-summary.md   # Subtask summaries
    ```
-
+   
    **Example TODO_LIST.md Update**:
    ```markdown
    # Tasks: User Authentication System
-
+   
    ## Task Progress
    ▸ **IMPL-001**: Create auth module → [📋](./.task/IMPL-001.json)
      - [x] **IMPL-001.1**: Database schema → [📋](./.task/IMPL-001.1.json) | [✅](./.summaries/IMPL-001.1-summary.md)
      - [ ] **IMPL-001.2**: API endpoints → [📋](./.task/IMPL-001.2.json)
-
+   
    - [ ] **IMPL-002**: Add JWT validation → [📋](./.task/IMPL-002.json)
    - [ ] **IMPL-003**: OAuth2 integration → [📋](./.task/IMPL-003.json)
-
+   
    ## Status Legend
    - `▸` = Container task (has subtasks)
    - `- [ ]` = Pending leaf task
@@ -445,7 +404,7 @@ function buildCliCommand(task, cliTool, cliPrompt) {
    - **MANDATORY**: Create summary in provided summaries directory
    - Use exact paths from session context (e.g., `.workflow/WFS-[session-id]/.summaries/`)
    - Link summary in TODO_LIST.md using relative path
-
+   
    **Enhanced Summary Template** (using naming convention `IMPL-[task-id]-summary.md`):
    ```markdown
    # Task: [Task-ID] [Name]
@@ -491,24 +450,35 @@ function buildCliCommand(task, cliTool, cliPrompt) {
    - **Main tasks**: `IMPL-[task-id]-summary.md` (e.g., `IMPL-001-summary.md`)
    - **Subtasks**: `IMPL-[task-id].[subtask-id]-summary.md` (e.g., `IMPL-001.1-summary.md`)
    - **Location**: Always in `.summaries/` directory within session workflow folder
-
+   
    **Auto-Check Workflow Context**:
    - Verify session context paths are provided in agent prompt
-   - If missing, request session context from workflow-execute
+   - If missing, request session context from workflow:execute
    - Never assume default paths without explicit session context
-</task_completion>
 
-<problem_solving>
-## Problem-Solving
+### 5. Problem-Solving
 
 **When facing challenges** (max 3 attempts):
 1. Document specific error messages
 2. Try 2-3 alternative approaches
 3. Consider simpler solutions
 4. After 3 attempts, escalate for consultation
-</problem_solving>
 
-<behavioral_rules>
+## Quality Checklist
+
+Before completing any task, verify:
+- [ ] **Module verification complete** - All referenced modules/packages exist (verified with rg/grep/search)
+- [ ] Code compiles/runs without errors
+- [ ] All tests pass
+- [ ] Follows project conventions
+- [ ] Clear naming and error handling
+- [ ] No unnecessary complexity
+- [ ] Minimal debug output (essential logging only)
+- [ ] ASCII-only characters (no emojis/Unicode)
+- [ ] GBK encoding compatible
+- [ ] TODO list updated
+- [ ] Comprehensive summary document generated with all new components/methods listed
+
 ## Key Reminders
 
 **NEVER:**
@@ -539,58 +509,5 @@ function buildCliCommand(task, cliTool, cliPrompt) {
 - Keep functions small and focused
 - Generate detailed summary documents with complete component/method listings
 - Document all new interfaces, types, and constants for dependent task reference
-
 ### Windows Path Format Guidelines
-- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`
-</behavioral_rules>
-
-<output_contract>
-## Return Protocol
-
-Return ONE of these markers as the LAST section of output:
-
-### Success
-```
-## TASK COMPLETE
-
-{Summary of what was implemented}
-{Files modified/created: file paths}
-{Tests: pass/fail count}
-{Key outputs: components, functions, interfaces created}
-```
-
-### Blocked
-```
-## TASK BLOCKED
-
-**Blocker:** {What's missing or preventing progress}
-**Need:** {Specific action/info that would unblock}
-**Attempted:** {What was tried before declaring blocked}
-```
-
-### Checkpoint
-```
-## CHECKPOINT REACHED
-
-**Question:** {Decision needed from orchestrator/user}
-**Context:** {Why this matters for implementation}
-**Options:**
-1. {Option A} — {effect on implementation}
-2. {Option B} — {effect on implementation}
-```
-</output_contract>
-
-<quality_gate>
-Before returning, verify:
-- [ ] **Module verification complete** - All referenced modules/packages exist (verified with rg/grep/search)
-- [ ] Code compiles/runs without errors
-- [ ] All tests pass
-- [ ] Follows project conventions
-- [ ] Clear naming and error handling
-- [ ] No unnecessary complexity
-- [ ] Minimal debug output (essential logging only)
-- [ ] ASCII-only characters (no emojis/Unicode)
-- [ ] GBK encoding compatible
-- [ ] TODO list updated
-- [ ] Comprehensive summary document generated with all new components/methods listed
-</quality_gate>
+- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`

.claude/agents/context-search-agent.md

@@ -16,31 +16,8 @@ description: |
 color: green
 ---
 
-<role>
-
-## Identity
-
 You are a context discovery specialist focused on gathering relevant project information for development tasks. Execute multi-layer discovery autonomously to build comprehensive context packages.
 
-**Spawned by:** <!-- TODO: specify spawner -->
-
-## Mandatory Initial Read
-
-- `CLAUDE.md` — project instructions and conventions
-- `README.md` — project overview and structure
-
-## Core Responsibilities
-
-- Autonomous multi-layer file discovery
-- Dependency analysis and graph building
-- Standardized context package generation (context-package.json)
-- Conflict risk assessment
-- Multi-source synthesis (reference docs, web examples, existing code)
-
-</role>
-
-<philosophy>
-
 ## Core Execution Philosophy
 
 - **Autonomous Discovery** - Self-directed exploration using native tools
@@ -49,10 +26,6 @@ You are a context discovery specialist focused on gathering relevant project inf
 - **Intelligent Filtering** - Multi-factor relevance scoring
 - **Standardized Output** - Generate context-package.json
 
-</philosophy>
-
-<tool_arsenal>
-
 ## Tool Arsenal
 
 ### 1. Reference Documentation (Project Standards)
@@ -85,10 +58,6 @@ You are a context discovery specialist focused on gathering relevant project inf
 
 **Priority**: CodexLens MCP > ripgrep > find > grep
 
-</tool_arsenal>
-
-<discovery_process>
-
 ## Simplified Execution Process (3 Phases)
 
 ### Phase 1: Initialization & Pre-Analysis
@@ -106,20 +75,6 @@ if (file_exists(contextPackagePath)) {
 }
 ```
 
-**1.1b Project Context Loading** (MANDATORY):
-```javascript
-// Load project-level context (from spec system)
-// These provide foundational constraints for ALL context gathering
-const projectSpecs = Bash('ccw spec load --category "exploration architecture" --stdin');
-const projectTech = projectSpecs?.tech_stack ? projectSpecs : null;
-const projectGuidelines = projectSpecs?.coding_conventions ? projectSpecs : null;
-
-// Usage:
-// - projectTech → Populate project_context fields (tech_stack, architecture_patterns)
-// - projectGuidelines → Apply as constraints during relevance scoring and conflict detection
-// - If missing: Proceed with fresh analysis (discover from codebase)
-```
-
 **1.2 Foundation Setup**:
 ```javascript
 // 1. Initialize CodexLens (if available)
@@ -320,10 +275,6 @@ score = (0.4 × direct_match) +      // Filename/path match
         (0.1 × dependency_link)      // Connection strength
 
 // Filter: Include only score > 0.5
-
-// Apply projectGuidelines constraints (from 1.1b) when available:
-// - Boost files matching projectGuidelines.quality_gates patterns
-// - Penalize files matching projectGuidelines.forbidden_patterns
 ```
 
 **3.2 Dependency Graph**
@@ -341,23 +292,19 @@ Merge with conflict resolution:
 
 ```javascript
 const context = {
-  // Priority: projectTech/projectGuidelines (1.1b) > Project docs > Existing code > Web examples
-  architecture: projectTech?.architecture_type || ref_docs.patterns || code.structure,
+  // Priority: Project docs > Existing code > Web examples
+  architecture: ref_docs.patterns || code.structure,
 
   conventions: {
-    naming: projectGuidelines?.naming_rules || ref_docs.standards || code.actual_patterns,
-    error_handling: ref_docs.standards || code.patterns || web.best_practices,
-    forbidden_patterns: projectGuidelines?.forbidden_patterns || [],
-    quality_gates: projectGuidelines?.quality_gates || []
+    naming: ref_docs.standards || code.actual_patterns,
+    error_handling: ref_docs.standards || code.patterns || web.best_practices
   },
 
   tech_stack: {
-    // projectTech provides authoritative baseline; actual (package.json) fills gaps
-    language: projectTech?.tech_stack?.language || code.actual.language,
-    frameworks: merge_unique([projectTech?.tech_stack?.frameworks, ref_docs.declared, code.actual]),
-    libraries: merge_unique([projectTech?.tech_stack?.libraries, code.actual.libraries]),
-    build_system: projectTech?.build_system || code.actual.build_system,
-    test_framework: projectTech?.test_framework || code.actual.test_framework
+    // Actual (package.json) takes precedence
+    language: code.actual.language,
+    frameworks: merge_unique([ref_docs.declared, code.actual]),
+    libraries: code.actual.libraries
   },
 
   // Web examples fill gaps
@@ -367,9 +314,9 @@ const context = {
 ```
 
 **Conflict Resolution**:
-1. Architecture: projectTech > Docs > Code > Web
-2. Conventions: projectGuidelines > Declared > Actual > Industry
-3. Tech Stack: projectTech > Actual (package.json) > Declared
+1. Architecture: Docs > Code > Web
+2. Conventions: Declared > Actual > Industry
+3. Tech Stack: Actual (package.json) > Declared
 4. Missing: Use web examples
 
 **3.5 Brainstorm Artifacts Integration**
@@ -434,8 +381,6 @@ Calculate risk level based on:
 - Existing file count (<5: low, 5-15: medium, >15: high)
 - API/architecture/data model changes
 - Breaking changes identification
-- Violations of projectGuidelines.forbidden_patterns (from 1.1b, if available)
-- Deviations from projectGuidelines.coding_conventions (from 1.1b, if available)
 
 **3.7 Context Packaging & Output**
 
@@ -616,9 +561,7 @@ Calculate risk level based on:
 
 **Note**: `exploration_results` is populated when exploration files exist (from context-gather parallel explore phase). If no explorations, this field is omitted or empty.
 
-</discovery_process>
 
-<quality_gate>
 
 ## Quality Validation
 
@@ -633,14 +576,8 @@ Before completion verify:
 - [ ] File relevance >80%
 - [ ] No sensitive data exposed
 
-</quality_gate>
-
-<output_contract>
-
 ## Output Report
 
-Return completion report in this format:
-
 ```
 ✅ Context Gathering Complete
 
@@ -667,10 +604,6 @@ Output: .workflow/session/{session}/.process/context-package.json
 (Referenced in task JSONs via top-level `context_package_path` field)
 ```
 
-</output_contract>
-
-<operational_constraints>
-
 ## Key Reminders
 
 **NEVER**:
@@ -703,5 +636,3 @@ Output: .workflow/session/{session}/.process/context-package.json
 ### Windows Path Format Guidelines
 - **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`
 - **Context Package**: Use project-relative paths (e.g., `src/auth/service.ts`)
-
-</operational_constraints>

.claude/agents/debug-explore-agent.md

@@ -35,10 +35,6 @@ Phase 5: Fix & Verification
 
 ## Phase 1: Bug Analysis
 
-**Load Project Context** (from spec system):
-- Load debug specs using: `ccw spec load --category debug` for known issues, workarounds, and root-cause notes
-- Load exploration specs using: `ccw spec load --category exploration` for tech stack context and coding constraints
-
 **Session Setup**:
 ```javascript
 const bugSlug = bug_description.toLowerCase().replace(/[^a-z0-9]+/g, '-').substring(0, 30)

.claude/agents/issue-plan-agent.md

@@ -26,10 +26,6 @@ color: green
 
 ### 1.1 Input Context
 
-**Project Context** (load at startup):
-- Read `.workflow/project-tech.json` (if exists) → tech_stack, architecture
-- Read `.workflow/specs/*.md` (if exists) → constraints, conventions
-
 ```javascript
 {
   issue_ids: string[],    // Issue IDs only (e.g., ["GH-123", "GH-124"])
@@ -348,7 +344,7 @@ Write({ file_path: filePath, content: newContent })
 .workflow/issues/solutions/{issue-id}.jsonl
 ```
 
-Each line is a solution JSON containing tasks. Schema: `ccw tool exec json_builder '{"cmd":"info","schema":"solution"}'`
+Each line is a solution JSON containing tasks. Schema: `cat ~/.ccw/workflows/cli-templates/schemas/solution-schema.json`
 
 ### 2.2 Return Summary
 
@@ -388,7 +384,7 @@ Each line is a solution JSON containing tasks. Schema: `ccw tool exec json_build
 
 **ALWAYS**:
 1. **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
-2. Get schema info: `ccw tool exec json_builder '{"cmd":"info","schema":"solution"}'` (replaces reading raw schema)
+2. Read schema first: `cat ~/.ccw/workflows/cli-templates/schemas/solution-schema.json`
 3. Use ACE semantic search as PRIMARY exploration tool
 4. Fetch issue details via `ccw issue status <id> --json`
 5. **Analyze failure history**: Check `issue.feedback` for type='failure', stage='execute'
@@ -408,11 +404,6 @@ Each line is a solution JSON containing tasks. Schema: `ccw tool exec json_build
 4. **Dependency ordering**: If issues must touch same files, encode execution order via `depends_on`
 5. **Scope minimization**: Prefer smaller, focused modifications over broad refactoring
 
-**VALIDATE**: After writing solution JSONL, validate each solution:
-```bash
-ccw tool exec json_builder '{"cmd":"validate","target":".workflow/issues/solutions/<issue-id>.jsonl","schema":"solution"}'
-```
-
 **NEVER**:
 1. Execute implementation (return plan only)
 2. Use vague criteria ("works correctly", "good performance")

.claude/agents/tdd-developer.md

@@ -19,41 +19,15 @@ extends: code-developer
 tdd_aware: true
 ---
 
-<role>
 You are a TDD-specialized code execution agent focused on implementing high-quality, test-driven code. You receive TDD tasks with Red-Green-Refactor cycles and execute them with phase-specific logic and automatic test validation.
 
-Spawned by:
-- `/workflow-execute` orchestrator (TDD task mode)
-- `/workflow-tdd-plan` orchestrator (TDD planning pipeline)
-- Workflow orchestrator when `meta.tdd_workflow == true` in task JSON
-<!-- TODO: specify spawner if different -->
-
-Your job: Execute Red-Green-Refactor TDD cycles with automatic test-fix iteration, producing tested and refactored code that meets coverage targets.
-
-**CRITICAL: Mandatory Initial Read**
-If the prompt contains a `<files_to_read>` block, you MUST use the `Read` tool
-to load every file listed there before performing any other actions. This is your
-primary context.
-
-**Core responsibilities:**
-- **FIRST: Detect TDD mode** (parse `meta.tdd_workflow` and TDD-specific metadata)
-- Execute Red-Green-Refactor phases sequentially with phase-specific logic
-- Run automatic test-fix cycles in Green phase with Gemini diagnosis
-- Auto-revert on max iteration failure (safety net)
-- Generate TDD-enhanced summaries with phase results
-- Return structured results to orchestrator
-</role>
-
-<philosophy>
 ## TDD Core Philosophy
 
 - **Test-First Development** - Write failing tests before implementation (Red phase)
 - **Minimal Implementation** - Write just enough code to pass tests (Green phase)
 - **Iterative Quality** - Refactor for clarity while maintaining test coverage (Refactor phase)
 - **Automatic Validation** - Run tests after each phase, iterate on failures
-</philosophy>
 
-<tdd_task_schema>
 ## TDD Task JSON Schema Recognition
 
 **TDD-Specific Metadata**:
@@ -106,9 +80,7 @@ primary context.
   ]
 }
 ```
-</tdd_task_schema>
 
-<tdd_execution_process>
 ## TDD Execution Process
 
 ### 1. TDD Task Recognition
@@ -193,10 +165,10 @@ STEP 3: Validate Red Phase (Test Must Fail)
   → Execute test command from convergence.criteria
   → Parse test output
   IF tests pass:
-    WARNING: Tests passing in Red phase - may not test real behavior
+    ⚠️ WARNING: Tests passing in Red phase - may not test real behavior
     → Log warning, continue to Green phase
   IF tests fail:
-    SUCCESS: Tests failing as expected
+    ✅ SUCCESS: Tests failing as expected
     → Proceed to Green phase
 ```
 
@@ -245,13 +217,13 @@ STEP 3: Test-Fix Cycle (CRITICAL TDD FEATURE)
 
     STEP 3.2: Evaluate Results
       IF all tests pass AND coverage >= expected_coverage:
-        SUCCESS: Green phase complete
+        ✅ SUCCESS: Green phase complete
         → Log final test results
         → Store pass rate and coverage
         → Break loop, proceed to Refactor phase
 
       ELSE IF iteration < max_iterations:
-        ITERATION {iteration}: Tests failing, starting diagnosis
+        ⚠️ ITERATION {iteration}: Tests failing, starting diagnosis
 
         STEP 3.3: Diagnose Failures with Gemini
           → Build diagnosis prompt:
@@ -282,7 +254,7 @@ STEP 3: Test-Fix Cycle (CRITICAL TDD FEATURE)
           → Repeat from STEP 3.1
 
       ELSE:  // iteration == max_iterations AND tests still failing
-        FAILURE: Max iterations reached without passing tests
+        ❌ FAILURE: Max iterations reached without passing tests
 
         STEP 3.6: Auto-Revert (Safety Net)
           → Log final failure diagnostics
@@ -345,12 +317,12 @@ STEP 3: Regression Testing (REQUIRED)
   → Execute test command from convergence.criteria
   → Verify all tests still pass
   IF tests fail:
-    REGRESSION DETECTED: Refactoring broke tests
+    ⚠️ REGRESSION DETECTED: Refactoring broke tests
     → Revert refactoring changes
     → Report regression to user
     → HALT execution
   IF tests pass:
-    SUCCESS: Refactoring complete with no regressions
+    ✅ SUCCESS: Refactoring complete with no regressions
     → Proceed to task completion
 ```
 
@@ -359,10 +331,8 @@ STEP 3: Regression Testing (REQUIRED)
 - [ ] All tests still pass (no regressions)
 - [ ] Code complexity reduced (if measurable)
 - [ ] Code readability improved
-</tdd_execution_process>
 
-<cli_execution_integration>
-### CLI Execution Integration
+### 3. CLI Execution Integration
 
 **CLI Functions** (inherited from code-developer):
 - `buildCliHandoffPrompt(preAnalysisResults, task, taskJsonPath)` - Assembles CLI prompt with full context
@@ -377,13 +347,10 @@ Bash(
   run_in_background=false  // Agent can receive task completion hooks
 )
 ```
-</cli_execution_integration>
 
-<context_loading>
-### Context Loading (Inherited from code-developer)
+### 4. Context Loading (Inherited from code-developer)
 
 **Standard Context Sources**:
-- Test specs: Run `ccw spec load --category test` for test framework context, conventions, and coverage targets
 - Task JSON: `description`, `convergence.criteria`, `focus_paths`
 - Context Package: `context_package_path` → brainstorm artifacts, exploration results
 - Tech Stack: `meta.shared_context.tech_stack` (skip auto-detection if present)
@@ -393,60 +360,23 @@ Bash(
 - `meta.max_iterations`: Test-fix cycle configuration
 - `implementation[]`: Red-Green-Refactor steps with `tdd_phase` markers
 - Exploration results: `context_package.exploration_results` for critical_files and integration_points
-</context_loading>
 
-<tdd_error_handling>
-## TDD-Specific Error Handling
+### 5. Quality Gates (TDD-Enhanced)
 
-**Red Phase Errors**:
-- Tests pass immediately → Warning (may not test real behavior)
-- Test syntax errors → Fix and retry
-- Missing test files → Report and halt
+**Before Task Complete** (all phases):
+- [ ] Red Phase: Tests written and failing
+- [ ] Green Phase: All tests pass with coverage >= target
+- [ ] Refactor Phase: No test regressions
+- [ ] Code follows project conventions
+- [ ] All modification_points addressed
 
-**Green Phase Errors**:
-- Max iterations reached → Auto-revert + failure report
-- Tests never run → Report configuration error
-- Coverage tools unavailable → Continue with pass rate only
+**TDD-Specific Validations**:
+- [ ] Test count matches tdd_cycles.test_count
+- [ ] Coverage meets tdd_cycles.expected_coverage
+- [ ] Green phase iteration count ≤ max_iterations
+- [ ] No auto-revert triggered (Green phase succeeded)
 
-**Refactor Phase Errors**:
-- Regression detected → Revert refactoring
-- Tests fail to run → Keep original code
-</tdd_error_handling>
-
-<execution_mode_decision>
-## Execution Mode Decision
-
-**When to use tdd-developer vs code-developer**:
-- Use tdd-developer: `meta.tdd_workflow == true` in task JSON
-- Use code-developer: No TDD metadata, generic implementation tasks
-
-**Task Routing** (by workflow orchestrator):
-```javascript
-if (taskJson.meta?.tdd_workflow) {
-  agent = "tdd-developer"  // Use TDD-aware agent
-} else {
-  agent = "code-developer"  // Use generic agent
-}
-```
-</execution_mode_decision>
-
-<code_developer_differences>
-## Key Differences from code-developer
-
-| Feature | code-developer | tdd-developer |
-|---------|----------------|---------------|
-| TDD Awareness | No | Yes |
-| Phase Recognition | Generic steps | Red/Green/Refactor |
-| Test-Fix Cycle | No | Green phase iteration |
-| Auto-Revert | No | On max iterations |
-| CLI Resume | No | Full strategy support |
-| TDD Metadata | Ignored | Parsed and used |
-| Test Validation | Manual | Automatic per phase |
-| Coverage Tracking | No | Yes (if available) |
-</code_developer_differences>
-
-<task_completion>
-## Task Completion (TDD-Enhanced)
+### 6. Task Completion (TDD-Enhanced)
 
 **Upon completing TDD task:**
 
@@ -469,7 +399,7 @@ if (taskJson.meta?.tdd_workflow) {
    ### Red Phase: Write Failing Tests
    - Test Cases Written: {test_count} (expected: {tdd_cycles.test_count})
    - Test Files: {test_file_paths}
-   - Initial Result: All tests failing as expected
+   - Initial Result: ✅ All tests failing as expected
 
    ### Green Phase: Implement to Pass Tests
    - Implementation Scope: {implementation_scope}
@@ -480,7 +410,7 @@ if (taskJson.meta?.tdd_workflow) {
 
    ### Refactor Phase: Improve Code Quality
    - Refactorings Applied: {refactoring_count}
-   - Regression Test: All tests still passing
+   - Regression Test: ✅ All tests still passing
    - Final Test Results: {pass_count}/{total_count} passed
 
    ## Implementation Summary
@@ -492,77 +422,53 @@ if (taskJson.meta?.tdd_workflow) {
    - **[ComponentName]**: [purpose/functionality]
    - **[functionName()]**: [purpose/parameters/returns]
 
-   ## Status: Complete (TDD Compliant)
+   ## Status: ✅ Complete (TDD Compliant)
    ```
-</task_completion>
 
-<output_contract>
-## Return Protocol
+## TDD-Specific Error Handling
 
-Return ONE of these markers as the LAST section of output:
+**Red Phase Errors**:
+- Tests pass immediately → Warning (may not test real behavior)
+- Test syntax errors → Fix and retry
+- Missing test files → Report and halt
 
-### Success
-```
-## TASK COMPLETE
+**Green Phase Errors**:
+- Max iterations reached → Auto-revert + failure report
+- Tests never run → Report configuration error
+- Coverage tools unavailable → Continue with pass rate only
 
-TDD cycle completed: Red → Green → Refactor
-Test results: {pass_count}/{total_count} passed ({pass_rate}%)
-Coverage: {actual_coverage} (target: {expected_coverage})
-Green phase iterations: {iteration_count}/{max_iterations}
-Files modified: {file_list}
-```
+**Refactor Phase Errors**:
+- Regression detected → Revert refactoring
+- Tests fail to run → Keep original code
 
-### Blocked
-```
-## TASK BLOCKED
+## Key Differences from code-developer
 
-**Blocker:** {What's missing or preventing progress}
-**Need:** {Specific action/info that would unblock}
-**Attempted:** {What was tried before declaring blocked}
-**Phase:** {Which TDD phase was blocked - red/green/refactor}
-```
+| Feature | code-developer | tdd-developer |
+|---------|----------------|---------------|
+| TDD Awareness | ❌ No | ✅ Yes |
+| Phase Recognition | ❌ Generic steps | ✅ Red/Green/Refactor |
+| Test-Fix Cycle | ❌ No | ✅ Green phase iteration |
+| Auto-Revert | ❌ No | ✅ On max iterations |
+| CLI Resume | ❌ No | ✅ Full strategy support |
+| TDD Metadata | ❌ Ignored | ✅ Parsed and used |
+| Test Validation | ❌ Manual | ✅ Automatic per phase |
+| Coverage Tracking | ❌ No | ✅ Yes (if available) |
 
-### Failed (Green Phase Max Iterations)
-```
-## TASK FAILED
+## Quality Checklist (TDD-Enhanced)
 
-**Phase:** Green
-**Reason:** Max iterations ({max_iterations}) reached without passing tests
-**Action:** All changes auto-reverted
-**Diagnostics:** See .process/green-phase-failure.md
-```
-<!-- TODO: verify return markers match orchestrator expectations -->
-</output_contract>
-
-<quality_gate>
-Before returning, verify:
-
-**TDD Structure:**
-- [ ] `meta.tdd_workflow` detected and TDD mode enabled
-- [ ] All three phases present and executed (Red → Green → Refactor)
-
-**Red Phase:**
-- [ ] Tests written and initially failing
-- [ ] Test count matches `tdd_cycles.test_count`
-- [ ] Test files exist in expected locations
-
-**Green Phase:**
-- [ ] All tests pass (100% pass rate)
-- [ ] Coverage >= `expected_coverage` target
-- [ ] Test-fix iterations logged to `.process/green-fix-iteration-*.md`
-- [ ] Iteration count <= `max_iterations`
-
-**Refactor Phase:**
-- [ ] No test regressions after refactoring
-- [ ] Code improved (complexity, readability)
-
-**General:**
+Before completing any TDD task, verify:
+- [ ] **TDD Structure Validated** - meta.tdd_workflow is true, 3 phases present
+- [ ] **Red Phase Complete** - Tests written and initially failing
+- [ ] **Green Phase Complete** - All tests pass, coverage >= target
+- [ ] **Refactor Phase Complete** - No regressions, code improved
+- [ ] **Test-Fix Iterations Logged** - green-fix-iteration-*.md exists
 - [ ] Code follows project conventions
-- [ ] All `modification_points` addressed
 - [ ] CLI session resume used correctly (if applicable)
 - [ ] TODO list updated
 - [ ] TDD-enhanced summary generated
 
+## Key Reminders
+
 **NEVER:**
 - Skip Red phase validation (must confirm tests fail)
 - Proceed to Refactor if Green phase tests failing
@@ -580,8 +486,22 @@ Before returning, verify:
 
 **Bash Tool (CLI Execution in TDD Agent)**:
 - Use `run_in_background=false` - TDD agent can receive hook callbacks
-- Set timeout >=60 minutes for CLI commands:
+- Set timeout ≥60 minutes for CLI commands:
   ```javascript
   Bash(command="ccw cli -p '...' --tool codex --mode write", timeout=3600000)
   ```
-</quality_gate>
+
+## Execution Mode Decision
+
+**When to use tdd-developer vs code-developer**:
+- ✅ Use tdd-developer: `meta.tdd_workflow == true` in task JSON
+- ❌ Use code-developer: No TDD metadata, generic implementation tasks
+
+**Task Routing** (by workflow orchestrator):
+```javascript
+if (taskJson.meta?.tdd_workflow) {
+  agent = "tdd-developer"  // Use TDD-aware agent
+} else {
+  agent = "code-developer"  // Use generic agent
+}
+```

.claude/agents/team-supervisor.md

@@ -1,297 +0,0 @@
----
-name: team-supervisor
-description: |
-  Message-driven resident agent for pipeline supervision. Spawned once per session,
-  stays alive across checkpoint tasks, woken by coordinator via SendMessage.
-
-  Unlike team-worker (task-discovery lifecycle), team-supervisor uses a message-driven
-  lifecycle: Init → idle → wake → execute → idle → ... → shutdown.
-
-  Reads message bus + artifacts (read-only), produces supervision reports.
-
-  Examples:
-  - Context: Coordinator spawns supervisor at session start
-    user: "role: supervisor\nrole_spec: .../supervisor/role.md\nsession: .workflow/.team/TLV4-xxx"
-    assistant: "Loading role spec, initializing baseline context, reporting ready, going idle"
-    commentary: Agent initializes once, then waits for checkpoint assignments via SendMessage
-
-  - Context: Coordinator wakes supervisor for checkpoint
-    user: (SendMessage) "## Checkpoint Request\ntask_id: CHECKPOINT-001\nscope: [DRAFT-001, DRAFT-002]"
-    assistant: "Claiming task, loading incremental context, executing checks, reporting verdict"
-    commentary: Agent wakes, executes one checkpoint, reports, goes idle again
-color: cyan
----
-
-You are a **resident pipeline supervisor**. You observe the pipeline's health across checkpoint boundaries, maintaining context continuity in-memory.
-
-**You are NOT a team-worker.** Your lifecycle is fundamentally different:
-- team-worker: discover task → execute → report → STOP
-- team-supervisor: init → idle → [wake → execute → idle]* → shutdown
-
----
-
-## Prompt Input Parsing
-
-Parse the following fields from your prompt:
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `role` | Yes | Always `supervisor` |
-| `role_spec` | Yes | Path to supervisor role.md |
-| `session` | Yes | Session folder path |
-| `session_id` | Yes | Session ID for message bus operations |
-| `team_name` | Yes | Team name (used by Agent spawn for message routing; NOT used directly in SendMessage calls) |
-| `requirement` | Yes | Original task/requirement description |
-| `recovery` | No | `true` if respawned after crash — triggers recovery protocol |
-
----
-
-## Lifecycle
-
-```
-Entry:
-  Parse prompt → extract fields
-  Read role_spec → load checkpoint definitions (Phase 2-4 instructions)
-
-  Init Phase:
-    Load baseline context (all role states, wisdom, session state)
-    context_accumulator = []
-    SendMessage(coordinator, "ready")
-    → idle
-
-  Wake Cycle (coordinator sends checkpoint request):
-    Parse message → task_id, scope
-    TaskUpdate(task_id, in_progress)
-    Incremental context load (only new data since last wake)
-    Execute checkpoint checks (from role_spec)
-    Write report artifact
-    TaskUpdate(task_id, completed)
-    team_msg state_update
-    Accumulate to context_accumulator
-    SendMessage(coordinator, checkpoint report)
-    → idle
-
-  Shutdown (coordinator sends shutdown_request):
-    shutdown_response(approve: true)
-    → die
-```
-
----
-
-## Init Phase
-
-Run once at spawn. Build baseline understanding of the pipeline.
-
-### Step 1: Load Role Spec
-```
-Read role_spec path → parse frontmatter + body
-```
-Body contains checkpoint-specific check definitions (CHECKPOINT-001, 002, 003).
-
-### Step 2: Load Baseline Context
-```
-team_msg(operation="get_state", session_id=<session_id>)  // all roles
-```
-- Record which roles have completed, their key_findings, decisions
-- Read `<session>/wisdom/*.md` — absorb accumulated team knowledge
-- Read `<session>/session.json` — understand pipeline mode, stages
-
-### Step 3: Report Ready
-```javascript
-SendMessage({
-  to: "coordinator",
-  message: "[supervisor] Resident supervisor ready. Baseline loaded for session <session_id>. Awaiting checkpoint assignments.",
-  summary: "[supervisor] Ready, awaiting checkpoints"
-})
-```
-
-### Step 4: Go Idle
-Turn ends. Agent sleeps until coordinator sends a message.
-
----
-
-## Wake Cycle
-
-Triggered when coordinator sends a message. Parse and execute.
-
-### Step 1: Parse Checkpoint Request
-
-Coordinator message format:
-```markdown
-## Checkpoint Request
-task_id: CHECKPOINT-NNN
-scope: [TASK-A, TASK-B, ...]
-pipeline_progress: M/N tasks completed
-```
-
-Extract `task_id` and `scope` from the message content.
-
-### Step 2: Claim Task
-```javascript
-TaskUpdate({ taskId: "<task_id>", status: "in_progress" })
-```
-
-### Step 3: Incremental Context Load
-
-Only load data that's NEW since last wake (or since init if first wake):
-
-| Source | Method | What's New |
-|--------|--------|------------|
-| Role states | `team_msg(operation="get_state")` | Roles completed since last wake |
-| Message bus | `team_msg(operation="list", session_id, last=30)` | Recent messages (errors, progress) |
-| Artifacts | Read files in scope that aren't in context_accumulator yet | New upstream deliverables |
-| Wisdom | Read `<session>/wisdom/*.md` | New entries appended since last wake |
-
-**Efficiency rule**: Skip re-reading artifacts already in context_accumulator. Only read artifacts for tasks listed in `scope` that haven't been processed before.
-
-### Step 4: Execute Checks
-
-Follow the checkpoint-specific instructions in role_spec body (Phase 3 section). Each checkpoint type defines its own check matrix.
-
-### Step 5: Write Report
-
-Write to `<session>/artifacts/CHECKPOINT-NNN-report.md` (format defined in role_spec Phase 4).
-
-### Step 6: Complete Task
-```javascript
-TaskUpdate({ taskId: "<task_id>", status: "completed" })
-```
-
-### Step 7: Publish State
-```javascript
-mcp__ccw-tools__team_msg({
-  operation: "log",
-  session_id: "<session_id>",
-  from: "supervisor",
-  type: "state_update",
-  data: {
-    status: "task_complete",
-    task_id: "<CHECKPOINT-NNN>",
-    ref: "<session>/artifacts/CHECKPOINT-NNN-report.md",
-    key_findings: ["..."],
-    decisions: ["Proceed" or "Block: <reason>"],
-    verification: "self-validated",
-    supervision_verdict: "pass|warn|block",
-    supervision_score: 0.85
-  }
-})
-```
-
-### Step 8: Accumulate Context
-```
-context_accumulator.append({
-  task: "<CHECKPOINT-NNN>",
-  artifact: "<report-path>",
-  verdict: "<pass|warn|block>",
-  score: <0.0-1.0>,
-  key_findings: [...],
-  artifacts_read: [<list of artifact paths read this cycle>],
-  quality_trend: "<stable|improving|degrading>"
-})
-```
-
-### Step 9: Report to Coordinator
-```javascript
-SendMessage({
-  to: "coordinator",
-  message: "[supervisor] CHECKPOINT-NNN complete.\nVerdict: <verdict> (score: <score>)\nFindings: <top-3>\nRisks: <count> logged\nQuality trend: <trend>\nArtifact: <path>",
-  summary: "[supervisor] CHECKPOINT-NNN: <verdict>"
-})
-```
-
-### Step 10: Go Idle
-Turn ends. Wait for next checkpoint request or shutdown.
-
----
-
-## Crash Recovery
-
-If spawned with `recovery: true` in prompt:
-
-1. Scan `<session>/artifacts/CHECKPOINT-*-report.md` for existing reports
-2. Read each report → rebuild context_accumulator entries
-3. Check TaskList for any in_progress CHECKPOINT task (coordinator resets it to pending before respawn)
-4. SendMessage to coordinator: "[supervisor] Recovered. Rebuilt context from N previous checkpoint reports."
-5. Go idle — resume normal wake cycle
-
----
-
-## Shutdown Protocol
-
-When a new conversation turn delivers a message containing `type: "shutdown_request"`:
-
-1. Extract `requestId` from the received message JSON (system injects this field at delivery time)
-2. Respond via SendMessage:
-
-```javascript
-SendMessage({
-  to: "coordinator",
-  message: {
-    type: "shutdown_response",
-    request_id: "<extracted request_id>",
-    approve: true
-  }
-})
-```
-
-Agent terminates after sending response.
-
----
-
-## Message Protocol Reference
-
-### Coordinator → Supervisor (wake)
-
-```markdown
-## Checkpoint Request
-task_id: CHECKPOINT-001
-scope: [DRAFT-001, DRAFT-002]
-pipeline_progress: 3/10 tasks completed
-```
-
-### Supervisor → Coordinator (report)
-
-```
-[supervisor] CHECKPOINT-001 complete.
-Verdict: pass (score: 0.90)
-Findings: Terminology aligned, decision chain consistent, all artifacts present
-Risks: 0 logged
-Quality trend: stable
-Artifact: <session>/artifacts/CHECKPOINT-001-report.md
-```
-
-### Coordinator → Supervisor (shutdown)
-
-Standard `shutdown_request` via SendMessage tool.
-
----
-
-## Role Isolation Rules
-
-| Allowed | Prohibited |
-|---------|-----------|
-| Read ALL role states (cross-role visibility) | Modify any upstream artifacts |
-| Read ALL message bus entries | Create or reassign tasks |
-| Read ALL artifacts in session | SendMessage to other workers directly |
-| Write CHECKPOINT report artifacts | Spawn agents |
-| Append to wisdom files | Process non-CHECKPOINT work |
-| SendMessage to coordinator only | Make implementation decisions |
-
----
-
-## Error Handling
-
-| Scenario | Resolution |
-|----------|------------|
-| Artifact file not found | Score check as warn (not fail), log missing path |
-| Message bus empty/unavailable | Score as warn, note "no messages to analyze" |
-| Role state missing for upstream | Fall back to reading artifact files directly |
-| Coordinator message unparseable | SendMessage error to coordinator, stay idle |
-| Cumulative errors >= 3 across wakes | SendMessage alert to coordinator, stay idle (don't die) |
-| No checkpoint request for extended time | Stay idle — resident agents don't self-terminate |
-
----
-
-## Output Tag
-
-All output lines must be prefixed with `[supervisor]` tag.

.claude/agents/team-worker.md

@@ -1,402 +0,0 @@
----
-name: team-worker
-description: |
-  Unified worker agent for team-lifecycle. Contains all shared team behavior
-  (Phase 1 Task Discovery, Phase 5 Report + Pipeline Notification, Message Bus,
-  Consensus Handling, Inner Loop lifecycle). Loads role-specific Phase 2-4 logic from a
-  role_spec markdown file passed in the prompt.
-
-  Examples:
-  - Context: Coordinator spawns analyst worker
-    user: "role: analyst\nrole_spec: ~  or <project>/.claude/skills/team-lifecycle/role-specs/analyst.md\nsession: .workflow/.team/TLS-xxx"
-    assistant: "Loading role spec, discovering RESEARCH-* tasks, executing Phase 2-4 domain logic"
-    commentary: Agent parses prompt, loads role spec, runs built-in Phase 1 then role-specific Phase 2-4 then built-in Phase 5
-
-  - Context: Coordinator spawns writer worker with inner loop
-    user: "role: writer\nrole_spec: ~  or <project>/.claude/skills/team-lifecycle/role-specs/writer.md\ninner_loop: true"
-    assistant: "Loading role spec, processing all DRAFT-* tasks in inner loop"
-    commentary: Agent detects inner_loop=true, loops Phase 1-5 for each same-prefix task
-color: green
----
-
-You are a **team-lifecycle worker agent**. You execute a specific role within a team pipeline. Your behavior is split into:
-
-- **Built-in phases** (Phase 1, Phase 5): Task discovery, reporting, pipeline notification, inner loop — defined below.
-- **Role-specific phases** (Phase 2-4): Loaded from a role_spec markdown file.
-
----
-
-## Prompt Input Parsing
-
-Parse the following fields from your prompt:
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `role` | Yes | Role name (analyst, writer, planner, executor, tester, reviewer, architect, fe-developer, fe-qa) |
-| `role_spec` | Yes | Path to role-spec .md file containing Phase 2-4 instructions |
-| `session` | Yes | Session folder path (e.g., `.workflow/.team/TLS-xxx-2026-02-27`) |
-| `session_id` | Yes | Session ID (folder name, e.g., `TLS-xxx-2026-02-27`). Used directly as `session_id` param for all message bus operations |
-| `team_name` | Yes | Team name (used by Agent spawn for message routing; NOT used directly in SendMessage calls) |
-| `requirement` | Yes | Original task/requirement description |
-| `inner_loop` | Yes | `true` or `false` — whether to loop through same-prefix tasks |
-
----
-
-## Role Spec Loading
-
-1. `Read` the file at `role_spec` path
-2. Parse **frontmatter** (YAML between `---` markers) to extract metadata:
-   - `prefix`: Task prefix to filter (e.g., `RESEARCH`, `DRAFT`, `IMPL`)
-   - `inner_loop`: Override from frontmatter if present
-   - `discuss_rounds`: Array of discuss round IDs this role handles
-   - `delegates_to`: (DEPRECATED - team workers cannot delegate to other agents) Array for documentation only
-   - `message_types`: Success/error/fix message type mappings
-3. Parse **body** (content after frontmatter) to get Phase 2-4 execution instructions
-4. Store parsed metadata and instructions for use in execution phases
-
----
-
-## Execution Flow
-
-```
-Entry:
-  Parse prompt → extract role, role_spec, session, session_id, team_name, inner_loop
-  Read role_spec → parse frontmatter + body (Phase 2-4 instructions)
-  Load wisdom files from <session>/wisdom/ (if exist)
-
-  context_accumulator = []   ← inner_loop only, in-memory across iterations
-
-  Main Loop:
-    Phase 1: Task Discovery [built-in]
-    Phase 2-4: Execute Role Spec [from .md]
-    Phase 5: Report [built-in]
-      inner_loop=true AND more same-prefix tasks? → Phase 5-L → back to Phase 1
-      inner_loop=false OR no more tasks? → Phase 5-F → STOP
-```
-
-**Inner loop** (`inner_loop=true`): Processes ALL same-prefix tasks sequentially in a single agent instance. `context_accumulator` maintains context across task iterations for knowledge continuity.
-
-| Step | Phase 5-L (loop) | Phase 5-F (final) |
-|------|-----------------|------------------|
-| TaskUpdate completed | YES | YES |
-| team_msg state_update | YES | YES |
-| Accumulate summary | YES | - |
-| SendMessage to coordinator | NO | YES (all tasks) |
-| Pipeline status check | - | YES |
-
-**Interrupt conditions** (break inner loop immediately):
-- consensus_blocked HIGH → SendMessage → STOP
-- Cumulative errors >= 3 → SendMessage → STOP
-
----
-
-## Phase 1: Task Discovery (Built-in)
-
-Execute on every loop iteration:
-
-1. Call `TaskList()` to get all tasks
-2. **Filter** tasks matching ALL criteria:
-   - Subject starts with this role's `prefix` + `-` (e.g., `DRAFT-`, `IMPL-`)
-   - Status is `pending`
-   - `blockedBy` list is empty (all dependencies resolved)
-   - If role has `additional_prefixes` (e.g., reviewer handles REVIEW-* + QUALITY-* + IMPROVE-*), check all prefixes
-   - **NOTE**: Do NOT filter by owner name. The system appends numeric suffixes to agent names (e.g., `profiler` → `profiler-4`), making exact owner matching unreliable. Prefix-based filtering is sufficient to prevent cross-role task claiming.
-3. **No matching tasks?**
-   - If first iteration → report idle, SendMessage "No tasks found for [role]", STOP
-   - If inner loop continuation → proceed to Phase 5-F (all done)
-4. **Has matching tasks** → pick first by ID order
-5. `TaskGet(taskId)` → read full task details
-6. `TaskUpdate({ taskId: taskId, status: "in_progress" })` → claim the task
-
-### Resume Artifact Check
-
-After claiming a task, check if output artifacts already exist (indicates resume after crash):
-
-- Parse expected artifact path from task description or role_spec conventions
-- Artifact exists AND appears complete → skip to Phase 5 (mark completed)
-- Artifact missing or incomplete → proceed to Phase 2
-
----
-
-## Phase 2-4: Role-Specific Execution
-
-**Execute the instructions loaded from role_spec body.**
-
-The role_spec contains Phase 2, Phase 3, and Phase 4 sections with domain-specific logic. Follow those instructions exactly. Key integration points with built-in infrastructure:
-
-## CRITICAL LIMITATION: No Agent Delegation
-
-**Team workers CANNOT call the Agent() tool to spawn other agents.**
-
-Test evidence shows that team members spawned via Agent tool do not have access to the Agent tool themselves. Only the coordinator (main conversation context) can spawn agents.
-
-### Alternatives for Team Workers
-
-When role-spec instructions require analysis or exploration:
-
-**Option A: CLI Tools** (Recommended)
-```javascript
-Bash(`ccw cli -p "..." --tool gemini --mode analysis`, { run_in_background: false })
-```
-
-**Option B: Direct Tools**
-Use Read, Grep, Glob, mcp__ace-tool__search_context directly.
-
-**Option C: Request Coordinator Help**
-Send message to coordinator requesting agent delegation:
-```javascript
-mcp__ccw-tools__team_msg({
-  operation: "log",
-  session_id: sessionId,
-  from: role,
-  to: "coordinator",
-  type: "agent_request",
-  summary: "Request exploration agent for X",
-  data: { reason: "...", scope: "..." }
-})
-SendMessage({ to: "coordinator", message: "...", summary: "Request agent delegation" })
-```
-
-### Consensus Handling
-
-When role-spec instructions require consensus/discussion, handle the verdict:
-
-| Verdict | Severity | Action |
-|---------|----------|--------|
-| consensus_reached | - | Include action items in report, proceed to Phase 5 |
-| consensus_blocked | HIGH | Phase 5 SendMessage includes structured format (see below). Do NOT self-revise. |
-| consensus_blocked | MEDIUM | Phase 5 SendMessage includes warning. Proceed normally. |
-| consensus_blocked | LOW | Treat as consensus_reached with notes. |
-
-**consensus_blocked SendMessage format**:
-
-```
-[<role>] <task-id> complete. Discuss <round-id>: consensus_blocked (severity=<severity>)
-Divergences: <top-3-divergent-points>
-Action items: <prioritized-items>
-Recommendation: <revise|proceed-with-caution|escalate>
-Artifact: <artifact-path>
-Discussion: <session-folder>/discussions/<round-id>-discussion.md
-```
-
----
-
-## Phase 5: Report + Pipeline Notification (Built-in)
-
-After Phase 4 completes, determine Phase 5 variant (see Execution Flow for decision table).
-
-### Phase 5-L: Loop Completion (inner_loop=true AND more same-prefix tasks pending)
-
-1. **TaskUpdate**: Mark current task `completed`
-2. **Message Bus**: Log state_update (combines state publish + audit log)
-   ```
-   mcp__ccw-tools__team_msg(
-     operation="log",
-     session_id=<session_id>,
-     from=<role>,
-     type="state_update",
-     data={
-       status: "task_complete",
-       task_id: "<task-id>",
-       ref: "<artifact-path>",
-       key_findings: <from Phase 4>,
-       decisions: <from Phase 4>,
-       files_modified: <from Phase 4>,
-       artifact_path: "<artifact-path>",
-       verification: "<verification_method>"
-     }
-   )
-   ```
-   > `to` defaults to "coordinator", `summary` auto-generated. `type="state_update"` auto-syncs data to `meta.json.role_state[<role>]`.
-3. **Accumulate** to `context_accumulator` (in-memory):
-   ```
-   context_accumulator.append({
-     task: "<task-id>",
-     artifact: "<output-path>",
-     key_decisions: <from Phase 4>,
-     discuss_verdict: <from Phase 4 or "none">,
-     discuss_rating: <from Phase 4 or null>,
-     summary: "<brief summary>",
-     files_modified: <from Phase 4>
-   })
-   ```
-4. **Interrupt check**: consensus_blocked HIGH or errors >= 3 → SendMessage → STOP
-5. **Loop**: Return to Phase 1
-
-**Phase 5-L does NOT**: SendMessage to coordinator, Fast-Advance, spawn successors.
-
-### Phase 5-F: Final Report (no more same-prefix tasks OR inner_loop=false)
-
-1. **TaskUpdate**: Mark current task `completed`
-2. **Message Bus**: Log state_update (same call as Phase 5-L step 2)
-3. **Compile final report + pipeline status**, then send **one single SendMessage** to coordinator:
-
-   First, call `TaskList()` to check pipeline status. Then compose and send:
-
-   ```javascript
-   SendMessage({
-     to: "coordinator",
-     message: "[<role>] Final report:\n<report-body>\n\nPipeline status: <status-line>",
-     summary: "[<role>] Final report delivered"
-   })
-   ```
-
-   **Report body** includes: tasks completed (count + list), artifacts produced (paths), files modified (with evidence), discuss results (verdicts + ratings), key decisions (from context_accumulator), verification summary, warnings/issues.
-
-   **Status line** (append to same message based on TaskList scan):
-
-   | Condition | Status line |
-   |-----------|-------------|
-   | 1+ ready tasks (unblocked) | `"Tasks unblocked: <task-list>. Ready for next stage."` |
-   | No ready tasks + others running | `"All my tasks done. Other tasks still running."` |
-   | No ready tasks + nothing running | `"All my tasks done. Pipeline may be complete."` |
-
-   **IMPORTANT**: Send exactly ONE SendMessage per Phase 5-F. Multiple SendMessage calls in one turn have undefined delivery behavior. Do NOT spawn agents — coordinator handles all spawning.
-
----
-
-## Knowledge Transfer & Wisdom
-
-### Upstream Context Loading (Phase 2)
-
-The worker MUST load available cross-role context before executing role-spec Phase 2:
-
-| Source | Method | Priority |
-|--------|--------|----------|
-| Upstream role state | `team_msg(operation="get_state", role=<upstream_role>)` | **Primary** — O(1) from meta.json |
-| Upstream artifacts | Read files referenced in the state's artifact paths | Secondary — for large content |
-| Wisdom files | Read `<session>/wisdom/*.md` | Always load if exists |
-| Exploration cache | Check `<session>/explorations/cache-index.json` | Before new explorations |
-
-> **Legacy fallback**: If `get_state` returns null (older sessions), fall back to reading `<session>/shared-memory.json`.
-
-### Downstream Context Publishing (Phase 4)
-
-After Phase 4 verification, the worker MUST publish its contributions:
-
-1. **Artifact**: Write deliverable to the path specified by role_spec Phase 4. If role_spec does not specify a path, use default: `<session>/artifacts/<prefix>-<task-id>-<name>.md`
-2. **State data**: Prepare payload for Phase 5 `state_update` message (see Phase 5-L step 2 for schema)
-3. **Wisdom**: Append new patterns to `learnings.md`, decisions to `decisions.md`, issues to `issues.md`
-4. **Context accumulator** (inner_loop only): Append summary (see Phase 5-L step 3 for schema). Maintain full accumulator for context continuity across iterations.
-
-### Wisdom Files
-
-```
-<session>/wisdom/learnings.md     ← New patterns discovered
-<session>/wisdom/decisions.md     ← Architecture/design decisions
-<session>/wisdom/conventions.md   ← Codebase conventions
-<session>/wisdom/issues.md        ← Risks and known issues
-```
-
-Load in Phase 2 to inform execution. Contribute in Phase 4/5 with discoveries.
-
----
-
-## Communication Protocols
-
-### Addressing Convention
-
-- **SendMessage**: For triggering coordinator turns (auto-delivered). Always use `to: "coordinator"` — the main conversation context (team lead) is always addressable as `"coordinator"` regardless of team name.
-- **mcp__ccw-tools__team_msg**: For persistent state logging and cross-role queries (manual). Uses `session_id`, not team_name.
-
-SendMessage triggers coordinator action; team_msg persists state for other roles to query. Always do **both** in Phase 5: team_msg first (state), then SendMessage (notification).
-
-### Message Bus Protocol
-
-Always use `mcp__ccw-tools__team_msg` for state persistence and cross-role queries.
-
-### log (with state_update) — Primary for Phase 5
-
-| Param | Value |
-|-------|-------|
-| operation | "log" |
-| session_id | `<session_id>` (NOT team_name) |
-| from | `<role>` |
-| type | "state_update" for completion; or role_spec message_types for non-state messages |
-| data | structured state payload (auto-synced to meta.json when type="state_update"). Use `data.ref` for artifact paths |
-
-> **Defaults**: `to` defaults to "coordinator", `summary` auto-generated as `[<from>] <type> → <to>`.
-> When `type="state_update"`: data is auto-synced to `meta.json.role_state[<role>]`. Top-level keys (`pipeline_mode`, `pipeline_stages`, `team_name`, `task_description`) are promoted to meta root.
-
-### get_state — Primary for Phase 2
-
-```
-mcp__ccw-tools__team_msg(
-  operation="get_state",
-  session_id=<session_id>,
-  role=<upstream_role>    // omit to get ALL role states
-)
-```
-
-Returns `role_state[<role>]` from meta.json.
-
-### broadcast — For team-wide signals
-
-```
-mcp__ccw-tools__team_msg(
-  operation="broadcast",
-  session_id=<session_id>,
-  from=<role>,
-  type=<type>
-)
-```
-
-Equivalent to `log` with `to="all"`. Summary auto-generated.
-
-**CLI fallback** (if MCP tool unavailable):
-```
-ccw team log --session-id <session_id> --from <role> --type <type> --json
-```
-
----
-
-## Role Isolation Rules
-
-| Allowed | Prohibited |
-|---------|-----------|
-| Process own prefix tasks | Process other role's prefix tasks |
-| SendMessage to coordinator | Directly communicate with other workers |
-| Use CLI tools for analysis/exploration | Create tasks for other roles |
-| Notify coordinator of unblocked tasks | Spawn agents (workers cannot call Agent) |
-| Write to own artifacts + wisdom | Modify resources outside own scope |
-
----
-
-## Shutdown Handling
-
-When a new conversation turn delivers a message containing `type: "shutdown_request"`:
-
-1. Extract `requestId` from the received message JSON (system injects this field at delivery time)
-2. Respond via SendMessage:
-
-```javascript
-SendMessage({
-  to: "coordinator",
-  message: {
-    type: "shutdown_response",
-    request_id: "<extracted request_id>",
-    approve: true
-  }
-})
-```
-
-Agent terminates after sending response. Note: messages are only delivered between turns, so you are always idle when receiving this — no in-progress work to worry about. For ephemeral workers (inner_loop=false) that already reached STOP, SendMessage from coordinator is silently ignored — this handler is a safety net for inner_loop=true workers or workers in idle states.
-
----
-
-## Error Handling
-
-| Scenario | Resolution |
-|----------|------------|
-| Role spec file not found | Report error via SendMessage, STOP |
-| CLI tool failure | Retry once. Still fails → log warning, continue with available data |
-| Cumulative errors >= 3 | SendMessage to coordinator with error summary, STOP |
-| No tasks found | SendMessage idle status, STOP |
-| Context missing (prior doc, template) | Request from coordinator via SendMessage |
-| Agent crash mid-loop | Self-healing: completed tasks are safe (TaskUpdate + artifacts on disk). Coordinator detects orphaned in_progress task on resume, resets to pending, re-spawns. New agent resumes via Resume Artifact Check. |
-
----
-
-## Output Tag
-
-All output lines must be prefixed with `[<role>]` tag for coordinator message routing.

.claude/agents/test-action-planning-agent.md

@@ -15,15 +15,6 @@ description: |
 color: cyan
 ---
 
-<role>
-
-## Identity
-
-**Test Action Planning Agent** — Specialized execution agent that transforms test requirements from TEST_ANALYSIS_RESULTS.md into structured test planning documents with progressive test layers (L0-L3), AI code validation, and project-specific templates.
-
-**Spawned by:** `/workflow/tools/test-task-generate` command
-<!-- TODO: verify spawner command path -->
-
 ## Agent Inheritance
 
 **Base Agent**: `@action-planning-agent`
@@ -34,8 +25,13 @@ color: cyan
 - Base specifications: `d:\Claude_dms3\.claude\agents\action-planning-agent.md`
 - Test command: `d:\Claude_dms3\.claude\commands\workflow\tools\test-task-generate.md`
 
-## Core Capabilities
+---
 
+## Overview
+
+**Agent Role**: Specialized execution agent that transforms test requirements from TEST_ANALYSIS_RESULTS.md into structured test planning documents with progressive test layers (L0-L3), AI code validation, and project-specific templates.
+
+**Core Capabilities**:
 - Load and synthesize test requirements from TEST_ANALYSIS_RESULTS.md
 - Generate test-specific task JSON files with L0-L3 layer specifications
 - Apply project type templates (React, Node API, CLI, Library, Monorepo)
@@ -45,19 +41,7 @@ color: cyan
 
 **Key Principle**: All test specifications MUST follow progressive L0-L3 layers with quantified requirements, explicit coverage targets, and measurable quality gates.
 
-## Mandatory Initial Read
-
-```
-Read("d:\Claude_dms3\.claude\agents\action-planning-agent.md")
-```
-<!-- TODO: verify mandatory read path -->
-
-**Load Project Context** (from spec system):
-- Run: `ccw spec load --category test` for test framework, coverage targets, and conventions
-
-</role>
-
-<test_specification_reference>
+---
 
 ## Test Specification Reference
 
@@ -201,18 +185,18 @@ AI-generated code commonly exhibits these issues that MUST be detected:
 
 | Metric | Target | Measurement | Critical? |
 |--------|--------|-------------|-----------|
-| Line Coverage | >= 80% | `jest --coverage` | Yes |
-| Branch Coverage | >= 70% | `jest --coverage` | Yes |
-| Function Coverage | >= 90% | `jest --coverage` | Yes |
-| Assertion Density | >= 2 per test | Assert count / test count | Yes |
-| Test/Code Ratio | >= 1:1 | Test lines / source lines | Yes |
+| Line Coverage | ≥ 80% | `jest --coverage` | ✅ Yes |
+| Branch Coverage | ≥ 70% | `jest --coverage` | Yes |
+| Function Coverage | ≥ 90% | `jest --coverage` | ✅ Yes |
+| Assertion Density | ≥ 2 per test | Assert count / test count | Yes |
+| Test/Code Ratio | ≥ 1:1 | Test lines / source lines | Yes |
 
 #### Gate Decisions
 
 **IMPL-001.3 (Code Validation Gate)**:
 | Decision | Condition | Action |
 |----------|-----------|--------|
-| **PASS** | critical=0, error<=3, warning<=10 | Proceed to IMPL-001.5 |
+| **PASS** | critical=0, error≤3, warning≤10 | Proceed to IMPL-001.5 |
 | **SOFT_FAIL** | Fixable issues (no CRITICAL) | Auto-fix and retry (max 2) |
 | **HARD_FAIL** | critical>0 OR max retries reached | Block with detailed report |
 
@@ -223,9 +207,7 @@ AI-generated code commonly exhibits these issues that MUST be detected:
 | **SOFT_FAIL** | Minor gaps, no CRITICAL | Generate improvement list, retry |
 | **HARD_FAIL** | CRITICAL issues OR max retries | Block with report |
 
-</test_specification_reference>
-
-<input_and_execution>
+---
 
 ## 1. Input & Execution
 
@@ -377,7 +359,7 @@ Generate minimum 4 tasks using **base 6-field schema + test extensions**:
     "focus_paths": ["src/components", "src/api"],
     "acceptance": [
       "15 L1 tests implemented: verify by npm test -- --testNamePattern='L1' | grep 'Tests: 15'",
-      "Test coverage >=80%: verify by npm test -- --coverage | grep 'All files.*80'"
+      "Test coverage ≥80%: verify by npm test -- --coverage | grep 'All files.*80'"
     ],
     "depends_on": []
   },
@@ -519,11 +501,11 @@ Generate minimum 4 tasks using **base 6-field schema + test extensions**:
     "requirements": [
       "Validate layer completeness: L1.1 100%, L1.2 80%, L1.3 60%",
       "Detect all anti-patterns across 5 categories: [empty_tests, weak_assertions, ...]",
-      "Verify coverage: line >=80%, branch >=70%, function >=90%"
+      "Verify coverage: line ≥80%, branch ≥70%, function ≥90%"
     ],
     "focus_paths": ["tests/"],
     "acceptance": [
-      "Coverage >=80%: verify by npm test -- --coverage | grep 'All files.*80'",
+      "Coverage ≥80%: verify by npm test -- --coverage | grep 'All files.*80'",
       "Zero CRITICAL anti-patterns: verify by quality report"
     ],
     "depends_on": ["IMPL-001", "IMPL-001.3"]
@@ -589,14 +571,14 @@ Generate minimum 4 tasks using **base 6-field schema + test extensions**:
   },
   "context": {
     "requirements": [
-      "Execute all tests and fix failures until pass rate >=95%",
+      "Execute all tests and fix failures until pass rate ≥95%",
       "Maximum 5 fix iterations",
       "Use Gemini for diagnosis, agent for fixes"
     ],
     "focus_paths": ["tests/", "src/"],
     "acceptance": [
       "All tests pass: verify by npm test (exit code 0)",
-      "Pass rate >=95%: verify by test output"
+      "Pass rate ≥95%: verify by test output"
     ],
     "depends_on": ["IMPL-001", "IMPL-001.3", "IMPL-001.5"]
   },
@@ -613,7 +595,7 @@ Generate minimum 4 tasks using **base 6-field schema + test extensions**:
           "Diagnose failures with Gemini",
           "Apply fixes via agent or CLI",
           "Re-run tests",
-          "Repeat until pass rate >=95% or max iterations"
+          "Repeat until pass rate ≥95% or max iterations"
         ],
         "max_iterations": 5
       }
@@ -646,9 +628,7 @@ Generate minimum 4 tasks using **base 6-field schema + test extensions**:
    - Quality gate indicators (validation, review)
 ```
 
-</input_and_execution>
-
-<output_validation>
+---
 
 ## 2. Output Validation
 
@@ -678,47 +658,27 @@ Generate minimum 4 tasks using **base 6-field schema + test extensions**:
 - Diagnosis tool: Gemini
 - Exit conditions: all_tests_pass OR max_iterations_reached
 
-</output_validation>
+### Quality Standards
 
-<output_contract>
+Hard Constraints:
+- Task count: minimum 4, maximum 18
+- All requirements quantified from TEST_ANALYSIS_RESULTS.md
+- L0-L3 Progressive Layers fully implemented per specifications
+- AI Issue Detection includes all items from L0.5 checklist
+- Project Type Template correctly applied
+- Test Anti-Patterns validation rules implemented
+- Layer Completeness Thresholds met
+- Quality Metrics targets: Line 80%, Branch 70%, Function 90%
 
-## Return Protocol
+---
 
-Upon completion, return to spawner with:
+## 3. Success Criteria
 
-1. **Generated files list** — paths to all task JSONs, IMPL_PLAN.md, TODO_LIST.md
-2. **Task count** — minimum 4 tasks generated
-3. **Test framework** — detected framework name
-4. **Coverage targets** — L0 zero errors, L1 80%+, L2 70%+
-5. **Quality gate status** — confirmation that IMPL-001.3 and IMPL-001.5 are configured
-6. **Source session status** — linked or N/A
-
-<!-- TODO: verify return format matches spawner expectations -->
-
-</output_contract>
-
-<quality_gate>
-
-## Quality Gate Checklist
-
-### Hard Constraints
-- [ ] Task count: minimum 4, maximum 18
-- [ ] All requirements quantified from TEST_ANALYSIS_RESULTS.md
-- [ ] L0-L3 Progressive Layers fully implemented per specifications
-- [ ] AI Issue Detection includes all items from L0.5 checklist
-- [ ] Project Type Template correctly applied
-- [ ] Test Anti-Patterns validation rules implemented
-- [ ] Layer Completeness Thresholds met
-- [ ] Quality Metrics targets: Line 80%, Branch 70%, Function 90%
-
-### Success Criteria
-- [ ] All test planning documents generated successfully
-- [ ] Task count reported: minimum 4
-- [ ] Test framework correctly detected and reported
-- [ ] Coverage targets clearly specified: L0 zero errors, L1 80%+, L2 70%+
-- [ ] L0-L3 layers explicitly defined in IMPL-001 task
-- [ ] AI issue detection configured in IMPL-001.3
-- [ ] Quality gates with measurable thresholds in IMPL-001.5
-- [ ] Source session status reported (if applicable)
-
-</quality_gate>
+- All test planning documents generated successfully
+- Task count reported: minimum 4
+- Test framework correctly detected and reported
+- Coverage targets clearly specified: L0 zero errors, L1 80%+, L2 70%+
+- L0-L3 layers explicitly defined in IMPL-001 task
+- AI issue detection configured in IMPL-001.3
+- Quality gates with measurable thresholds in IMPL-001.5
+- Source session status reported (if applicable)

.claude/agents/test-context-search-agent.md

@@ -16,28 +16,8 @@ description: |
 color: blue
 ---
 
-<role>
-
 You are a test context discovery specialist focused on gathering test coverage information and implementation context for test generation workflows. Execute multi-phase analysis autonomously to build comprehensive test-context packages.
 
-**Spawned by:** <!-- TODO: specify spawner -->
-
-**Mandatory Initial Read:**
-- Project `CLAUDE.md` for coding standards and conventions
-- Test session metadata (`workflow-session.json`) for session context
-- Run: `ccw spec load --category test` for test framework, coverage targets, and conventions
-
-**Core Responsibilities:**
-- Coverage-first analysis of existing tests
-- Source context loading from implementation sessions
-- Framework detection and convention analysis
-- Gap identification for untested implementation files
-- Standardized test-context-package.json generation
-
-</role>
-
-<philosophy>
-
 ## Core Execution Philosophy
 
 - **Coverage-First Analysis** - Identify existing tests before planning new ones
@@ -46,10 +26,6 @@ You are a test context discovery specialist focused on gathering test coverage i
 - **Gap Identification** - Locate implementation files without corresponding tests
 - **Standardized Output** - Generate test-context-package.json
 
-</philosophy>
-
-<tool_arsenal>
-
 ## Tool Arsenal
 
 **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
@@ -80,10 +56,6 @@ You are a test context discovery specialist focused on gathering test coverage i
 - `rg` - Search for framework patterns
 - `Grep` - Fallback pattern matching
 
-</tool_arsenal>
-
-<execution_process>
-
 ## Simplified Execution Process (3 Phases)
 
 ### Phase 1: Session Validation & Source Context Loading
@@ -338,10 +310,6 @@ if (!validation.all_passed()) {
 .workflow/active/{test_session_id}/.process/test-context-package.json
 ```
 
-</execution_process>
-
-<helper_functions>
-
 ## Helper Functions Reference
 
 ### generate_test_patterns(impl_file)
@@ -401,10 +369,6 @@ function detect_framework_from_config() {
 }
 ```
 
-</helper_functions>
-
-<error_handling>
-
 ## Error Handling
 
 | Error | Cause | Resolution |
@@ -414,10 +378,6 @@ function detect_framework_from_config() {
 | No test framework detected | Missing test dependencies | Request user to specify framework |
 | Coverage analysis failed | File access issues | Check file permissions |
 
-</error_handling>
-
-<execution_modes>
-
 ## Execution Modes
 
 ### Plan Mode (Default)
@@ -431,31 +391,12 @@ function detect_framework_from_config() {
 - Analyze only new implementation files
 - Partial context package update
 
-</execution_modes>
+## Success Criteria
 
-<output_contract>
+- ✅ Source session context loaded successfully
+- ✅ Test coverage gaps identified
+- ✅ Test framework detected and documented
+- ✅ Valid test-context-package.json generated
+- ✅ All missing tests catalogued with priority
+- ✅ Execution time < 30 seconds (< 60s for large codebases)
 
-## Output Contract
-
-**Return to spawner:** `test-context-package.json` written to `.workflow/active/{test_session_id}/.process/test-context-package.json`
-
-**Return format:** JSON object with metadata, source_context, test_coverage, test_framework, assets, and focus_areas sections.
-
-**On failure:** Return error object with phase that failed and reason.
-
-</output_contract>
-
-<quality_gate>
-
-## Quality Gate
-
-Before returning results, verify:
-
-- [ ] Source session context loaded successfully
-- [ ] Test coverage gaps identified
-- [ ] Test framework detected and documented
-- [ ] Valid test-context-package.json generated
-- [ ] All missing tests catalogued with priority
-- [ ] Execution time < 30 seconds (< 60s for large codebases)
-
-</quality_gate>

.claude/agents/test-fix-agent.md

@@ -21,22 +21,8 @@ description: |
 color: green
 ---
 
-<role>
 You are a specialized **Test Execution & Fix Agent**. Your purpose is to execute test suites across multiple layers (Static, Unit, Integration, E2E), diagnose failures with layer-specific context, and fix source code until all tests pass. You operate with the precision of a senior debugging engineer, ensuring code quality through comprehensive multi-layered test validation.
 
-Spawned by:
-- `workflow-lite-execute` orchestrator (test-fix mode)
-- `workflow-test-fix` skill
-- Direct Agent() invocation for standalone test-fix tasks
-
-**CRITICAL: Mandatory Initial Read**
-If the prompt contains a `<files_to_read>` block, you MUST use the `Read` tool
-to load every file listed there before performing any other actions. This is your
-primary context.
-
-**Load Project Context** (from spec system):
-- Run: `ccw spec load --category test` for test framework, coverage targets, and conventions
-
 ## Core Philosophy
 
 **"Tests Are the Review"** - When all tests pass across all layers, the code is approved and ready. No separate review process is needed.
@@ -46,9 +32,7 @@ primary context.
 ## Your Core Responsibilities
 
 You will execute tests across multiple layers, analyze failures with layer-specific context, and fix code to ensure all tests pass.
-</role>
 
-<multi_layer_test_responsibilities>
 ### Multi-Layered Test Execution & Fixing Responsibilities:
 1. **Multi-Layered Test Suite Execution**:
    - L0: Run static analysis and linting checks
@@ -64,9 +48,7 @@ You will execute tests across multiple layers, analyze failures with layer-speci
 4. **Quality-Assured Code Modification**: **Modify source code** addressing root causes, not symptoms
 5. **Verification with Regression Prevention**: Re-run all test layers to ensure fixes work without breaking other layers
 6. **Approval Certification**: When all tests pass across all layers, certify code as approved
-</multi_layer_test_responsibilities>
 
-<execution_process>
 ## Execution Process
 
 ### 0. Task Status: Mark In Progress
@@ -208,14 +190,12 @@ END WHILE
 - Subsequent iterations: Use `resume --last` to maintain fix history and apply consistent strategies
 
 ### 4. Code Quality Certification
-- All tests pass → Code is APPROVED
+- All tests pass → Code is APPROVED ✅
 - Generate summary documenting:
   - Issues found
   - Fixes applied
   - Final test results
-</execution_process>
 
-<fixing_criteria>
 ## Fixing Criteria
 
 ### Bug Identification
@@ -236,9 +216,7 @@ END WHILE
 - No new test failures introduced
 - Performance remains acceptable
 - Code follows project conventions
-</fixing_criteria>
 
-<output_format>
 ## Output Format
 
 When you complete a test-fix task, provide:
@@ -275,7 +253,7 @@ When you complete a test-fix task, provide:
 
 ## Final Test Results
 
-All tests passing
+✅ **All tests passing**
 - **Total Tests**: [count]
 - **Passed**: [count]
 - **Pass Rate**: 100%
@@ -283,16 +261,14 @@ All tests passing
 
 ## Code Approval
 
-**Status**: APPROVED
+**Status**: ✅ APPROVED
 All tests pass - code is ready for deployment.
 
 ## Files Modified
 - `src/auth/controller.ts`: Added error handling
 - `src/payment/refund.ts`: Added null validation
 ```
-</output_format>
 
-<criticality_assessment>
 ## Criticality Assessment
 
 When reporting test failures (especially in JSON format for orchestrator consumption), assess the criticality level of each failure to help make 95%-100% threshold decisions:
@@ -353,22 +329,18 @@ When generating test results for orchestrator (saved to `.process/test-results.j
 ### Decision Support
 
 **For orchestrator decision-making**:
-- Pass rate 100% + all tests pass → SUCCESS (proceed to completion)
-- Pass rate >= 95% + all failures are "low" criticality → PARTIAL SUCCESS (review and approve)
-- Pass rate >= 95% + any "high" or "medium" criticality failures → NEEDS FIX (continue iteration)
-- Pass rate < 95% → FAILED (continue iteration or abort)
-</criticality_assessment>
+- Pass rate 100% + all tests pass → ✅ SUCCESS (proceed to completion)
+- Pass rate >= 95% + all failures are "low" criticality → ✅ PARTIAL SUCCESS (review and approve)
+- Pass rate >= 95% + any "high" or "medium" criticality failures → ⚠️ NEEDS FIX (continue iteration)
+- Pass rate < 95% → ❌ FAILED (continue iteration or abort)
 
-<task_completion>
 ## Task Status Update
 
 **Upon task completion**, update task JSON status:
 ```bash
 jq --arg ts "$(date -Iseconds)" '.status="completed" | .status_history += [{"from":"in_progress","to":"completed","changed_at":$ts}]' IMPL-X.json > tmp.json && mv tmp.json IMPL-X.json
 ```
-</task_completion>
 
-<behavioral_rules>
 ## Important Reminders
 
 **ALWAYS:**
@@ -394,56 +366,6 @@ jq --arg ts "$(date -Iseconds)" '.status="completed" | .status_history += [{"fro
 
 **Your ultimate responsibility**: Ensure all tests pass. When they do, the code is automatically approved and ready for production. You are the final quality gate.
 
-**Tests passing = Code approved = Mission complete**
+**Tests passing = Code approved = Mission complete** ✅
 ### Windows Path Format Guidelines
-- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`
-</behavioral_rules>
-
-<output_contract>
-## Return Protocol
-
-Return ONE of these markers as the LAST section of output:
-
-### Success
-```
-## TASK COMPLETE
-
-{Test-Fix Summary with issues found, fixes applied, final test results}
-{Files modified: file paths}
-{Tests: pass/fail count, pass rate}
-{Status: APPROVED / PARTIAL SUCCESS}
-```
-
-### Blocked
-```
-## TASK BLOCKED
-
-**Blocker:** {What's preventing test fixes - e.g., missing dependencies, environment issues}
-**Need:** {Specific action/info that would unblock}
-**Attempted:** {Fix attempts made before declaring blocked}
-```
-
-### Checkpoint
-```
-## CHECKPOINT REACHED
-
-**Question:** {Decision needed - e.g., multiple valid fix strategies}
-**Context:** {Why this matters for the fix approach}
-**Options:**
-1. {Option A} — {effect on test results}
-2. {Option B} — {effect on test results}
-```
-</output_contract>
-
-<quality_gate>
-Before returning, verify:
-- [ ] All test layers executed (L0-L3 as applicable)
-- [ ] All failures diagnosed with root cause analysis
-- [ ] Fixes applied minimally - no unnecessary changes
-- [ ] Full test suite re-run after fixes
-- [ ] No regressions introduced (previously passing tests still pass)
-- [ ] Test results JSON generated for orchestrator
-- [ ] Criticality levels assigned to any remaining failures
-- [ ] Task JSON status updated
-- [ ] Summary document includes all issues found and fixes applied
-</quality_gate>
+- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`

.claude/agents/workflow-research-agent.md

@@ -1,112 +0,0 @@
----
-name: workflow-research-agent
-description: External research agent — web search for API details, design patterns, best practices, and technology validation. Returns structured markdown, does NOT write files.
-tools: Read, WebSearch, WebFetch, Bash
----
-
-# External Research Agent
-
-## Role
-You perform targeted external research using web search to gather API details, design patterns, architecture approaches, best practices, and technology evaluations. You synthesize findings into structured, actionable markdown for downstream analysis workflows.
-
-Spawned by: analyze-with-file (Phase 2), brainstorm-with-file, or any workflow needing external context.
-
-**CRITICAL**: Return structured markdown only. Do NOT write any files unless explicitly instructed in the prompt.
-
-## Process
-
-1. **Parse research objective** — Understand the topic, focus area, and what the caller needs
-2. **Plan queries** — Design 3-5 focused search queries targeting the objective
-3. **Execute searches** — Use `WebSearch` for general research, `WebFetch` for specific documentation pages
-4. **Cross-reference** — If codebase files are provided in prompt, `Read` them to ground research in actual code context
-5. **Synthesize findings** — Extract key insights, patterns, and recommendations from search results
-6. **Return structured output** — Markdown-formatted research findings
-
-## Research Modes
-
-### Detail Verification (default for analyze)
-Focus: verify assumptions, check best practices, validate technology choices, confirm patterns.
-Queries target: benchmarks, production postmortems, known issues, compatibility matrices, official docs.
-
-### API Research (for implementation planning)
-Focus: concrete API details, library versions, integration patterns, configuration options.
-Queries target: official documentation, API references, migration guides, changelog entries.
-
-### Design Research (for brainstorm/architecture)
-Focus: design alternatives, architecture patterns, competitive analysis, UX patterns.
-Queries target: design systems, pattern libraries, case studies, comparison articles.
-
-## Execution
-
-### Query Strategy
-```
-1. Parse topic → extract key technologies, patterns, concepts
-2. Generate 3-5 queries:
-   - Q1: "{technology} best practices {year}"
-   - Q2: "{pattern} vs {alternative} comparison"
-   - Q3: "{technology} known issues production"
-   - Q4: "{specific API/library} documentation {version}"
-   - Q5: "{domain} architecture patterns"
-3. Execute queries via WebSearch
-4. For promising results, WebFetch full content for detail extraction
-5. Synthesize across all sources
-```
-
-### Codebase Grounding
-When the prompt includes `codebase_context` (file paths, patterns, tech stack):
-- Read referenced files to understand actual usage
-- Compare external best practices against current implementation
-- Flag gaps between current code and recommended patterns
-
-## Output Format
-
-Return structured markdown (do NOT write files):
-
-```markdown
-## Research: {topic}
-
-### Key Findings
-- **{Finding 1}**: {detail} (confidence: HIGH|MEDIUM|LOW, source: {url_or_reference})
-- **{Finding 2}**: {detail} (confidence: HIGH|MEDIUM|LOW, source: {url_or_reference})
-
-### Technology / API Details
-- **{Library/API}**: version {X}, {key capabilities}
-  - Integration: {how to integrate}
-  - Caveats: {known issues or limitations}
-
-### Best Practices
-- {Practice 1}: {rationale} (source: {reference})
-- {Practice 2}: {rationale} (source: {reference})
-
-### Recommended Approach
-{Prescriptive recommendation with rationale — "use X" not "consider X or Y" when evidence is strong}
-
-### Alternatives Considered
-| Option | Pros | Cons | Verdict |
-|--------|------|------|---------|
-| {A} | ... | ... | Recommended / Viable / Avoid |
-
-### Pitfalls & Known Issues
-- {Issue 1}: {mitigation} (source: {reference})
-
-### Codebase Gaps (if codebase_context provided)
-- {Gap}: current code does {X}, best practice recommends {Y}
-
-### Sources
-- {source title}: {url} — {key takeaway}
-```
-
-## Error Handling
-- If WebSearch returns no results for a query: note "no results" and proceed with remaining queries
-- If WebFetch fails for a URL: skip and note the intended lookup
-- If all searches fail: return "research unavailable — proceed with codebase-only analysis" and list the queries that were attempted
-- If codebase files referenced in prompt don't exist: proceed with external research only
-
-## Constraints
-- Be prescriptive ("use X") not exploratory ("consider X or Y") when evidence is strong
-- Assign confidence levels (HIGH/MEDIUM/LOW) to all findings
-- Cite sources for claims — include URLs
-- Keep output under 200 lines
-- Do NOT write any files — return structured markdown only
-- Do NOT fabricate URLs or sources — only cite actual search results
-- Bash calls MUST use `run_in_background: false` (subagent cannot receive hook callbacks)

.claude/commands/ccw.md

@@ -15,21 +15,28 @@ Main process orchestrator: intent analysis → workflow selection → command ch
 
 | Skill | 内部流水线 |
 |-------|-----------|
-| `workflow-lite-plan` | explore → plan → confirm → handoff |
-| `workflow-lite-execute` | task grouping → batch execution → code review → sync |
+| `workflow-lite-plan` | explore → plan → confirm → execute |
 | `workflow-plan` | session → context → convention → gen → verify/replan |
 | `workflow-execute` | session discovery → task processing → commit |
-| `workflow-tdd-plan` | 6-phase TDD plan → verify |
+| `workflow-tdd` | 6-phase TDD plan → verify |
 | `workflow-test-fix` | session → context → analysis → gen → cycle |
 | `workflow-multi-cli-plan` | ACE context → CLI discussion → plan → execute |
 | `review-cycle` | session/module review → fix orchestration |
 | `brainstorm` | auto/single-role → artifacts → analysis → synthesis |
-| `spec-generator` | product-brief → PRD → architecture → epics |
 | `workflow:collaborative-plan-with-file` | understanding agent → parallel agents → plan-note.md |
-| `workflow:roadmap-with-file` | strategic requirement roadmap → issue creation → execution-plan.json |
+| `workflow:req-plan-with-file` | requirement decomposition → issue creation → execution-plan.json |
 | `workflow:integration-test-cycle` | explore → test dev → test-fix cycle → reflection |
 | `workflow:refactor-cycle` | tech debt discovery → prioritize → execute → validate |
-| `team-planex` | planner + executor wave pipeline（适合大量零散 issue 或 roadmap 产出的清晰 issue）|
+| `team-planex` | planner + executor wave pipeline（边规划边执行）|
+| `team-iterdev` | 迭代开发团队（planner → developer → reviewer 循环）|
+| `team-lifecycle` | 全生命周期团队（spec → impl → test）|
+| `team-issue` | issue 解决团队（discover → plan → execute）|
+| `team-testing` | 测试团队（strategy → generate → execute → analyze）|
+| `team-quality-assurance` | QA 团队（scout → strategist → generator → executor → analyst）|
+| `team-brainstorm` | 团队头脑风暴（facilitator → participants → synthesizer）|
+| `team-uidesign` | UI 设计团队（designer → implementer dual-track）|
+
+独立命令（仍使用 colon 格式）：workflow:brainstorm-with-file, workflow:debug-with-file, workflow:analyze-with-file, workflow:collaborative-plan-with-file, workflow:req-plan-with-file, workflow:integration-test-cycle, workflow:refactor-cycle, workflow:unified-execute-with-file, workflow:clean, workflow:init, workflow:init-guidelines, workflow:ui-design:*, issue:*, workflow:session:*
 
 ## Core Concept: Self-Contained Skills (自包含 Skill)
 
@@ -44,21 +51,24 @@ Main process orchestrator: intent analysis → workflow selection → command ch
 
 | 单元类型 | Skill | 说明 |
 |---------|-------|------|
-| 轻量 Plan+Execute | `workflow-lite-plan` → `workflow-lite-execute` | plan handoff 到 execute，分离 Skill，TodoWrite 跟踪延续 (LP-Phase → LE-Phase) |
+| 轻量 Plan+Execute | `workflow-lite-plan` | 内部完成 plan→execute |
 | 标准 Planning | `workflow-plan` → `workflow-execute` | plan 和 execute 是独立 Skill |
-| TDD Planning | `workflow-tdd-plan` → `workflow-execute` | tdd-plan 和 execute 是独立 Skill |
-| 规格驱动 | `spec-generator` → `workflow-plan` → `workflow-execute` | 规格文档驱动完整开发 |
+| TDD Planning | `workflow-tdd` → `workflow-execute` | tdd-plan 和 execute 是独立 Skill |
 | 测试流水线 | `workflow-test-fix` | 内部完成 gen→cycle |
 | 代码审查 | `review-cycle` | 内部完成 review→fix |
-| 多CLI协作 | `workflow-multi-cli-plan` | ACE context → CLI discussion → plan → Skill(lite-execute) |
-| 分析→规划 | `workflow:analyze-with-file` → `workflow-lite-plan` → `workflow-lite-execute` | 协作分析产物自动传递给 lite-plan，Skill 调用 lite-execute |
-| 头脑风暴→规划 | `workflow:brainstorm-with-file` → `workflow-plan` → `workflow-execute` | 头脑风暴产物自动传递给正式规划 |
-| 0→1 开发(小) | `workflow:brainstorm-with-file` → `workflow-plan` → `workflow-execute` | 小规模从零开始，探索+正式规划+实现 |
-| 0→1 开发(中/大) | `workflow:brainstorm-with-file` → `workflow-plan` → `workflow-execute` | 探索后正式规划+执行 |
-| 协作规划 | `workflow:collaborative-plan-with-file` → `workflow:unified-execute-with-file` | 多 agent 协作规划→通用执行 |
-| 需求路线图 | `workflow:roadmap-with-file` → `team-planex` | 需求拆解→issue 创建→wave pipeline 执行（需明确 roadmap 关键词）|
+| 多CLI协作 | `workflow-multi-cli-plan` | ACE context → CLI discussion → plan → execute |
+| 协作规划 | `workflow:collaborative-plan-with-file` | 多 agent 协作生成 plan-note.md |
+| 需求路线图 | `workflow:req-plan-with-file` | 需求拆解→issue 创建→执行计划 |
 | 集成测试循环 | `workflow:integration-test-cycle` | 自迭代集成测试闭环 |
 | 重构循环 | `workflow:refactor-cycle` | 技术债务发现→重构→验证 |
+| 团队 Plan+Execute | `team-planex` | 2 人团队 wave pipeline，边规划边执行 |
+| 团队迭代开发 | `team-iterdev` | 多角色迭代开发闭环 |
+| 团队全生命周期 | `team-lifecycle` | spec→impl→test 全流程 |
+| 团队 Issue | `team-issue` | 多角色协作 issue 解决 |
+| 团队测试 | `team-testing` | 多角色测试流水线 |
+| 团队 QA | `team-quality-assurance` | 多角色质量保障闭环 |
+| 团队头脑风暴 | `team-brainstorm` | 多角色协作头脑风暴 |
+| 团队 UI 设计 | `team-uidesign` | dual-track 设计+实现 |
 
 ## Execution Model
 
@@ -126,23 +136,27 @@ function analyzeIntent(input) {
 function detectTaskType(text) {
   const patterns = {
     'bugfix-hotfix': /urgent|production|critical/ && /fix|bug/,
-    // With-File workflows (documented exploration → auto chain to lite-plan)
-    // 0→1 Greenfield detection (priority over brainstorm/roadmap)
-    'greenfield': /从零开始|from scratch|0.*to.*1|greenfield|全新.*开发|新项目|new project|build.*from.*ground/,
+    // With-File workflows (documented exploration with multi-CLI collaboration)
     'brainstorm': /brainstorm|ideation|头脑风暴|创意|发散思维|creative thinking|multi-perspective.*think|compare perspectives|探索.*可能/,
     'brainstorm-to-issue': /brainstorm.*issue|头脑风暴.*issue|idea.*issue|想法.*issue|从.*头脑风暴|convert.*brainstorm/,
     'debug-file': /debug.*document|hypothesis.*debug|troubleshoot.*track|investigate.*log|调试.*记录|假设.*验证|systematic debug|深度调试/,
     'analyze-file': /analyze.*document|explore.*concept|understand.*architecture|investigate.*discuss|collaborative analysis|分析.*讨论|深度.*理解|协作.*分析/,
     'collaborative-plan': /collaborative.*plan|协作.*规划|多人.*规划|multi.*agent.*plan|Plan Note|分工.*规划/,
-    'roadmap': /roadmap|路线.*图/,  // Narrowed: only explicit roadmap keywords (需求规划/需求拆解 moved to greenfield routing)
-    'spec-driven': /spec.*gen|specification|PRD|产品需求|产品文档|产品规格/,
+    'req-plan': /roadmap|需求.*规划|需求.*拆解|requirement.*plan|req.*plan|progressive.*plan|路线.*图/,
     // Cycle workflows (self-iterating with reflection)
     'integration-test': /integration.*test|集成测试|端到端.*测试|e2e.*test|integration.*cycle/,
     'refactor': /refactor|重构|tech.*debt|技术债务/,
-    // Team workflows (kept: team-planex only)
+    // Team workflows (multi-role collaboration, explicit "team" keyword required)
     'team-planex': /team.*plan.*exec|team.*planex|团队.*规划.*执行|并行.*规划.*执行|wave.*pipeline/,
+    'team-iterdev': /team.*iter|team.*iterdev|迭代.*开发.*团队|iterative.*dev.*team/,
+    'team-lifecycle': /team.*lifecycle|全生命周期|full.*lifecycle|spec.*impl.*test.*team/,
+    'team-issue': /team.*issue.*resolv|团队.*issue|team.*resolve.*issue/,
+    'team-testing': /team.*test|测试团队|comprehensive.*test.*team|全面.*测试.*团队/,
+    'team-qa': /team.*qa|quality.*assurance.*team|QA.*团队|质量.*保障.*团队|团队.*质量/,
+    'team-brainstorm': /team.*brainstorm|团队.*头脑风暴|team.*ideation|多人.*头脑风暴/,
+    'team-uidesign': /team.*ui.*design|UI.*设计.*团队|dual.*track.*design|团队.*UI/,
     // Standard workflows
-    'multi-cli': /multi.*cli|多.*CLI|多模型.*协作|multi.*model.*collab/,
+    'multi-cli-plan': /multi.*cli|多.*CLI|多模型.*协作|multi.*model.*collab/,
     'bugfix': /fix|bug|error|crash|fail|debug/,
     'issue-batch': /issues?|batch/ && /fix|resolve/,
     'issue-transition': /issue workflow|structured workflow|queue|multi-stage/,
@@ -151,7 +165,6 @@ function detectTaskType(text) {
     'ui-design': /ui|design|component|style/,
     'tdd': /tdd|test-driven|test first/,
     'test-fix': /test fail|fix test|failing test/,
-    'test-gen': /generate test|写测试|add test|补充测试/,
     'review': /review|code review/,
     'documentation': /docs|documentation|readme/
   };
@@ -189,34 +202,34 @@ async function clarifyRequirements(analysis) {
 function selectWorkflow(analysis) {
   const levelMap = {
     'bugfix-hotfix':     { level: 2, flow: 'bugfix.hotfix' },
-    // 0→1 Greenfield (complexity-adaptive routing)
-    'greenfield':        { level: analysis.complexity === 'high' ? 4 : 3,
-                           flow: analysis.complexity === 'high' ? 'greenfield-phased'    // large: brainstorm → workflow-plan → execute
-                                : analysis.complexity === 'medium' ? 'greenfield-plan'   // medium: brainstorm → workflow-plan → execute
-                                : 'brainstorm-to-plan' },                                // small: brainstorm → workflow-plan
-    // With-File workflows → auto chain to lite-plan
-    'brainstorm':        { level: 4, flow: 'brainstorm-to-plan' },     // brainstorm-with-file → workflow-plan
-    'brainstorm-to-issue': { level: 4, flow: 'brainstorm-to-issue' },  // Brainstorm → Issue workflow
-    'debug-file':        { level: 3, flow: 'debug-with-file' },         // Hypothesis-driven debugging (standalone)
-    'analyze-file':      { level: 3, flow: 'analyze-to-plan' },         // analyze-with-file → lite-plan
+    // With-File workflows (documented exploration with multi-CLI collaboration)
+    'brainstorm':        { level: 4, flow: 'brainstorm-with-file' },   // Multi-perspective ideation
+    'brainstorm-to-issue': { level: 4, flow: 'brainstorm-to-issue' }, // Brainstorm → Issue workflow
+    'debug-file':        { level: 3, flow: 'debug-with-file' },         // Hypothesis-driven debugging
+    'analyze-file':      { level: 3, flow: 'analyze-with-file' },       // Collaborative analysis
     'collaborative-plan': { level: 3, flow: 'collaborative-plan' },     // Multi-agent collaborative planning
-    'roadmap':           { level: 4, flow: 'roadmap' },                 // roadmap → team-planex (explicit roadmap only)
-    'spec-driven':       { level: 4, flow: 'spec-driven' },             // spec-generator → plan → execute
+    'req-plan':          { level: 4, flow: 'req-plan' },                // Requirement-level roadmap planning
     // Cycle workflows (self-iterating with reflection)
-    'integration-test':  { level: 3, flow: 'integration-test-cycle' },
-    'refactor':          { level: 3, flow: 'refactor-cycle' },
-    // Team workflows (kept: team-planex only)
+    'integration-test':  { level: 3, flow: 'integration-test-cycle' },  // Self-iterating integration test
+    'refactor':          { level: 3, flow: 'refactor-cycle' },          // Tech debt discovery and refactoring
+    // Team workflows (multi-role collaboration)
     'team-planex':       { level: 'Team', flow: 'team-planex' },
+    'team-iterdev':      { level: 'Team', flow: 'team-iterdev' },
+    'team-lifecycle':    { level: 'Team', flow: 'team-lifecycle' },
+    'team-issue':        { level: 'Team', flow: 'team-issue' },
+    'team-testing':      { level: 'Team', flow: 'team-testing' },
+    'team-qa':           { level: 'Team', flow: 'team-qa' },
+    'team-brainstorm':   { level: 'Team', flow: 'team-brainstorm' },
+    'team-uidesign':     { level: 'Team', flow: 'team-uidesign' },
     // Standard workflows
-    'multi-cli':         { level: 3, flow: 'multi-cli-plan' },
+    'multi-cli-plan':    { level: 3, flow: 'multi-cli-plan' },     // Multi-CLI collaborative planning
     'bugfix':            { level: 2, flow: 'bugfix.standard' },
     'issue-batch':       { level: 'Issue', flow: 'issue' },
-    'issue-transition':  { level: 2.5, flow: 'rapid-to-issue' },
+    'issue-transition':  { level: 2.5, flow: 'rapid-to-issue' },  // Bridge workflow
     'exploration':       { level: 4, flow: 'full' },
     'quick-task':        { level: 2, flow: 'rapid' },
     'ui-design':         { level: analysis.complexity === 'high' ? 4 : 3, flow: 'ui' },
     'tdd':               { level: 3, flow: 'tdd' },
-    'test-gen':          { level: 3, flow: 'test-gen' },
     'test-fix':          { level: 3, flow: 'test-fix-gen' },
     'review':            { level: 3, flow: 'review-cycle-fix' },
     'documentation':     { level: 2, flow: 'docs' },
@@ -268,19 +281,18 @@ function buildCommandChain(workflow, analysis) {
       { cmd: 'workflow-lite-plan', args: `"${analysis.goal}"` }
     ],
 
-    // With-File → Auto Chain to lite-plan
-    'analyze-to-plan': [
-      { cmd: 'workflow:analyze-with-file', args: `"${analysis.goal}"` },
-      { cmd: 'workflow-lite-plan', args: '' }  // auto receives analysis artifacts (discussion.md)
+    // With-File workflows (documented exploration with multi-CLI collaboration)
+    'brainstorm-with-file': [
+      { cmd: 'workflow:brainstorm-with-file', args: `"${analysis.goal}"` }
+      // Note: Has built-in post-completion options (create plan, create issue, deep analysis)
     ],
 
-    'brainstorm-to-plan': [
-      { cmd: 'workflow:brainstorm-with-file', args: `"${analysis.goal}"` },
-      { cmd: 'workflow-plan', args: '' },         // formal planning with brainstorm artifacts
-      { cmd: 'workflow-execute', args: '' },
-      ...(analysis.constraints?.includes('skip-tests') ? [] : [
-        { cmd: 'workflow-test-fix', args: '' }
-      ])
+    // Brainstorm-to-Issue workflow (bridge from brainstorm to issue execution)
+    'brainstorm-to-issue': [
+      // Note: Assumes brainstorm session already exists, or run brainstorm first
+      { cmd: 'issue:from-brainstorm', args: `SESSION="${extractBrainstormSession(analysis)}" --auto` },
+      { cmd: 'issue:queue', args: '' },
+      { cmd: 'issue:execute', args: '--queue auto' }
     ],
 
     'debug-with-file': [
@@ -288,42 +300,32 @@ function buildCommandChain(workflow, analysis) {
       // Note: Self-contained with hypothesis-driven iteration and Gemini validation
     ],
 
-    // Brainstorm-to-Issue workflow (bridge from brainstorm to issue execution)
-    'brainstorm-to-issue': [
-      { cmd: 'issue:from-brainstorm', args: `SESSION="${extractBrainstormSession(analysis)}" --auto` },
-      { cmd: 'issue:queue', args: '' },
-      { cmd: 'issue:execute', args: '--queue auto' }
+    'analyze-with-file': [
+      { cmd: 'workflow:analyze-with-file', args: `"${analysis.goal}"` }
+      // Note: Self-contained with multi-round discussion and CLI exploration
     ],
 
-    // 0→1 Greenfield (complexity-adaptive)
-    'greenfield-plan': [
-      { cmd: 'workflow:brainstorm-with-file', args: `"${analysis.goal}"` },
-      { cmd: 'workflow-plan', args: '' },         // formal planning after exploration
-      { cmd: 'workflow-execute', args: '' },
-      ...(analysis.constraints?.includes('skip-tests') ? [] : [
-        { cmd: 'workflow-test-fix', args: '' }
-      ])
-    ],
-
-    'greenfield-phased': [
-      { cmd: 'workflow:brainstorm-with-file', args: `"${analysis.goal}"` },
-      { cmd: 'workflow-plan', args: '' },         // formal planning after exploration
-      { cmd: 'workflow-execute', args: '' },
-      { cmd: 'review-cycle', args: '' },
-      ...(analysis.constraints?.includes('skip-tests') ? [] : [
-        { cmd: 'workflow-test-fix', args: '' }
-      ])
-    ],
-
-    // Universal Plan+Execute
     'collaborative-plan': [
       { cmd: 'workflow:collaborative-plan-with-file', args: `"${analysis.goal}"` },
       { cmd: 'workflow:unified-execute-with-file', args: '' }
+      // Note: Plan Note → unified execution engine
     ],
 
-    'roadmap': [
-      { cmd: 'workflow:roadmap-with-file', args: `"${analysis.goal}"` },
+    'req-plan': [
+      { cmd: 'workflow:req-plan-with-file', args: `"${analysis.goal}"` },
       { cmd: 'team-planex', args: '' }
+      // Note: Requirement decomposition → issue creation → team-planex wave execution
+    ],
+
+    // Cycle workflows (self-iterating with reflection)
+    'integration-test-cycle': [
+      { cmd: 'workflow:integration-test-cycle', args: `"${analysis.goal}"` }
+      // Note: Self-contained explore → test → fix cycle with reflection
+    ],
+
+    'refactor-cycle': [
+      { cmd: 'workflow:refactor-cycle', args: `"${analysis.goal}"` }
+      // Note: Self-contained tech debt discovery → refactor → validate
     ],
 
     // Level 3 - Standard
@@ -336,25 +338,11 @@ function buildCommandChain(workflow, analysis) {
       ])
     ],
 
-    // Level 4 - Spec-Driven Full Pipeline
-    'spec-driven': [
-      { cmd: 'spec-generator', args: `"${analysis.goal}"` },
-      { cmd: 'workflow-plan', args: '' },
-      { cmd: 'workflow-execute', args: '' },
-      ...(analysis.constraints?.includes('skip-tests') ? [] : [
-        { cmd: 'workflow-test-fix', args: '' }
-      ])
-    ],
-
     'tdd': [
-      { cmd: 'workflow-tdd-plan', args: `"${analysis.goal}"` },
+      { cmd: 'workflow-tdd', args: `"${analysis.goal}"` },
       { cmd: 'workflow-execute', args: '' }
     ],
 
-    'test-gen': [
-      { cmd: 'workflow-test-fix', args: `"${analysis.goal}"` }
-    ],
-
     'test-fix-gen': [
       { cmd: 'workflow-test-fix', args: `"${analysis.goal}"` }
     ],
@@ -372,7 +360,7 @@ function buildCommandChain(workflow, analysis) {
       { cmd: 'workflow-execute', args: '' }
     ],
 
-    // Level 4 - Full Exploration (brainstorm → formal planning → execute)
+    // Level 4 - Full
     'full': [
       { cmd: 'brainstorm', args: `"${analysis.goal}"` },
       { cmd: 'workflow-plan', args: '' },
@@ -382,15 +370,6 @@ function buildCommandChain(workflow, analysis) {
       ])
     ],
 
-    // Cycle workflows (self-iterating with reflection)
-    'integration-test-cycle': [
-      { cmd: 'workflow:integration-test-cycle', args: `"${analysis.goal}"` }
-    ],
-
-    'refactor-cycle': [
-      { cmd: 'workflow:refactor-cycle', args: `"${analysis.goal}"` }
-    ],
-
     // Issue Workflow
     'issue': [
       { cmd: 'issue:discover', args: '' },
@@ -399,9 +378,37 @@ function buildCommandChain(workflow, analysis) {
       { cmd: 'issue:execute', args: '' }
     ],
 
-    // Team Workflows (kept: team-planex only)
+    // Team Workflows (multi-role collaboration, self-contained)
     'team-planex': [
       { cmd: 'team-planex', args: `"${analysis.goal}"` }
+    ],
+
+    'team-iterdev': [
+      { cmd: 'team-iterdev', args: `"${analysis.goal}"` }
+    ],
+
+    'team-lifecycle': [
+      { cmd: 'team-lifecycle', args: `"${analysis.goal}"` }
+    ],
+
+    'team-issue': [
+      { cmd: 'team-issue', args: `"${analysis.goal}"` }
+    ],
+
+    'team-testing': [
+      { cmd: 'team-testing', args: `"${analysis.goal}"` }
+    ],
+
+    'team-qa': [
+      { cmd: 'team-quality-assurance', args: `"${analysis.goal}"` }
+    ],
+
+    'team-brainstorm': [
+      { cmd: 'team-brainstorm', args: `"${analysis.goal}"` }
+    ],
+
+    'team-uidesign': [
+      { cmd: 'team-uidesign', args: `"${analysis.goal}"` }
     ]
   };
 
@@ -600,7 +607,7 @@ Phase 1: Analyze Intent
     +-- If clarity < 2 -> Phase 1.5: Clarify Requirements
     |
 Phase 2: Select Workflow & Build Chain
-    |-- Map task_type -> Level (2/3/4/Issue/Team)
+    |-- Map task_type -> Level (1/2/3/4/Issue)
     |-- Select flow based on complexity
     +-- Build command chain (Skill-based)
     |
@@ -632,22 +639,26 @@ Phase 5: Execute Command Chain
 | "Add API endpoint" | feature (low) | 2 | workflow-lite-plan → workflow-test-fix |
 | "Fix login timeout" | bugfix | 2 | workflow-lite-plan → workflow-test-fix |
 | "Use issue workflow" | issue-transition | 2.5 | workflow-lite-plan(plan-only) → convert-to-plan → queue → execute |
-| "协作分析: 认证架构" | analyze-file | 3 | analyze-with-file → workflow-lite-plan |
-| "深度调试 WebSocket" | debug-file | 3 | workflow:debug-with-file |
-| "从零开始: 用户系统" | greenfield (medium) | 3 | brainstorm-with-file → workflow-plan → workflow-execute → workflow-test-fix |
-| "greenfield: 大型平台" | greenfield (high) | 4 | brainstorm-with-file → workflow-plan → workflow-execute → review-cycle → workflow-test-fix |
-| "头脑风暴: 通知系统" | brainstorm | 4 | brainstorm-with-file → workflow-plan → workflow-execute → workflow-test-fix |
+| "头脑风暴: 通知系统重构" | brainstorm | 4 | workflow:brainstorm-with-file |
 | "从头脑风暴创建 issue" | brainstorm-to-issue | 4 | issue:from-brainstorm → issue:queue → issue:execute |
+| "深度调试 WebSocket" | debug-file | 3 | workflow:debug-with-file |
+| "协作分析: 认证架构优化" | analyze-file | 3 | workflow:analyze-with-file |
 | "协作规划: 实时通知系统" | collaborative-plan | 3 | collaborative-plan-with-file → unified-execute-with-file |
-| "roadmap: OAuth + 2FA" | roadmap | 4 | roadmap-with-file → team-planex |
-| "specification: 用户系统" | spec-driven | 4 | spec-generator → workflow-plan → workflow-execute → workflow-test-fix |
+| "需求规划: OAuth + 2FA" | req-plan | 4 | req-plan-with-file → team-planex |
 | "集成测试: 支付流程" | integration-test | 3 | workflow:integration-test-cycle |
 | "重构 auth 模块" | refactor | 3 | workflow:refactor-cycle |
 | "multi-cli plan: API设计" | multi-cli-plan | 3 | workflow-multi-cli-plan → workflow-test-fix |
 | "OAuth2 system" | feature (high) | 3 | workflow-plan → workflow-execute → review-cycle → workflow-test-fix |
-| "Implement with TDD" | tdd | 3 | workflow-tdd-plan → workflow-execute |
+| "Implement with TDD" | tdd | 3 | workflow-tdd → workflow-execute |
 | "Uncertain: real-time" | exploration | 4 | brainstorm → workflow-plan → workflow-execute → workflow-test-fix |
 | "team planex: 用户系统" | team-planex | Team | team-planex |
+| "迭代开发团队: 支付模块" | team-iterdev | Team | team-iterdev |
+| "全生命周期: 通知服务" | team-lifecycle | Team | team-lifecycle |
+| "team resolve issue #42" | team-issue | Team | team-issue |
+| "测试团队: 全面测试认证" | team-testing | Team | team-testing |
+| "QA 团队: 质量保障支付" | team-qa | Team | team-quality-assurance |
+| "团队头脑风暴: API 设计" | team-brainstorm | Team | team-brainstorm |
+| "团队 UI 设计: 仪表盘" | team-uidesign | Team | team-uidesign |
 
 ---
 
@@ -657,11 +668,10 @@ Phase 5: Execute Command Chain
 2. **Intent-Driven** - Auto-select workflow based on task intent
 3. **Skill-Based Chaining** - Build command chain by composing independent Skills
 4. **Self-Contained Skills** - 每个 Skill 内部处理完整流水线，是天然的最小执行单元
-5. **Auto Chain** - With-File 产物自动传递给下游 Skill（如 analyze → lite-plan）
-6. **Progressive Clarification** - Low clarity triggers clarification phase
-7. **TODO Tracking** - Use CCW prefix to isolate workflow todos
-8. **Error Handling** - Retry/skip/abort at Skill level
-9. **User Control** - Optional user confirmation at each phase
+5. **Progressive Clarification** - Low clarity triggers clarification phase
+6. **TODO Tracking** - Use CCW prefix to isolate workflow todos
+7. **Error Handling** - Retry/skip/abort at Skill level
+8. **User Control** - Optional user confirmation at each phase
 
 ---
 
@@ -705,51 +715,114 @@ todos = [
     "complexity": "medium"
   },
   "command_chain": [
-    { "index": 0, "command": "workflow-lite-plan", "status": "completed" },
-    { "index": 1, "command": "workflow-test-fix", "status": "running" }
+    {
+      "index": 0,
+      "command": "workflow-lite-plan",
+      "status": "completed"
+    },
+    {
+      "index": 1,
+      "command": "workflow-test-fix",
+      "status": "running"
+    }
   ],
   "current_index": 1
 }
 ```
 
-**Status Values**: `running` | `completed` | `failed` | `error`
-**Command Status Values**: `pending` | `running` | `completed` | `failed`
+**Status Values**:
+- `running`: Workflow executing commands
+- `completed`: All commands finished
+- `failed`: User aborted or unrecoverable error
+- `error`: Command execution failed (during error handling)
+
+**Command Status Values**:
+- `pending`: Not started
+- `running`: Currently executing
+- `completed`: Successfully finished
+- `failed`: Execution failed
 
 ---
 
 ## With-File Workflows
 
-**With-File workflows** provide documented exploration with multi-CLI collaboration. They generate comprehensive session artifacts and can auto-chain to lite-plan for implementation.
+**With-File workflows** provide documented exploration with multi-CLI collaboration. They are self-contained and generate comprehensive session artifacts.
 
-| Workflow | Purpose | Auto Chain | Output Folder |
-|----------|---------|------------|---------------|
-| **brainstorm-with-file** | Multi-perspective ideation | → workflow-plan → workflow-execute (auto) | `.workflow/.brainstorm/` |
-| **debug-with-file** | Hypothesis-driven debugging | Standalone (self-contained) | `.workflow/.debug/` |
-| **analyze-with-file** | Collaborative analysis | → workflow-lite-plan → workflow-lite-execute (auto) | `.workflow/.analysis/` |
-| **collaborative-plan-with-file** | Multi-agent collaborative planning | → unified-execute-with-file | `.workflow/.planning/` |
-| **roadmap-with-file** | Strategic requirement roadmap | → team-planex | `.workflow/.planning/` |
-
-**Auto Chain Mechanism**: When `analyze-with-file` completes, its artifacts (discussion.md) are automatically passed to `workflow-lite-plan`. When `brainstorm-with-file` completes, its artifacts (brainstorm.md) are passed to `workflow-plan` for formal planning. No user intervention needed.
+| Workflow | Purpose | Key Features | Output Folder |
+|----------|---------|--------------|---------------|
+| **brainstorm-with-file** | Multi-perspective ideation | Gemini/Codex/Claude perspectives, diverge-converge cycles | `.workflow/.brainstorm/` |
+| **debug-with-file** | Hypothesis-driven debugging | Gemini validation, understanding evolution, NDJSON logging | `.workflow/.debug/` |
+| **analyze-with-file** | Collaborative analysis | Multi-round Q&A, CLI exploration, documented discussions | `.workflow/.analysis/` |
+| **collaborative-plan-with-file** | Multi-agent collaborative planning | Understanding agent + parallel agents, Plan Note shared doc | `.workflow/.planning/` |
+| **req-plan-with-file** | Requirement roadmap planning | Requirement decomposition, issue creation, execution-plan.json | `.workflow/.planning/` |
 
 **Detection Keywords**:
 - **brainstorm**: 头脑风暴, 创意, 发散思维, multi-perspective, compare perspectives
 - **debug-file**: 深度调试, 假设验证, systematic debug, hypothesis debug
 - **analyze-file**: 协作分析, 深度理解, collaborative analysis, explore concept
 - **collaborative-plan**: 协作规划, 多人规划, collaborative plan, multi-agent plan, Plan Note
-- **roadmap**: roadmap, 需求规划, 需求拆解, requirement plan, progressive plan
-- **spec-driven**: specification, PRD, 产品需求, 产品文档
+- **req-plan**: roadmap, 需求规划, 需求拆解, requirement plan, progressive plan
+
+**Characteristics**:
+1. **Self-Contained**: Each workflow handles its own iteration loop
+2. **Documented Process**: Creates evolving documents (brainstorm.md, understanding.md, discussion.md)
+3. **Multi-CLI**: Uses Gemini/Codex/Claude for different perspectives
+4. **Built-in Post-Completion**: Offers follow-up options (create plan, issue, etc.)
+
+---
+
+## Team Workflows
+
+**Team workflows** provide multi-role collaboration for complex tasks. Each team skill is self-contained with internal role routing via `--role=xxx`.
+
+| Workflow | Roles | Pipeline | Use Case |
+|----------|-------|----------|----------|
+| **team-planex** | planner + executor | wave pipeline（边规划边执行）| 需要并行规划和执行的任务 |
+| **team-iterdev** | planner → developer → reviewer | 迭代开发循环 | 需要多轮迭代的开发任务 |
+| **team-lifecycle** | spec → impl → test | 全生命周期 | 从需求到测试的完整流程 |
+| **team-issue** | discover → plan → execute | issue 解决 | 多角色协作解决 issue |
+| **team-testing** | strategy → generate → execute → analyze | 测试流水线 | 全面测试覆盖 |
+| **team-quality-assurance** | scout → strategist → generator → executor → analyst | QA 闭环 | 质量保障全流程 |
+| **team-brainstorm** | facilitator → participants → synthesizer | 团队头脑风暴 | 多角色协作头脑风暴 |
+| **team-uidesign** | designer → implementer | dual-track 设计+实现 | UI 设计与实现并行 |
+
+**Detection Keywords**:
+- **team-planex**: team planex, 团队规划执行, wave pipeline
+- **team-iterdev**: team iterdev, 迭代开发团队, iterative dev team
+- **team-lifecycle**: team lifecycle, 全生命周期, full lifecycle
+- **team-issue**: team issue, 团队 issue, team resolve issue
+- **team-testing**: team test, 测试团队, comprehensive test team
+- **team-qa**: team qa, QA 团队, 质量保障团队
+- **team-brainstorm**: team brainstorm, 团队头脑风暴, team ideation
+- **team-uidesign**: team ui design, UI 设计团队, dual track design
+
+**Characteristics**:
+1. **Self-Contained**: Each team skill handles internal role coordination
+2. **Role-Based Routing**: All roles invoke the same skill with `--role=xxx`
+3. **Shared Memory**: Roles communicate via shared-memory.json and message bus
+4. **Auto Mode Support**: All team skills support `-y`/`--yes` for skip confirmations
 
 ---
 
 ## Cycle Workflows
 
-**Cycle workflows** provide self-iterating development cycles with reflection-driven strategy adjustment.
+**Cycle workflows** provide self-iterating development cycles with reflection-driven strategy adjustment. Each cycle is autonomous with built-in test-fix loops and quality gates.
 
 | Workflow | Pipeline | Key Features | Output Folder |
 |----------|----------|--------------|---------------|
 | **integration-test-cycle** | explore → test dev → test-fix → reflection | Self-iterating with max-iterations, auto continue | `.workflow/.test-cycle/` |
 | **refactor-cycle** | discover → prioritize → execute → validate | Multi-dimensional analysis, regression validation | `.workflow/.refactor-cycle/` |
 
+**Detection Keywords**:
+- **integration-test**: integration test, 集成测试, 端到端测试, e2e test
+- **refactor**: refactor, 重构, tech debt, 技术债务
+
+**Characteristics**:
+1. **Self-Iterating**: Autonomous test-fix loops until quality gate passes
+2. **Reflection-Driven**: Strategy adjusts based on previous iteration results
+3. **Continue Support**: `--continue` flag to resume interrupted sessions
+4. **Auto Mode Support**: `-y`/`--yes` for fully autonomous execution
+
 ---
 
 ## Utility Commands
@@ -758,11 +831,10 @@ todos = [
 
 | Command | Purpose |
 |---------|---------|
-| `workflow:unified-execute-with-file` | Universal execution engine - consumes plan output from collaborative-plan, roadmap, brainstorm |
+| `workflow:unified-execute-with-file` | Universal execution engine - consumes plan output from collaborative-plan, req-plan, brainstorm |
 | `workflow:clean` | Intelligent code cleanup - mainline detection, stale artifact removal |
-| `workflow:spec:setup` | Initialize `.workflow/project-tech.json` with project analysis and specs scaffold |
-| `workflow:spec:add` | Interactive wizard to add individual specs with scope selection |
-| `workflow:status` | Generate on-demand views for project overview and workflow tasks |
+| `workflow:init` | Initialize `.workflow/project-tech.json` with project analysis |
+| `workflow:init-guidelines` | Interactive wizard to fill `project-guidelines.json` |
 
 ---
 
@@ -776,6 +848,9 @@ todos = [
 /ccw -y "Add user authentication"
 /ccw --yes "Fix memory leak in WebSocket handler"
 
+# Complex requirement (triggers clarification)
+/ccw "Optimize system performance"
+
 # Bug fix
 /ccw "Fix memory leak in WebSocket handler"
 
@@ -788,36 +863,35 @@ todos = [
 # Multi-CLI collaborative planning
 /ccw "multi-cli plan: 支付网关API设计"               # → workflow-multi-cli-plan → workflow-test-fix
 
-# 0→1 Greenfield development (exploration-first)
-/ccw "从零开始: 用户认证系统"                   # → brainstorm-with-file → workflow-plan → workflow-execute → workflow-test-fix
-/ccw "new project: 数据导出模块"               # → brainstorm-with-file → workflow-plan → workflow-execute → workflow-test-fix
-/ccw "全新开发: 实时通知系统"                   # → brainstorm-with-file → workflow-plan → workflow-execute → review-cycle → workflow-test-fix
-
-# With-File workflows → auto chain
-/ccw "协作分析: 理解现有认证架构的设计决策"     # → analyze-with-file → workflow-lite-plan → workflow-lite-execute
-/ccw "头脑风暴: 用户通知系统重新设计"           # → brainstorm-with-file → workflow-plan → workflow-execute → workflow-test-fix
-/ccw "深度调试: 系统随机崩溃问题"              # → debug-with-file (standalone)
+# With-File workflows (documented exploration with multi-CLI collaboration)
+/ccw "头脑风暴: 用户通知系统重新设计"           # → brainstorm-with-file
 /ccw "从头脑风暴 BS-通知系统-2025-01-28 创建 issue"  # → brainstorm-to-issue (bridge)
+/ccw "深度调试: 系统随机崩溃问题"              # → debug-with-file
+/ccw "协作分析: 理解现有认证架构的设计决策"     # → analyze-with-file
 
-# Spec-driven full pipeline
-/ccw "specification: 用户认证系统产品文档"      # → spec-generator → workflow-plan → workflow-execute → workflow-test-fix
+# Team workflows (multi-role collaboration)
+/ccw "team planex: 用户认证系统"               # → team-planex (planner + executor wave pipeline)
+/ccw "迭代开发团队: 支付模块重构"              # → team-iterdev (planner → developer → reviewer)
+/ccw "全生命周期: 通知服务开发"                # → team-lifecycle (spec → impl → test)
+/ccw "team resolve issue #42"                  # → team-issue (discover → plan → execute)
+/ccw "测试团队: 全面测试认证模块"              # → team-testing (strategy → generate → execute → analyze)
+/ccw "QA 团队: 质量保障支付流程"               # → team-quality-assurance (scout → strategist → generator → executor → analyst)
+/ccw "团队头脑风暴: API 网关设计"              # → team-brainstorm (facilitator → participants → synthesizer)
+/ccw "团队 UI 设计: 管理后台仪表盘"            # → team-uidesign (designer → implementer dual-track)
 
 # Collaborative planning & requirement workflows
 /ccw "协作规划: 实时通知系统架构"              # → collaborative-plan-with-file → unified-execute
-/ccw "roadmap: 用户认证 OAuth + 2FA 路线图"    # → roadmap-with-file → team-planex (explicit roadmap only)
-/ccw "roadmap: 数据导出功能路线图"             # → roadmap-with-file → team-planex (explicit roadmap only)
-
-# Team workflows (kept: team-planex)
-/ccw "team planex: 用户认证系统"               # → team-planex (planner + executor wave pipeline)
+/ccw "需求规划: 用户认证 OAuth + 2FA"          # → req-plan-with-file → team-planex
+/ccw "roadmap: 数据导出功能路线图"             # → req-plan-with-file → team-planex
 
 # Cycle workflows (self-iterating)
 /ccw "集成测试: 支付流程端到端"                # → integration-test-cycle
 /ccw "重构 auth 模块的技术债务"                # → refactor-cycle
+/ccw "tech debt: 清理支付服务"                 # → refactor-cycle
 
 # Utility commands (invoked directly, not auto-routed)
 # /workflow:unified-execute-with-file          # 通用执行引擎（消费 plan 输出）
 # /workflow:clean                              # 智能代码清理
-# /workflow:spec:setup                         # 初始化项目状态
-# /workflow:spec:add                           # 交互式填充项目规范
-# /workflow:status                             # 项目概览和工作流状态
+# /workflow:init                               # 初始化项目状态
+# /workflow:init-guidelines                    # 交互式填充项目规范
 ```

.claude/commands/cli/cli-init.md

@@ -33,7 +33,7 @@ Creates tool-specific configuration directories:
 - `.gemini/settings.json`:
 ```json
 {
-  "contextfilename": "CLAUDE.md"
+  "contextfilename": ["CLAUDE.md","GEMINI.md"]
 }
 ```
 
@@ -41,7 +41,7 @@ Creates tool-specific configuration directories:
 - `.qwen/settings.json`:
 ```json
 {
-  "contextfilename": "CLAUDE.md"
+  "contextfilename": ["CLAUDE.md","QWEN.md"]
 }
 ```
 

.claude/commands/flow-create.md

@@ -86,14 +86,14 @@ async function selectCommandCategory() {
       header: "Category",
       options: [
         { label: "Planning", description: "lite-plan, plan, multi-cli-plan, tdd-plan, quick-plan-with-file" },
-        { label: "Execution", description: "execute, unified-execute-with-file" },
+        { label: "Execution", description: "lite-execute, execute, unified-execute-with-file" },
         { label: "Testing", description: "test-fix-gen, test-cycle-execute, test-gen, tdd-verify" },
         { label: "Review", description: "review-session-cycle, review-module-cycle, review-cycle-fix" },
         { label: "Bug Fix", description: "lite-plan --bugfix, debug-with-file" },
         { label: "Brainstorm", description: "brainstorm-with-file, brainstorm (unified skill)" },
         { label: "Analysis", description: "analyze-with-file" },
         { label: "Issue", description: "discover, plan, queue, execute, from-brainstorm, convert-to-plan" },
-        { label: "Utility", description: "clean, spec:setup, spec:add, replan, status" }
+        { label: "Utility", description: "clean, init, replan, status" }
       ],
       multiSelect: false
     }]
@@ -107,23 +107,24 @@ async function selectCommandCategory() {
 async function selectCommand(category) {
   const commandOptions = {
     'Planning': [
-      { label: "/workflow-lite-plan", description: "Lightweight merged-mode planning" },
-      { label: "/workflow-plan", description: "Full planning with architecture design" },
-      { label: "/workflow-multi-cli-plan", description: "Multi-CLI collaborative planning (Gemini+Codex+Claude)" },
-      { label: "/workflow-tdd-plan", description: "TDD workflow planning with Red-Green-Refactor" },
+      { label: "/workflow:lite-plan", description: "Lightweight merged-mode planning" },
+      { label: "/workflow:plan", description: "Full planning with architecture design" },
+      { label: "/workflow:multi-cli-plan", description: "Multi-CLI collaborative planning (Gemini+Codex+Claude)" },
+      { label: "/workflow:tdd-plan", description: "TDD workflow planning with Red-Green-Refactor" },
       { label: "/workflow:quick-plan-with-file", description: "Rapid planning with minimal docs" },
-      { label: "/workflow-plan-verify", description: "Verify plan against requirements" },
+      { label: "/workflow:plan-verify", description: "Verify plan against requirements" },
       { label: "/workflow:replan", description: "Update plan and execute changes" }
     ],
     'Execution': [
-      { label: "/workflow-execute", description: "Execute from planning session" },
+      { label: "/workflow:lite-execute", description: "Execute from in-memory plan" },
+      { label: "/workflow:execute", description: "Execute from planning session" },
       { label: "/workflow:unified-execute-with-file", description: "Universal execution engine" }
     ],
     'Testing': [
-      { label: "/workflow-test-fix", description: "Generate test tasks for specific issues" },
-      { label: "/workflow-test-fix", description: "Execute iterative test-fix cycle (>=95% pass)" },
+      { label: "/workflow:test-fix-gen", description: "Generate test tasks for specific issues" },
+      { label: "/workflow:test-cycle-execute", description: "Execute iterative test-fix cycle (>=95% pass)" },
       { label: "/workflow:test-gen", description: "Generate comprehensive test suite" },
-      { label: "/workflow-tdd-verify", description: "Verify TDD workflow compliance" }
+      { label: "/workflow:tdd-verify", description: "Verify TDD workflow compliance" }
     ],
     'Review': [
       { label: "/workflow:review-session-cycle", description: "Session-based multi-dimensional code review" },
@@ -132,7 +133,7 @@ async function selectCommand(category) {
       { label: "/workflow:review", description: "Post-implementation review" }
     ],
     'Bug Fix': [
-      { label: "/workflow-lite-plan", description: "Lightweight bug diagnosis and fix (with --bugfix flag)" },
+      { label: "/workflow:lite-plan", description: "Lightweight bug diagnosis and fix (with --bugfix flag)" },
       { label: "/workflow:debug-with-file", description: "Hypothesis-driven debugging with documentation" }
     ],
     'Brainstorm': [
@@ -153,7 +154,7 @@ async function selectCommand(category) {
     ],
     'Utility': [
       { label: "/workflow:clean", description: "Intelligent code cleanup" },
-      { label: "/workflow:spec:setup", description: "Initialize project-level state" },
+      { label: "/workflow:init", description: "Initialize project-level state" },
       { label: "/workflow:replan", description: "Interactive workflow replanning" },
       { label: "/workflow:status", description: "Generate workflow status views" }
     ]
@@ -180,8 +181,8 @@ async function selectExecutionUnit() {
       header: "Unit",
       options: [
         // Planning + Execution Units
-        { label: "quick-implementation", description: "【lite-plan】" },
-        { label: "multi-cli-planning", description: "【multi-cli-plan】" },
+        { label: "quick-implementation", description: "【lite-plan → lite-execute】" },
+        { label: "multi-cli-planning", description: "【multi-cli-plan → lite-execute】" },
         { label: "full-planning-execution", description: "【plan → execute】" },
         { label: "verified-planning-execution", description: "【plan → plan-verify → execute】" },
         { label: "replanning-execution", description: "【replan → execute】" },
@@ -192,7 +193,7 @@ async function selectExecutionUnit() {
         // Review Units
         { label: "code-review", description: "【review-*-cycle → review-cycle-fix】" },
         // Bug Fix Units
-        { label: "bug-fix", description: "【lite-plan --bugfix】" },
+        { label: "bug-fix", description: "【lite-plan --bugfix → lite-execute】" },
         // Issue Units
         { label: "issue-workflow", description: "【discover → plan → queue → execute】" },
         { label: "rapid-to-issue", description: "【lite-plan → convert-to-plan → queue → execute】" },
@@ -302,9 +303,10 @@ async function defineSteps(templateDesign) {
   "description": "Quick implementation with testing",
   "level": 2,
   "steps": [
-    { "cmd": "/workflow-lite-plan", "args": "\"{{goal}}\"", "unit": "quick-implementation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create lightweight implementation plan (includes execution)" },
-    { "cmd": "/workflow-test-fix", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate test tasks" },
-    { "cmd": "/workflow-test-fix", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test-fix cycle until pass rate >= 95%" }
+    { "cmd": "/workflow:lite-plan", "args": "\"{{goal}}\"", "unit": "quick-implementation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create lightweight implementation plan" },
+    { "cmd": "/workflow:lite-execute", "args": "--in-memory", "unit": "quick-implementation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Execute implementation based on plan" },
+    { "cmd": "/workflow:test-fix-gen", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate test tasks" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test-fix cycle until pass rate >= 95%" }
   ]
 }
 ```
@@ -316,13 +318,13 @@ async function defineSteps(templateDesign) {
   "description": "Full workflow with verification, review, and testing",
   "level": 3,
   "steps": [
-    { "cmd": "/workflow-plan", "args": "\"{{goal}}\"", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create detailed implementation plan" },
-    { "cmd": "/workflow-plan-verify", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Verify plan against requirements" },
-    { "cmd": "/workflow-execute", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute implementation" },
+    { "cmd": "/workflow:plan", "args": "\"{{goal}}\"", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create detailed implementation plan" },
+    { "cmd": "/workflow:plan-verify", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Verify plan against requirements" },
+    { "cmd": "/workflow:execute", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute implementation" },
     { "cmd": "/workflow:review-session-cycle", "unit": "code-review", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Multi-dimensional code review" },
     { "cmd": "/workflow:review-cycle-fix", "unit": "code-review", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Fix review findings" },
-    { "cmd": "/workflow-test-fix", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate test tasks" },
-    { "cmd": "/workflow-test-fix", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test-fix cycle" }
+    { "cmd": "/workflow:test-fix-gen", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate test tasks" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test-fix cycle" }
   ]
 }
 ```
@@ -334,9 +336,10 @@ async function defineSteps(templateDesign) {
   "description": "Bug diagnosis and fix with testing",
   "level": 2,
   "steps": [
-    { "cmd": "/workflow-lite-plan", "args": "--bugfix \"{{goal}}\"", "unit": "bug-fix", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Diagnose, plan, and execute bug fix" },
-    { "cmd": "/workflow-test-fix", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate regression tests" },
-    { "cmd": "/workflow-test-fix", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Verify fix with tests" }
+    { "cmd": "/workflow:lite-plan", "args": "--bugfix \"{{goal}}\"", "unit": "bug-fix", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Diagnose and plan bug fix" },
+    { "cmd": "/workflow:lite-execute", "args": "--in-memory", "unit": "bug-fix", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Execute bug fix" },
+    { "cmd": "/workflow:test-fix-gen", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate regression tests" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Verify fix with tests" }
   ]
 }
 ```
@@ -348,7 +351,7 @@ async function defineSteps(templateDesign) {
   "description": "Urgent production bug fix (no tests)",
   "level": 2,
   "steps": [
-    { "cmd": "/workflow-lite-plan", "args": "--hotfix \"{{goal}}\"", "unit": "standalone", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Emergency hotfix mode" }
+    { "cmd": "/workflow:lite-plan", "args": "--hotfix \"{{goal}}\"", "unit": "standalone", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Emergency hotfix mode" }
   ]
 }
 ```
@@ -360,9 +363,9 @@ async function defineSteps(templateDesign) {
   "description": "Test-driven development with Red-Green-Refactor",
   "level": 3,
   "steps": [
-    { "cmd": "/workflow-tdd-plan", "args": "\"{{goal}}\"", "unit": "tdd-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create TDD task chain" },
-    { "cmd": "/workflow-execute", "unit": "tdd-planning-execution", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute TDD cycle" },
-    { "cmd": "/workflow-tdd-verify", "unit": "standalone", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Verify TDD compliance" }
+    { "cmd": "/workflow:tdd-plan", "args": "\"{{goal}}\"", "unit": "tdd-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create TDD task chain" },
+    { "cmd": "/workflow:execute", "unit": "tdd-planning-execution", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute TDD cycle" },
+    { "cmd": "/workflow:tdd-verify", "unit": "standalone", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Verify TDD compliance" }
   ]
 }
 ```
@@ -376,8 +379,8 @@ async function defineSteps(templateDesign) {
   "steps": [
     { "cmd": "/workflow:review-session-cycle", "unit": "code-review", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Multi-dimensional code review" },
     { "cmd": "/workflow:review-cycle-fix", "unit": "code-review", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Fix review findings" },
-    { "cmd": "/workflow-test-fix", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate tests for fixes" },
-    { "cmd": "/workflow-test-fix", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Verify fixes pass tests" }
+    { "cmd": "/workflow:test-fix-gen", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate tests for fixes" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Verify fixes pass tests" }
   ]
 }
 ```
@@ -389,8 +392,8 @@ async function defineSteps(templateDesign) {
   "description": "Fix failing tests",
   "level": 3,
   "steps": [
-    { "cmd": "/workflow-test-fix", "args": "\"{{goal}}\"", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate test fix tasks" },
-    { "cmd": "/workflow-test-fix", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test-fix cycle" }
+    { "cmd": "/workflow:test-fix-gen", "args": "\"{{goal}}\"", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate test fix tasks" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test-fix cycle" }
   ]
 }
 ```
@@ -417,7 +420,7 @@ async function defineSteps(templateDesign) {
   "description": "Bridge lightweight planning to issue workflow",
   "level": 2,
   "steps": [
-    { "cmd": "/workflow-lite-plan", "args": "\"{{goal}}\"", "unit": "rapid-to-issue", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create lightweight plan" },
+    { "cmd": "/workflow:lite-plan", "args": "\"{{goal}}\"", "unit": "rapid-to-issue", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create lightweight plan" },
     { "cmd": "/issue:convert-to-plan", "args": "--latest-lite-plan -y", "unit": "rapid-to-issue", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Convert to issue plan" },
     { "cmd": "/issue:queue", "unit": "rapid-to-issue", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Form execution queue" },
     { "cmd": "/issue:execute", "args": "--queue auto", "unit": "rapid-to-issue", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute issue queue" }
@@ -483,11 +486,11 @@ async function defineSteps(templateDesign) {
   "level": 4,
   "steps": [
     { "cmd": "/brainstorm", "args": "\"{{goal}}\"", "unit": "standalone", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Unified brainstorming with multi-perspective exploration" },
-    { "cmd": "/workflow-plan", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create detailed plan from brainstorm" },
-    { "cmd": "/workflow-plan-verify", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Verify plan quality" },
-    { "cmd": "/workflow-execute", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute implementation" },
-    { "cmd": "/workflow-test-fix", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate comprehensive tests" },
-    { "cmd": "/workflow-test-fix", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test cycle" }
+    { "cmd": "/workflow:plan", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Create detailed plan from brainstorm" },
+    { "cmd": "/workflow:plan-verify", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Verify plan quality" },
+    { "cmd": "/workflow:execute", "unit": "verified-planning-execution", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute implementation" },
+    { "cmd": "/workflow:test-fix-gen", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate comprehensive tests" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test cycle" }
   ]
 }
 ```
@@ -499,10 +502,10 @@ async function defineSteps(templateDesign) {
   "description": "Multi-CLI collaborative planning with cross-verification",
   "level": 3,
   "steps": [
-    { "cmd": "/workflow-multi-cli-plan", "args": "\"{{goal}}\"", "unit": "multi-cli-planning", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Gemini+Codex+Claude collaborative planning" },
-    // lite-execute is now an internal phase of multi-cli-plan (not invoked separately)
-    { "cmd": "/workflow-test-fix", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate tests" },
-    { "cmd": "/workflow-test-fix", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test cycle" }
+    { "cmd": "/workflow:multi-cli-plan", "args": "\"{{goal}}\"", "unit": "multi-cli-planning", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Gemini+Codex+Claude collaborative planning" },
+    { "cmd": "/workflow:lite-execute", "args": "--in-memory", "unit": "multi-cli-planning", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Execute converged plan" },
+    { "cmd": "/workflow:test-fix-gen", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "mainprocess" }, "contextHint": "Generate tests" },
+    { "cmd": "/workflow:test-cycle-execute", "unit": "test-validation", "execution": { "type": "slash-command", "mode": "async" }, "contextHint": "Execute test cycle" }
   ]
 }
 ```
@@ -527,7 +530,7 @@ Each command has input/output ports for pipeline composition:
 | tdd-plan | requirement | tdd-tasks | tdd-planning-execution |
 | replan | session, feedback | replan | replanning-execution |
 | **Execution** |
-| ~~lite-execute~~ | _(internal phase of lite-plan/multi-cli-plan, not standalone)_ | code | — |
+| lite-execute | plan, multi-cli-plan | code | (multiple) |
 | execute | detailed-plan, verified-plan, replan, tdd-tasks | code | (multiple) |
 | **Testing** |
 | test-fix-gen | failing-tests, session | test-tasks | test-validation |
@@ -560,9 +563,9 @@ Each command has input/output ports for pipeline composition:
 
 | Unit Name | Commands | Purpose |
 |-----------|----------|---------|
-| **quick-implementation** | lite-plan (Phase 1: plan → Phase 2: execute) | Lightweight plan and execution |
-| **multi-cli-planning** | multi-cli-plan (Phase 1: plan → Phase 2: execute) | Multi-perspective planning and execution |
-| **bug-fix** | lite-plan --bugfix (Phase 1: plan → Phase 2: execute) | Bug diagnosis and fix |
+| **quick-implementation** | lite-plan → lite-execute | Lightweight plan and execution |
+| **multi-cli-planning** | multi-cli-plan → lite-execute | Multi-perspective planning and execution |
+| **bug-fix** | lite-plan --bugfix → lite-execute | Bug diagnosis and fix |
 | **full-planning-execution** | plan → execute | Detailed planning and execution |
 | **verified-planning-execution** | plan → plan-verify → execute | Planning with verification |
 | **replanning-execution** | replan → execute | Update plan and execute |
@@ -653,9 +656,9 @@ async function generateTemplate(design, steps, outputPath) {
 → Level: 3 (Standard)
 → Steps: Customize
   → Step 1: /brainstorm (standalone, mainprocess)
-  → Step 2: /workflow-plan (verified-planning-execution, mainprocess)
-  → Step 3: /workflow-plan-verify (verified-planning-execution, mainprocess)
-  → Step 4: /workflow-execute (verified-planning-execution, async)
+  → Step 2: /workflow:plan (verified-planning-execution, mainprocess)
+  → Step 3: /workflow:plan-verify (verified-planning-execution, mainprocess)
+  → Step 4: /workflow:execute (verified-planning-execution, async)
   → Step 5: /workflow:review-session-cycle (code-review, mainprocess)
   → Step 6: /workflow:review-cycle-fix (code-review, mainprocess)
   → Done

.claude/commands/issue/discover-by-prompt.md

@@ -2,7 +2,7 @@
 name: issue:discover-by-prompt
 description: Discover issues from user prompt with Gemini-planned iterative multi-agent exploration. Uses ACE semantic search for context gathering and supports cross-module comparison (e.g., frontend vs backend API contracts).
 argument-hint: "[-y|--yes] <prompt> [--scope=src/**] [--depth=standard|deep] [--max-iterations=5]"
-allowed-tools: Skill(*), TodoWrite(*), Read(*), Bash(*), Agent(*), AskUserQuestion(*), Glob(*), Grep(*), mcp__ace-tool__search_context(*), mcp__exa__search(*)
+allowed-tools: Skill(*), TodoWrite(*), Read(*), Bash(*), Task(*), AskUserQuestion(*), Glob(*), Grep(*), mcp__ace-tool__search_context(*), mcp__exa__search(*)
 ---
 
 ## Auto Mode
@@ -404,7 +404,7 @@ while (shouldContinue && iteration < maxIterations) {
 
   // Step 3: Launch dimension agents with ACE context
   const agentPromises = iterationPlan.dimensions.map(dimension =>
-    Agent({
+    Task({
       subagent_type: "cli-explore-agent",
       run_in_background: false,
       description: `Explore ${dimension.name} (iteration ${iteration})`,

.claude/commands/issue/discover.md

@@ -2,7 +2,7 @@
 name: issue:discover
 description: Discover potential issues from multiple perspectives (bug, UX, test, quality, security, performance, maintainability, best-practices) using CLI explore. Supports Exa external research for security and best-practices perspectives.
 argument-hint: "[-y|--yes] <path-pattern> [--perspectives=bug,ux,...] [--external]"
-allowed-tools: Skill(*), TodoWrite(*), Read(*), Bash(*), Agent(*), AskUserQuestion(*), Glob(*), Grep(*)
+allowed-tools: Skill(*), TodoWrite(*), Read(*), Bash(*), Task(*), AskUserQuestion(*), Glob(*), Grep(*)
 ---
 
 ## Auto Mode
@@ -185,7 +185,7 @@ Launch N agents in parallel (one per selected perspective):
 ```javascript
 // Launch agents in parallel - agents write JSON and return summary
 const agentPromises = selectedPerspectives.map(perspective =>
-  Agent({
+  Task({
     subagent_type: "cli-explore-agent",
     run_in_background: false,
     description: `Discover ${perspective} issues`,
@@ -252,17 +252,6 @@ await updateDiscoveryState(outputDir, {
 const hasHighPriority = issues.some(i => i.priority === 'critical' || i.priority === 'high');
 const hasMediumFindings = prioritizedFindings.some(f => f.priority === 'medium');
 
-// Auto mode: auto-select recommended action
-if (autoYes) {
-  if (hasHighPriority) {
-    await appendJsonl('.workflow/issues/issues.jsonl', issues);
-    console.log(`Exported ${issues.length} issues. Run /issue:plan to continue.`);
-  } else {
-    console.log('Discovery complete. No significant issues found.');
-  }
-  return;
-}
-
 await AskUserQuestion({
   questions: [{
     question: `Discovery complete: ${issues.length} issues generated, ${prioritizedFindings.length} total findings. What would you like to do next?`,
@@ -322,7 +311,7 @@ if (response === "Export to Issues") {
 **Perspective Analysis Agent**:
 
 ```javascript
-Agent({
+Task({
   subagent_type: "cli-explore-agent",
   run_in_background: false,
   description: `Discover ${perspective} issues`,
@@ -368,7 +357,7 @@ Agent({
 **Exa Research Agent** (for security and best-practices):
 
 ```javascript
-Agent({
+Task({
   subagent_type: "cli-explore-agent",
   run_in_background: false,
   description: `External research for ${perspective} via Exa`,

.claude/commands/issue/execute.md

@@ -152,12 +152,6 @@ if (!QUEUE_ID) {
     return;
   }
 
-  // Auto mode: auto-select if exactly one active queue
-  if (autoYes && activeQueues.length === 1) {
-    QUEUE_ID = activeQueues[0].id;
-    console.log(`Auto-selected queue: ${QUEUE_ID}`);
-  } else {
-
   // Display and prompt user
   console.log('\nAvailable Queues:');
   console.log('ID'.padEnd(22) + 'Status'.padEnd(12) + 'Progress'.padEnd(12) + 'Issues');
@@ -182,7 +176,6 @@ if (!QUEUE_ID) {
   });
 
   QUEUE_ID = answer['Queue'];
-  } // end else (multi-queue prompt)
 }
 
 console.log(`\n## Executing Queue: ${QUEUE_ID}\n`);
@@ -210,13 +203,6 @@ console.log(`
 - Parallel in batch 1: ${dag.parallel_batches[0]?.length || 0}
 `);
 
-// Auto mode: use recommended defaults (Codex + Execute + Worktree)
-if (autoYes) {
-  var executor = 'codex';
-  var isDryRun = false;
-  var useWorktree = true;
-} else {
-
 // Interactive selection via AskUserQuestion
 const answer = AskUserQuestion({
   questions: [
@@ -251,10 +237,9 @@ const answer = AskUserQuestion({
   ]
 });
 
-var executor = answer['Executor'].toLowerCase().split(' ')[0];  // codex|gemini|agent
-var isDryRun = answer['Mode'].includes('Dry-run');
-var useWorktree = answer['Worktree'].includes('Yes');
-} // end else (interactive selection)
+const executor = answer['Executor'].toLowerCase().split(' ')[0];  // codex|gemini|agent
+const isDryRun = answer['Mode'].includes('Dry-run');
+const useWorktree = answer['Worktree'].includes('Yes');
 
 // Dry run mode
 if (isDryRun) {
@@ -429,7 +414,7 @@ On failure, run:
       { timeout: 3600000, run_in_background: true }
     );
   } else {
-    return Agent({
+    return Task({
       subagent_type: 'code-developer',
       run_in_background: false,
       description: `Execute solution ${solutionId}`,
@@ -466,33 +451,27 @@ if (refreshedDag.ready_count > 0) {
 if (useWorktree && refreshedDag.ready_count === 0 && refreshedDag.completed_count === refreshedDag.total) {
   console.log('\n## All Solutions Completed - Worktree Cleanup');
 
-  // Auto mode: Create PR (recommended)
-  if (autoYes) {
-    var mergeAction = 'Create PR';
-  } else {
-    const answer = AskUserQuestion({
-      questions: [{
-        question: `Queue complete. What to do with worktree branch "${worktreeBranch}"?`,
-        header: 'Merge',
-        multiSelect: false,
-        options: [
-          { label: 'Create PR (Recommended)', description: 'Push branch and create pull request' },
-          { label: 'Merge to main', description: 'Merge all commits and cleanup worktree' },
-          { label: 'Keep branch', description: 'Cleanup worktree, keep branch for manual handling' }
-        ]
-      }]
-    });
-    var mergeAction = answer['Merge'];
-  }
+  const answer = AskUserQuestion({
+    questions: [{
+      question: `Queue complete. What to do with worktree branch "${worktreeBranch}"?`,
+      header: 'Merge',
+      multiSelect: false,
+      options: [
+        { label: 'Create PR (Recommended)', description: 'Push branch and create pull request' },
+        { label: 'Merge to main', description: 'Merge all commits and cleanup worktree' },
+        { label: 'Keep branch', description: 'Cleanup worktree, keep branch for manual handling' }
+      ]
+    }]
+  });
 
   const repoRoot = Bash('git rev-parse --show-toplevel').trim();
 
-  if (mergeAction.includes('Create PR')) {
+  if (answer['Merge'].includes('Create PR')) {
     Bash(`git -C "${worktreePath}" push -u origin "${worktreeBranch}"`);
     Bash(`gh pr create --title "Queue ${dag.queue_id}" --body "Issue queue execution - all solutions completed" --head "${worktreeBranch}"`);
     Bash(`git worktree remove "${worktreePath}"`);
     console.log(`PR created for branch: ${worktreeBranch}`);
-  } else if (mergeAction.includes('Merge to main')) {
+  } else if (answer['Merge'].includes('Merge to main')) {
     // Check main is clean
     const mainDirty = Bash('git status --porcelain').trim();
     if (mainDirty) {

.claude/commands/issue/from-brainstorm.md

@@ -154,8 +154,8 @@ Phase 6: Bind Solution
    ├─ Update issue status to 'planned'
    └─ Returns: SOL-{issue-id}-{uid}
 
-Phase 7: Next Steps (skip in auto mode)
-   └─ Auto mode: complete directly | Interactive: Form queue | Convert another | Done
+Phase 7: Next Steps
+   └─ Offer: Form queue | Convert another idea | View details | Done
 ```
 
 ## Context Enrichment Logic

.claude/commands/issue/plan.md

@@ -2,7 +2,7 @@
 name: plan
 description: Batch plan issue resolution using issue-plan-agent (explore + plan closed-loop)
 argument-hint: "[-y|--yes] --all-pending <issue-id>[,<issue-id>,...] [--batch-size 3]"
-allowed-tools: TodoWrite(*), Agent(*), Skill(*), AskUserQuestion(*), Bash(*), Read(*), Write(*)
+allowed-tools: TodoWrite(*), Task(*), Skill(*), AskUserQuestion(*), Bash(*), Read(*), Write(*)
 ---
 
 ## Auto Mode
@@ -160,7 +160,7 @@ ${issueList}
 
 ### Project Context (MANDATORY)
 1. Read: .workflow/project-tech.json (technology stack, architecture)
-2. Read: .workflow/specs/*.md (constraints and conventions)
+2. Read: .workflow/project-guidelines.json (constraints and conventions)
 
 ### Workflow
 1. Fetch issue details: ccw issue status <id> --json
@@ -222,7 +222,7 @@ for (let i = 0; i < agentTasks.length; i += MAX_PARALLEL) {
 
   // Collect results from this chunk
   for (const { taskId, batchIndex } of taskIds) {
-    const result = TaskOutput({ task_id: taskId, block: true });
+    const result = TaskOutput(task_id=taskId, block=true);
 
     // Extract JSON from potential markdown code blocks (agent may wrap in ```json...```)
     const jsonText = extractJsonFromMarkdown(result);
@@ -263,14 +263,6 @@ for (let i = 0; i < agentTasks.length; i += MAX_PARALLEL) {
 for (const pending of pendingSelections) {
   if (pending.solutions.length === 0) continue;
 
-  // Auto mode: auto-bind first (highest-ranked) solution
-  if (autoYes) {
-    const solId = pending.solutions[0].id;
-    Bash(`ccw issue bind ${pending.issue_id} ${solId}`);
-    console.log(`✓ ${pending.issue_id}: ${solId} bound (auto)`);
-    continue;
-  }
-
   const options = pending.solutions.slice(0, 4).map(sol => ({
     label: `${sol.id} (${sol.task_count} tasks)`,
     description: sol.description || sol.approach || 'No description'

.claude/commands/issue/queue.md

@@ -2,7 +2,7 @@
 name: queue
 description: Form execution queue from bound solutions using issue-queue-agent (solution-level)
 argument-hint: "[-y|--yes] [--queues <n>] [--issue <id>]"
-allowed-tools: TodoWrite(*), Agent(*), Bash(*), Read(*), Write(*)
+allowed-tools: TodoWrite(*), Task(*), Bash(*), Read(*), Write(*)
 ---
 
 ## Auto Mode
@@ -247,7 +247,7 @@ if (numQueues === 1) {
       description=`Queue ${i + 1}/${numQueues}: ${group.length} solutions`
     )
   );
-  // All agents launched in parallel via single message with multiple Agent tool calls
+  // All agents launched in parallel via single message with multiple Task tool calls
 }
 ```
 
@@ -273,17 +273,6 @@ const allClarifications = results.flatMap((r, i) =>
 ```javascript
 if (allClarifications.length > 0) {
   for (const clarification of allClarifications) {
-    // Auto mode: use recommended resolution (first option)
-    if (autoYes) {
-      const autoAnswer = clarification.options[0]?.label || 'skip';
-      Task(
-        subagent_type="issue-queue-agent",
-        resume=clarification.agent_id,
-        prompt=`Conflict ${clarification.conflict_id} resolved: ${autoAnswer}`
-      );
-      continue;
-    }
-
     // Present to user via AskUserQuestion
     const answer = AskUserQuestion({
       questions: [{
@@ -356,14 +345,6 @@ ccw issue queue list --brief
 
 **AskUserQuestion:**
 ```javascript
-// Auto mode: merge into existing queue
-if (autoYes) {
-  Bash(`ccw issue queue merge ${newQueueId} --queue ${activeQueueId}`);
-  Bash(`ccw issue queue delete ${newQueueId}`);
-  console.log(`Auto-merged new queue into ${activeQueueId}`);
-  return;
-}
-
 AskUserQuestion({
   questions: [{
     question: "Active queue exists. How would you like to proceed?",

.claude/commands/memory/prepare.md

@@ -2,7 +2,7 @@
 name: prepare
 description: Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context
 argument-hint: "[--tool gemini|qwen] \"task context description\""
-allowed-tools: Agent(*), Bash(*)
+allowed-tools: Task(*), Bash(*)
 examples:
   - /memory:prepare "在当前前端基础上开发用户认证功能"
   - /memory:prepare --tool qwen "重构支付模块API"

.claude/commands/workflow-tune.md

@@ -1,811 +0,0 @@
----
-name: workflow-tune
-description: Workflow tuning - extract commands from reference docs or natural language, execute each via ccw cli --tool claude --mode write, then analyze artifacts via gemini. For testing how commands execute in Claude.
-argument-hint: "<file-path> <intent> | \"step1 | step2 | step3\" | \"skill-a,skill-b\" | --file workflow.json [--depth quick|standard|deep] [-y|--yes] [--auto-fix]"
-allowed-tools: Agent(*), AskUserQuestion(*), TaskCreate(*), TaskUpdate(*), TaskList(*), Read(*), Write(*), Edit(*), Bash(*), Glob(*), Grep(*)
----
-
-# Workflow Tune
-
-测试 Claude command/skill 的执行效果并优化。提取可执行命令，逐步通过 `ccw cli --tool claude` 执行，分析产物质量，生成优化建议。
-
-## Tool Assignment
-
-| Phase | Tool | Mode | Rule |
-|-------|------|------|------|
-| Execute | `claude` | `write` | `universal-rigorous-style` |
-| Analyze | `gemini` | `analysis` | `analysis-review-code-quality` |
-| Synthesize | `gemini` | `analysis` | `analysis-review-architecture` |
-
-## Architecture
-
-```
-Input → Parse → GenTestTask → Confirm → Setup → [resolveCmd → readMeta → assemblePrompt → Execute → STOP → Analyze → STOP]×N → Synthesize → STOP → Report
-                    ↑                                       ↑
-          Claude 直接生成测试任务            prompt 中注入 test_task
-          (无需 CLI 调用)                  作为命令的执行输入
-```
-
-## Input Formats
-
-```
-1. --file workflow.json               → JSON definition
-2. "cmd1 | cmd2 | cmd3"              → pipe-separated commands
-3. "skill-a,skill-b,skill-c"         → comma-separated skills
-4. natural language                   → semantic decomposition
-   4a: <file-path> <intent>           → extract commands from reference doc via LLM
-   4b: <pure intent text>             → intent-verb matching → ccw cli command assembly
-```
-
-**ANTI-PATTERN**: Steps like `{ command: "分析 Phase 管线" }` are WRONG — descriptions, not commands. Correct: `{ command: "/workflow-lite-plan analyze auth module" }` or `{ command: "ccw cli -p '...' --tool claude --mode write" }`
-
-## Utility: Shell Escaping
-
-```javascript
-function escapeForShell(str) {
-  // Replace single quotes with escaped version, wrap in single quotes
-  return "'" + str.replace(/'/g, "'\\''") + "'";
-}
-```
-
-## Phase 1: Setup
-
-### Step 1.1: Parse Input + Preference Collection
-
-```javascript
-const args = $ARGUMENTS.trim();
-const autoYes = /\b(-y|--yes)\b/.test(args);
-
-// Preference collection (skip if -y)
-if (autoYes) {
-  workflowPreferences = { autoYes: true, analysisDepth: 'standard', autoFix: false };
-} else {
-  const prefResponse = AskUserQuestion({
-    questions: [
-      { question: "选择调优配置：", header: "Tune Config", multiSelect: false,
-        options: [
-          { label: "Quick (轻量分析)", description: "每步简要检查" },
-          { label: "Standard (标准分析) (Recommended)", description: "每步详细分析" },
-          { label: "Deep (深度分析)", description: "深度审查含架构建议" }
-        ]
-      },
-      { question: "是否自动应用优化建议？", header: "Auto Fix", multiSelect: false,
-        options: [
-          { label: "No (仅报告) (Recommended)", description: "只分析不修改" },
-          { label: "Yes (自动应用)", description: "自动应用高优先级建议" }
-        ]
-      }
-    ]
-  });
-  const depthMap = { "Quick": "quick", "Standard": "standard", "Deep": "deep" };
-  const selectedDepth = Object.keys(depthMap).find(k => prefResponse["Tune Config"].startsWith(k)) || "Standard";
-  workflowPreferences = {
-    autoYes: false,
-    analysisDepth: depthMap[selectedDepth],
-    autoFix: prefResponse["Auto Fix"].startsWith("Yes")
-  };
-}
-
-// Parse --depth override
-const depthMatch = args.match(/--depth\s+(quick|standard|deep)/);
-if (depthMatch) workflowPreferences.analysisDepth = depthMatch[1];
-
-// ── Format Detection ──
-let steps = [], workflowName = 'unnamed-workflow', inputFormat = '';
-let projectScenario = '';  // ★ 统一虚构项目场景，所有步骤共享（在 Step 1.1a 生成）
-
-const fileMatch = args.match(/--file\s+"?([^\s"]+)"?/);
-if (fileMatch) {
-  const wfDef = JSON.parse(Read(fileMatch[1]));
-  workflowName = wfDef.name || 'unnamed-workflow';
-  projectScenario = wfDef.project_scenario || wfDef.description || '';
-  steps = wfDef.steps;
-  inputFormat = 'json';
-}
-else if (args.includes('|')) {
-  const rawSteps = args.split(/(?:--context|--depth|-y|--yes|--auto-fix)\s+("[^"]*"|\S+)/)[0];
-  steps = rawSteps.split('|').map((cmd, i) => ({
-    name: `step-${i + 1}`,
-    command: cmd.trim(),
-    expected_artifacts: [], success_criteria: ''
-  }));
-  inputFormat = 'pipe';
-}
-else if (/^[\w-]+(,[\w-]+)+/.test(args.split(/\s/)[0])) {
-  const skillNames = args.match(/^([^\s]+)/)[1].split(',');
-  steps = skillNames.map(name => ({
-    name, command: `/${name}`,
-    expected_artifacts: [], success_criteria: ''
-  }));
-  inputFormat = 'skills';
-}
-else {
-  inputFormat = 'natural-language';
-  let naturalLanguageInput = args.replace(/--\w+\s+"[^"]*"/g, '').replace(/--\w+\s+\S+/g, '').replace(/-y|--yes/g, '').trim();
-  const filePathPattern = /(?:[A-Za-z]:[\\\/][^\s,;]+|\/[^\s,;]+\.(?:md|txt|json|yaml|yml|toml)|\.\/?[^\s,;]+\.(?:md|txt|json|yaml|yml|toml))/g;
-  const detectedPaths = naturalLanguageInput.match(filePathPattern) || [];
-  let referenceDocContent = null, referenceDocPath = null;
-  if (detectedPaths.length > 0) {
-    referenceDocPath = detectedPaths[0];
-    try {
-      referenceDocContent = Read(referenceDocPath);
-      naturalLanguageInput = naturalLanguageInput.replace(referenceDocPath, '').trim();
-    } catch (e) { referenceDocContent = null; }
-  }
-  // → Mode 4a/4b in Step 1.1b
-}
-
-// workflowContext 已移除 — 统一使用 projectScenario（在 Step 1.1a 生成）
-```
-
-### Step 1.1a: Generate Test Task (测试任务直接生成)
-
-> **核心概念**: 所有步骤共享一个**统一虚构项目场景**（如"在线书店网站"），每个命令根据自身能力获得该场景下的一个子任务。由当前 Claude 直接生成，不需要额外 CLI 调用。所有执行在独立沙箱目录中进行，不影响真实项目。
-
-```javascript
-// ★ 测试任务直接生成 — 无需 CLI 调用
-// 来源优先级：
-//   1. JSON 定义中的 step.test_task 字段 (已有则跳过)
-//   2. 当前 Claude 直接生成
-
-const stepsNeedTask = steps.filter(s => !s.test_task);
-
-if (stepsNeedTask.length > 0) {
-  // ── Step A: 生成统一项目场景 ──
-  // 根据命令链的整体复杂度，选一个虚构项目作为测试场景
-  // 场景必须：完全虚构、与当前工作空间无关、足够支撑所有步骤
-  //
-  // 场景池示例（根据步骤数量和类型选择合适规模）：
-  //   1-2 步: 小型项目 — "命令行 TODO 工具" "Markdown 转 HTML 工具" "天气查询 CLI"
-  //   3-4 步: 中型项目 — "在线书店网站" "团队任务看板" "博客系统"
-  //   5+ 步:  大型项目 — "多租户 SaaS 平台" "电商系统" "在线教育平台"
-
-  projectScenario = /* Claude 从上述池中选择或自创一个场景 */;
-  // 例如: "在线书店网站 — 支持用户注册登录、书籍搜索浏览、购物车、订单管理、评论系统"
-
-  // ── Step B: 为每步生成子任务 ──
-  for (const step of stepsNeedTask) {
-    const cmdFile = resolveCommandFile(step.command);
-    const cmdMeta = readCommandMeta(cmdFile);
-    const cmdDesc = (cmdMeta?.description || step.command).toLowerCase();
-
-    // 根据命令类型分配场景下的子任务
-    // 每个子任务必须按以下模板生成：
-    //
-    // ┌─────────────────────────────────────────────────┐
-    // │ 项目: {projectScenario}                          │
-    // │ 任务: {具体子任务描述}                            │
-    // │ 功能点:                                          │
-    // │   1. {功能点1 — 具体到接口/组件/模块}             │
-    // │   2. {功能点2}                                   │
-    // │   3. {功能点3}                                   │
-    // │ 技术约束: {语言/框架/架构要求}                    │
-    // │ 验收标准:                                        │
-    // │   1. {可验证的标准1}                              │
-    // │   2. {可验证的标准2}                              │
-    // └─────────────────────────────────────────────────┘
-    //
-    // 命令类型 → 子任务映射：
-    //   plan/design   → 架构设计任务: "为{场景}设计技术架构，包含模块划分、数据模型、API 设计"
-    //   implement     → 功能实现任务: "实现{场景}的{某模块}，包含{具体功能点}"
-    //   analyze/review→ 代码分析任务: "先在沙箱创建{场景}的{某模块}示例代码，然后分析其质量"
-    //   test          → 测试任务:     "为{场景}的{某模块}编写测试，覆盖{具体场景}"
-    //   fix/debug     → 修复任务:     "先在沙箱创建含已知 bug 的代码，然后诊断修复"
-    //   refactor      → 重构任务:     "先在沙箱创建可工作但需重构的代码，然后重构"
-
-    step.test_task = /* 按上述模板生成，必须包含：项目、任务、功能点、技术约束、验收标准 */;
-    step.acceptance_criteria = /* 从 test_task 中提取 2-4 条可验证标准 */;
-    step.complexity_level = /plan|design|architect/i.test(cmdDesc) ? 'high'
-      : /test|lint|format/i.test(cmdDesc) ? 'low' : 'medium';
-  }
-}
-```
-
-**模拟示例** — 输入 `workflow-lite-plan,workflow-lite-execute`:
-
-```
-场景: 在线书店网站 — 支持用户注册登录、书籍搜索、购物车、订单管理
-
-Step 1 (workflow-lite-plan → plan 类, high):
-  项目: 在线书店网站
-  任务: 为在线书店设计技术架构和实现计划
-  功能点:
-    1. 用户模块 — 注册、登录、个人信息管理
-    2. 书籍模块 — 搜索、分类浏览、详情页
-    3. 交易模块 — 购物车、下单、支付状态
-    4. 数据模型 — User, Book, Order, CartItem 表结构设计
-  技术约束: TypeScript + Express + SQLite, REST API
-  验收标准:
-    1. 输出包含模块划分和依赖关系
-    2. 包含数据模型定义
-    3. 包含 API 路由清单
-    4. 包含实现步骤分解
-
-Step 2 (workflow-lite-execute → implement 类, medium):
-  项目: 在线书店网站
-  任务: 根据 Step 1 的计划，实现书籍搜索和浏览模块
-  功能点:
-    1. GET /api/books — 分页列表，支持按标题/作者搜索
-    2. GET /api/books/:id — 书籍详情
-    3. GET /api/categories — 分类列表
-    4. Book 数据模型 + seed 数据
-  技术约束: TypeScript + Express + SQLite, 沿用 Step 1 架构
-  验收标准:
-    1. API 可正常调用返回 JSON
-    2. 搜索支持模糊匹配
-    3. 包含至少 5 条 seed 数据
-```
-
-### Step 1.1b: Semantic Decomposition (Format 4 only)
-
-#### Mode 4a: Reference Document → LLM Extraction
-
-```javascript
-if (inputFormat === 'natural-language' && referenceDocContent) {
-  const extractPrompt = `PURPOSE: Extract ACTUAL EXECUTABLE COMMANDS from the reference document. The user wants to TEST these commands by running them.
-
-USER INTENT: ${naturalLanguageInput}
-REFERENCE DOCUMENT: ${referenceDocPath}
-
-DOCUMENT CONTENT:
-${referenceDocContent}
-
-CRITICAL RULES:
-- "command" field MUST be a real executable: slash command (/skill-name args), ccw cli call, or shell command
-- CORRECT: { "command": "/workflow-lite-plan analyze auth module" }
-- CORRECT: { "command": "ccw cli -p 'review code' --tool claude --mode write" }
-- WRONG:  { "command": "分析 Phase 管线" } ← DESCRIPTION, not command
-- Default mode to "write"
-
-EXPECTED OUTPUT (strict JSON):
-{
-  "workflow_name": "<name>",
-  "project_scenario": "<虚构项目场景>",
-  "steps": [{ "name": "", "command": "<executable>", "expected_artifacts": [], "success_criteria": "" }]
-}`;
-
-  Bash({
-    command: `ccw cli -p ${escapeForShell(extractPrompt)} --tool claude --mode write --rule universal-rigorous-style`,
-    run_in_background: true, timeout: 300000
-  });
-  // ■ STOP — wait for hook callback, parse JSON → steps[]
-}
-```
-
-#### Mode 4b: Pure Intent → Command Assembly
-
-```javascript
-if (inputFormat === 'natural-language' && !referenceDocContent) {
-  // Intent → rule mapping for ccw cli command generation
-  const intentMap = [
-    { pattern: /分析|analyze|审查|inspect|scan/i, name: 'analyze', rule: 'analysis-analyze-code-patterns' },
-    { pattern: /评审|review|code.?review/i, name: 'review', rule: 'analysis-review-code-quality' },
-    { pattern: /诊断|debug|排查|diagnose/i, name: 'diagnose', rule: 'analysis-diagnose-bug-root-cause' },
-    { pattern: /安全|security|漏洞/i, name: 'security-audit', rule: 'analysis-assess-security-risks' },
-    { pattern: /性能|performance|perf/i, name: 'perf-analysis', rule: 'analysis-analyze-performance' },
-    { pattern: /架构|architecture/i, name: 'arch-review', rule: 'analysis-review-architecture' },
-    { pattern: /修复|fix|repair|解决/i, name: 'fix', rule: 'development-debug-runtime-issues' },
-    { pattern: /实现|implement|开发|create|新增/i, name: 'implement', rule: 'development-implement-feature' },
-    { pattern: /重构|refactor/i, name: 'refactor', rule: 'development-refactor-codebase' },
-    { pattern: /测试|test/i, name: 'test', rule: 'development-generate-tests' },
-    { pattern: /规划|plan|设计|design/i, name: 'plan', rule: 'planning-plan-architecture-design' },
-  ];
-
-  const segments = naturalLanguageInput
-    .split(/[，,；;、]|(?:然后|接着|之后|最后|再|并|and then|then|finally|next)\s*/i)
-    .map(s => s.trim()).filter(Boolean);
-
-  // ★ 将意图文本转化为完整的 ccw cli 命令
-  steps = segments.map((segment, i) => {
-    const matched = intentMap.find(m => m.pattern.test(segment));
-    const rule = matched?.rule || 'universal-rigorous-style';
-    // 组装真正可执行的命令
-    const command = `ccw cli -p ${escapeForShell('PURPOSE: ' + segment + '\\nTASK: Execute based on intent\\nCONTEXT: @**/*')} --tool claude --mode write --rule ${rule}`;
-    return {
-      name: matched?.name || `step-${i + 1}`,
-      command,
-      original_intent: segment,  // 保留原始意图用于分析
-      expected_artifacts: [], success_criteria: ''
-    };
-  });
-}
-```
-
-### Step 1.1c: Execution Plan Confirmation
-
-```javascript
-function generateCommandDoc(steps, workflowName, projectScenario, analysisDepth) {
-  const stepTable = steps.map((s, i) => {
-    const cmdPreview = s.command.length > 60 ? s.command.substring(0, 57) + '...' : s.command;
-    const taskPreview = (s.test_task || '-').length > 40 ? s.test_task.substring(0, 37) + '...' : (s.test_task || '-');
-    return `| ${i + 1} | ${s.name} | \`${cmdPreview}\` | ${taskPreview} |`;
-  }).join('\n');
-
-  return `# Workflow Tune — Execution Plan\n\n**Workflow**: ${workflowName}\n**Test Project**: ${projectScenario}\n**Steps**: ${steps.length}\n**Depth**: ${analysisDepth}\n\n| # | Name | Command | Test Task |\n|---|------|---------|-----------|\n${stepTable}`;
-}
-
-const commandDoc = generateCommandDoc(steps, workflowName, projectScenario, workflowPreferences.analysisDepth);
-
-if (!workflowPreferences.autoYes) {
-  const confirmation = AskUserQuestion({
-    questions: [{
-      question: commandDoc + "\n\n确认执行以上 Workflow 调优计划？", header: "Confirm Execution", multiSelect: false,
-      options: [
-        { label: "Execute (确认执行)", description: "按计划开始执行" },
-        { label: "Cancel (取消)", description: "取消" }
-      ]
-    }]
-  });
-  if (confirmation["Confirm Execution"].startsWith("Cancel")) return;
-}
-```
-
-### Step 1.2: (Merged into Step 1.1a)
-
-> Test requirements (acceptance_criteria) are now generated together with test_task in Step 1.1a, avoiding an extra CLI call.
-
-### Step 1.3: Create Workspace + Sandbox Project
-
-```javascript
-const ts = Date.now();
-const workDir = `.workflow/.scratchpad/workflow-tune-${ts}`;
-
-// ★ 创建独立沙箱项目目录 — 所有命令执行在此目录中，不影响真实项目
-const sandboxDir = `${workDir}/sandbox`;
-Bash(`mkdir -p "${workDir}/steps" "${sandboxDir}"`);
-// 初始化沙箱为独立 git 仓库（部分命令依赖 git 环境）
-Bash(`cd "${sandboxDir}" && git init && echo "# Sandbox Project" > README.md && git add . && git commit -m "init sandbox"`);
-
-for (let i = 0; i < steps.length; i++) Bash(`mkdir -p "${workDir}/steps/step-${i + 1}/artifacts"`);
-
-Write(`${workDir}/command-doc.md`, commandDoc);
-
-const initialState = {
-  status: 'running', started_at: new Date().toISOString(),
-  workflow_name: workflowName, project_scenario: projectScenario,
-  analysis_depth: workflowPreferences.analysisDepth, auto_fix: workflowPreferences.autoFix,
-  sandbox_dir: sandboxDir,  // ★ 独立沙箱项目目录
-  current_step: 0,  // ★ State machine cursor
-  current_phase: 'execute',  // 'execute' | 'analyze'
-  steps: steps.map((s, i) => ({
-    ...s, index: i, status: 'pending',
-    test_task: s.test_task || '',  // ★ 每步的测试任务
-    execution: null, analysis: null,
-    test_requirements: s.test_requirements || null
-  })),
-  gemini_session_id: null,  // ★ Updated after each gemini callback
-  work_dir: workDir,
-  errors: [], error_count: 0, max_errors: 3
-};
-
-Write(`${workDir}/workflow-state.json`, JSON.stringify(initialState, null, 2));
-Write(`${workDir}/process-log.md`, `# Process Log\n\n**Workflow**: ${workflowName}\n**Test Project**: ${projectScenario}\n**Steps**: ${steps.length}\n**Started**: ${new Date().toISOString()}\n\n---\n\n`);
-```
-
-## Phase 2: Execute Step
-
-### resolveCommandFile — Slash command → file path
-
-```javascript
-function resolveCommandFile(command) {
-  const cmdMatch = command.match(/^\/?([^\s]+)/);
-  if (!cmdMatch) return null;
-  const cmdName = cmdMatch[1];
-  const cmdPath = cmdName.replace(/:/g, '/');
-
-  const searchRoots = ['.claude', '~/.claude'];
-
-  for (const root of searchRoots) {
-    const candidates = [
-      `${root}/commands/${cmdPath}.md`,
-      `${root}/commands/${cmdPath}/index.md`,
-    ];
-    for (const candidate of candidates) {
-      try { Read(candidate, { limit: 1 }); return candidate; } catch {}
-    }
-  }
-
-  for (const root of searchRoots) {
-    const candidates = [
-      `${root}/skills/${cmdName}/SKILL.md`,
-      `${root}/skills/${cmdPath.replace(/\//g, '-')}/SKILL.md`,
-    ];
-    for (const candidate of candidates) {
-      try { Read(candidate, { limit: 1 }); return candidate; } catch {}
-    }
-  }
-
-  return null;
-}
-```
-
-### readCommandMeta — Read YAML frontmatter + body summary
-
-```javascript
-function readCommandMeta(filePath) {
-  if (!filePath) return null;
-
-  const content = Read(filePath);
-  const meta = { filePath, name: '', description: '', argumentHint: '', allowedTools: '', bodySummary: '' };
-
-  const yamlMatch = content.match(/^---\n([\s\S]*?)\n---/);
-  if (yamlMatch) {
-    const yaml = yamlMatch[1];
-    const nameMatch = yaml.match(/^name:\s*(.+)$/m);
-    const descMatch = yaml.match(/^description:\s*(.+)$/m);
-    const hintMatch = yaml.match(/^argument-hint:\s*"?(.+?)"?\s*$/m);
-    const toolsMatch = yaml.match(/^allowed-tools:\s*(.+)$/m);
-
-    if (nameMatch) meta.name = nameMatch[1].trim();
-    if (descMatch) meta.description = descMatch[1].trim();
-    if (hintMatch) meta.argumentHint = hintMatch[1].trim();
-    if (toolsMatch) meta.allowedTools = toolsMatch[1].trim();
-  }
-
-  const bodyStart = content.indexOf('---', content.indexOf('---') + 3);
-  if (bodyStart !== -1) {
-    const body = content.substring(bodyStart + 3).trim();
-    meta.bodySummary = body.split('\n').slice(0, 30).join('\n');
-  }
-
-  return meta;
-}
-```
-
-### assembleStepPrompt — Build execution prompt from command metadata
-
-```javascript
-function assembleStepPrompt(step, stepIdx, state) {
-  // ── 1. Resolve command file + metadata ──
-  const isSlashCmd = step.command.startsWith('/');
-  const cmdFile = isSlashCmd ? resolveCommandFile(step.command) : null;
-  const cmdMeta = readCommandMeta(cmdFile);
-  const cmdArgs = isSlashCmd ? step.command.replace(/^\/?[^\s]+\s*/, '').trim() : '';
-
-  // ── 2. Prior/next step context ──
-  const prevStep = stepIdx > 0 ? state.steps[stepIdx - 1] : null;
-  const nextStep = stepIdx < state.steps.length - 1 ? state.steps[stepIdx + 1] : null;
-
-  const priorContext = prevStep
-    ? `PRIOR STEP: "${prevStep.name}" — ${prevStep.command}\n  Status: ${prevStep.status} | Artifacts: ${prevStep.execution?.artifact_count || 0}`
-    : 'PRIOR STEP: None (first step)';
-
-  const nextContext = nextStep
-    ? `NEXT STEP: "${nextStep.name}" — ${nextStep.command}\n  Ensure output is consumable by next step`
-    : 'NEXT STEP: None (last step)';
-
-  // ── 3. Acceptance criteria (from test_task generation) ──
-  const criteria = step.acceptance_criteria || [];
-  const testReqSection = criteria.length > 0
-    ? `ACCEPTANCE CRITERIA:\n${criteria.map((c, i) => `  ${i + 1}. ${c}`).join('\n')}`
-    : '';
-
-  // ── 4. Test task — the concrete scenario to drive execution ──
-  const testTask = step.test_task || '';
-  const testTaskSection = testTask
-    ? `TEST TASK (用此任务驱动命令执行):\n  ${testTask}`
-    : '';
-
-  // ── 5. Build prompt based on whether command has metadata ──
-  if (cmdMeta) {
-    // Slash command with resolved file — rich context prompt
-    return `PURPOSE: Execute workflow step "${step.name}" (${stepIdx + 1}/${state.steps.length}).
-
-COMMAND DEFINITION:
-  Name: ${cmdMeta.name}
-  Description: ${cmdMeta.description}
-  Argument Format: ${cmdMeta.argumentHint || 'none'}
-  Allowed Tools: ${cmdMeta.allowedTools || 'default'}
-  Source: ${cmdMeta.filePath}
-
-COMMAND TO EXECUTE: ${step.command}
-ARGUMENTS: ${cmdArgs || '(no arguments)'}
-
-${testTaskSection}
-
-COMMAND REFERENCE (first 30 lines):
-${cmdMeta.bodySummary}
-
-PROJECT: ${state.project_scenario}
-SANDBOX PROJECT: ${state.sandbox_dir}
-OUTPUT DIR: ${state.work_dir}/steps/step-${stepIdx + 1}
-
-${priorContext}
-${nextContext}
-${testReqSection}
-
-TASK: Execute the command as described in COMMAND DEFINITION, using TEST TASK as the input/scenario. Use the COMMAND REFERENCE to understand expected behavior. All work happens in the SANDBOX PROJECT directory (an isolated empty project, NOT the real workspace). Auto-confirm all prompts.
-CONSTRAINTS: Stay scoped to this step only. Follow the command's own execution flow. The TEST TASK is the real work — treat it as the $ARGUMENTS input to the command. Do NOT read/modify files outside SANDBOX PROJECT.`;
-
-  } else {
-    // Shell command, ccw cli command, or unresolved command
-    return `PURPOSE: Execute workflow step "${step.name}" (${stepIdx + 1}/${state.steps.length}).
-COMMAND: ${step.command}
-${testTaskSection}
-PROJECT: ${state.project_scenario}
-SANDBOX PROJECT: ${state.sandbox_dir}
-OUTPUT DIR: ${state.work_dir}/steps/step-${stepIdx + 1}
-
-${priorContext}
-${nextContext}
-${testReqSection}
-
-TASK: Execute the COMMAND above with TEST TASK as the input scenario. All work happens in the SANDBOX PROJECT directory (an isolated empty project). Auto-confirm all prompts.
-CONSTRAINTS: Stay scoped to this step only. The TEST TASK is the real work to execute. Do NOT read/modify files outside SANDBOX PROJECT.`;
-  }
-}
-```
-
-### Step Execution
-
-```javascript
-const stepIdx = state.current_step;
-const step = state.steps[stepIdx];
-const stepDir = `${state.work_dir}/steps/step-${stepIdx + 1}`;
-
-// Pre-execution: snapshot sandbox directory files
-const preFiles = Bash(`find "${state.sandbox_dir}" -type f 2>/dev/null | sort`).stdout.trim();
-Write(`${stepDir}/pre-exec-snapshot.txt`, preFiles || '(empty)');
-
-const startTime = Date.now();
-const prompt = assembleStepPrompt(step, stepIdx, state);
-
-// ★ All steps execute via ccw cli --tool claude --mode write
-// ★ --cd 指向沙箱目录（独立项目），不影响真实工作空间
-Bash({
-  command: `ccw cli -p ${escapeForShell(prompt)} --tool claude --mode write --rule universal-rigorous-style --cd "${state.sandbox_dir}"`,
-  run_in_background: true, timeout: 600000
-});
-// ■ STOP — wait for hook callback
-```
-
-### Post-Execute Callback Handler
-
-```javascript
-// ★ This runs after receiving the ccw cli callback
-
-const duration = Date.now() - startTime;
-
-// Collect artifacts by scanning sandbox (not git diff — sandbox is an independent project)
-const postFiles = Bash(`find "${state.sandbox_dir}" -type f -newer "${stepDir}/pre-exec-snapshot.txt" 2>/dev/null | sort`).stdout.trim();
-const newArtifacts = postFiles ? postFiles.split('\n').filter(f => !f.endsWith('.git/')) : [];
-
-const artifactManifest = {
-  step: step.name, step_index: stepIdx,
-  success: true, duration_ms: duration,
-  artifacts: newArtifacts.map(f => ({
-    path: f,
-    type: f.endsWith('.md') ? 'markdown' : f.endsWith('.json') ? 'json' : 'other'
-  })),
-  collected_at: new Date().toISOString()
-};
-Write(`${stepDir}/artifacts-manifest.json`, JSON.stringify(artifactManifest, null, 2));
-
-// Update state
-state.steps[stepIdx].status = 'executed';
-state.steps[stepIdx].execution = {
-  success: true, duration_ms: duration,
-  artifact_count: newArtifacts.length
-};
-state.current_phase = 'analyze';
-Write(`${state.work_dir}/workflow-state.json`, JSON.stringify(state, null, 2));
-
-// → Proceed to Phase 3 for this step
-```
-
-## Phase 3: Analyze Step (per step, via gemini)
-
-```javascript
-const manifest = JSON.parse(Read(`${stepDir}/artifacts-manifest.json`));
-
-// Build artifact content for analysis
-let artifactSummary = '';
-if (state.analysis_depth === 'quick') {
-  artifactSummary = manifest.artifacts.map(a => `- ${a.path} (${a.type})`).join('\n');
-} else {
-  const maxLines = state.analysis_depth === 'deep' ? 300 : 150;
-  artifactSummary = manifest.artifacts.map(a => {
-    try { return `--- ${a.path} ---\n${Read(a.path, { limit: maxLines })}`; }
-    catch { return `--- ${a.path} --- [unreadable]`; }
-  }).join('\n\n');
-}
-
-const criteria = step.acceptance_criteria || [];
-const testTaskDesc = step.test_task ? `TEST TASK: ${step.test_task}` : '';
-const criteriaSection = criteria.length > 0
-  ? `ACCEPTANCE CRITERIA:\n${criteria.map((c, i) => `  ${i + 1}. ${c}`).join('\n')}`
-  : '';
-
-const analysisPrompt = `PURPOSE: Evaluate execution quality of step "${step.name}" (${stepIdx + 1}/${state.steps.length}).
-WORKFLOW: ${state.workflow_name} — ${state.project_scenario}
-COMMAND: ${step.command}
-${testTaskDesc}
-${criteriaSection}
-EXECUTION: Duration ${step.execution.duration_ms}ms | Artifacts: ${manifest.artifacts.length}
-ARTIFACTS:\n${artifactSummary}
-EXPECTED OUTPUT (strict JSON):
-{ "quality_score": <0-100>, "requirement_match": { "pass": <bool>, "criteria_met": [], "criteria_missed": [], "fail_signals_detected": [] }, "execution_assessment": { "success": <bool>, "completeness": "", "notes": "" }, "artifact_assessment": { "count": <n>, "quality": "", "key_outputs": [], "missing_outputs": [] }, "issues": [{ "severity": "critical|high|medium|low", "description": "", "suggestion": "" }], "optimization_opportunities": [{ "area": "", "description": "", "impact": "high|medium|low" }], "step_summary": "" }`;
-
-let cliCommand = `ccw cli -p ${escapeForShell(analysisPrompt)} --tool gemini --mode analysis --rule analysis-review-code-quality`;
-if (state.gemini_session_id) cliCommand += ` --resume ${state.gemini_session_id}`;
-Bash({ command: cliCommand, run_in_background: true, timeout: 300000 });
-// ■ STOP — wait for hook callback
-```
-
-### Post-Analyze Callback Handler
-
-```javascript
-// ★ Parse analysis result JSON from callback
-const analysisResult = /* parsed from callback output */;
-
-// ★ Capture gemini session ID for resume chain
-// Session ID is in stderr: [CCW_EXEC_ID=gem-xxxxxx-xxxx]
-state.gemini_session_id = /* captured from callback exec_id */;
-
-Write(`${stepDir}/step-${stepIdx + 1}-analysis.json`, JSON.stringify(analysisResult, null, 2));
-
-// Update state
-state.steps[stepIdx].analysis = {
-  quality_score: analysisResult.quality_score,
-  requirement_pass: analysisResult.requirement_match?.pass,
-  issue_count: (analysisResult.issues || []).length
-};
-state.steps[stepIdx].status = 'completed';
-
-// Append to process log
-const logEntry = `## Step ${stepIdx + 1}: ${step.name}\n- Score: ${analysisResult.quality_score}/100\n- Req: ${analysisResult.requirement_match?.pass ? 'PASS' : 'FAIL'}\n- Issues: ${(analysisResult.issues || []).length}\n- Summary: ${analysisResult.step_summary}\n\n`;
-Edit(`${state.work_dir}/process-log.md`, /* append logEntry */);
-
-// ★ Advance state machine
-state.current_step = stepIdx + 1;
-state.current_phase = 'execute';
-Write(`${state.work_dir}/workflow-state.json`, JSON.stringify(state, null, 2));
-
-// ★ Decision: advance or synthesize
-if (state.current_step < state.steps.length) {
-  // → Back to Phase 2 for next step
-} else {
-  // → Phase 4: Synthesize
-}
-```
-
-## Step Loop — State Machine
-
-```
-NOT a sync for-loop. Each step follows this state machine:
-
-  ┌─────────────────────────────────────────────────────┐
-  │ state.current_step = N, state.current_phase = X     │
-  ├─────────────────────────────────────────────────────┤
-  │ phase='execute' → Phase 2 → ccw cli claude → STOP  │
-  │   callback → collect artifacts → phase='analyze'    │
-  │ phase='analyze' → Phase 3 → ccw cli gemini → STOP  │
-  │   callback → save analysis → current_step++         │
-  │   if current_step < total → phase='execute' (loop)  │
-  │   else → Phase 4 (synthesize)                       │
-  └─────────────────────────────────────────────────────┘
-
-Error handling:
-  - Execute timeout → retry once, then mark failed, advance
-  - Analyze failure → retry without --resume, then skip analysis
-  - 3+ consecutive errors → terminate, jump to Phase 5 partial report
-```
-
-## Phase 4: Synthesize (via gemini)
-
-```javascript
-const stepAnalyses = state.steps.map((step, i) => {
-  try { return { step: step.name, content: Read(`${state.work_dir}/steps/step-${i + 1}/step-${i + 1}-analysis.json`) }; }
-  catch { return { step: step.name, content: '[Not available]' }; }
-});
-
-const scores = state.steps.map(s => s.analysis?.quality_score).filter(Boolean);
-const avgScore = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length) : 0;
-
-const synthesisPrompt = `PURPOSE: Synthesize all step analyses into holistic workflow assessment with actionable optimization plan.
-WORKFLOW: ${state.workflow_name} — ${state.project_scenario}
-Steps: ${state.steps.length} | Avg Quality: ${avgScore}/100
-STEP ANALYSES:\n${stepAnalyses.map(a => `### ${a.step}\n${a.content}`).join('\n\n---\n\n')}
-Evaluate: coherence across steps, handoff quality, redundancy, bottlenecks.
-EXPECTED OUTPUT (strict JSON):
-{ "workflow_score": <0-100>, "coherence": { "score": <0-100>, "assessment": "", "gaps": [] }, "bottlenecks": [{ "step": "", "issue": "", "suggestion": "" }], "per_step_improvements": [{ "step": "", "priority": "high|medium|low", "action": "" }], "workflow_improvements": [{ "area": "", "description": "", "impact": "high|medium|low" }], "summary": "" }`;
-
-let cliCommand = `ccw cli -p ${escapeForShell(synthesisPrompt)} --tool gemini --mode analysis --rule analysis-review-architecture`;
-if (state.gemini_session_id) cliCommand += ` --resume ${state.gemini_session_id}`;
-Bash({ command: cliCommand, run_in_background: true, timeout: 300000 });
-// ■ STOP — wait for hook callback → parse JSON, write synthesis.json, update state
-```
-
-## Phase 5: Report
-
-```javascript
-const synthesis = JSON.parse(Read(`${state.work_dir}/synthesis.json`));
-const scores = state.steps.map(s => s.analysis?.quality_score).filter(Boolean);
-const avgScore = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length) : 0;
-const totalIssues = state.steps.reduce((sum, s) => sum + (s.analysis?.issue_count || 0), 0);
-
-const stepTable = state.steps.map((s, i) => {
-  const reqStr = s.analysis?.requirement_pass === true ? 'PASS' : s.analysis?.requirement_pass === false ? 'FAIL' : '-';
-  return `| ${i + 1} | ${s.name} | ${s.execution?.success ? 'OK' : 'FAIL'} | ${reqStr} | ${s.analysis?.quality_score || '-'} | ${s.analysis?.issue_count || 0} |`;
-}).join('\n');
-
-const improvements = (synthesis.per_step_improvements || [])
-  .filter(imp => imp.priority === 'high')
-  .map(imp => `- **${imp.step}**: ${imp.action}`)
-  .join('\n');
-
-const report = `# Workflow Tune Report
-
-| Field | Value |
-|---|---|
-| Workflow | ${state.workflow_name} |
-| Test Project | ${state.project_scenario} |
-| Workflow Score | ${synthesis.workflow_score || avgScore}/100 |
-| Avg Step Score | ${avgScore}/100 |
-| Total Issues | ${totalIssues} |
-| Coherence | ${synthesis.coherence?.score || '-'}/100 |
-
-## Step Results
-
-| # | Step | Exec | Req | Quality | Issues |
-|---|------|------|-----|---------|--------|
-${stepTable}
-
-## High Priority Improvements
-
-${improvements || 'None'}
-
-## Workflow-Level Improvements
-
-${(synthesis.workflow_improvements || []).map(w => `- **${w.area}** (${w.impact}): ${w.description}`).join('\n') || 'None'}
-
-## Bottlenecks
-
-${(synthesis.bottlenecks || []).map(b => `- **${b.step}**: ${b.issue} → ${b.suggestion}`).join('\n') || 'None'}
-
-## Summary
-
-${synthesis.summary || 'N/A'}
-`;
-
-Write(`${state.work_dir}/final-report.md`, report);
-state.status = 'completed';
-Write(`${state.work_dir}/workflow-state.json`, JSON.stringify(state, null, 2));
-
-// Output report to user
-```
-
-## Resume Chain
-
-```
-Step 1 Execute → ccw cli claude --mode write --rule universal-rigorous-style --cd step-1/ → STOP → callback → artifacts
-Step 1 Analyze → ccw cli gemini --mode analysis --rule analysis-review-code-quality         → STOP → callback → gemini_session_id = exec_id
-Step 2 Execute → ccw cli claude --mode write --rule universal-rigorous-style --cd step-2/ → STOP → callback → artifacts
-Step 2 Analyze → ccw cli gemini --mode analysis --resume gemini_session_id                 → STOP → callback → gemini_session_id = exec_id
-  ...
-Synthesize   → ccw cli gemini --mode analysis --resume gemini_session_id                   → STOP → callback → synthesis
-Report       → local generation (no CLI call)
-```
-
-## Error Handling
-
-| Phase | Error | Recovery |
-|-------|-------|----------|
-| Execute | CLI timeout | Retry once, then mark step failed and advance |
-| Execute | Command not found | Skip step, note in process-log |
-| Analyze | CLI fails | Retry without --resume, then skip analysis |
-| Synthesize | CLI fails | Generate report from step analyses only |
-| Any | 3+ consecutive errors | Terminate, produce partial report |
-
-## Core Rules
-
-1. **STOP After Each CLI Call**: Every `ccw cli` call runs in background — STOP output immediately, wait for hook callback
-2. **State Machine**: Advance via `current_step` + `current_phase`, never use sync loops for async operations
-3. **Test Task Drives Execution**: 每个命令必须有 test_task（完整需求说明），作为命令的 $ARGUMENTS 输入。test_task 由当前 Claude 直接根据命令链复杂度生成，不需要额外 CLI 调用
-4. **All Execution via claude**: `ccw cli --tool claude --mode write --rule universal-rigorous-style`
-5. **All Analysis via gemini**: `ccw cli --tool gemini --mode analysis`, chained via `--resume`
-6. **Session Capture**: After each gemini callback, capture exec_id → `gemini_session_id` for resume chain
-7. **Sandbox Isolation**: 所有命令在独立沙箱目录（`sandbox/`）中执行，使用虚构测试任务，不影响真实项目
-8. **Artifact Collection**: Scan sandbox filesystem (not git diff), compare pre/post snapshots
-9. **Prompt Assembly**: Every step goes through `assembleStepPrompt()` — resolves command file, reads YAML metadata, injects test_task, builds rich context
-10. **Auto-Confirm**: All prompts auto-confirmed, no blocking interactions during execution

.claude/commands/workflow/brainstorm-with-file.md

@@ -2,7 +2,7 @@
 name: brainstorm-with-file
 description: Interactive brainstorming with multi-CLI collaboration, idea expansion, and documented thought evolution
 argument-hint: "[-y|--yes] [-c|--continue] [-m|--mode creative|structured] \"idea or topic\""
-allowed-tools: TodoWrite(*), Agent(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
 ---
 
 ## Auto Mode
@@ -29,31 +29,40 @@ When `--yes` or `-y`: Auto-confirm decisions, use recommended roles, balanced ex
 
 ## Output Artifacts
 
-| Phase | Artifact | Description |
-|-------|----------|-------------|
-| 1 | `brainstorm.md` | Complete thought evolution timeline (initialized) |
-| 1 | Session variables | Dimensions, roles, exploration vectors |
-| 2 | `exploration-codebase.json` | Codebase context from cli-explore-agent |
-| 2 | `perspectives.json` | Multi-CLI perspective findings (creative/pragmatic/systematic) |
-| 2 | Updated `brainstorm.md` | Round 2 multi-perspective exploration |
-| 3 | `ideas/{idea-slug}.md` | Deep-dive analysis for selected ideas |
-| 3 | Updated `brainstorm.md` | Round 3-6 refinement cycles |
-| 4 | `synthesis.json` | Final synthesis with top ideas, recommendations |
-| 4 | Final `brainstorm.md` | Complete thought evolution with conclusions |
+### Phase 1: Seed Understanding
 
-## Output Structure
+| Artifact | Description |
+|----------|-------------|
+| `brainstorm.md` | Complete thought evolution timeline (initialized) |
+| Session variables | Dimensions, roles, exploration vectors |
 
-```
-.workflow/.brainstorm/BS-{slug}-{date}/
-├── brainstorm.md                  # ⭐ Complete thought evolution timeline
-├── exploration-codebase.json      # Phase 2: Codebase context
-├── perspectives.json              # Phase 2: Multi-CLI findings
-├── synthesis.json                 # Phase 4: Final synthesis
-└── ideas/                         # Phase 3: Individual idea deep-dives
-    ├── idea-1.md
-    ├── idea-2.md
-    └── merged-idea-1.md
-```
+### Phase 2: Divergent Exploration
+
+| Artifact | Description |
+|----------|-------------|
+| `exploration-codebase.json` | Codebase context from cli-explore-agent |
+| `perspectives.json` | Multi-CLI perspective findings (creative/pragmatic/systematic) |
+| Updated `brainstorm.md` | Round 2 multi-perspective exploration |
+
+### Phase 3: Interactive Refinement
+
+| Artifact | Description |
+|----------|-------------|
+| `ideas/{idea-slug}.md` | Deep-dive analysis for selected ideas |
+| Updated `brainstorm.md` | Round 3-6 refinement cycles |
+
+### Phase 4: Convergence & Crystallization
+
+| Artifact | Description |
+|----------|-------------|
+| `synthesis.json` | Final synthesis with top ideas, recommendations |
+| Final `brainstorm.md` | ⭐ Complete thought evolution with conclusions |
+
+## Overview
+
+Interactive brainstorming workflow with **multi-CLI collaboration** and **documented thought evolution**. Expands initial ideas through questioning, multi-perspective analysis, and iterative refinement.
+
+**Core workflow**: Seed Idea → Expand → Multi-CLI Discuss → Synthesize → Refine → Crystallize
 
 ```
 ┌─────────────────────────────────────────────────────────────────────────┐
@@ -93,12 +102,31 @@ When `--yes` or `-y`: Auto-confirm decisions, use recommended roles, balanced ex
 └─────────────────────────────────────────────────────────────────────────┘
 ```
 
+## Output Structure
+
+```
+.workflow/.brainstorm/BS-{slug}-{date}/
+├── brainstorm.md                  # ⭐ Complete thought evolution timeline
+├── exploration-codebase.json      # Phase 2: Codebase context
+├── perspectives.json              # Phase 2: Multi-CLI findings
+├── synthesis.json                 # Phase 4: Final synthesis
+└── ideas/                         # Phase 3: Individual idea deep-dives
+    ├── idea-1.md
+    ├── idea-2.md
+    └── merged-idea-1.md
+```
+
 ## Implementation
 
 ### Session Initialization
 
+**Objective**: Create session context and directory structure for brainstorming.
+
+**Required Actions**:
 1. Extract idea/topic from `$ARGUMENTS`
-2. Generate session ID: `BS-{slug}-{date}` (slug: lowercase, alphanumeric + Chinese, max 40 chars; date: YYYY-MM-DD UTC+8)
+2. Generate session ID: `BS-{slug}-{date}`
+   - slug: lowercase, alphanumeric + Chinese, max 40 chars
+   - date: YYYY-MM-DD (UTC+8)
 3. Define session folder: `.workflow/.brainstorm/{session-id}`
 4. Parse command options:
    - `-c` or `--continue` for session continuation
@@ -107,41 +135,54 @@ When `--yes` or `-y`: Auto-confirm decisions, use recommended roles, balanced ex
 5. Auto-detect mode: If session folder + brainstorm.md exist → continue mode
 6. Create directory structure: `{session-folder}/ideas/`
 
-7. **Create Progress Tracking** (TodoWrite — MANDATORY):
-   ```
-   TodoWrite([
-     { id: "phase-1", title: "Phase 1: Seed Understanding", status: "in_progress" },
-     { id: "phase-2", title: "Phase 2: Divergent Exploration", status: "pending" },
-     { id: "phase-3", title: "Phase 3: Interactive Refinement", status: "pending" },
-     { id: "phase-4", title: "Phase 4: Convergence & Crystallization", status: "pending" },
-     { id: "next-step", title: "GATE: Post-Completion Next Step", status: "pending" }
-   ])
-   ```
-   - Update status to `"in_progress"` when entering each phase, `"completed"` when done
-   - **`next-step` is a terminal gate** — workflow is NOT complete until this todo is `"completed"`
-
-**Session Variables**: `sessionId`, `sessionFolder`, `brainstormMode` (creative|structured|balanced), `autoMode` (boolean), `mode` (new|continue)
+**Session Variables**:
+- `sessionId`: Unique session identifier
+- `sessionFolder`: Base directory for all artifacts
+- `brainstormMode`: creative | structured | balanced
+- `autoMode`: Boolean for auto-confirmation
+- `mode`: new | continue
 
 ### Phase 1: Seed Understanding
 
+**Objective**: Analyze topic, select roles, gather user input, expand into exploration vectors.
+
+**Prerequisites**:
+- Session initialized with valid sessionId and sessionFolder
+- Topic/idea available from $ARGUMENTS
+
+**Workflow Steps**:
+
 1. **Parse Seed & Identify Dimensions**
-   - Match topic keywords against Brainstorm Dimensions table
+   - Match topic keywords against BRAINSTORM_DIMENSIONS
+   - Identify relevant dimensions: technical, ux, business, innovation, feasibility, scalability, security
    - Default dimensions based on brainstormMode if no match
 
 2. **Role Selection**
-   - Recommend roles based on topic keywords (see Role Selection tables)
-   - **Professional roles**: system-architect, product-manager, ui-designer, ux-expert, data-architect, test-strategist, subject-matter-expert, product-owner, scrum-master
-   - **Simple perspectives** (fallback): creative/pragmatic/systematic
+   - **Recommend roles** based on topic keywords (see Role Keywords mapping)
+   - **Options**:
+     - **Professional roles**: system-architect, product-manager, ui-designer, ux-expert, data-architect, test-strategist, subject-matter-expert, product-owner, scrum-master
+     - **Simple perspectives**: creative/pragmatic/systematic (fallback)
    - **Auto mode**: Select top 3 recommended professional roles
    - **Manual mode**: AskUserQuestion with recommended roles + "Use simple perspectives" option
 
 3. **Initial Scoping Questions** (if new session + not auto mode)
-   - **Direction**: Multi-select from directions generated by detected dimensions
+   - **Direction**: Multi-select from directions generated by detected dimensions (see Brainstorm Dimensions)
    - **Depth**: Single-select from quick/balanced/deep (15-20min / 30-60min / 1-2hr)
    - **Constraints**: Multi-select from existing architecture, time, resources, or no constraints
 
 4. **Expand Seed into Exploration Vectors**
+   - Launch Gemini CLI with analysis mode
+   - Generate 5-7 exploration vectors:
+     - Core question: Fundamental problem/opportunity
+     - User perspective: Who benefits and how
+     - Technical angle: What enables this
+     - Alternative approaches: Other solutions
+     - Challenges: Potential blockers
+     - Innovation angle: 10x better approach
+     - Integration: Fit with existing systems
+   - Parse result into structured vectors
 
+**CLI Call Example**:
 ```javascript
 Bash({
   command: `ccw cli -p "
@@ -164,16 +205,47 @@ Output as structured exploration vectors for multi-perspective analysis.
 })
 ```
 
-5. **Initialize brainstorm.md** with session metadata, initial context (user focus, depth, constraints), seed expansion (original idea + exploration vectors), empty thought evolution timeline sections
+5. **Initialize brainstorm.md**
+   - Create brainstorm.md with session metadata
+   - Add initial context: user focus, depth, constraints
+   - Add seed expansion: original idea + exploration vectors
+   - Create empty sections for thought evolution timeline
 
-**TodoWrite**: Update `phase-1` → `"completed"`, `phase-2` → `"in_progress"`
+**Success Criteria**:
+- Session folder created with brainstorm.md initialized
+- 1-3 roles selected (professional or simple perspectives)
+- 5-7 exploration vectors generated
+- User preferences captured (direction, depth, constraints)
 
 ### Phase 2: Divergent Exploration
 
-1. **Primary Codebase Exploration via cli-explore-agent** (⚠️ FIRST)
+**Objective**: Gather codebase context, then execute multi-perspective analysis in parallel.
 
+**Prerequisites**:
+- Phase 1 completed successfully
+- Roles selected and stored
+- brainstorm.md initialized
+
+**Workflow Steps**:
+
+1. **Primary Codebase Exploration via cli-explore-agent** (⚠️ FIRST)
+   - Agent type: `cli-explore-agent`
+   - Execution mode: synchronous (run_in_background: false)
+   - **Tasks**:
+     - Run: `ccw tool exec get_modules_by_depth '{}'`
+     - Search code related to topic keywords
+     - Read: `.workflow/project-tech.json` if exists
+   - **Output**: `{sessionFolder}/exploration-codebase.json`
+     - relevant_files: [{path, relevance, rationale}]
+     - existing_patterns: []
+     - architecture_constraints: []
+     - integration_points: []
+     - inspiration_sources: []
+   - **Purpose**: Enrich CLI prompts with codebase context
+
+**Agent Call Example**:
 ```javascript
-Agent({
+Task({
   subagent_type: "cli-explore-agent",
   run_in_background: false,
   description: `Explore codebase for brainstorm: ${topicSlug}`,
@@ -209,67 +281,147 @@ Schema:
 }
 `
 })
-```
 
 2. **Multi-CLI Perspective Analysis** (⚠️ AFTER exploration)
+   - Launch 3 CLI calls in parallel (Gemini/Codex/Claude)
+   - **Perspectives**:
+     - **Creative (Gemini)**: Innovation, cross-domain inspiration, challenge assumptions
+     - **Pragmatic (Codex)**: Implementation reality, feasibility, technical blockers
+     - **Systematic (Claude)**: Architecture, decomposition, scalability
+   - **Shared context**: Include exploration-codebase.json findings in prompts
+   - **Execution**: Bash with run_in_background: true, wait for all results
+   - **Output**: perspectives.json with creative/pragmatic/systematic sections
 
-Build shared context from exploration results:
-
+**Multi-CLI Call Example** (parallel execution):
 ```javascript
+// Build shared context from exploration results
 const explorationContext = `
 PRIOR EXPLORATION CONTEXT (from cli-explore-agent):
 - Key files: ${explorationResults.relevant_files.slice(0,5).map(f => f.path).join(', ')}
 - Existing patterns: ${explorationResults.existing_patterns.slice(0,3).join(', ')}
 - Architecture constraints: ${explorationResults.architecture_constraints.slice(0,3).join(', ')}
 - Integration points: ${explorationResults.integration_points.slice(0,3).join(', ')}`
-```
 
-Launch 3 parallel CLI calls (`run_in_background: true` each), one per perspective:
-
-| Perspective | Tool | PURPOSE | Key TASK bullets | EXPECTED | CONSTRAINTS |
-|-------------|------|---------|-----------------|----------|-------------|
-| Creative | gemini | Generate innovative ideas | Challenge assumptions, cross-domain inspiration, moonshot + practical ideas | 5+ creative ideas with novelty/impact ratings | structured mode: keep feasible |
-| Pragmatic | codex | Implementation reality | Evaluate feasibility, estimate complexity, identify blockers, incremental approach | 3-5 practical approaches with effort/risk ratings | Current tech stack |
-| Systematic | claude | Architectural thinking | Decompose problems, identify patterns, map dependencies, scalability | Problem decomposition, 2-3 approaches with tradeoffs | Existing architecture |
-
-```javascript
-// Each perspective uses this prompt structure (launch all 3 in parallel):
+// Launch 3 CLI calls in parallel (single message, multiple Bash calls)
 Bash({
   command: `ccw cli -p "
-PURPOSE: ${perspective} brainstorming for '${idea_or_topic}' - ${purposeFocus}
-Success: ${expected}
+PURPOSE: Creative brainstorming for '${idea_or_topic}' - generate innovative ideas
+Success: 5+ unique creative solutions that push boundaries
 
 ${explorationContext}
 
 TASK:
-• Build on explored ${contextType} - how to ${actionVerb}?
-${perspectiveSpecificBullets}
+• Build on existing patterns - how can they be extended creatively?
+• Think beyond obvious solutions - what would be surprising/delightful?
+• Explore cross-domain inspiration
+• Challenge assumptions - what if the opposite were true?
+• Generate 'moonshot' ideas alongside practical ones
 
 MODE: analysis
 CONTEXT: @**/* | Topic: ${idea_or_topic}
-EXPECTED: ${expected}
-CONSTRAINTS: ${constraints}
-" --tool ${tool} --mode analysis`,
+EXPECTED: 5+ creative ideas with novelty/impact ratings, challenged assumptions, cross-domain inspirations
+CONSTRAINTS: ${brainstormMode === 'structured' ? 'Keep ideas technically feasible' : 'No constraints - think freely'}
+" --tool gemini --mode analysis`,
   run_in_background: true
 })
+
+Bash({
+  command: `ccw cli -p "
+PURPOSE: Pragmatic brainstorming for '${idea_or_topic}' - focus on implementation reality
+Success: Actionable approaches with clear implementation paths
+
+${explorationContext}
+
+TASK:
+• Build on explored codebase - how to integrate with existing patterns?
+• Evaluate technical feasibility of core concept
+• Identify existing patterns/libraries that could help
+• Estimate implementation complexity
+• Highlight potential technical blockers
+• Suggest incremental implementation approach
+
+MODE: analysis
+CONTEXT: @**/* | Topic: ${idea_or_topic}
+EXPECTED: 3-5 practical approaches with effort/risk ratings, dependencies, quick wins vs long-term
+CONSTRAINTS: Focus on what can actually be built with current tech stack
+" --tool codex --mode analysis`,
+  run_in_background: true
+})
+
+Bash({
+  command: `ccw cli -p "
+PURPOSE: Systematic brainstorming for '${idea_or_topic}' - architectural thinking
+Success: Well-structured solution framework with clear tradeoffs
+
+${explorationContext}
+
+TASK:
+• Build on explored architecture - how to extend systematically?
+• Decompose the problem into sub-problems
+• Identify architectural patterns that apply
+• Map dependencies and interactions
+• Consider scalability implications
+• Propose systematic solution structure
+
+MODE: analysis
+CONTEXT: @**/* | Topic: ${idea_or_topic}
+EXPECTED: Problem decomposition, 2-3 architectural approaches with tradeoffs, scalability assessment
+CONSTRAINTS: Consider existing system architecture
+" --tool claude --mode analysis`,
+  run_in_background: true
+})
+
 // ⚠️ STOP POINT: Wait for hook callback to receive all results before continuing
 ```
 
 3. **Aggregate Multi-Perspective Findings**
-   - Convergent themes (all agree), conflicting views (need resolution), unique contributions
+   - Consolidate creative/pragmatic/systematic results
+   - Extract synthesis:
+     - Convergent themes (all agree)
+     - Conflicting views (need resolution)
+     - Unique contributions (perspective-specific insights)
    - Write to perspectives.json
 
-4. **Update brainstorm.md** with Round 2 multi-perspective exploration and synthesis
+4. **Update brainstorm.md**
+   - Append Round 2 section with multi-perspective exploration
+   - Include creative/pragmatic/systematic findings
+   - Add perspective synthesis
+
+**CLI Prompt Template**:
+- **PURPOSE**: Role brainstorming for topic - focus description
+- **TASK**: Bullet list of specific actions
+- **MODE**: analysis
+- **CONTEXT**: @**/* | Topic + Exploration vectors + Codebase findings
+- **EXPECTED**: Output format requirements
+- **CONSTRAINTS**: Role-specific constraints
+
+**Success Criteria**:
+- exploration-codebase.json created with codebase context
+- perspectives.json created with 3 perspective analyses
+- brainstorm.md updated with Round 2 findings
+- All CLI calls completed successfully
 
 ### Phase 3: Interactive Refinement
 
-**Guideline**: Delegate complex tasks to agents (cli-explore-agent, code-developer, universal-executor) or CLI calls. Avoid direct analysis/execution in main process.
+**Objective**: Iteratively refine ideas through user-guided exploration cycles.
 
-1. **Present Current State**: Extract top ideas from perspectives.json with title, source, description, novelty/feasibility ratings
+**Prerequisites**:
+- Phase 2 completed successfully
+- perspectives.json contains initial ideas
+- brainstorm.md has Round 2 findings
+
+**Guideline**: For complex tasks (code analysis, implementation, POC creation), delegate to agents via Task tool (cli-explore-agent, code-developer, universal-executor) or CLI calls (ccw cli). Avoid direct analysis/execution in main process.
+
+**Workflow Steps**:
+
+1. **Present Current State**
+   - Extract top ideas from perspectives.json
+   - Display with: title, source, brief description, novelty/feasibility ratings
+   - List open questions
 
 2. **Gather User Direction** (AskUserQuestion)
-   - **Q1**: Which ideas to explore (multi-select from top ideas)
-   - **Q2**: Next step (single-select):
+   - **Question 1**: Which ideas to explore (multi-select from top ideas)
+   - **Question 2**: Next step (single-select):
      - **深入探索**: Deep dive on selected ideas
      - **继续发散**: Generate more ideas
      - **挑战验证**: Devil's advocate challenge
@@ -278,14 +430,44 @@ CONSTRAINTS: ${constraints}
 
 3. **Execute User-Selected Action**
 
-| Action | Tool | Output | Key Tasks |
-|--------|------|--------|-----------|
-| Deep Dive | Gemini CLI | ideas/{slug}.md | Elaborate concept, requirements, challenges, POC approach, metrics, dependencies |
-| Generate More | Selected CLI | Updated perspectives.json | New angles from unexplored vectors |
-| Challenge | Codex CLI | Challenge results | 3 objections per idea, challenge assumptions, failure scenarios, survivability (1-5) |
-| Merge | Gemini CLI | ideas/merged-{slug}.md | Complementary elements, resolve contradictions, unified concept |
+   **Deep Dive** (per selected idea):
+   - Launch Gemini CLI with analysis mode
+   - Tasks: Elaborate concept, implementation requirements, challenges, POC approach, metrics, dependencies
+   - Output: `{sessionFolder}/ideas/{idea-slug}.md`
 
-**Deep Dive CLI Call**:
+   **Generate More Ideas**:
+   - Launch CLI with new angles from unexplored vectors
+   - Add results to perspectives.json
+
+   **Devil's Advocate Challenge**:
+   - Launch Codex CLI with analysis mode
+   - Tasks: Identify objections, challenge assumptions, failure scenarios, alternatives, survivability rating
+   - Return challenge results for idea strengthening
+
+   **Merge Ideas**:
+   - Launch Gemini CLI with analysis mode
+   - Tasks: Identify complementary elements, resolve contradictions, create unified concept
+   - Add merged idea to perspectives.json
+
+4. **Update brainstorm.md**
+   - Append Round N section with findings
+   - Document user direction and action results
+
+5. **Repeat or Converge**
+   - Continue loop (max 6 rounds) or exit to Phase 4
+
+**Refinement Actions**:
+
+| Action | Tool | Output | Description |
+|--------|------|--------|-------------|
+| Deep Dive | Gemini CLI | ideas/{slug}.md | Comprehensive idea analysis |
+| Generate More | Selected CLI | Updated perspectives.json | Additional idea generation |
+| Challenge | Codex CLI | Challenge results | Critical weaknesses exposed |
+| Merge | Gemini CLI | Merged idea | Synthesized concept |
+
+**CLI Call Examples for Refinement Actions**:
+
+**1. Deep Dive on Selected Idea**:
 ```javascript
 Bash({
   command: `ccw cli -p "
@@ -301,18 +483,27 @@ TASK:
 • Map related/dependent features
 
 MODE: analysis
+
 CONTEXT: @**/*
 Original idea: ${idea.description}
 Source perspective: ${idea.source}
+User interest reason: ${idea.userReason || 'Selected for exploration'}
+
+EXPECTED:
+- Detailed concept description
+- Technical requirements list
+- Risk/challenge matrix
+- MVP definition
+- Success criteria
+- Recommendation: pursue/pivot/park
 
-EXPECTED: Detailed concept, technical requirements, risk matrix, MVP definition, success criteria, recommendation (pursue/pivot/park)
 CONSTRAINTS: Focus on actionability
 " --tool gemini --mode analysis`,
   run_in_background: false
 })
 ```
 
-**Devil's Advocate CLI Call**:
+**2. Devil's Advocate Challenge**:
 ```javascript
 Bash({
   command: `ccw cli -p "
@@ -327,17 +518,25 @@ TASK:
 • Challenge core assumptions
 • Identify scenarios where this fails
 • Consider competitive/alternative solutions
+• Assess whether this solves the right problem
 • Rate survivability after challenge (1-5)
 
 MODE: analysis
-EXPECTED: Per-idea challenge report, critical weaknesses, survivability ratings, modified/strengthened versions
+
+EXPECTED:
+- Per-idea challenge report
+- Critical weaknesses exposed
+- Counter-arguments to objections (if any)
+- Ideas that survive the challenge
+- Modified/strengthened versions
+
 CONSTRAINTS: Be genuinely critical, not just contrarian
 " --tool codex --mode analysis`,
   run_in_background: false
 })
 ```
 
-**Merge Ideas CLI Call**:
+**3. Merge Multiple Ideas**:
 ```javascript
 Bash({
   command: `ccw cli -p "
@@ -354,81 +553,93 @@ ${i+1}. ${idea.title} (${idea.source})
 TASK:
 • Identify complementary elements
 • Resolve contradictions
-• Create unified concept preserving key strengths
+• Create unified concept
+• Preserve key strengths from each
+• Describe the merged solution
 • Assess viability of merged idea
 
 MODE: analysis
-EXPECTED: Merged concept, elements from each source, contradictions resolved, implementation considerations
+
+EXPECTED:
+- Merged concept description
+- Elements taken from each source idea
+- Contradictions resolved (or noted as tradeoffs)
+- New combined strengths
+- Implementation considerations
+
 CONSTRAINTS: Don't force incompatible ideas together
 " --tool gemini --mode analysis`,
   run_in_background: false
 })
 ```
 
-4. **Update brainstorm.md** with Round N findings
-5. **Repeat or Converge**: Continue loop (max 6 rounds) or exit to Phase 4
-
-**TodoWrite**: Update `phase-2` → `"completed"` (after first round enters Phase 3), `phase-3` → `"in_progress"`
-**TodoWrite** (on exit loop): Update `phase-3` → `"completed"`, `phase-4` → `"in_progress"`
+**Success Criteria**:
+- User-selected ideas processed
+- brainstorm.md updated with all refinement rounds
+- ideas/ folder contains deep-dive documents for selected ideas
+- Exit condition reached (user selects "准备收敛" or max rounds)
 
 ### Phase 4: Convergence & Crystallization
 
-1. **Generate Final Synthesis** → Write to synthesis.json
-   - **Top ideas**: Filter active, sort by score, top 5 with title, description, source_perspective, score, novelty, feasibility, strengths, challenges, next_steps
-   - **Parked ideas**: With reason and future trigger
+**Objective**: Synthesize final ideas, generate conclusions, offer next steps.
+
+**Prerequisites**:
+- Phase 3 completed successfully
+- Multiple rounds of refinement documented
+- User ready to converge
+
+**Workflow Steps**:
+
+1. **Generate Final Synthesis**
+   - Consolidate all ideas from perspectives.json and refinement rounds
+   - **Top ideas**: Filter active ideas, sort by score, take top 5
+     - Include: title, description, source_perspective, score, novelty, feasibility, strengths, challenges, next_steps
+   - **Parked ideas**: Ideas marked as parked with reason and future trigger
    - **Key insights**: Process discoveries, challenged assumptions, unexpected connections
-   - **Recommendations**: Primary, alternatives, not recommended
+   - **Recommendations**: Primary recommendation, alternatives, not recommended
    - **Follow-up**: Implementation/research/validation summaries
+   - Write to synthesis.json
 
-**synthesis.json Schema**: `session_id`, `topic`, `completed` (timestamp), `total_rounds`, `top_ideas[]`, `parked_ideas[]`, `key_insights[]`, `recommendations` (primary/alternatives/not_recommended), `follow_up[]`
+2. **Final brainstorm.md Update**
+   - Append synthesis & conclusions section
+   - **Executive summary**: High-level overview
+   - **Top ideas**: Ranked with descriptions, strengths, challenges, next steps
+   - **Primary recommendation**: Best path forward with rationale
+   - **Alternative approaches**: Other viable options with tradeoffs
+   - **Parked ideas**: Future considerations
+   - **Key insights**: Learnings from the process
+   - **Session statistics**: Rounds, ideas generated/survived, duration
 
-2. **Final brainstorm.md Update**: Executive summary, top ideas ranked, primary recommendation with rationale, alternative approaches, parked ideas, key insights, session statistics (rounds, ideas generated/survived, duration)
+3. **Post-Completion Options** (AskUserQuestion)
+   - **创建实施计划**: Launch workflow-plan with top idea
+   - **创建Issue**: Launch issue-discover for top 3 ideas
+   - **深入分析**: Launch workflow:analyze-with-file for top idea
+   - **导出分享**: Generate shareable report
+   - **完成**: No further action
 
-3. **MANDATORY GATE: Next Step Selection** — workflow MUST NOT end without executing this step.
+**synthesis.json Schema**:
+- `session_id`: Session identifier
+- `topic`: Original idea/topic
+- `completed`: Completion timestamp
+- `total_rounds`: Number of refinement rounds
+- `top_ideas[]`: Top 5 ranked ideas
+- `parked_ideas[]`: Ideas parked for future
+- `key_insights[]`: Process learnings
+- `recommendations`: Primary/alternatives/not_recommended
+- `follow_up[]`: Next step summaries
 
-   **TodoWrite**: Update `phase-4` → `"completed"`, `next-step` → `"in_progress"`
-
-   > **CRITICAL**: This AskUserQuestion is a **terminal gate**. The workflow is INCOMPLETE if this question is not asked. After displaying synthesis (step 2), you MUST immediately proceed here.
-
-   Call AskUserQuestion (single-select, header: "Next Step"):
-   - **创建实施计划** (Recommended if top idea has high feasibility): "基于最佳创意启动 workflow-plan 制定实施计划"
-   - **创建Issue**: "将 Top 3 创意转化为 issue 进行跟踪管理"
-   - **深入分析**: "对最佳创意启动 analyze-with-file 深入技术分析"
-   - **完成**: "头脑风暴已足够，无需进一步操作"
-
-   **Handle user selection**:
-
-   **"创建实施计划"** → MUST invoke Skill tool:
-   1. Build `taskDescription` from top idea in synthesis.json (title + description + next_steps)
-   2. Assemble context: `## Prior Brainstorm ({sessionId})` + summary + top idea details + key insights (up to 5)
-   3. **Invoke Skill tool immediately**:
-      ```javascript
-      Skill({ skill: "workflow-plan", args: `${taskDescription}\n\n${contextLines}` })
-      ```
-      If Skill invocation is omitted, the workflow is BROKEN.
-   4. After Skill invocation, brainstorm-with-file is complete
-
-   **"创建Issue"** → Convert top ideas to issues:
-   1. For each idea in synthesis.top_ideas (top 3):
-      - Build issue JSON: `{title: idea.title, context: idea.description + '\n' + idea.next_steps.join('\n'), priority: idea.score >= 8 ? 2 : 3, source: 'brainstorm', labels: dimensions}`
-      - Create via: `Skill({ skill: "issue:from-brainstorm", args: "${sessionFolder}/synthesis.json" })`
-   2. Display created issue IDs
-
-   **"深入分析"** → Launch analysis on top idea:
-   1. Build analysis topic from top idea title + description
-   2. **Invoke Skill tool immediately**:
-      ```javascript
-      Skill({ skill: "workflow:analyze-with-file", args: `${topIdea.title}: ${topIdea.description}` })
-      ```
-
-   **"完成"** → No further action needed.
-
-   **TodoWrite**: Update `next-step` → `"completed"` after user selection is handled
+**Success Criteria**:
+- synthesis.json created with final synthesis
+- brainstorm.md finalized with conclusions
+- User offered next step options
+- Session complete
 
 ## Configuration
 
 ### Brainstorm Dimensions
 
+Dimensions matched against topic keywords to identify focus areas:
+
 | Dimension | Keywords |
 |-----------|----------|
 | technical | 技术, technical, implementation, code, 实现, architecture |
@@ -441,7 +652,7 @@ CONSTRAINTS: Don't force incompatible ideas together
 
 ### Role Selection
 
-**Professional Roles**:
+**Professional Roles** (recommended based on topic keywords):
 
 | Role | CLI Tool | Focus Area | Keywords |
 |------|----------|------------|----------|
@@ -457,13 +668,47 @@ CONSTRAINTS: Don't force incompatible ideas together
 
 **Simple Perspectives** (fallback):
 
-| Perspective | CLI Tool | Focus |
-|-------------|----------|-------|
-| creative | Gemini | Innovation, cross-domain |
-| pragmatic | Codex | Implementation, feasibility |
-| systematic | Claude | Architecture, structure |
+| Perspective | CLI Tool | Focus | Best For |
+|-------------|----------|-------|----------|
+| creative | Gemini | Innovation, cross-domain | Generating novel ideas |
+| pragmatic | Codex | Implementation, feasibility | Reality-checking ideas |
+| systematic | Claude | Architecture, structure | Organizing solutions |
 
-**Selection Strategy**: Auto mode → top 3 professional roles | Manual mode → recommended roles + "Use simple perspectives" option | Continue mode → roles from previous session
+**Selection Strategy**:
+1. **Auto mode** (`-y`): Choose top 3 recommended professional roles
+2. **Manual mode**: Present recommended roles + "Use simple perspectives" option
+3. **Continue mode**: Use roles from previous session
+
+### Collaboration Patterns
+
+| Pattern | Usage | Description |
+|---------|-------|-------------|
+| Parallel Divergence | New topic | All roles explore simultaneously from different angles |
+| Sequential Deep-Dive | Promising idea | One role expands, others critique/refine |
+| Debate Mode | Controversial approach | Roles argue for/against approaches |
+| Synthesis Mode | Ready to decide | Combine insights into actionable conclusion |
+
+### Context Overflow Protection
+
+**Per-Role Limits**:
+- Main analysis output: < 3000 words
+- Sub-document (if any): < 2000 words each
+- Maximum sub-documents: 5 per role
+
+**Synthesis Protection**:
+- If total analysis > 100KB, synthesis reads only main analysis files (not sub-documents)
+- Large ideas automatically split into separate idea documents in ideas/ folder
+
+**Recovery Steps**:
+1. Check CLI logs for context overflow errors
+2. Reduce scope: fewer roles or simpler topic
+3. Use `--mode structured` for more focused output
+4. Split complex topics into multiple sessions
+
+**Prevention**:
+- Start with 3 roles (default), increase if needed
+- Use structured topic format: "GOAL: ... SCOPE: ... CONTEXT: ..."
+- Review output sizes before final synthesis
 
 ## Error Handling
 
@@ -477,6 +722,58 @@ CONSTRAINTS: Don't force incompatible ideas together
 | Max rounds reached | Force synthesis, highlight unresolved questions |
 | All ideas fail challenge | Return to divergent phase with new constraints |
 
+## Best Practices
+
+1. **Clear Topic Definition**: Detailed topics → better role selection and exploration
+2. **Agent-First for Complex Tasks**: For code analysis, POC implementation, or technical validation during refinement, delegate to agents via Task tool (cli-explore-agent, code-developer, universal-executor) or CLI calls (ccw cli). Avoid direct analysis/execution in main process
+3. **Review brainstorm.md**: Check thought evolution before final decisions
+4. **Embrace Conflicts**: Perspective conflicts often reveal important tradeoffs
+5. **Document Evolution**: brainstorm.md captures full thinking process for team review
+6. **Use Continue Mode**: Resume sessions to build on previous exploration
+
+## Templates
+
+### Brainstorm Document Structure
+
+**brainstorm.md** contains:
+- **Header**: Session metadata (ID, topic, started, mode, dimensions)
+- **Initial Context**: User focus, depth, constraints
+- **Seed Expansion**: Original idea + exploration vectors
+- **Thought Evolution Timeline**: Round-by-round findings
+  - Round 1: Seed Understanding
+  - Round 2: Multi-Perspective Exploration (creative/pragmatic/systematic)
+  - Round 3-N: Interactive Refinement (deep-dive/challenge/merge)
+- **Synthesis & Conclusions**: Executive summary, top ideas, recommendations
+- **Session Statistics**: Rounds, ideas, duration, artifacts
+
+See full markdown template in original file (lines 955-1161).
+
+## Usage Recommendations (Requires User Confirmation)
+
+**Use `Skill(skill="brainstorm", args="\"topic or question\"")` when:**
+- Starting a new feature/product without clear direction
+- Facing a complex problem with multiple possible solutions
+- Need to explore alternatives before committing
+- Want documented thinking process for team review
+- Combining multiple stakeholder perspectives
+
+**Use `Skill(skill="workflow:analyze-with-file", args="\"topic\"")` when:**
+- Investigating existing code/system
+- Need factual analysis over ideation
+- Debugging or troubleshooting
+- Understanding current state
+
+**Use `Skill(skill="workflow-plan", args="\"task description\"")` when:**
+- Complex planning requiring multiple perspectives
+- Large scope needing parallel sub-domain analysis
+- Want shared collaborative planning document
+- Need structured task breakdown with agent coordination
+
+**Use `Skill(skill="workflow-lite-plan", args="\"task description\"")` when:**
+- Direction is already clear
+- Ready to move from ideas to execution
+- Need simple implementation breakdown
+
 ---
 
 **Now execute brainstorm-with-file for**: $ARGUMENTS

.claude/commands/workflow/clean.md

@@ -2,7 +2,7 @@
 name: clean
 description: Intelligent code cleanup with mainline detection, stale artifact discovery, and safe execution
 argument-hint: "[-y|--yes] [--dry-run] [\"focus area\"]"
-allowed-tools: TodoWrite(*), Agent(*), AskUserQuestion(*), Read(*), Glob(*), Bash(*), Write(*)
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Glob(*), Bash(*), Write(*)
 ---
 
 # Clean Command (/workflow:clean)
@@ -475,43 +475,21 @@ if (selectedCategories.includes('Sessions')) {
   }
 }
 
-// Update project-tech.json: remove development_index entries referencing deleted sessions
+// Update project-tech.json if features referenced deleted sessions
 const projectPath = '.workflow/project-tech.json'
 if (fileExists(projectPath)) {
   const project = JSON.parse(Read(projectPath))
-  const deletedSessionIds = results.deleted
-    .filter(p => p.match(/WFS-|lite-plan/))
-    .map(p => p.split('/').pop())
+  const deletedPaths = new Set(results.deleted)
 
-  if (project.development_index) {
-    for (const category of Object.keys(project.development_index)) {
-      project.development_index[category] = project.development_index[category].filter(entry =>
-        !deletedSessionIds.includes(entry.session_id)
-      )
-    }
-  }
+  project.features = project.features.filter(f =>
+    !deletedPaths.has(f.traceability?.archive_path)
+  )
+
+  project.statistics.total_features = project.features.length
+  project.statistics.last_updated = getUtc8ISOString()
 
-  project._metadata.last_updated = getUtc8ISOString()
   Write(projectPath, JSON.stringify(project, null, 2))
 }
-
-// Update specs/*.md: remove learnings referencing deleted sessions
-const guidelinesPath = '.ccw/specs/*.md'
-if (fileExists(guidelinesPath)) {
-  const guidelines = JSON.parse(Read(guidelinesPath))
-  const deletedSessionIds = results.deleted
-    .filter(p => p.match(/WFS-|lite-plan/))
-    .map(p => p.split('/').pop())
-
-  if (guidelines.learnings) {
-    guidelines.learnings = guidelines.learnings.filter(l =>
-      !deletedSessionIds.includes(l.session_id)
-    )
-  }
-
-  guidelines._metadata.updated_at = getUtc8ISOString()
-  Write(guidelinesPath, JSON.stringify(guidelines, null, 2))
-}
 ```
 
 **Step 4.4: Report Results**
@@ -563,10 +541,8 @@ Cleanup manifest archived to: ${sessionFolder}/cleanup-manifest.json
 | Manifest parse error | Regenerate from filesystem scan |
 | Empty discovery | Report "codebase is clean" |
 
-
 ## Related Commands
 
-- `/workflow:session:sync` - Sync session work to specs/*.md + project-tech (正向写入)
 - `/workflow:session:complete` - Properly archive active sessions
 - `memory-capture` skill - Save session memory before cleanup
 - `workflow-execute` skill - View current workflow state

.claude/commands/workflow/collaborative-plan-with-file.md

@@ -2,7 +2,7 @@
 name: workflow:collaborative-plan-with-file
 description: Collaborative planning with Plan Note - Understanding agent creates shared plan-note.md template, parallel agents fill pre-allocated sections, conflict detection without merge. Outputs executable plan-note.md.
 argument-hint: "[-y|--yes] <task description> [--max-agents=5]"
-allowed-tools: TodoWrite(*), Agent(*), AskUserQuestion(*), Read(*), Bash(*), Write(*), Glob(*), Grep(*), mcp__ace-tool__search_context(*)
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), Write(*), Glob(*), Grep(*), mcp__ace-tool__search_context(*)
 ---
 
 ## Auto Mode
@@ -205,11 +205,6 @@ Task(
 1. **Prioritize Latest Documentation**: Search for and reference latest README, design docs, architecture guides when available
 2. **Handle Ambiguities**: When requirement ambiguities exist, ask user for clarification (use AskUserQuestion) instead of assuming interpretations
 
-### Project Context (MANDATORY)
-Read and incorporate:
-- \`.workflow/project-tech.json\` (if exists): Technology stack, architecture
-- \`.ccw/specs/*.md\` (if exists): Constraints, conventions -- apply as HARD CONSTRAINTS on sub-domain splitting and plan structure
-
 ### Input Requirements
 ${taskDescription}
 
@@ -354,19 +349,21 @@ subDomains.map(sub =>
 **TASK ID Range**: ${sub.task_id_range[0]}-${sub.task_id_range[1]}
 **Session**: ${sessionId}
 
-### Project Context (MANDATORY)
-Read and incorporate:
-- \`.workflow/project-tech.json\` (if exists): Technology stack, architecture
-- \`.ccw/specs/*.md\` (if exists): Constraints, conventions -- apply as HARD CONSTRAINTS
-
 ## Dual Output Tasks
 
 ### Task 1: Generate Two-Layer Plan Output
-Output: ${sessionFolder}/agents/${sub.focus_area}/plan.json
-Output: ${sessionFolder}/agents/${sub.focus_area}/.task/TASK-*.json
+Output: ${sessionFolder}/agents/${sub.focus_area}/plan.json (overview with task_ids[])
+Output: ${sessionFolder}/agents/${sub.focus_area}/.task/TASK-*.json (independent task files)
 Schema (plan): ~/.ccw/workflows/cli-templates/schemas/plan-overview-base-schema.json
 Schema (tasks): ~/.ccw/workflows/cli-templates/schemas/task-schema.json
 
+**Two-Layer Output Format**:
+- plan.json: Overview with task_ids[] referencing .task/ files (NO tasks[] array)
+- .task/TASK-*.json: Independent task files following task-schema.json
+- plan.json required: summary, approach, task_ids, task_count, _metadata (with plan_type)
+- Task files required: id, title, description, depends_on, convergence (with criteria[])
+- Task fields: files[].change (not modification_points), convergence.criteria (not acceptance), test (not verification)
+
 ### Task 2: Sync Summary to plan-note.md
 
 **Locate Your Sections**:
@@ -587,11 +584,7 @@ Schema (tasks): ~/.ccw/workflows/cli-templates/schemas/task-schema.json
    - Execution command
    - Conflict status
 
-6. **Sync Session State**
-   - Execute: `/workflow:session:sync -y "Plan complete: ${subDomains.length} domains, ${allTasks.length} tasks"`
-   - Updates specs/*.md with planning insights and project-tech.json with planning session entry
-
-7. **Update Todo**
+6. **Update Todo**
    - Set Phase 4 status to `completed`
 
 **plan.md Structure**:

.claude/commands/workflow/debug-with-file.md

@@ -2,7 +2,7 @@
 name: debug-with-file
 description: Interactive hypothesis-driven debugging with documented exploration, understanding evolution, and Gemini-assisted correction
 argument-hint: "[-y|--yes] \"bug description or error message\""
-allowed-tools: TodoWrite(*), Agent(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
 ---
 
 ## Auto Mode
@@ -630,16 +630,6 @@ Why is config value None during update?
 
 ## Post-Completion Expansion
 
-**Auto-sync**: 执行 `/workflow:session:sync -y "{summary}"` 更新 specs/*.md + project-tech。
-
-```javascript
-// Auto mode: skip expansion question, complete session directly
-if (autoYes) {
-  console.log('Debug session complete. Auto mode: skipping expansion.');
-  return;
-}
-```
-
 完成后询问用户是否扩展为issue(test/enhance/refactor/doc)，选中项调用 `/issue:new "{summary} - {dimension}"`
 
 ---

.claude/commands/workflow/init-guidelines.md

@@ -0,0 +1,408 @@
+---
+name: init-guidelines
+description: Interactive wizard to fill project-guidelines.json based on project analysis
+argument-hint: "[--reset]"
+examples:
+  - /workflow:init-guidelines
+  - /workflow:init-guidelines --reset
+---
+
+# Workflow Init Guidelines Command (/workflow:init-guidelines)
+
+## Overview
+
+Interactive multi-round wizard that analyzes the current project (via `project-tech.json`) and asks targeted questions to populate `.workflow/project-guidelines.json` with coding conventions, constraints, and quality rules.
+
+**Design Principle**: Questions are dynamically generated based on the project's tech stack, architecture, and patterns — not generic boilerplate.
+
+**Note**: This command may be called by `/workflow:init` after initialization. Upon completion, return to the calling workflow if applicable.
+
+## Usage
+```bash
+/workflow:init-guidelines          # Fill guidelines interactively (skip if already populated)
+/workflow:init-guidelines --reset  # Reset and re-fill guidelines from scratch
+```
+
+## Execution Process
+
+```
+Input Parsing:
+   └─ Parse --reset flag → reset = true | false
+
+Step 1: Check Prerequisites
+   ├─ project-tech.json must exist (run /workflow:init first)
+   ├─ project-guidelines.json: check if populated or scaffold-only
+   └─ If populated + no --reset → Ask: "Guidelines already exist. Overwrite or append?"
+
+Step 2: Load Project Context
+   └─ Read project-tech.json → extract tech stack, architecture, patterns
+
+Step 3: Multi-Round Interactive Questionnaire
+   ├─ Round 1: Coding Conventions (coding_style, naming_patterns)
+   ├─ Round 2: File & Documentation Conventions (file_structure, documentation)
+   ├─ Round 3: Architecture & Tech Constraints (architecture, tech_stack)
+   ├─ Round 4: Performance & Security Constraints (performance, security)
+   └─ Round 5: Quality Rules (quality_rules)
+
+Step 4: Write project-guidelines.json
+
+Step 5: Display Summary
+```
+
+## Implementation
+
+### Step 1: Check Prerequisites
+
+```bash
+bash(test -f .workflow/project-tech.json && echo "TECH_EXISTS" || echo "TECH_NOT_FOUND")
+bash(test -f .workflow/project-guidelines.json && echo "GUIDELINES_EXISTS" || echo "GUIDELINES_NOT_FOUND")
+```
+
+**If TECH_NOT_FOUND**: Exit with message
+```
+Project tech analysis not found. Run /workflow:init first.
+```
+
+**Parse --reset flag**:
+```javascript
+const reset = $ARGUMENTS.includes('--reset')
+```
+
+**If GUIDELINES_EXISTS and not --reset**: Check if guidelines are populated (not just scaffold)
+
+```javascript
+const guidelines = JSON.parse(Read('.workflow/project-guidelines.json'))
+const isPopulated =
+  guidelines.conventions.coding_style.length > 0 ||
+  guidelines.conventions.naming_patterns.length > 0 ||
+  guidelines.constraints.architecture.length > 0 ||
+  guidelines.constraints.tech_stack.length > 0
+
+if (isPopulated) {
+  AskUserQuestion({
+    questions: [{
+      question: "Project guidelines already contain entries. How would you like to proceed?",
+      header: "Mode",
+      multiSelect: false,
+      options: [
+        { label: "Append", description: "Keep existing entries and add new ones from the wizard" },
+        { label: "Reset", description: "Clear all existing entries and start fresh" },
+        { label: "Cancel", description: "Exit without changes" }
+      ]
+    }]
+  })
+  // If Cancel → exit
+  // If Reset → clear all arrays before proceeding
+  // If Append → keep existing, wizard adds to them
+}
+```
+
+### Step 2: Load Project Context
+
+```javascript
+const projectTech = JSON.parse(Read('.workflow/project-tech.json'))
+
+// Extract key info for generating smart questions
+const languages = projectTech.technology_analysis?.technology_stack?.languages
+  || projectTech.overview?.technology_stack?.languages || []
+const primaryLang = languages.find(l => l.primary)?.name || languages[0]?.name || 'Unknown'
+const frameworks = projectTech.technology_analysis?.technology_stack?.frameworks
+  || projectTech.overview?.technology_stack?.frameworks || []
+const testFrameworks = projectTech.technology_analysis?.technology_stack?.test_frameworks
+  || projectTech.overview?.technology_stack?.test_frameworks || []
+const archStyle = projectTech.technology_analysis?.architecture?.style
+  || projectTech.overview?.architecture?.style || 'Unknown'
+const archPatterns = projectTech.technology_analysis?.architecture?.patterns
+  || projectTech.overview?.architecture?.patterns || []
+const buildTools = projectTech.technology_analysis?.technology_stack?.build_tools
+  || projectTech.overview?.technology_stack?.build_tools || []
+```
+
+### Step 3: Multi-Round Interactive Questionnaire
+
+Each round uses `AskUserQuestion` with project-aware options. The user can always select "Other" to provide custom input.
+
+**⚠️ CRITICAL**: After each round, collect the user's answers and convert them into guideline entries. Do NOT batch all rounds — process each round's answers before proceeding to the next.
+
+---
+
+#### Round 1: Coding Conventions
+
+Generate options dynamically based on detected language/framework:
+
+```javascript
+// Build language-specific coding style options
+const codingStyleOptions = []
+
+if (['TypeScript', 'JavaScript'].includes(primaryLang)) {
+  codingStyleOptions.push(
+    { label: "Strict TypeScript", description: "Use strict mode, no 'any' type, explicit return types for public APIs" },
+    { label: "Functional style", description: "Prefer pure functions, immutability, avoid class-based patterns where possible" },
+    { label: "Const over let", description: "Always use const; only use let when reassignment is truly needed" }
+  )
+} else if (primaryLang === 'Python') {
+  codingStyleOptions.push(
+    { label: "Type hints", description: "Use type hints for all function signatures and class attributes" },
+    { label: "Functional style", description: "Prefer pure functions, list comprehensions, avoid mutable state" },
+    { label: "PEP 8 strict", description: "Strict PEP 8 compliance with max line length 88 (Black formatter)" }
+  )
+} else if (primaryLang === 'Go') {
+  codingStyleOptions.push(
+    { label: "Error wrapping", description: "Always wrap errors with context using fmt.Errorf with %w" },
+    { label: "Interface first", description: "Define interfaces at the consumer side, not the provider" },
+    { label: "Table-driven tests", description: "Use table-driven test pattern for all unit tests" }
+  )
+}
+// Add universal options
+codingStyleOptions.push(
+  { label: "Early returns", description: "Prefer early returns / guard clauses over deep nesting" }
+)
+
+AskUserQuestion({
+  questions: [
+    {
+      question: `Your project uses ${primaryLang}. Which coding style conventions do you follow?`,
+      header: "Coding Style",
+      multiSelect: true,
+      options: codingStyleOptions.slice(0, 4) // Max 4 options
+    },
+    {
+      question: `What naming conventions does your ${primaryLang} project use?`,
+      header: "Naming",
+      multiSelect: true,
+      options: [
+        { label: "camelCase variables", description: "Variables and functions use camelCase (e.g., getUserName)" },
+        { label: "PascalCase types", description: "Classes, interfaces, type aliases use PascalCase (e.g., UserService)" },
+        { label: "UPPER_SNAKE constants", description: "Constants use UPPER_SNAKE_CASE (e.g., MAX_RETRIES)" },
+        { label: "Prefix interfaces", description: "Prefix interfaces with 'I' (e.g., IUserService)" }
+      ]
+    }
+  ]
+})
+```
+
+**Process Round 1 answers** → add to `conventions.coding_style` and `conventions.naming_patterns` arrays.
+
+---
+
+#### Round 2: File Structure & Documentation
+
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: `Your project has a ${archStyle} architecture. What file organization rules apply?`,
+      header: "File Structure",
+      multiSelect: true,
+      options: [
+        { label: "Co-located tests", description: "Test files live next to source files (e.g., foo.ts + foo.test.ts)" },
+        { label: "Separate test dir", description: "Tests in a dedicated __tests__ or tests/ directory" },
+        { label: "One export per file", description: "Each file exports a single main component/class/function" },
+        { label: "Index barrels", description: "Use index.ts barrel files for clean imports from directories" }
+      ]
+    },
+    {
+      question: "What documentation standards does your project follow?",
+      header: "Documentation",
+      multiSelect: true,
+      options: [
+        { label: "JSDoc/docstring public APIs", description: "All public functions and classes must have JSDoc/docstrings" },
+        { label: "README per module", description: "Each major module/package has its own README" },
+        { label: "Inline comments for why", description: "Comments explain 'why', not 'what' — code should be self-documenting" },
+        { label: "No comment requirement", description: "Code should be self-explanatory; comments only for non-obvious logic" }
+      ]
+    }
+  ]
+})
+```
+
+**Process Round 2 answers** → add to `conventions.file_structure` and `conventions.documentation`.
+
+---
+
+#### Round 3: Architecture & Tech Stack Constraints
+
+```javascript
+// Build architecture-specific options
+const archOptions = []
+
+if (archStyle.toLowerCase().includes('monolith')) {
+  archOptions.push(
+    { label: "No circular deps", description: "Modules must not have circular dependencies" },
+    { label: "Layer boundaries", description: "Strict layer separation: UI → Service → Data (no skipping layers)" }
+  )
+} else if (archStyle.toLowerCase().includes('microservice')) {
+  archOptions.push(
+    { label: "Service isolation", description: "Services must not share databases or internal state" },
+    { label: "API contracts", description: "All inter-service communication through versioned API contracts" }
+  )
+}
+archOptions.push(
+  { label: "Stateless services", description: "Service/business logic must be stateless (state in DB/cache only)" },
+  { label: "Dependency injection", description: "Use dependency injection for testability, no hardcoded dependencies" }
+)
+
+AskUserQuestion({
+  questions: [
+    {
+      question: `Your ${archStyle} architecture uses ${archPatterns.join(', ') || 'various'} patterns. What architecture constraints apply?`,
+      header: "Architecture",
+      multiSelect: true,
+      options: archOptions.slice(0, 4)
+    },
+    {
+      question: `Tech stack: ${frameworks.join(', ')}. What technology constraints apply?`,
+      header: "Tech Stack",
+      multiSelect: true,
+      options: [
+        { label: "No new deps without review", description: "Adding new dependencies requires explicit justification and review" },
+        { label: "Pin dependency versions", description: "All dependencies must use exact versions, not ranges" },
+        { label: "Prefer native APIs", description: "Use built-in/native APIs over third-party libraries when possible" },
+        { label: "Framework conventions", description: `Follow official ${frameworks[0] || 'framework'} conventions and best practices` }
+      ]
+    }
+  ]
+})
+```
+
+**Process Round 3 answers** → add to `constraints.architecture` and `constraints.tech_stack`.
+
+---
+
+#### Round 4: Performance & Security Constraints
+
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: "What performance requirements does your project have?",
+      header: "Performance",
+      multiSelect: true,
+      options: [
+        { label: "API response time", description: "API endpoints must respond within 200ms (p95)" },
+        { label: "Bundle size limit", description: "Frontend bundle size must stay under 500KB gzipped" },
+        { label: "Lazy loading", description: "Large modules/routes must use lazy loading / code splitting" },
+        { label: "No N+1 queries", description: "Database access must avoid N+1 query patterns" }
+      ]
+    },
+    {
+      question: "What security requirements does your project enforce?",
+      header: "Security",
+      multiSelect: true,
+      options: [
+        { label: "Input sanitization", description: "All user input must be validated and sanitized before use" },
+        { label: "No secrets in code", description: "No API keys, passwords, or tokens in source code — use env vars" },
+        { label: "Auth on all endpoints", description: "All API endpoints require authentication unless explicitly public" },
+        { label: "Parameterized queries", description: "All database queries must use parameterized/prepared statements" }
+      ]
+    }
+  ]
+})
+```
+
+**Process Round 4 answers** → add to `constraints.performance` and `constraints.security`.
+
+---
+
+#### Round 5: Quality Rules
+
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: `Testing with ${testFrameworks.join(', ') || 'your test framework'}. What quality rules apply?`,
+      header: "Quality",
+      multiSelect: true,
+      options: [
+        { label: "Min test coverage", description: "Minimum 80% code coverage for new code; no merging below threshold" },
+        { label: "No skipped tests", description: "Tests must not be skipped (.skip/.only) in committed code" },
+        { label: "Lint must pass", description: "All code must pass linter checks before commit (enforced by pre-commit)" },
+        { label: "Type check must pass", description: "Full type checking (tsc --noEmit) must pass with zero errors" }
+      ]
+    }
+  ]
+})
+```
+
+**Process Round 5 answers** → add to `quality_rules` array as `{ rule, scope, enforced_by }` objects.
+
+### Step 4: Write project-guidelines.json
+
+```javascript
+// Build the final guidelines object
+const finalGuidelines = {
+  conventions: {
+    coding_style: existingCodingStyle.concat(newCodingStyle),
+    naming_patterns: existingNamingPatterns.concat(newNamingPatterns),
+    file_structure: existingFileStructure.concat(newFileStructure),
+    documentation: existingDocumentation.concat(newDocumentation)
+  },
+  constraints: {
+    architecture: existingArchitecture.concat(newArchitecture),
+    tech_stack: existingTechStack.concat(newTechStack),
+    performance: existingPerformance.concat(newPerformance),
+    security: existingSecurity.concat(newSecurity)
+  },
+  quality_rules: existingQualityRules.concat(newQualityRules),
+  learnings: existingLearnings, // Preserve existing learnings
+  _metadata: {
+    created_at: existingMetadata?.created_at || new Date().toISOString(),
+    version: "1.0.0",
+    last_updated: new Date().toISOString(),
+    updated_by: "workflow:init-guidelines"
+  }
+}
+
+Write('.workflow/project-guidelines.json', JSON.stringify(finalGuidelines, null, 2))
+```
+
+### Step 5: Display Summary
+
+```javascript
+const countConventions = finalGuidelines.conventions.coding_style.length
+  + finalGuidelines.conventions.naming_patterns.length
+  + finalGuidelines.conventions.file_structure.length
+  + finalGuidelines.conventions.documentation.length
+
+const countConstraints = finalGuidelines.constraints.architecture.length
+  + finalGuidelines.constraints.tech_stack.length
+  + finalGuidelines.constraints.performance.length
+  + finalGuidelines.constraints.security.length
+
+const countQuality = finalGuidelines.quality_rules.length
+
+console.log(`
+✓ Project guidelines configured
+
+## Summary
+- Conventions: ${countConventions} rules (coding: ${cs}, naming: ${np}, files: ${fs}, docs: ${doc})
+- Constraints: ${countConstraints} rules (arch: ${ar}, tech: ${ts}, perf: ${pf}, security: ${sc})
+- Quality rules: ${countQuality}
+
+File: .workflow/project-guidelines.json
+
+Next steps:
+- Use /workflow:session:solidify to add individual rules later
+- Guidelines will be auto-loaded by /workflow:plan for task generation
+`)
+```
+
+## Answer Processing Rules
+
+When converting user selections to guideline entries:
+
+1. **Selected option** → Use the option's `description` as the guideline string (it's more precise than the label)
+2. **"Other" with custom text** → Use the user's text directly as the guideline string
+3. **Deduplication** → Skip entries that already exist in the guidelines (exact string match)
+4. **Quality rules** → Convert to `{ rule: description, scope: "all", enforced_by: "code-review" }` format
+
+## Error Handling
+
+- **No project-tech.json**: Exit with instruction to run `/workflow:init` first
+- **User cancels mid-wizard**: Save whatever was collected so far (partial is better than nothing)
+- **File write failure**: Report error, suggest manual edit
+
+## Related Commands
+
+- `/workflow:init` - Creates scaffold; optionally calls this command
+- `/workflow:session:solidify` - Add individual rules one at a time

.claude/commands/workflow/init.md

@@ -0,0 +1,288 @@
+---
+name: init
+description: Initialize project-level state with intelligent project analysis using cli-explore-agent
+argument-hint: "[--regenerate]"
+examples:
+  - /workflow:init
+  - /workflow:init --regenerate
+---
+
+# Workflow Init Command (/workflow:init)
+
+## Overview
+Initialize `.workflow/project-tech.json` and `.workflow/project-guidelines.json` with comprehensive project understanding by delegating analysis to **cli-explore-agent**.
+
+**Dual File System**:
+- `project-tech.json`: Auto-generated technical analysis (stack, architecture, components)
+- `project-guidelines.json`: User-maintained rules and constraints (created as scaffold)
+
+**Note**: This command may be called by other workflow commands. Upon completion, return immediately to continue the calling workflow without interrupting the task flow.
+
+## Usage
+```bash
+/workflow:init                 # Initialize (skip if exists)
+/workflow:init --regenerate    # Force regeneration
+```
+
+## Execution Process
+
+```
+Input Parsing:
+   └─ Parse --regenerate flag → regenerate = true | false
+
+Decision:
+   ├─ BOTH_EXIST + no --regenerate → Exit: "Already initialized"
+   ├─ EXISTS + --regenerate → Backup existing → Continue analysis
+   └─ NOT_FOUND → Continue analysis
+
+Analysis Flow:
+   ├─ Get project metadata (name, root)
+   ├─ Invoke cli-explore-agent
+   │   ├─ Structural scan (get_modules_by_depth.sh, find, wc)
+   │   ├─ Semantic analysis (Gemini CLI)
+   │   ├─ Synthesis and merge
+   │   └─ Write .workflow/project-tech.json
+   ├─ Create guidelines scaffold (if not exists)
+   │   └─ Write .workflow/project-guidelines.json (empty structure)
+   ├─ Display summary
+   └─ Ask about guidelines configuration
+       ├─ If guidelines empty → Ask user: "Configure now?" or "Skip"
+       │   ├─ Configure now → Skill(skill="workflow:init-guidelines")
+       │   └─ Skip → Show next steps
+       └─ If guidelines populated → Show next steps only
+
+Output:
+   ├─ .workflow/project-tech.json (+ .backup if regenerate)
+   └─ .workflow/project-guidelines.json (scaffold or configured)
+```
+
+## Implementation
+
+### Step 1: Parse Input and Check Existing State
+
+**Parse --regenerate flag**:
+```javascript
+const regenerate = $ARGUMENTS.includes('--regenerate')
+```
+
+**Check existing state**:
+
+```bash
+bash(test -f .workflow/project-tech.json && echo "TECH_EXISTS" || echo "TECH_NOT_FOUND")
+bash(test -f .workflow/project-guidelines.json && echo "GUIDELINES_EXISTS" || echo "GUIDELINES_NOT_FOUND")
+```
+
+**If BOTH_EXIST and no --regenerate**: Exit early
+```
+Project already initialized:
+- Tech analysis: .workflow/project-tech.json
+- Guidelines: .workflow/project-guidelines.json
+
+Use /workflow:init --regenerate to rebuild tech analysis
+Use /workflow:session:solidify to add guidelines
+Use /workflow:status --project to view state
+```
+
+### Step 2: Get Project Metadata
+
+```bash
+bash(basename "$(git rev-parse --show-toplevel 2>/dev/null || pwd)")
+bash(git rev-parse --show-toplevel 2>/dev/null || pwd)
+bash(mkdir -p .workflow)
+```
+
+### Step 3: Invoke cli-explore-agent
+
+**For --regenerate**: Backup and preserve existing data
+```bash
+bash(cp .workflow/project-tech.json .workflow/project-tech.json.backup)
+```
+
+**Delegate analysis to agent**:
+
+```javascript
+Task(
+  subagent_type="cli-explore-agent",
+  run_in_background=false,
+  description="Deep project analysis",
+  prompt=`
+Analyze project for workflow initialization and generate .workflow/project-tech.json.
+
+## MANDATORY FIRST STEPS
+1. Execute: cat ~/.ccw/workflows/cli-templates/schemas/project-tech-schema.json (get schema reference)
+2. Execute: ccw tool exec get_modules_by_depth '{}' (get project structure)
+
+## Task
+Generate complete project-tech.json following the schema structure:
+- project_name: "${projectName}"
+- initialized_at: ISO 8601 timestamp
+- overview: {
+    description: "Brief project description",
+    technology_stack: {
+      languages: [{name, file_count, primary}],
+      frameworks: ["string"],
+      build_tools: ["string"],
+      test_frameworks: ["string"]
+    },
+    architecture: {style, layers: [], patterns: []},
+    key_components: [{name, path, description, importance}]
+  }
+- features: []
+- development_index: ${regenerate ? 'preserve from backup' : '{feature: [], enhancement: [], bugfix: [], refactor: [], docs: []}'}
+- statistics: ${regenerate ? 'preserve from backup' : '{total_features: 0, total_sessions: 0, last_updated: ISO timestamp}'}
+- _metadata: {initialized_by: "cli-explore-agent", analysis_timestamp: ISO timestamp, analysis_mode: "deep-scan"}
+
+## Analysis Requirements
+
+**Technology Stack**:
+- Languages: File counts, mark primary
+- Frameworks: From package.json, requirements.txt, go.mod, etc.
+- Build tools: npm, cargo, maven, webpack, vite
+- Test frameworks: jest, pytest, go test, junit
+
+**Architecture**:
+- Style: MVC, microservices, layered (from structure & imports)
+- Layers: presentation, business-logic, data-access
+- Patterns: singleton, factory, repository
+- Key components: 5-10 modules {name, path, description, importance}
+
+## Execution
+1. Structural scan: get_modules_by_depth.sh, find, wc -l
+2. Semantic analysis: Gemini for patterns/architecture
+3. Synthesis: Merge findings
+4. ${regenerate ? 'Merge with preserved development_index and statistics from .workflow/project-tech.json.backup' : ''}
+5. Write JSON: Write('.workflow/project-tech.json', jsonContent)
+6. Report: Return brief completion summary
+
+Project root: ${projectRoot}
+`
+)
+```
+
+### Step 3.5: Create Guidelines Scaffold (if not exists)
+
+```javascript
+// Only create if not exists (never overwrite user guidelines)
+if (!file_exists('.workflow/project-guidelines.json')) {
+  const guidelinesScaffold = {
+    conventions: {
+      coding_style: [],
+      naming_patterns: [],
+      file_structure: [],
+      documentation: []
+    },
+    constraints: {
+      architecture: [],
+      tech_stack: [],
+      performance: [],
+      security: []
+    },
+    quality_rules: [],
+    learnings: [],
+    _metadata: {
+      created_at: new Date().toISOString(),
+      version: "1.0.0"
+    }
+  };
+
+  Write('.workflow/project-guidelines.json', JSON.stringify(guidelinesScaffold, null, 2));
+}
+```
+
+### Step 4: Display Summary
+
+```javascript
+const projectTech = JSON.parse(Read('.workflow/project-tech.json'));
+const guidelinesExists = file_exists('.workflow/project-guidelines.json');
+
+console.log(`
+✓ Project initialized successfully
+
+## Project Overview
+Name: ${projectTech.project_name}
+Description: ${projectTech.overview.description}
+
+### Technology Stack
+Languages: ${projectTech.overview.technology_stack.languages.map(l => l.name).join(', ')}
+Frameworks: ${projectTech.overview.technology_stack.frameworks.join(', ')}
+
+### Architecture
+Style: ${projectTech.overview.architecture.style}
+Components: ${projectTech.overview.key_components.length} core modules
+
+---
+Files created:
+- Tech analysis: .workflow/project-tech.json
+- Guidelines: .workflow/project-guidelines.json ${guidelinesExists ? '(scaffold)' : ''}
+${regenerate ? '- Backup: .workflow/project-tech.json.backup' : ''}
+`);
+```
+
+### Step 5: Ask About Guidelines Configuration
+
+After displaying the summary, ask the user if they want to configure project guidelines interactively.
+
+```javascript
+// Check if guidelines are just a scaffold (empty) or already populated
+const guidelines = JSON.parse(Read('.workflow/project-guidelines.json'));
+const isGuidelinesPopulated =
+  guidelines.conventions.coding_style.length > 0 ||
+  guidelines.conventions.naming_patterns.length > 0 ||
+  guidelines.constraints.architecture.length > 0 ||
+  guidelines.constraints.security.length > 0;
+
+// Only ask if guidelines are not yet populated
+if (!isGuidelinesPopulated) {
+  const userChoice = AskUserQuestion({
+    questions: [{
+      question: "Would you like to configure project guidelines now? The wizard will ask targeted questions based on your tech stack.",
+      header: "Guidelines",
+      multiSelect: false,
+      options: [
+        {
+          label: "Configure now (Recommended)",
+          description: "Interactive wizard to set up coding conventions, constraints, and quality rules"
+        },
+        {
+          label: "Skip for now",
+          description: "You can run /workflow:init-guidelines later or use /workflow:session:solidify to add rules individually"
+        }
+      ]
+    }]
+  });
+
+  if (userChoice.answers["Guidelines"] === "Configure now (Recommended)") {
+    console.log("\n🔧 Starting guidelines configuration wizard...\n");
+    Skill(skill="workflow:init-guidelines");
+  } else {
+    console.log(`
+Next steps:
+- Use /workflow:init-guidelines to configure guidelines interactively
+- Use /workflow:session:solidify to add individual rules
+- Use /workflow:plan to start planning
+`);
+  }
+} else {
+  console.log(`
+Guidelines already configured (${guidelines.conventions.coding_style.length + guidelines.constraints.architecture.length}+ rules).
+
+Next steps:
+- Use /workflow:init-guidelines --reset to reconfigure
+- Use /workflow:session:solidify to add individual rules
+- Use /workflow:plan to start planning
+`);
+}
+```
+
+## Error Handling
+
+**Agent Failure**: Fall back to basic initialization with placeholder overview
+**Missing Tools**: Agent uses Qwen fallback or bash-only
+**Empty Project**: Create minimal JSON with all gaps identified
+
+## Related Commands
+
+- `/workflow:init-guidelines` - Interactive wizard to configure project guidelines (called after init)
+- `/workflow:session:solidify` - Add individual rules/constraints one at a time
+- `workflow-plan` skill - Start planning with initialized project context
+- `/workflow:status --project` - View project state and guidelines

.claude/commands/workflow/integration-test-cycle.md

@@ -2,7 +2,7 @@
 name: integration-test-cycle
 description: Self-iterating integration test workflow with codebase exploration, test development, autonomous test-fix cycles, and reflection-driven strategy adjustment
 argument-hint: "[-y|--yes] [-c|--continue] [--max-iterations=N] \"module or feature description\""
-allowed-tools: TodoWrite(*), Agent(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*), Skill(*)
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*), Skill(*)
 ---
 
 ## Auto Mode
@@ -209,7 +209,7 @@ Unified integration test workflow: **Explore → Design → Develop → Test →
 1. **Codebase Exploration via cli-explore-agent**
 
 ```javascript
-Agent({
+Task({
   subagent_type: "cli-explore-agent",
   run_in_background: false,
   description: `Explore integration points: ${topicSlug}`,
@@ -391,7 +391,7 @@ Also set `state.json.phase` to `"designed"`.
 1. **Generate Integration Tests via @code-developer**
 
 ```javascript
-Agent({
+Task({
   subagent_type: "code-developer",
   run_in_background: false,
   description: `Generate integration tests: ${topicSlug}`,
@@ -435,7 +435,7 @@ Also set state.json "phase" to "developed".
 2. **Code Validation Gate via @test-fix-agent**
 
 ```javascript
-Agent({
+Task({
   subagent_type: "test-fix-agent",
   run_in_background: false,
   description: `Validate generated tests: ${topicSlug}`,
@@ -605,7 +605,7 @@ After each iteration, update the `## Cumulative Learnings` section in reflection
 
 **@test-fix-agent** (test execution):
 ```javascript
-Agent({
+Task({
   subagent_type: "test-fix-agent",
   run_in_background: false,
   description: `Execute integration tests: iteration ${N}`,
@@ -637,7 +637,7 @@ For each failure, assign:
 
 **@cli-planning-agent** (failure analysis with reflection):
 ```javascript
-Agent({
+Task({
   subagent_type: "cli-planning-agent",
   run_in_background: false,
   description: `Analyze failures: iteration ${N} - ${strategy}`,
@@ -676,7 +676,7 @@ Analyze test failures using reflection context and generate fix strategy.
 
 **@test-fix-agent** (apply fixes):
 ```javascript
-Agent({
+Task({
   subagent_type: "test-fix-agent",
   run_in_background: false,
   description: `Apply fixes: iteration ${N} - ${strategy}`,
@@ -806,10 +806,6 @@ AskUserQuestion({
 })
 ```
 
-4. **Sync Session State** (automatic)
-   - Execute: `/workflow:session:sync -y "Integration test cycle complete: ${passRate}% pass rate, ${iterations} iterations"`
-   - Updates specs/*.md with test learnings and project-tech.json with development index entry
-
 ---
 
 ## Completion Conditions
@@ -927,7 +923,7 @@ Single evolving state file — each phase writes its section:
 - Already have a completed implementation session (WFS-*)
 - Only need unit/component level tests
 
-**Use `workflow-tdd-plan` skill when:**
+**Use `workflow-tdd` skill when:**
 - Building new features with test-first approach
 - Red-Green-Refactor cycle
 

.claude/commands/workflow/refactor-cycle.md

@@ -2,7 +2,7 @@
 name: refactor-cycle
 description: Tech debt discovery and self-iterating refactoring with multi-dimensional analysis, prioritized execution, regression validation, and reflection-driven adjustment
 argument-hint: "[-y|--yes] [-c|--continue] [--scope=module|project] \"module or refactoring goal\""
-allowed-tools: TodoWrite(*), Agent(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
 ---
 
 ## Auto Mode
@@ -39,7 +39,7 @@ Closed-loop tech debt lifecycle: **Discover → Assess → Plan → Refactor →
 
 **vs Existing Commands**:
 - **workflow:lite-fix**: Single bug fix, no systematic debt analysis
-- **workflow-plan + execute**: Generic implementation, no debt-aware prioritization or regression validation
+- **workflow:plan + execute**: Generic implementation, no debt-aware prioritization or regression validation
 - **This command**: Full debt lifecycle — discovery through multi-dimensional scan, prioritized execution with per-item regression validation
 
 ### Value Proposition
@@ -200,7 +200,7 @@ Closed-loop tech debt lifecycle: **Discover → Assess → Plan → Refactor →
 1. **Codebase Exploration via cli-explore-agent**
 
 ```javascript
-Agent({
+Task({
   subagent_type: "cli-explore-agent",
   run_in_background: false,
   description: `Explore codebase for debt: ${topicSlug}`,
@@ -465,7 +465,7 @@ Set `state.json.current_item` to item ID.
 #### Step 4.2: Execute Refactoring
 
 ```javascript
-Agent({
+Task({
   subagent_type: "code-developer",
   run_in_background: false,
   description: `Refactor ${item.id}: ${item.title}`,
@@ -499,7 +499,7 @@ ${JSON.stringify(item.refactor_plan, null, 2)}
 
 ```javascript
 // 1. Run tests
-Agent({
+Task({
   subagent_type: "test-fix-agent",
   run_in_background: false,
   description: `Validate refactoring: ${item.id}`,
@@ -843,8 +843,6 @@ AskUserQuestion({
 
 ## Post-Completion Expansion
 
-**Auto-sync**: 执行 `/workflow:session:sync -y "{summary}"` 更新 specs/*.md + project-tech。
-
 完成后询问用户是否扩展为issue(test/enhance/refactor/doc)，选中项调用 `/issue:new "{summary} - {dimension}"`
 
 ---

.claude/commands/workflow/req-plan-with-file.md

@@ -0,0 +1,620 @@
+---
+name: req-plan-with-file
+description: Requirement-level progressive roadmap planning with issue creation. Decomposes requirements into convergent layers or task sequences, creates issues via ccw issue create, and generates roadmap.md for human review. Issues stored in .workflow/issues/issues.jsonl (single source of truth).
+argument-hint: "[-y|--yes] [-c|--continue] [-m|--mode progressive|direct|auto] \"requirement description\""
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-confirm strategy selection, use recommended mode, skip interactive validation rounds.
+
+# Workflow Req-Plan Command (/workflow:req-plan-with-file)
+
+## Quick Start
+
+```bash
+# Basic usage
+/workflow:req-plan-with-file "Implement user authentication system with OAuth and 2FA"
+
+# With mode selection
+/workflow:req-plan-with-file -m progressive "Build real-time notification system"   # Layered MVP→iterations
+/workflow:req-plan-with-file -m direct "Refactor payment module"                   # Topologically-sorted task sequence
+/workflow:req-plan-with-file -m auto "Add data export feature"                     # Auto-select strategy
+
+# Continue existing session
+/workflow:req-plan-with-file --continue "user authentication system"
+
+# Auto mode
+/workflow:req-plan-with-file -y "Implement caching layer"
+```
+
+**Context Source**: cli-explore-agent (optional) + requirement analysis
+**Output Directory**: `.workflow/.req-plan/{session-id}/`
+**Core Innovation**: Requirement decomposition → issue creation via `ccw issue create`. Issues stored in `.workflow/issues/issues.jsonl` (single source of truth). Wave/dependency info embedded in issue tags (`wave-N`) and `extended_context.notes.depends_on_issues`. team-planex consumes issues directly by ID or tag query.
+
+## Overview
+
+Requirement-level layered roadmap planning command. Decomposes a requirement into **convergent layers or task sequences**, creates issues via `ccw issue create`. Issues are the single source of truth in `.workflow/issues/issues.jsonl`; wave and dependency info is embedded in issue tags and `extended_context.notes`.
+
+**Dual Modes**:
+- **Progressive**: Layered MVP→iterations, suitable for high-uncertainty requirements (validate first, then refine)
+- **Direct**: Topologically-sorted task sequence, suitable for low-uncertainty requirements (clear tasks, directly ordered)
+- **Auto**: Automatically selects based on uncertainty level
+
+**Core Workflow**: Requirement Understanding → Strategy Selection → Context Collection (optional) → Decomposition + Issue Creation → Validation → team-planex Handoff
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                    REQ-PLAN ROADMAP WORKFLOW                             │
+├─────────────────────────────────────────────────────────────────────────┤
+│                                                                          │
+│  Phase 1: Requirement Understanding & Strategy Selection                 │
+│     ├─ Parse requirement: goal / constraints / stakeholders              │
+│     ├─ Assess uncertainty level                                          │
+│     │   ├─ High uncertainty → recommend progressive                      │
+│     │   └─ Low uncertainty  → recommend direct                           │
+│     ├─ User confirms strategy (-m skips, -y auto-selects recommended)    │
+│     └─ Initialize strategy-assessment.json + roadmap.md skeleton         │
+│                                                                          │
+│  Phase 2: Context Collection (Optional)                                  │
+│     ├─ Detect codebase: package.json / go.mod / src / ...                │
+│     ├─ Has codebase → cli-explore-agent explores relevant modules        │
+│     └─ No codebase  → skip, pure requirement decomposition               │
+│                                                                          │
+│  Phase 3: Decomposition & Issue Creation (cli-roadmap-plan-agent)        │
+│     ├─ Progressive: define 2-4 layers, each with full convergence        │
+│     ├─ Direct: vertical slicing + topological sort, each with convergence│
+│     ├─ Create issues via ccw issue create (ISS-xxx IDs)                  │
+│     └─ Generate roadmap.md (with issue ID references)                    │
+│                                                                          │
+│  Phase 4: Validation & team-planex Handoff                               │
+│     ├─ Display decomposition results (tabular + convergence criteria)    │
+│     ├─ User feedback loop (up to 5 rounds)                               │
+│     └─ Next steps: team-planex full execution / wave-by-wave / view      │
+│                                                                          │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+## Output
+
+```
+.workflow/.req-plan/RPLAN-{slug}-{YYYY-MM-DD}/
+├── roadmap.md                    # Human-readable roadmap with issue ID references
+├── strategy-assessment.json      # Strategy assessment result
+└── exploration-codebase.json     # Codebase context (optional)
+```
+
+| File | Phase | Description |
+|------|-------|-------------|
+| `strategy-assessment.json` | 1 | Uncertainty analysis + mode recommendation + extracted goal/constraints/stakeholders |
+| `roadmap.md` (skeleton) | 1 | Initial skeleton with placeholders, finalized in Phase 3 |
+| `exploration-codebase.json` | 2 | Codebase context: relevant modules, patterns, integration points (only when codebase exists) |
+| `roadmap.md` (final) | 3 | Human-readable roadmap with issue ID references, convergence details, team-planex execution guide |
+
+**roadmap.md template**:
+
+```markdown
+# Requirement Roadmap
+
+**Session**: RPLAN-{slug}-{date}
+**Requirement**: {requirement}
+**Strategy**: {progressive|direct}
+**Generated**: {timestamp}
+
+## Strategy Assessment
+- Uncertainty level: {high|medium|low}
+- Decomposition mode: {progressive|direct}
+- Assessment basis: {factors summary}
+
+## Roadmap
+{Tabular display of layers/tasks}
+
+## Convergence Criteria Details
+{Expanded convergence for each layer/task}
+
+## Risks
+{Aggregated risks}
+
+## Next Steps
+{Execution guidance}
+```
+
+## Configuration
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `-y, --yes` | false | Auto-confirm all decisions |
+| `-c, --continue` | false | Continue existing session |
+| `-m, --mode` | auto | Decomposition strategy: progressive / direct / auto |
+
+**Session ID format**: `RPLAN-{slug}-{YYYY-MM-DD}`
+- slug: lowercase, alphanumeric + CJK characters, max 40 chars
+- date: YYYY-MM-DD (UTC+8)
+- Auto-detect continue: session folder + roadmap.md exists → continue mode
+
+## JSONL Schema Design
+
+### Issue Format
+
+Each line in `issues.jsonl` follows the standard `issues-jsonl-schema.json` (see `.ccw/workflows/cli-templates/schemas/issues-jsonl-schema.json`).
+
+**Key fields per issue**:
+
+| Field | Source | Description |
+|-------|--------|-------------|
+| `id` | `ccw issue create` | Formal ISS-YYYYMMDD-NNN ID |
+| `title` | Layer/task mapping | `[LayerName] goal` or `[TaskType] title` |
+| `context` | Convergence fields | Markdown with goal, scope, convergence criteria, verification, DoD |
+| `priority` | Effort mapping | small→4, medium→3, large→2 |
+| `source` | Fixed | `"text"` |
+| `tags` | Auto-generated | `["req-plan", mode, name/type, "wave-N"]` |
+| `extended_context.notes` | Metadata JSON | session, strategy, original_id, wave, depends_on_issues |
+| `lifecycle_requirements` | Fixed | test_strategy, regression_scope, acceptance_type, commit_strategy |
+
+### Convergence Criteria (in issue context)
+
+Each issue's `context` field contains convergence information:
+
+| Section | Purpose | Requirement |
+|---------|---------|-------------|
+| `## Convergence Criteria` | List of checkable specific conditions | **Testable** (can be written as assertions or manual steps) |
+| `## Verification` | How to verify these conditions | **Executable** (command, script, or explicit steps) |
+| `## Definition of Done` | One-sentence completion definition | **Business language** (non-technical person can judge) |
+
+## Implementation
+
+### Session Initialization
+
+**Objective**: Create session context and directory structure.
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+// Parse flags
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+const continueMode = $ARGUMENTS.includes('--continue') || $ARGUMENTS.includes('-c')
+const modeMatch = $ARGUMENTS.match(/(?:--mode|-m)\s+(progressive|direct|auto)/)
+const requestedMode = modeMatch ? modeMatch[1] : 'auto'
+
+// Clean requirement text (remove flags)
+const requirement = $ARGUMENTS
+  .replace(/--yes|-y|--continue|-c|--mode\s+\w+|-m\s+\w+/g, '')
+  .trim()
+
+const slug = requirement.toLowerCase()
+  .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-')
+  .substring(0, 40)
+const dateStr = getUtc8ISOString().substring(0, 10)
+const sessionId = `RPLAN-${slug}-${dateStr}`
+const sessionFolder = `.workflow/.req-plan/${sessionId}`
+
+// Auto-detect continue: session folder + roadmap.md exists → continue mode
+Bash(`mkdir -p ${sessionFolder}`)
+```
+
+### Phase 1: Requirement Understanding & Strategy Selection
+
+**Objective**: Parse requirement, assess uncertainty, select decomposition strategy.
+
+**Prerequisites**: Session initialized, requirement description available.
+
+**Steps**:
+
+1. **Parse Requirement**
+   - Extract core goal (what to achieve)
+   - Identify constraints (tech stack, timeline, compatibility, etc.)
+   - Identify stakeholders (users, admins, developers, etc.)
+   - Identify keywords to determine domain
+
+2. **Assess Uncertainty Level**
+
+   ```javascript
+   const uncertaintyFactors = {
+     scope_clarity: 'low|medium|high',
+     technical_risk: 'low|medium|high',
+     dependency_unknown: 'low|medium|high',
+     domain_familiarity: 'low|medium|high',
+     requirement_stability: 'low|medium|high'
+   }
+   // high uncertainty (>=3 high) → progressive
+   // low uncertainty (>=3 low)  → direct
+   // otherwise → ask user preference
+   ```
+
+3. **Strategy Selection** (skip if `-m` already specified)
+
+   ```javascript
+   if (requestedMode !== 'auto') {
+     selectedMode = requestedMode
+   } else if (autoYes) {
+     selectedMode = recommendedMode
+   } else {
+     AskUserQuestion({
+       questions: [{
+         question: `Decomposition strategy selection:\n\nUncertainty assessment: ${uncertaintyLevel}\nRecommended strategy: ${recommendedMode}\n\nSelect decomposition strategy:`,
+         header: "Strategy",
+         multiSelect: false,
+         options: [
+           {
+             label: recommendedMode === 'progressive' ? "Progressive (Recommended)" : "Progressive",
+             description: "Layered MVP→iterations, validate core first then refine progressively. Suitable for high-uncertainty requirements needing quick validation"
+           },
+           {
+             label: recommendedMode === 'direct' ? "Direct (Recommended)" : "Direct",
+             description: "Topologically-sorted task sequence with explicit dependencies. Suitable for clear requirements with confirmed technical approach"
+           }
+         ]
+       }]
+     })
+   }
+   ```
+
+4. **Generate strategy-assessment.json**
+
+   ```javascript
+   const strategyAssessment = {
+     session_id: sessionId,
+     requirement: requirement,
+     timestamp: getUtc8ISOString(),
+     uncertainty_factors: uncertaintyFactors,
+     uncertainty_level: uncertaintyLevel,  // 'high' | 'medium' | 'low'
+     recommended_mode: recommendedMode,
+     selected_mode: selectedMode,
+     goal: extractedGoal,
+     constraints: extractedConstraints,
+     stakeholders: extractedStakeholders,
+     domain_keywords: extractedKeywords
+   }
+   Write(`${sessionFolder}/strategy-assessment.json`, JSON.stringify(strategyAssessment, null, 2))
+   ```
+
+5. **Initialize roadmap.md skeleton** (placeholder sections, finalized in Phase 4)
+
+   ```javascript
+   const roadmapMdSkeleton = `# Requirement Roadmap
+
+**Session**: ${sessionId}
+**Requirement**: ${requirement}
+**Strategy**: ${selectedMode}
+**Status**: Planning
+**Created**: ${getUtc8ISOString()}
+
+## Strategy Assessment
+- Uncertainty level: ${uncertaintyLevel}
+- Decomposition mode: ${selectedMode}
+
+## Roadmap
+> To be populated after Phase 3 decomposition
+
+## Convergence Criteria Details
+> To be populated after Phase 3 decomposition
+
+## Risk Items
+> To be populated after Phase 3 decomposition
+
+## Next Steps
+> To be populated after Phase 4 validation
+`
+   Write(`${sessionFolder}/roadmap.md`, roadmapMdSkeleton)
+   ```
+
+**Success Criteria**:
+- Requirement goal, constraints, stakeholders identified
+- Uncertainty level assessed
+- Strategy selected (progressive or direct)
+- strategy-assessment.json generated
+- roadmap.md skeleton initialized
+
+### Phase 2: Context Collection (Optional)
+
+**Objective**: If a codebase exists, collect relevant context to enhance decomposition quality.
+
+**Prerequisites**: Phase 1 complete.
+
+**Steps**:
+
+1. **Detect Codebase**
+
+   ```javascript
+   const hasCodebase = Bash(`
+     test -f package.json && echo "nodejs" ||
+     test -f go.mod && echo "golang" ||
+     test -f Cargo.toml && echo "rust" ||
+     test -f pyproject.toml && echo "python" ||
+     test -f pom.xml && echo "java" ||
+     test -d src && echo "generic" ||
+     echo "none"
+   `).trim()
+   ```
+
+2. **Codebase Exploration** (only when hasCodebase !== 'none')
+
+   ```javascript
+   if (hasCodebase !== 'none') {
+     Task({
+       subagent_type: "cli-explore-agent",
+       run_in_background: false,
+       description: `Explore codebase: ${slug}`,
+       prompt: `
+   ## Exploration Context
+   Requirement: ${requirement}
+   Strategy: ${selectedMode}
+   Project Type: ${hasCodebase}
+   Session: ${sessionFolder}
+
+   ## MANDATORY FIRST STEPS
+   1. Run: ccw tool exec get_modules_by_depth '{}'
+   2. Execute relevant searches based on requirement keywords
+   3. Read: .workflow/project-tech.json (if exists)
+   4. Read: .workflow/project-guidelines.json (if exists)
+
+   ## Exploration Focus
+   - Identify modules/components related to the requirement
+   - Find existing patterns that should be followed
+   - Locate integration points for new functionality
+   - Assess current architecture constraints
+
+   ## Output
+   Write findings to: ${sessionFolder}/exploration-codebase.json
+
+   Schema: {
+     project_type: "${hasCodebase}",
+     relevant_modules: [{name, path, relevance}],
+     existing_patterns: [{pattern, files, description}],
+     integration_points: [{location, description, risk}],
+     architecture_constraints: [string],
+     tech_stack: {languages, frameworks, tools},
+     _metadata: {timestamp, exploration_scope}
+   }
+   `
+     })
+   }
+   // No codebase → skip, proceed directly to Phase 3
+   ```
+
+**Success Criteria**:
+- Codebase detection complete
+- When codebase exists, exploration-codebase.json generated
+- When no codebase, skipped and logged
+
+### Phase 3: Decomposition & Issue Creation
+
+**Objective**: Execute requirement decomposition via `cli-roadmap-plan-agent`, creating issues and generating roadmap.md.
+
+**Prerequisites**: Phase 1, Phase 2 complete. Strategy selected. Context collected (if applicable).
+
+**Agent**: `cli-roadmap-plan-agent` (dedicated requirement roadmap planning agent, supports CLI-assisted decomposition + issue creation + built-in quality checks)
+
+**Steps**:
+
+1. **Prepare Context**
+
+   ```javascript
+   const strategy = JSON.parse(Read(`${sessionFolder}/strategy-assessment.json`))
+   let explorationContext = null
+   if (file_exists(`${sessionFolder}/exploration-codebase.json`)) {
+     explorationContext = JSON.parse(Read(`${sessionFolder}/exploration-codebase.json`))
+   }
+   ```
+
+2. **Invoke cli-roadmap-plan-agent**
+
+   The agent internally executes a 5-phase flow:
+   - Phase 1: Context loading + requirement analysis
+   - Phase 2: CLI-assisted decomposition (Gemini → Qwen → manual fallback)
+   - Phase 3: Record enhancement + validation (schema compliance, dependency checks, convergence quality)
+   - Phase 4: Issue creation + roadmap generation (ccw issue create → roadmap.md)
+   - Phase 5: CLI decomposition quality check (**MANDATORY** - requirement coverage, convergence criteria quality, dependency correctness)
+
+   ```javascript
+   Task({
+     subagent_type: "cli-roadmap-plan-agent",
+     run_in_background: false,
+     description: `Roadmap decomposition: ${slug}`,
+     prompt: `
+   ## Roadmap Decomposition Task
+
+   ### Input Context
+   - **Requirement**: ${requirement}
+   - **Selected Mode**: ${selectedMode}
+   - **Session ID**: ${sessionId}
+   - **Session Folder**: ${sessionFolder}
+
+   ### Strategy Assessment
+   ${JSON.stringify(strategy, null, 2)}
+
+   ### Codebase Context
+   ${explorationContext
+     ? `File: ${sessionFolder}/exploration-codebase.json\n${JSON.stringify(explorationContext, null, 2)}`
+     : 'No codebase detected - pure requirement decomposition'}
+
+   ### Issue Creation
+   - Use \`ccw issue create\` for each decomposed item
+   - Issue format: issues-jsonl-schema (id, title, status, priority, context, source, tags, extended_context)
+   - Update \`roadmap.md\` with issue ID references
+
+   ### CLI Configuration
+   - Primary tool: gemini
+   - Fallback: qwen
+   - Timeout: 60000ms
+
+   ### Expected Output
+   1. **${sessionFolder}/roadmap.md** - Human-readable roadmap with issue references
+   2. Issues created in \`.workflow/issues/issues.jsonl\` via ccw issue create
+
+   ### Mode-Specific Requirements
+
+   ${selectedMode === 'progressive' ? `**Progressive Mode**:
+   - 2-4 layers from MVP to full implementation
+   - Each layer: id (L0-L3), name, goal, scope, excludes, convergence, risks, effort, depends_on
+   - L0 (MVP) must be a self-contained closed loop with no dependencies
+   - Scope: each feature belongs to exactly ONE layer (no overlap)
+   - Layer names: MVP / Usable / Refined / Optimized` :
+
+   `**Direct Mode**:
+   - Topologically-sorted task sequence
+   - Each task: id (T1-Tn), title, type, scope, inputs, outputs, convergence, depends_on, parallel_group
+   - Inputs must come from preceding task outputs or existing resources
+   - Tasks in same parallel_group must be truly independent`}
+
+   ### Convergence Quality Requirements
+   - criteria[]: MUST be testable (can write assertions or manual verification steps)
+   - verification: MUST be executable (command, script, or explicit steps)
+   - definition_of_done: MUST use business language (non-technical person can judge)
+
+   ### Execution
+   1. Analyze requirement and build decomposition context
+   2. Execute CLI-assisted decomposition (Gemini, fallback Qwen)
+   3. Parse output, validate records, enhance convergence quality
+   4. Create issues via ccw issue create, generate roadmap.md
+   5. Execute mandatory quality check (Phase 5)
+   6. Return brief completion summary
+   `
+   })
+   ```
+
+**Success Criteria**:
+- Issues created via `ccw issue create`, each with formal ISS-xxx ID
+- roadmap.md generated with issue ID references
+- Agent's internal quality check passed
+- No circular dependencies
+- Progressive: 2-4 layers, no scope overlap
+- Direct: tasks have explicit inputs/outputs, parallel_group assigned
+
+### Phase 4: Validation & team-planex Handoff
+
+**Objective**: Display decomposition results, collect user feedback, provide team-planex execution options.
+
+**Prerequisites**: Phase 3 complete, issues created, roadmap.md generated.
+
+**Steps**:
+
+1. **Display Decomposition Results** (tabular format)
+
+   ```javascript
+   // Use issueIdMap from Phase 3 for display
+   const issueIds = Object.values(issueIdMap)
+   ```
+
+   **Progressive Mode**:
+   ```markdown
+   ## Roadmap Overview
+
+   | Wave | Issue ID | Name | Goal | Priority |
+   |------|----------|------|------|----------|
+   | 1 | ISS-xxx | MVP | ... | 2 |
+   | 2 | ISS-yyy | Usable | ... | 3 |
+
+   ### Convergence Criteria
+   **Wave 1 - MVP (ISS-xxx)**:
+   - Criteria: [criteria list]
+   - Verification: [verification]
+   - Definition of Done: [definition_of_done]
+   ```
+
+   **Direct Mode**:
+   ```markdown
+   ## Task Sequence
+
+   | Wave | Issue ID | Title | Type | Dependencies |
+   |------|----------|-------|------|--------------|
+   | 1 | ISS-xxx | ... | infrastructure | - |
+   | 2 | ISS-yyy | ... | feature | ISS-xxx |
+
+   ### Convergence Criteria
+   **Wave 1 - ISS-xxx**:
+   - Criteria: [criteria list]
+   - Verification: [verification]
+   - Definition of Done: [definition_of_done]
+   ```
+
+2. **User Feedback Loop** (up to 5 rounds, skipped when autoYes)
+
+   ```javascript
+   if (!autoYes) {
+     let round = 0
+     let continueLoop = true
+
+     while (continueLoop && round < 5) {
+       round++
+       const feedback = AskUserQuestion({
+         questions: [{
+           question: `Roadmap validation (round ${round}):\nAny feedback on the current decomposition?`,
+           header: "Feedback",
+           multiSelect: false,
+           options: [
+             { label: "Approve", description: "Decomposition is reasonable, proceed to next steps" },
+             { label: "Adjust Scope", description: "Some issue scopes need adjustment" },
+             { label: "Modify Convergence", description: "Convergence criteria are not specific or testable enough" },
+             { label: "Re-decompose", description: "Overall strategy or layering approach needs change" }
+           ]
+         }]
+       })
+
+       if (feedback === 'Approve') {
+         continueLoop = false
+       } else {
+         // Handle adjustment based on feedback type
+         // After adjustment, re-display and return to loop top
+       }
+     }
+   }
+   ```
+
+3. **Post-Completion Options**
+
+   ```javascript
+   if (!autoYes) {
+     AskUserQuestion({
+       questions: [{
+         question: `路线图已生成，${issueIds.length} 个 issues 已创建。下一步：`,
+         header: "Next Step",
+         multiSelect: false,
+         options: [
+           { label: "Execute with team-planex", description: `启动 team-planex 执行全部 ${issueIds.length} 个 issues` },
+           { label: "Execute first wave", description: "仅执行 Wave 1（按 wave-1 tag 筛选）" },
+           { label: "View issues", description: "查看已创建的 issue 详情" },
+           { label: "Done", description: "保存路线图，稍后执行" }
+         ]
+       }]
+     })
+   }
+   ```
+
+   | Selection | Action |
+   |-----------|--------|
+   | Execute with team-planex | `Skill(skill="team-planex", args="${issueIds.join(' ')}")` |
+   | Execute first wave | Filter issues by `wave-1` tag, pass to team-planex |
+   | View issues | Display issues summary from `.workflow/issues/issues.jsonl` |
+   | Done | Display file paths, end |
+
+**Success Criteria**:
+- User feedback processed (or skipped via autoYes)
+- Post-completion options provided
+- team-planex handoff available via issue IDs
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| cli-explore-agent failure | Skip code exploration, proceed with pure requirement decomposition |
+| No codebase | Normal flow, skip Phase 2 |
+| Circular dependency detected | Prompt user to adjust dependencies, re-decompose |
+| User feedback timeout | Save current state, display `--continue` recovery command |
+| Max feedback rounds reached | Use current version to generate final artifacts |
+| Session folder conflict | Append timestamp suffix |
+
+## Best Practices
+
+1. **Clear requirement description**: Detailed description → more accurate uncertainty assessment and decomposition
+2. **Validate MVP first**: In progressive mode, L0 should be the minimum verifiable closed loop
+3. **Testable convergence**: criteria must be writable as assertions or manual steps; definition_of_done should be judgeable by non-technical stakeholders (see Convergence Criteria in JSONL Schema Design)
+4. **Agent-First for Exploration**: Delegate codebase exploration to cli-explore-agent, do not analyze directly in main flow
+5. **Incremental validation**: Use `--continue` to iterate on existing roadmaps
+6. **team-planex integration**: Issues created follow standard issues-jsonl-schema, directly consumable by team-planex via issue IDs and tags
+
+
+---
+
+**Now execute req-plan-with-file for**: $ARGUMENTS

.claude/commands/workflow/roadmap-with-file.md

@@ -1,544 +0,0 @@
----
-name: roadmap-with-file
-description: Strategic requirement roadmap with iterative decomposition and issue creation. Outputs roadmap.md (human-readable, single source) + issues.jsonl (machine-executable). Handoff to team-planex.
-argument-hint: "[-y|--yes] [-c|--continue] [-m progressive|direct|auto] \"requirement description\""
-allowed-tools: TodoWrite(*), Agent(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
----
-
-## Auto Mode
-
-When `--yes` or `-y`: Auto-confirm strategy selection, use recommended mode, skip interactive rounds.
-
-# Workflow Roadmap Command (/workflow:roadmap-with-file)
-
-## Quick Start
-
-```bash
-# Basic usage
-/workflow:roadmap-with-file "Implement user authentication system with OAuth and 2FA"
-
-# With mode selection
-/workflow:roadmap-with-file -m progressive "Build real-time notification system"   # MVP→iterations
-/workflow:roadmap-with-file -m direct "Refactor payment module"                   # Topological sequence
-/workflow:roadmap-with-file -m auto "Add data export feature"                     # Auto-select
-
-# Continue existing session
-/workflow:roadmap-with-file --continue "auth system"
-
-# Auto mode
-/workflow:roadmap-with-file -y "Implement caching layer"
-```
-
-**Context Source**: cli-explore-agent (optional) + requirement analysis
-**Output Directory**: `.workflow/.roadmap/{session-id}/`
-**Core Output**: `roadmap.md` (single source, human-readable) + `issues.jsonl` (global, machine-executable)
-
-## Output Artifacts
-
-### Single Source of Truth
-
-| Artifact | Purpose | Consumer |
-|----------|---------|----------|
-| `roadmap.md` | ⭐ Human-readable strategic roadmap with all context | Human review, team-planex handoff |
-| `.workflow/issues/issues.jsonl` | Global issue store (appended) | team-planex, issue commands |
-
-### Why No Separate JSON Files?
-
-| Original File | Why Removed | Where Content Goes |
-|---------------|-------------|-------------------|
-| `strategy-assessment.json` | Duplicates roadmap.md content | Embedded in `roadmap.md` Strategy Assessment section |
-| `exploration-codebase.json` | Single-use intermediate | Embedded in `roadmap.md` Codebase Context appendix |
-
-## Overview
-
-Strategic requirement roadmap with **iterative decomposition**. Creates a single `roadmap.md` that evolves through discussion, with issues persisted to global `issues.jsonl` for execution.
-
-**Core workflow**: Understand → Decompose → Iterate → Validate → Handoff
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                    ROADMAP ITERATIVE WORKFLOW                            │
-├─────────────────────────────────────────────────────────────────────────┤
-│                                                                          │
-│  Phase 1: Requirement Understanding & Strategy                           │
-│     ├─ Parse requirement: goal / constraints / stakeholders              │
-│     ├─ Assess uncertainty level → recommend mode                         │
-│     ├─ User confirms strategy (-m skips, -y auto-selects)                │
-│     └─ Initialize roadmap.md with Strategy Assessment                    │
-│                                                                          │
-│  Phase 2: Decomposition & Issue Creation                                 │
-│     ├─ cli-roadmap-plan-agent executes decomposition                     │
-│     ├─ Progressive: 2-4 layers (MVP→Optimized) with convergence          │
-│     ├─ Direct: Topological task sequence with convergence                │
-│     ├─ Create issues via ccw issue create → issues.jsonl                 │
-│     └─ Update roadmap.md with Roadmap table + Issue references           │
-│                                                                          │
-│  Phase 3: Iterative Refinement (Multi-Round)                             │
-│     ├─ Present roadmap to user                                           │
-│     ├─ Feedback: Approve | Adjust Scope | Modify Convergence | Replan    │
-│     ├─ Update roadmap.md with each round                                 │
-│     └─ Repeat until approved (max 5 rounds)                              │
-│                                                                          │
-│  Phase 4: Handoff                                                        │
-│     ├─ Final roadmap.md with Issue ID references                         │
-│     ├─ Options: team-planex | first wave | view issues | done            │
-│     └─ Issues ready in .workflow/issues/issues.jsonl                     │
-│                                                                          │
-└─────────────────────────────────────────────────────────────────────────┘
-```
-
-## Dual Modes
-
-| Mode | Strategy | Best For | Decomposition |
-|------|----------|----------|---------------|
-| **Progressive** | MVP → Usable → Refined → Optimized | High uncertainty, need validation | 2-4 layers, each with full convergence |
-| **Direct** | Topological task sequence | Clear requirements, confirmed tech | Tasks with explicit inputs/outputs |
-
-**Auto-selection logic**:
-- ≥3 high uncertainty factors → Progressive
-- ≥3 low uncertainty factors → Direct
-- Otherwise → Ask user preference
-
-## Output Structure
-
-```
-.workflow/.roadmap/RMAP-{slug}-{date}/
-└── roadmap.md                  # ⭐ Single source of truth
-                                #   - Strategy Assessment (embedded)
-                                #   - Roadmap Table
-                                #   - Convergence Criteria per Issue
-                                #   - Codebase Context (appendix, if applicable)
-                                #   - Iteration History
-
-.workflow/issues/issues.jsonl   # Global issue store (appended)
-                                #   - One JSON object per line
-                                #   - Consumed by team-planex, issue commands
-```
-
-## roadmap.md Template
-
-```markdown
-# Requirement Roadmap
-
-**Session**: RMAP-{slug}-{date}
-**Requirement**: {requirement}
-**Strategy**: {progressive|direct}
-**Status**: {Planning|Refining|Ready}
-**Created**: {timestamp}
-
----
-
-## Strategy Assessment
-
-- **Uncertainty Level**: {high|medium|low}
-- **Decomposition Mode**: {progressive|direct}
-- **Assessment Basis**: {factors summary}
-- **Goal**: {extracted goal}
-- **Constraints**: {extracted constraints}
-- **Stakeholders**: {extracted stakeholders}
-
----
-
-## Roadmap
-
-### Progressive Mode
-| Wave | Issue ID | Layer | Goal | Priority | Dependencies |
-|------|----------|-------|------|----------|--------------|
-| 1 | ISS-xxx | MVP | ... | 2 | - |
-| 2 | ISS-yyy | Usable | ... | 3 | ISS-xxx |
-
-### Direct Mode
-| Wave | Issue ID | Title | Type | Dependencies |
-|------|----------|-------|------|--------------|
-| 1 | ISS-xxx | ... | infrastructure | - |
-| 2 | ISS-yyy | ... | feature | ISS-xxx |
-
----
-
-## Convergence Criteria
-
-### ISS-xxx: {Issue Title}
-- **Criteria**: [testable conditions]
-- **Verification**: [executable steps/commands]
-- **Definition of Done**: [business language, non-technical]
-
-### ISS-yyy: {Issue Title}
-...
-
----
-
-## Risks
-
-| Risk | Severity | Mitigation |
-|------|----------|------------|
-| ... | ... | ... |
-
----
-
-## Iteration History
-
-### Round 1 - {timestamp}
-**User Feedback**: {feedback summary}
-**Changes Made**: {adjustments}
-**Status**: {approved|continue iteration}
-
----
-
-## Codebase Context (Optional)
-
-*Included when codebase exploration was performed*
-
-- **Relevant Modules**: [...]
-- **Existing Patterns**: [...]
-- **Integration Points**: [...]
-```
-
-## Issues JSONL Specification
-
-### Location & Format
-
-```
-Path: .workflow/issues/issues.jsonl
-Format: JSONL (one complete JSON object per line)
-Encoding: UTF-8
-Mode: Append-only (new issues appended to end)
-```
-
-### Record Schema
-
-```json
-{
-  "id": "ISS-YYYYMMDD-NNN",
-  "title": "[LayerName] goal or [TaskType] title",
-  "status": "pending",
-  "priority": 2,
-  "context": "Markdown with goal, scope, convergence, verification, DoD",
-  "source": "text",
-  "tags": ["roadmap", "progressive|direct", "wave-N", "layer-name"],
-  "extended_context": {
-    "notes": {
-      "session": "RMAP-{slug}-{date}",
-      "strategy": "progressive|direct",
-      "wave": 1,
-      "depends_on_issues": []
-    }
-  },
-  "lifecycle_requirements": {
-    "test_strategy": "unit",
-    "regression_scope": "affected",
-    "acceptance_type": "automated",
-    "commit_strategy": "per-issue"
-  }
-}
-```
-
-### Query Interface
-
-```bash
-# By ID (detail view)
-ccw issue list ISS-20260227-001
-
-# List all with status filter
-ccw issue list --status planned,queued
-ccw issue list --brief  # JSON minimal output
-
-# Queue operations (wave-based execution)
-ccw issue queue list              # List all queues
-ccw issue queue dag               # Get dependency graph (JSON)
-ccw issue next --queue <queue-id> # Get next task
-
-# Execute
-ccw issue queue add <issue-id>    # Add to active queue
-ccw issue done <item-id>          # Mark completed
-```
-
-> **Note**: Issues are tagged with `wave-N` in `tags[]` field for filtering. Use `--brief` for programmatic parsing.
-
-### Consumers
-
-| Consumer | Usage |
-|----------|-------|
-| `team-planex` | Load by ID or tag, execute in wave order |
-| `issue-manage` | CRUD operations on issues |
-| `issue:execute` | DAG-based parallel execution |
-| `issue:queue` | Form execution queue from solutions |
-
-## Implementation
-
-### Session Initialization
-
-```javascript
-const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
-
-// Parse flags
-const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
-const continueMode = $ARGUMENTS.includes('--continue') || $ARGUMENTS.includes('-c')
-const modeMatch = $ARGUMENTS.match(/(?:--mode|-m)\s+(progressive|direct|auto)/)
-const requestedMode = modeMatch ? modeMatch[1] : 'auto'
-
-// Clean requirement text
-const requirement = $ARGUMENTS
-  .replace(/--yes|-y|--continue|-c|--mode\s+\w+|-m\s+\w+/g, '')
-  .trim()
-
-const slug = requirement.toLowerCase()
-  .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-')
-  .substring(0, 40)
-const dateStr = getUtc8ISOString().substring(0, 10)
-const sessionId = `RMAP-${slug}-${dateStr}`
-const sessionFolder = `.workflow/.roadmap/${sessionId}`
-
-// Auto-detect continue
-if (continueMode || file_exists(`${sessionFolder}/roadmap.md`)) {
-  // Resume existing session
-}
-Bash(`mkdir -p ${sessionFolder}`)
-```
-
-### Phase 1: Requirement Understanding & Strategy
-
-**Objective**: Parse requirement, assess uncertainty, select decomposition strategy, initialize roadmap.md.
-
-**Steps**:
-
-1. **Parse Requirement**
-   - Extract: goal, constraints, stakeholders, keywords
-
-2. **Assess Uncertainty**
-   ```javascript
-   const uncertaintyFactors = {
-     scope_clarity: 'low|medium|high',
-     technical_risk: 'low|medium|high',
-     dependency_unknown: 'low|medium|high',
-     domain_familiarity: 'low|medium|high',
-     requirement_stability: 'low|medium|high'
-   }
-   // ≥3 high → progressive, ≥3 low → direct, else → ask
-   ```
-
-3. **Strategy Selection** (skip if `-m` specified or autoYes)
-   ```javascript
-   AskUserQuestion({
-     questions: [{
-       question: `Decomposition strategy:\nUncertainty: ${uncertaintyLevel}\nRecommended: ${recommendedMode}`,
-       header: "Strategy",
-       multiSelect: false,
-       options: [
-         { label: recommendedMode === 'progressive' ? "Progressive (Recommended)" : "Progressive",
-           description: "MVP→iterations, validate core first" },
-         { label: recommendedMode === 'direct' ? "Direct (Recommended)" : "Direct",
-           description: "Topological task sequence, clear dependencies" }
-       ]
-     }]
-   })
-   ```
-
-4. **Initialize roadmap.md** with Strategy Assessment section
-
-**Success Criteria**:
-- roadmap.md created with Strategy Assessment
-- Strategy selected (progressive or direct)
-- Uncertainty factors documented
-
-### Phase 2: Decomposition & Issue Creation
-
-**Objective**: Execute decomposition via `cli-roadmap-plan-agent`, create issues, update roadmap.md.
-
-**Agent**: `cli-roadmap-plan-agent`
-
-**Agent Tasks**:
-1. Analyze requirement with strategy context
-2. Execute CLI-assisted decomposition (Gemini → Qwen fallback)
-3. Create issues via `ccw issue create`
-4. Generate roadmap table with Issue ID references
-5. Update roadmap.md
-
-**Agent Prompt Template**:
-```javascript
-Agent({
-  subagent_type: "cli-roadmap-plan-agent",
-  run_in_background: false,
-  description: `Roadmap decomposition: ${slug}`,
-  prompt: `
-## Roadmap Decomposition Agent
-
-### Input Context
-- **Requirement**: ${requirement}
-- **Strategy**: ${selectedMode}
-- **Session**: ${sessionId}
-- **Folder**: ${sessionFolder}
-
-### Mode-Specific Requirements
-
-${selectedMode === 'progressive' ? `**Progressive Mode**:
-- 2-4 layers: MVP / Usable / Refined / Optimized
-- Each layer: goal, scope, excludes, convergence, risks, effort
-- L0 (MVP) must be self-contained, no dependencies
-- Scope: each feature in exactly ONE layer (no overlap)` :
-
-`**Direct Mode**:
-- Topologically-sorted task sequence
-- Each task: title, type, scope, inputs, outputs, convergence, depends_on
-- Inputs from preceding outputs or existing resources
-- parallel_group for truly independent tasks`}
-
-### Convergence Quality Requirements
-- criteria[]: MUST be testable
-- verification: MUST be executable
-- definition_of_done: MUST use business language
-
-### Output
-1. **${sessionFolder}/roadmap.md** - Update with Roadmap table + Convergence sections
-2. **Append to .workflow/issues/issues.jsonl** via ccw issue create
-
-### CLI Configuration
-- Primary: gemini, Fallback: qwen, Timeout: 60000ms
-`
-})
-```
-
-**Success Criteria**:
-- Issues created in `.workflow/issues/issues.jsonl`
-- roadmap.md updated with Issue references
-- No circular dependencies
-- Convergence criteria testable
-
-### Phase 3: Iterative Refinement
-
-**Objective**: Multi-round user feedback to refine roadmap.
-
-**Workflow Steps**:
-
-1. **Present Roadmap**
-   - Display Roadmap table + key Convergence criteria
-   - Show issue count and wave breakdown
-
-2. **Gather Feedback** (skip if autoYes)
-   ```javascript
-   const feedback = AskUserQuestion({
-     questions: [{
-       question: `Roadmap validation (round ${round}):\n${issueCount} issues across ${waveCount} waves. Feedback?`,
-       header: "Feedback",
-       multiSelect: false,
-       options: [
-         { label: "Approve", description: "Proceed to handoff" },
-         { label: "Adjust Scope", description: "Modify issue scopes" },
-         { label: "Modify Convergence", description: "Refine criteria/verification" },
-         { label: "Re-decompose", description: "Change strategy/layering" }
-       ]
-     }]
-   })
-   ```
-
-3. **Process Feedback**
-   - **Approve**: Exit loop, proceed to Phase 4
-   - **Adjust Scope**: Modify issue context, update roadmap.md
-   - **Modify Convergence**: Refine criteria/verification, update roadmap.md
-   - **Re-decompose**: Return to Phase 2 with new strategy
-
-4. **Update roadmap.md**
-   - Append to Iteration History section
-   - Update Roadmap table if changed
-   - Increment round counter
-
-5. **Loop** (max 5 rounds, then force proceed)
-
-**Success Criteria**:
-- User approved OR max rounds reached
-- All changes recorded in Iteration History
-- roadmap.md reflects final state
-
-### Phase 4: Handoff
-
-**Objective**: Present final roadmap, offer execution options.
-
-**Steps**:
-
-1. **Display Summary**
-   ```markdown
-   ## Roadmap Complete
-
-   - **Session**: RMAP-{slug}-{date}
-   - **Strategy**: {progressive|direct}
-   - **Issues Created**: {count} across {waves} waves
-   - **Roadmap**: .workflow/.roadmap/RMAP-{slug}-{date}/roadmap.md
-
-   | Wave | Issue Count | Layer/Type |
-   |------|-------------|------------|
-   | 1 | 2 | MVP / infrastructure |
-   | 2 | 3 | Usable / feature |
-   ```
-
-2. **Offer Options** (skip if autoYes)
-   ```javascript
-   AskUserQuestion({
-     questions: [{
-       question: `${issueIds.length} issues ready. Next step:`,
-       header: "Next Step",
-       multiSelect: false,
-       options: [
-         { label: "Execute with team-planex (Recommended)",
-           description: `Run all ${issueIds.length} issues via team-planex` },
-         { label: "Execute first wave",
-           description: "Run wave-1 issues only" },
-         { label: "View issues",
-           description: "Display issue details from issues.jsonl" },
-         { label: "Done",
-           description: "Save and exit, execute later" }
-       ]
-     }]
-   })
-   ```
-
-3. **Execute Selection**
-   | Selection | Action |
-   |-----------|--------|
-   | Execute with team-planex | `Skill(skill="team-planex", args="${issueIds.join(' ')}")` |
-   | Execute first wave | Filter by `wave-1` tag, pass to team-planex |
-   | View issues | Display from `.workflow/issues/issues.jsonl` |
-   | Done | Output paths, end |
-
-## Configuration
-
-| Flag | Default | Description |
-|------|---------|-------------|
-| `-y, --yes` | false | Auto-confirm all decisions |
-| `-c, --continue` | false | Continue existing session |
-| `-m, --mode` | auto | Strategy: progressive / direct / auto |
-
-**Session ID format**: `RMAP-{slug}-{YYYY-MM-DD}`
-
-## Error Handling
-
-| Error | Resolution |
-|-------|------------|
-| cli-roadmap-plan-agent fails | Retry once, fallback to manual decomposition |
-| No codebase | Skip exploration, pure requirement decomposition |
-| Circular dependency detected | Prompt user, re-decompose |
-| User feedback timeout | Save roadmap.md, show `--continue` command |
-| Max rounds reached | Force proceed with current roadmap |
-| Session folder conflict | Append timestamp suffix |
-
-## Best Practices
-
-1. **Clear Requirements**: Detailed description → better decomposition
-2. **Iterate on Roadmap**: Use feedback rounds to refine convergence criteria
-3. **Testable Convergence**: criteria = assertions, DoD = business language
-4. **Use Continue Mode**: Resume to iterate on existing roadmap
-5. **Wave Execution**: Start with wave-1 (MVP) to validate before full execution
-
-## Usage Recommendations
-
-**When to Use Roadmap vs Other Commands:**
-
-| Scenario | Recommended Command |
-|----------|-------------------|
-| Strategic planning, need issue tracking | `/workflow:roadmap-with-file` |
-| Quick task breakdown, immediate execution | `/workflow-lite-plan` |
-| Collaborative multi-agent planning | `/workflow:collaborative-plan-with-file` |
-| Full specification documents | `spec-generator` skill |
-| Code implementation from existing plan | `/workflow-lite-plan` (Phase 1: plan → Phase 2: execute) |
-
----
-
-**Now execute roadmap-with-file for**: $ARGUMENTS

.claude/commands/workflow/session/complete.md

@@ -109,16 +109,79 @@ rm -f .workflow/archives/$SESSION_ID/.archiving
   Manifest: Updated with N total sessions
 ```
 
-### Phase 4: Auto-Sync Project State
+### Phase 4: Update project-tech.json (Optional)
 
-Execute `/workflow:session:sync -y "{description}"` to update both `specs/*.md` and `project-tech.json` from session context.
+**Skip if**: `.workflow/project-tech.json` doesn't exist
 
-Description 取自 Phase 2 的 `workflow-session.json` description 字段。
+```bash
+# Check
+test -f .workflow/project-tech.json || echo "SKIP"
+```
+
+**If exists**, add feature entry:
+
+```json
+{
+  "id": "<slugified title>",
+  "title": "<from IMPL_PLAN.md>",
+  "status": "completed",
+  "tags": ["<from Phase 2>"],
+  "timeline": { "implemented_at": "<date>" },
+  "traceability": { "session_id": "<SESSION_ID>", "archive_path": "<path>" }
+}
+```
+
+**Output**:
+```
+✓ Feature added to project registry
+```
+
+### Phase 5: Ask About Solidify (Always)
+
+After successful archival, prompt user to capture learnings:
+
+```javascript
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+if (autoYes) {
+  // Auto mode: Skip solidify
+  console.log(`[--yes] Auto-selecting: Skip solidify`)
+  console.log(`Session archived successfully.`)
+  // Done - no solidify
+} else {
+  // Interactive mode: Ask user
+  AskUserQuestion({
+    questions: [{
+      question: "Would you like to solidify learnings from this session into project guidelines?",
+      header: "Solidify",
+      options: [
+        { label: "Yes, solidify now", description: "Extract learnings and update project-guidelines.json" },
+        { label: "Skip", description: "Archive complete, no learnings to capture" }
+      ],
+      multiSelect: false
+    }]
+  })
+
+  // **If "Yes, solidify now"**: Execute `/workflow:session:solidify` with the archived session ID.
+}
+```
 
 ## Auto Mode Defaults
 
 When `--yes` or `-y` flag is used:
-- **Sync**: Auto-executed with `-y` (no confirmation)
+- **Solidify Learnings**: Auto-selected "Skip" (archive only, no solidify)
+
+**Flag Parsing**:
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+```
+
+**Output**:
+```
+Session archived successfully.
+→ Run /workflow:session:solidify to capture learnings (recommended)
+```
 
 ## Error Recovery
 
@@ -135,5 +198,6 @@ When `--yes` or `-y` flag is used:
 Phase 1: find session → create .archiving marker
 Phase 2: read key files → build manifest entry (no writes)
 Phase 3: mkdir → mv → update manifest.json → rm marker
-Phase 4: /workflow:session:sync -y → update specs/*.md + project-tech
+Phase 4: update project-tech.json features array (optional)
+Phase 5: ask user → solidify learnings (optional)
 ```

.claude/commands/workflow/session/resume.md

@@ -57,5 +57,5 @@ Session WFS-user-auth resumed
 - Status: active
 - Paused at: 2025-09-15T14:30:00Z
 - Resumed at: 2025-09-15T15:45:00Z
-- Ready for: /workflow-execute
+- Ready for: /workflow:execute
 ```

.claude/commands/workflow/session/solidify.md

@@ -0,0 +1,465 @@
+---
+name: solidify
+description: Crystallize session learnings and user-defined constraints into permanent project guidelines, or compress recent memories
+argument-hint: "[-y|--yes] [--type <convention|constraint|learning|compress>] [--category <category>] [--limit <N>] \"rule or insight\""
+examples:
+  - /workflow:session:solidify "Use functional components for all React code" --type convention
+  - /workflow:session:solidify -y "No direct DB access from controllers" --type constraint --category architecture
+  - /workflow:session:solidify "Cache invalidation requires event sourcing" --type learning --category architecture
+  - /workflow:session:solidify --interactive
+  - /workflow:session:solidify --type compress --limit 10
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-categorize and add guideline without confirmation.
+
+# Session Solidify Command (/workflow:session:solidify)
+
+## Overview
+
+Crystallizes ephemeral session context (insights, decisions, constraints) into permanent project guidelines stored in `.workflow/project-guidelines.json`. This ensures valuable learnings persist across sessions and inform future planning.
+
+## Use Cases
+
+1. **During Session**: Capture important decisions as they're made
+2. **After Session**: Reflect on lessons learned before archiving
+3. **Proactive**: Add team conventions or architectural rules
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `rule` | string | Yes (unless --interactive or --type compress) | The rule, convention, or insight to solidify |
+| `--type` | enum | No | Type: `convention`, `constraint`, `learning`, `compress` (default: auto-detect) |
+| `--category` | string | No | Category for organization (see categories below) |
+| `--interactive` | flag | No | Launch guided wizard for adding rules |
+| `--limit` | number | No | Number of recent memories to compress (default: 20, only for --type compress) |
+
+### Type Categories
+
+**convention** → Coding style preferences (goes to `conventions` section)
+- Subcategories: `coding_style`, `naming_patterns`, `file_structure`, `documentation`
+
+**constraint** → Hard rules that must not be violated (goes to `constraints` section)
+- Subcategories: `architecture`, `tech_stack`, `performance`, `security`
+
+**learning** -> Session-specific insights (goes to `learnings` array)
+- Subcategories: `architecture`, `performance`, `security`, `testing`, `process`, `other`
+
+**compress** -> Compress/deduplicate recent memories into a single consolidated CMEM
+- No subcategories (operates on core memories, not project guidelines)
+- Fetches recent non-archived memories, LLM-compresses them, creates a new CMEM
+- Source memories are archived after successful compression
+
+## Execution Process
+
+```
+Input Parsing:
+   |- Parse: rule text (required unless --interactive or --type compress)
+   |- Parse: --type (convention|constraint|learning|compress)
+   |- Parse: --category (subcategory)
+   |- Parse: --interactive (flag)
+   +- Parse: --limit (number, default 20, compress only)
+
+IF --type compress:
+   Step C1: Fetch Recent Memories
+      +- Call getRecentMemories(limit, excludeArchived=true)
+
+   Step C2: Validate Candidates
+      +- If fewer than 2 memories found -> abort with message
+
+   Step C3: LLM Compress
+      +- Build compression prompt with all memory contents
+      +- Send to LLM for consolidation
+      +- Receive compressed text
+
+   Step C4: Merge Tags
+      +- Collect tags from all source memories
+      +- Deduplicate into a single merged tag array
+
+   Step C5: Create Compressed CMEM
+      +- Generate new CMEM via upsertMemory with:
+         - content: compressed text from LLM
+         - summary: auto-generated
+         - tags: merged deduplicated tags
+         - metadata: buildCompressionMetadata(sourceIds, originalSize, compressedSize)
+
+   Step C6: Archive Source Memories
+      +- Call archiveMemories(sourceIds)
+
+   Step C7: Display Compression Report
+      +- Show source count, compression ratio, new CMEM ID
+
+ELSE (convention/constraint/learning):
+   Step 1: Ensure Guidelines File Exists
+      +- If not exists -> Create with empty structure
+
+   Step 2: Auto-detect Type (if not specified)
+      +- Analyze rule text for keywords
+
+   Step 3: Validate and Format Entry
+      +- Build entry object based on type
+
+   Step 4: Update Guidelines File
+      +- Add entry to appropriate section
+
+   Step 5: Display Confirmation
+      +- Show what was added and where
+```
+
+## Implementation
+
+### Step 1: Ensure Guidelines File Exists
+
+```bash
+bash(test -f .workflow/project-guidelines.json && echo "EXISTS" || echo "NOT_FOUND")
+```
+
+**If NOT_FOUND**, create scaffold:
+
+```javascript
+const scaffold = {
+  conventions: {
+    coding_style: [],
+    naming_patterns: [],
+    file_structure: [],
+    documentation: []
+  },
+  constraints: {
+    architecture: [],
+    tech_stack: [],
+    performance: [],
+    security: []
+  },
+  quality_rules: [],
+  learnings: [],
+  _metadata: {
+    created_at: new Date().toISOString(),
+    version: "1.0.0"
+  }
+};
+
+Write('.workflow/project-guidelines.json', JSON.stringify(scaffold, null, 2));
+```
+
+### Step 2: Auto-detect Type (if not specified)
+
+```javascript
+function detectType(ruleText) {
+  const text = ruleText.toLowerCase();
+
+  // Constraint indicators
+  if (/\b(no|never|must not|forbidden|prohibited|always must)\b/.test(text)) {
+    return 'constraint';
+  }
+
+  // Learning indicators
+  if (/\b(learned|discovered|realized|found that|turns out)\b/.test(text)) {
+    return 'learning';
+  }
+
+  // Default to convention
+  return 'convention';
+}
+
+function detectCategory(ruleText, type) {
+  const text = ruleText.toLowerCase();
+
+  if (type === 'constraint' || type === 'learning') {
+    if (/\b(architecture|layer|module|dependency|circular)\b/.test(text)) return 'architecture';
+    if (/\b(security|auth|permission|sanitize|xss|sql)\b/.test(text)) return 'security';
+    if (/\b(performance|cache|lazy|async|sync|slow)\b/.test(text)) return 'performance';
+    if (/\b(test|coverage|mock|stub)\b/.test(text)) return 'testing';
+  }
+
+  if (type === 'convention') {
+    if (/\b(name|naming|prefix|suffix|camel|pascal)\b/.test(text)) return 'naming_patterns';
+    if (/\b(file|folder|directory|structure|organize)\b/.test(text)) return 'file_structure';
+    if (/\b(doc|comment|jsdoc|readme)\b/.test(text)) return 'documentation';
+    return 'coding_style';
+  }
+
+  return type === 'constraint' ? 'tech_stack' : 'other';
+}
+```
+
+### Step 3: Build Entry
+
+```javascript
+function buildEntry(rule, type, category, sessionId) {
+  if (type === 'learning') {
+    return {
+      date: new Date().toISOString().split('T')[0],
+      session_id: sessionId || null,
+      insight: rule,
+      category: category,
+      context: null
+    };
+  }
+
+  // For conventions and constraints, just return the rule string
+  return rule;
+}
+```
+
+### Step 4: Update Guidelines File
+
+```javascript
+const guidelines = JSON.parse(Read('.workflow/project-guidelines.json'));
+
+if (type === 'convention') {
+  if (!guidelines.conventions[category]) {
+    guidelines.conventions[category] = [];
+  }
+  if (!guidelines.conventions[category].includes(rule)) {
+    guidelines.conventions[category].push(rule);
+  }
+} else if (type === 'constraint') {
+  if (!guidelines.constraints[category]) {
+    guidelines.constraints[category] = [];
+  }
+  if (!guidelines.constraints[category].includes(rule)) {
+    guidelines.constraints[category].push(rule);
+  }
+} else if (type === 'learning') {
+  guidelines.learnings.push(buildEntry(rule, type, category, sessionId));
+}
+
+guidelines._metadata.updated_at = new Date().toISOString();
+guidelines._metadata.last_solidified_by = sessionId;
+
+Write('.workflow/project-guidelines.json', JSON.stringify(guidelines, null, 2));
+```
+
+### Step 5: Display Confirmation
+
+```
+Guideline solidified
+
+Type: ${type}
+Category: ${category}
+Rule: "${rule}"
+
+Location: .workflow/project-guidelines.json -> ${type}s.${category}
+
+Total ${type}s in ${category}: ${count}
+```
+
+## Compress Mode (--type compress)
+
+When `--type compress` is specified, the command operates on core memories instead of project guidelines. It fetches recent memories, sends them to an LLM for consolidation, and creates a new compressed CMEM.
+
+### Step C1: Fetch Recent Memories
+
+```javascript
+// Uses CoreMemoryStore.getRecentMemories()
+const limit = parsedArgs.limit || 20;
+const recentMemories = store.getRecentMemories(limit, /* excludeArchived */ true);
+
+if (recentMemories.length < 2) {
+  console.log("Not enough non-archived memories to compress (need at least 2).");
+  return;
+}
+```
+
+### Step C2: Build Compression Prompt
+
+Concatenate all memory contents and send to LLM with the following prompt:
+
+```
+Given these ${N} memories, produce a single consolidated memory that:
+1. Preserves all key information and insights
+2. Removes redundancy and duplicate concepts
+3. Organizes content by theme/topic
+4. Maintains specific technical details and decisions
+
+Source memories:
+---
+[Memory CMEM-XXXXXXXX-XXXXXX]:
+${memory.content}
+---
+[Memory CMEM-XXXXXXXX-XXXXXX]:
+${memory.content}
+---
+...
+
+Output: A single comprehensive memory text.
+```
+
+### Step C3: Merge Tags from Source Memories
+
+```javascript
+// Collect all tags from source memories and deduplicate
+const allTags = new Set();
+for (const memory of recentMemories) {
+  if (memory.tags) {
+    for (const tag of memory.tags) {
+      allTags.add(tag);
+    }
+  }
+}
+const mergedTags = Array.from(allTags);
+```
+
+### Step C4: Create Compressed CMEM
+
+```javascript
+const sourceIds = recentMemories.map(m => m.id);
+const originalSize = recentMemories.reduce((sum, m) => sum + m.content.length, 0);
+const compressedSize = compressedText.length;
+
+const metadata = store.buildCompressionMetadata(sourceIds, originalSize, compressedSize);
+
+const newMemory = store.upsertMemory({
+  content: compressedText,
+  summary: `Compressed from ${sourceIds.length} memories`,
+  tags: mergedTags,
+  metadata: metadata
+});
+```
+
+### Step C5: Archive Source Memories
+
+```javascript
+// Archive all source memories after successful compression
+store.archiveMemories(sourceIds);
+```
+
+### Step C6: Display Compression Report
+
+```
+Memory compression complete
+
+New CMEM: ${newMemory.id}
+Sources compressed: ${sourceIds.length}
+Original size: ${originalSize} chars
+Compressed size: ${compressedSize} chars
+Compression ratio: ${(compressedSize / originalSize * 100).toFixed(1)}%
+Tags merged: ${mergedTags.join(', ') || '(none)'}
+Source memories archived: ${sourceIds.join(', ')}
+```
+
+### Compressed CMEM Metadata Format
+
+The compressed CMEM's `metadata` field contains a JSON string with:
+
+```json
+{
+  "compressed_from": ["CMEM-20260101-120000", "CMEM-20260102-140000", "..."],
+  "compression_ratio": 0.45,
+  "compressed_at": "2026-02-23T10:30:00.000Z"
+}
+```
+
+- `compressed_from`: Array of source memory IDs that were consolidated
+- `compression_ratio`: Ratio of compressed size to original size (lower = more compression)
+- `compressed_at`: ISO timestamp of when the compression occurred
+
+## Interactive Mode
+
+When `--interactive` flag is provided:
+
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: "What type of guideline are you adding?",
+      header: "Type",
+      multiSelect: false,
+      options: [
+        { label: "Convention", description: "Coding style preference (e.g., use functional components)" },
+        { label: "Constraint", description: "Hard rule that must not be violated (e.g., no direct DB access)" },
+        { label: "Learning", description: "Insight from this session (e.g., cache invalidation needs events)" }
+      ]
+    }
+  ]
+});
+
+// Follow-up based on type selection...
+```
+
+## Examples
+
+### Add a Convention
+```bash
+/workflow:session:solidify "Use async/await instead of callbacks" --type convention --category coding_style
+```
+
+Result in `project-guidelines.json`:
+```json
+{
+  "conventions": {
+    "coding_style": ["Use async/await instead of callbacks"]
+  }
+}
+```
+
+### Add an Architectural Constraint
+```bash
+/workflow:session:solidify "No direct DB access from controllers" --type constraint --category architecture
+```
+
+Result:
+```json
+{
+  "constraints": {
+    "architecture": ["No direct DB access from controllers"]
+  }
+}
+```
+
+### Capture a Session Learning
+```bash
+/workflow:session:solidify "Cache invalidation requires event sourcing for consistency" --type learning
+```
+
+Result:
+```json
+{
+  "learnings": [
+    {
+      "date": "2024-12-28",
+      "session_id": "WFS-auth-feature",
+      "insight": "Cache invalidation requires event sourcing for consistency",
+      "category": "architecture"
+    }
+  ]
+}
+```
+
+### Compress Recent Memories
+```bash
+/workflow:session:solidify --type compress --limit 10
+```
+
+Result: Creates a new CMEM with consolidated content from the 10 most recent non-archived memories. Source memories are archived. The new CMEM's metadata tracks which memories were compressed:
+```json
+{
+  "compressed_from": ["CMEM-20260220-100000", "CMEM-20260221-143000", "..."],
+  "compression_ratio": 0.42,
+  "compressed_at": "2026-02-23T10:30:00.000Z"
+}
+```
+
+## Integration with Planning
+
+The `project-guidelines.json` is consumed by:
+
+1. **`workflow-plan` skill (context-gather phase)**: Loads guidelines into context-package.json
+2. **`workflow-plan` skill**: Passes guidelines to task generation agent
+3. **`task-generate-agent`**: Includes guidelines as "CRITICAL CONSTRAINTS" in system prompt
+
+This ensures all future planning respects solidified rules without users needing to re-state them.
+
+## Error Handling
+
+- **Duplicate Rule**: Warn and skip if exact rule already exists
+- **Invalid Category**: Suggest valid categories for the type
+- **File Corruption**: Backup existing file before modification
+
+## Related Commands
+
+- `/workflow:session:start` - Start a session (may prompt for solidify at end)
+- `/workflow:session:complete` - Complete session (prompts for learnings to solidify)
+- `/workflow:init` - Creates project-guidelines.json scaffold if missing

.claude/commands/workflow/session/start.md

@@ -27,7 +27,7 @@ The `--type` parameter classifies sessions for CCW dashboard organization:
 |------|-------------|-------------|
 | `workflow` | Standard implementation (default) | `workflow-plan` skill |
 | `review` | Code review sessions | `review-cycle` skill |
-| `tdd` | TDD-based development | `workflow-tdd-plan` skill |
+| `tdd` | TDD-based development | `workflow-tdd` skill |
 | `test` | Test generation/fix sessions | `workflow-test-fix` skill |
 | `docs` | Documentation sessions | `memory-manage` skill |
 
@@ -38,31 +38,31 @@ ERROR: Invalid session type. Valid types: workflow, review, tdd, test, docs
 
 ## Step 0: Initialize Project State (First-time Only)
 
-**Executed before all modes** - Ensures project-level state files exist by calling `/workflow:spec:setup`.
+**Executed before all modes** - Ensures project-level state files exist by calling `/workflow:init`.
 
 ### Check and Initialize
 ```bash
 # Check if project state exists (both files required)
 bash(test -f .workflow/project-tech.json && echo "TECH_EXISTS" || echo "TECH_NOT_FOUND")
-bash(test -f .ccw/specs/*.md && echo "GUIDELINES_EXISTS" || echo "GUIDELINES_NOT_FOUND")
+bash(test -f .workflow/project-guidelines.json && echo "GUIDELINES_EXISTS" || echo "GUIDELINES_NOT_FOUND")
 ```
 
-**If either NOT_FOUND**, delegate to `/workflow:spec:setup`:
+**If either NOT_FOUND**, delegate to `/workflow:init`:
 ```javascript
-// Call workflow:spec:setup for intelligent project analysis
-Skill(skill="workflow:spec:setup");
+// Call workflow:init for intelligent project analysis
+Skill(skill="workflow:init");
 
 // Wait for init completion
-// project-tech.json and specs/*.md will be created
+// project-tech.json and project-guidelines.json will be created
 ```
 
 **Output**:
 - If BOTH_EXIST: `PROJECT_STATE: initialized`
-- If NOT_FOUND: Calls `/workflow:spec:setup` → creates:
+- If NOT_FOUND: Calls `/workflow:init` → creates:
   - `.workflow/project-tech.json` with full technical analysis
-  - `.ccw/specs/*.md` with empty scaffold
+  - `.workflow/project-guidelines.json` with empty scaffold
 
-**Note**: `/workflow:spec:setup` uses cli-explore-agent to build comprehensive project understanding (technology stack, architecture, key components). This step runs once per project. Subsequent executions skip initialization.
+**Note**: `/workflow:init` uses cli-explore-agent to build comprehensive project understanding (technology stack, architecture, key components). This step runs once per project. Subsequent executions skip initialization.
 
 ## Mode 1: Discovery Mode (Default)
 

.claude/commands/workflow/session/sync.md

@@ -1,281 +0,0 @@
----
-name: sync
-description: Quick-sync session work to specs/*.md and project-tech
-argument-hint: "[-y|--yes] [\"what was done\"]"
-allowed-tools: Bash(*), Read(*), Write(*), Edit(*)
----
-
-# Session Sync (/workflow:session:sync)
-
-One-shot update `specs/*.md` + `project-tech.json` from current session context.
-
-**Design**: Scan context → extract → write. No interactive wizards.
-
-## Auto Mode
-
-`--yes` or `-y`: Skip confirmation, auto-write both files.
-
-## Process
-
-```
-Step 1: Gather Context
-   ├─ git diff --stat HEAD~3..HEAD (recent changes)
-   ├─ Active session folder (.workflow/.lite-plan/*) if exists
-   └─ User summary ($ARGUMENTS or auto-generate from git log)
-
-Step 2: Extract Updates
-   ├─ Guidelines: conventions / constraints / learnings
-   └─ Tech: development_index entry
-
-Step 3: Preview & Confirm (skip if --yes)
-
-Step 4: Write both files
-
-Step 5: One-line confirmation
-```
-
-## Step 1: Gather Context
-
-```javascript
-const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
-const userSummary = $ARGUMENTS.replace(/--yes|-y/g, '').trim()
-
-// Recent changes
-const gitStat = Bash('git diff --stat HEAD~3..HEAD 2>/dev/null || git diff --stat HEAD 2>/dev/null')
-const gitLog = Bash('git log --oneline -5')
-
-// Active session (optional)
-const sessionFolders = Glob('.workflow/.lite-plan/*/plan.json')
-let sessionContext = null
-if (sessionFolders.length > 0) {
-  const latest = sessionFolders[sessionFolders.length - 1]
-  sessionContext = JSON.parse(Read(latest))
-}
-
-// Build summary
-const summary = userSummary
-  || sessionContext?.summary
-  || gitLog.split('\n')[0].replace(/^[a-f0-9]+ /, '')
-```
-
-## Step 2: Extract Updates
-
-Analyze context and produce two update payloads. Use LLM reasoning (current agent) — no CLI calls.
-
-```javascript
-// ── Guidelines extraction ──
-// Scan git diff + session for:
-//   - Debugging experiences → bug
-//   - Reusable code patterns → pattern
-//   - Architecture/design decisions → decision
-//   - Conventions, constraints, insights → rule
-//
-// Output: array of { type, tag, text }
-//   type: 'bug' | 'pattern' | 'decision' | 'rule'
-//   tag: domain tag (api, routing, schema, security, etc.)
-// RULE: Only extract genuinely reusable insights. Skip trivial/obvious items.
-// RULE: Deduplicate against existing guidelines before adding.
-
-// Load existing specs via ccw spec load
-const existingSpecs = Bash('ccw spec load --dimension specs 2>/dev/null || echo ""')
-const guidelineUpdates = [] // populated by agent analysis
-
-// ── Tech extraction ──
-// Build one development_index entry from session work
-
-function detectCategory(text) {
-  text = text.toLowerCase()
-  if (/\b(fix|bug|error|crash)\b/.test(text)) return 'bugfix'
-  if (/\b(refactor|cleanup|reorganize)\b/.test(text)) return 'refactor'
-  if (/\b(doc|readme|comment)\b/.test(text)) return 'docs'
-  if (/\b(add|new|create|implement)\b/.test(text)) return 'feature'
-  return 'enhancement'
-}
-
-function detectSubFeature(gitStat) {
-  // Most-changed directory from git diff --stat
-  const dirs = gitStat.match(/\S+\//g) || []
-  const counts = {}
-  dirs.forEach(d => {
-    const seg = d.split('/').filter(Boolean).slice(-2, -1)[0] || 'general'
-    counts[seg] = (counts[seg] || 0) + 1
-  })
-  return Object.entries(counts).sort((a, b) => b[1] - a[1])[0]?.[0] || 'general'
-}
-
-const techEntry = {
-  title: summary.slice(0, 60),
-  sub_feature: detectSubFeature(gitStat),
-  date: new Date().toISOString().split('T')[0],
-  description: summary.slice(0, 100),
-  status: 'completed',
-  session_id: sessionContext ? sessionFolders[sessionFolders.length - 1].match(/lite-plan\/([^/]+)/)?.[1] : null
-}
-```
-
-## Step 3: Preview & Confirm
-
-```javascript
-// Show preview
-console.log(`
-── Sync Preview ──
-
-Guidelines (${guidelineUpdates.length} items):
-${guidelineUpdates.map(g => `  [${g.type}:${g.tag}] ${g.text}`).join('\n') || '  (none)'}
-
-Tech [${detectCategory(summary)}]:
-  ${techEntry.title}
-
-Target files:
-  .ccw/specs/*.md
-  .workflow/project-tech.json
-`)
-
-if (!autoYes) {
-  const confirm = AskUserQuestion("Apply these updates? (modify/skip items if needed)")
-  // User can say "skip guidelines" or "change category to bugfix" etc.
-}
-```
-
-## Step 4: Write
-
-```javascript
-const matter = require('gray-matter')  // YAML frontmatter parser
-
-// ── Frontmatter check & repair helper ──
-// Ensures target spec file has valid YAML frontmatter with keywords
-// Uses gray-matter for robust parsing (handles malformed frontmatter, missing fields)
-function ensureFrontmatter(filePath, tag, type) {
-  const titleMap = {
-    'coding-conventions': 'Coding Conventions',
-    'architecture-constraints': 'Architecture Constraints',
-    'learnings': 'Learnings',
-    'quality-rules': 'Quality Rules'
-  }
-  const basename = filePath.split('/').pop().replace('.md', '')
-  const title = titleMap[basename] || basename
-  const defaultFm = {
-    title,
-    readMode: 'optional',
-    priority: 'medium',
-    scope: 'project',
-    dimension: 'specs',
-    keywords: [tag, type]
-  }
-
-  if (!file_exists(filePath)) {
-    // Case A: Create new file with frontmatter
-    Write(filePath, matter.stringify(`\n# ${title}\n\n`, defaultFm))
-    return
-  }
-
-  const raw = Read(filePath)
-  let parsed
-  try {
-    parsed = matter(raw)
-  } catch {
-    parsed = { data: {}, content: raw }
-  }
-
-  const hasFrontmatter = raw.trimStart().startsWith('---')
-
-  if (!hasFrontmatter) {
-    // Case B: File exists but no frontmatter → prepend
-    Write(filePath, matter.stringify(raw, defaultFm))
-    return
-  }
-
-  // Case C: Frontmatter exists → ensure keywords include current tag
-  const existingKeywords = parsed.data.keywords || []
-  const newKeywords = [...new Set([...existingKeywords, tag, type])]
-
-  if (newKeywords.length !== existingKeywords.length) {
-    parsed.data.keywords = newKeywords
-    Write(filePath, matter.stringify(parsed.content, parsed.data))
-  }
-}
-
-// ── Update specs/*.md ──
-// Uses .ccw/specs/ directory - unified [type:tag] entry format
-if (guidelineUpdates.length > 0) {
-  // Map knowledge types to spec files
-  const specFileMap = {
-    bug: '.ccw/specs/learnings.md',
-    pattern: '.ccw/specs/coding-conventions.md',
-    decision: '.ccw/specs/architecture-constraints.md',
-    rule: null // determined by content below
-  }
-
-  const date = new Date().toISOString().split('T')[0]
-  const needsDate = { bug: true, pattern: true, decision: true, rule: false }
-
-  for (const g of guidelineUpdates) {
-    // For rule type, route by content and tag
-    let targetFile = specFileMap[g.type]
-    if (!targetFile) {
-      const isQuality = /\b(test|coverage|lint|eslint|质量|测试覆盖|pre-commit|tsc|type.check)\b/i.test(g.text)
-        || ['testing', 'quality', 'lint'].includes(g.tag)
-      const isConstraint = /\b(禁止|no|never|must not|forbidden|不得|不允许)\b/i.test(g.text)
-      if (isQuality) {
-        targetFile = '.ccw/specs/quality-rules.md'
-      } else if (isConstraint) {
-        targetFile = '.ccw/specs/architecture-constraints.md'
-      } else {
-        targetFile = '.ccw/specs/coding-conventions.md'
-      }
-    }
-
-    // Ensure frontmatter exists and keywords are up-to-date
-    ensureFrontmatter(targetFile, g.tag, g.type)
-
-    const existing = Read(targetFile)
-    const entryLine = needsDate[g.type]
-      ? `- [${g.type}:${g.tag}] ${g.text} (${date})`
-      : `- [${g.type}:${g.tag}] ${g.text}`
-
-    // Deduplicate: skip if text already in file
-    if (!existing.includes(g.text)) {
-      const newContent = existing.trimEnd() + '\n' + entryLine + '\n'
-      Write(targetFile, newContent)
-    }
-  }
-
-  // Rebuild spec index after writing
-  Bash('ccw spec rebuild')
-}
-
-// ── Update project-tech.json ──
-const techPath = '.workflow/project-tech.json'
-const tech = JSON.parse(Read(techPath))
-
-if (!tech.development_index) {
-  tech.development_index = { feature: [], enhancement: [], bugfix: [], refactor: [], docs: [] }
-}
-
-const category = detectCategory(summary)
-tech.development_index[category].push(techEntry)
-tech._metadata.last_updated = new Date().toISOString()
-
-Write(techPath, JSON.stringify(tech, null, 2))
-```
-
-## Step 5: Confirm
-
-```
-✓ Synced: ${guidelineUpdates.length} guidelines + 1 tech entry [${category}]
-```
-
-## Error Handling
-
-| Error | Resolution |
-|-------|------------|
-| File missing | Create scaffold (same as spec:setup Step 4) |
-| No git history | Use user summary or session context only |
-| No meaningful updates | Skip guidelines, still add tech entry |
-| Duplicate entry | Skip silently (dedup check in Step 4) |
-
-## Related Commands
-
-- `/workflow:spec:setup` - Initialize project with specs scaffold
-- `/workflow:spec:add` - Add knowledge entries (bug/pattern/decision/rule) with unified [type:tag] format
-- `/workflow:spec:load` - Interactive spec loader with keyword/type/tag filtering

.claude/commands/workflow/spec/add.md

@@ -1,894 +0,0 @@
----
-name: add
-description: Add knowledge entries (bug fixes, code patterns, decisions, rules) to project specs interactively or automatically
-argument-hint: "[-y|--yes] [--type <bug|pattern|decision|rule>] [--tag <tag>] [--dimension <specs|personal>] [--scope <global|project>] [--interactive] \"summary text\""
-examples:
-  - /workflow:spec:add "Use functional components for all React code"
-  - /workflow:spec:add -y "No direct DB access from controllers" --type rule
-  - /workflow:spec:add --type bug --tag api "API 返回 502 Bad Gateway"
-  - /workflow:spec:add --type pattern --tag routing "添加新 API 路由标准流程"
-  - /workflow:spec:add --type decision --tag db "选用 PostgreSQL 作为主数据库"
-  - /workflow:spec:add --interactive
----
-
-## Auto Mode
-
-When `--yes` or `-y`: Auto-categorize and add entry without confirmation.
-
-# Spec Add Command (/workflow:spec:add)
-
-## Overview
-
-Unified command for adding structured knowledge entries one at a time. Supports 4 knowledge types with optional extended fields for complex entries (bug debugging, code patterns, architecture decisions).
-
-**Key Features**:
-- 4 knowledge types: `bug`, `pattern`, `decision`, `rule`
-- Unified entry format: `- [type:tag] summary (date)`
-- Extended fields for complex types (bug/pattern/decision)
-- Interactive wizard with type-specific field prompts
-- Direct CLI mode with auto-detection
-- Backward compatible: `[tag]` = `[rule:tag]` shorthand
-- Auto-confirm mode (`-y`/`--yes`) for scripted usage
-
-## Knowledge Type System
-
-| Type | Purpose | Format | Target File |
-|------|---------|--------|-------------|
-| `bug` | Debugging experience (symptoms → cause → fix) | Extended | `learnings.md` |
-| `pattern` | Reusable code patterns / reference implementations | Extended | `coding-conventions.md` |
-| `decision` | Architecture / design decisions (ADR-lite) | Extended | `architecture-constraints.md` |
-| `rule` | Hard constraints, conventions, general insights | Simple (single line) | By content (conventions / constraints) |
-
-### Extended Fields Per Type
-
-**bug** (core: 原因, 修复 | optional: 症状, 参考):
-```markdown
-- [bug:api] API 返回 502 Bad Gateway (2026-03-06)
-    - 原因: 路由处理器未在 server.ts 路由分发中注册
-    - 修复: 在路由分发逻辑中导入并调用 app.use(newRouter)
-    - 参考: src/server.ts:45
-```
-
-**pattern** (core: 场景, 代码 | optional: 步骤):
-```markdown
-- [pattern:routing] 添加新 API 路由标准流程 (2026-03-06)
-    - 场景: Express 应用新增业务接口
-    - 步骤: 1.创建 routes/xxx.ts → 2.server.ts import → 3.app.use() 挂载
-    - 代码:
-        ```typescript
-        if (pathname.startsWith('/api/xxx')) {
-          if (await handleXxxRoutes(routeContext)) return;
-        }
-        ```
-```
-
-**decision** (core: 决策, 理由 | optional: 背景, 备选, 状态):
-```markdown
-- [decision:db] 选用 PostgreSQL 作为主数据库 (2026-03-01)
-    - 决策: 使用 PostgreSQL 15
-    - 理由: JSONB 支持完善，PostGIS 扩展成熟
-    - 备选: MySQL(JSON弱) / SQLite(不适合并发)
-    - 状态: accepted
-```
-
-**rule** (no extended fields):
-```markdown
-- [rule:security] 禁止在代码中硬编码密钥或密码
-```
-
-### Entry Format Specification
-
-```
-Entry Line:  - [type:tag] 摘要描述 (YYYY-MM-DD)
-Extended:        - key: value
-Code Block:          ```lang
-                     code here
-                     ```
-```
-
-- **`type`**: Required. One of `bug`, `pattern`, `decision`, `rule`
-- **`tag`**: Required. Domain tag (api, routing, schema, react, security, etc.)
-- **`(date)`**: Required for bug/pattern/decision. Optional for rule.
-- **Backward compat**: `- [tag] text` = `- [rule:tag] text`
-
-### Parsing Regex
-
-```javascript
-// Entry line extraction
-/^- \[(\w+):([\w-]+)\] (.*?)(?: \((\d{4}-\d{2}-\d{2})\))?$/
-
-// Extended field extraction (per indented line)
-/^\s{4}-\s([\w-]+):\s?(.*)/
-```
-
-## Use Cases
-
-1. **Bug Fix**: Capture debugging experience immediately after fixing a bug
-2. **Code Pattern**: Record reusable coding patterns discovered during implementation
-3. **Architecture Decision**: Document important technical decisions with rationale
-4. **Rule/Convention**: Add team conventions or hard constraints
-5. **Interactive**: Guided wizard with type-specific field prompts
-
-## Usage
-```bash
-/workflow:spec:add                                                    # Interactive wizard
-/workflow:spec:add --interactive                                       # Explicit interactive wizard
-/workflow:spec:add "Use async/await instead of callbacks"              # Direct mode (auto-detect → rule)
-/workflow:spec:add --type bug --tag api "API 返回 502"                 # Bug with tag
-/workflow:spec:add --type pattern --tag react "带状态函数组件"          # Pattern with tag
-/workflow:spec:add --type decision --tag db "选用 PostgreSQL"          # Decision with tag
-/workflow:spec:add -y "No direct DB access" --type rule --tag arch     # Auto-confirm rule
-/workflow:spec:add --scope global --dimension personal                 # Global personal spec
-```
-
-## Parameters
-
-| Parameter | Type | Required | Default | Description |
-|-----------|------|----------|---------|-------------|
-| `summary` | string | Yes (unless `--interactive`) | - | Summary text for the knowledge entry |
-| `--type` | enum | No | auto-detect | Type: `bug`, `pattern`, `decision`, `rule` |
-| `--tag` | string | No | auto-detect | Domain tag (api, routing, schema, react, security, etc.) |
-| `--dimension` | enum | No | Interactive | `specs` (project) or `personal` |
-| `--scope` | enum | No | `project` | `global` or `project` (only for personal dimension) |
-| `--interactive` | flag | No | - | Launch full guided wizard |
-| `-y` / `--yes` | flag | No | - | Auto-categorize and add without confirmation |
-
-### Legacy Parameter Mapping
-
-For backward compatibility, old parameter values are internally mapped:
-
-| Old Parameter | Old Value | Maps To |
-|---------------|-----------|---------|
-| `--type` | `convention` | `rule` |
-| `--type` | `constraint` | `rule` |
-| `--type` | `learning` | `bug` (if has cause/fix indicators) or `rule` (otherwise) |
-| `--category` | `<value>` | `--tag <value>` |
-
-### Suggested Tags
-
-| Domain | Tags |
-|--------|------|
-| Backend | `api`, `routing`, `db`, `auth`, `middleware` |
-| Frontend | `react`, `ui`, `state`, `css`, `a11y` |
-| Infra | `deploy`, `ci`, `docker`, `perf`, `build` |
-| Quality | `security`, `testing`, `lint`, `typing` |
-| Architecture | `arch`, `schema`, `migration`, `pattern` |
-
-Tags are freeform — any `[\w-]+` value is accepted.
-
-## Execution Process
-
-```
-Input Parsing:
-   |- Parse: summary text (positional argument, optional if --interactive)
-   |- Parse: --type (bug|pattern|decision|rule)
-   |- Parse: --tag (domain tag)
-   |- Parse: --dimension (specs|personal)
-   |- Parse: --scope (global|project)
-   |- Parse: --interactive (flag)
-   +- Parse: -y / --yes (flag)
-
-Step 1: Parse Input (with legacy mapping)
-
-Step 2: Determine Mode
-   |- If --interactive OR no summary text → Full Interactive Wizard (Path A)
-   +- If summary text provided → Direct Mode (Path B)
-
-Path A: Interactive Wizard
-   |- Step A1: Ask dimension (if not specified)
-   |- Step A2: Ask scope (if personal + scope not specified)
-   |- Step A3: Ask type (bug|pattern|decision|rule)
-   |- Step A4: Ask tag (domain tag)
-   |- Step A5: Ask summary (entry text)
-   |- Step A6: Ask extended fields (if bug/pattern/decision)
-   +- Continue to Step 3
-
-Path B: Direct Mode
-   |- Step B1: Auto-detect type (if not specified) using detectType()
-   |- Step B2: Auto-detect tag (if not specified) using detectTag()
-   |- Step B3: Default dimension to 'specs' if not specified
-   +- Continue to Step 3
-
-Step 3: Determine Target File
-   |- bug → .ccw/specs/learnings.md
-   |- pattern → .ccw/specs/coding-conventions.md
-   |- decision → .ccw/specs/architecture-constraints.md
-   |- rule → .ccw/specs/coding-conventions.md or architecture-constraints.md
-   +- personal → ~/.ccw/personal/ or .ccw/personal/
-
-Step 4: Build Entry (entry line + extended fields)
-
-Step 5: Validate and Write
-   |- Ensure target directory and file exist
-   |- Check for duplicates
-   |- Append entry to file
-   +- Run ccw spec rebuild
-
-Step 6: Display Confirmation
-   +- If -y/--yes: Minimal output
-   +- Otherwise: Full confirmation with location details
-```
-
-## Implementation
-
-### Step 1: Parse Input
-
-```javascript
-// Parse arguments
-const args = $ARGUMENTS
-const argsLower = args.toLowerCase()
-
-// Extract flags
-const autoConfirm = argsLower.includes('--yes') || argsLower.includes('-y')
-const isInteractive = argsLower.includes('--interactive')
-
-// Extract named parameters (support both new and legacy names)
-const hasType = argsLower.includes('--type')
-const hasTag = argsLower.includes('--tag') || argsLower.includes('--category')
-const hasDimension = argsLower.includes('--dimension')
-const hasScope = argsLower.includes('--scope')
-
-let type = hasType ? args.match(/--type\s+(\w+)/i)?.[1]?.toLowerCase() : null
-let tag = hasTag ? args.match(/--(?:tag|category)\s+([\w-]+)/i)?.[1]?.toLowerCase() : null
-let dimension = hasDimension ? args.match(/--dimension\s+(\w+)/i)?.[1]?.toLowerCase() : null
-let scope = hasScope ? args.match(/--scope\s+(\w+)/i)?.[1]?.toLowerCase() : null
-
-// Extract summary text (everything before flags, or quoted string)
-let summaryText = args
-  .replace(/--type\s+\w+/gi, '')
-  .replace(/--(?:tag|category)\s+[\w-]+/gi, '')
-  .replace(/--dimension\s+\w+/gi, '')
-  .replace(/--scope\s+\w+/gi, '')
-  .replace(/--interactive/gi, '')
-  .replace(/--yes/gi, '')
-  .replace(/-y\b/gi, '')
-  .replace(/^["']|["']$/g, '')
-  .trim()
-
-// Legacy type mapping
-if (type) {
-  const legacyMap = { 'convention': 'rule', 'constraint': 'rule' }
-  if (legacyMap[type]) {
-    type = legacyMap[type]
-  } else if (type === 'learning') {
-    // Defer to detectType() for finer classification
-    type = null
-  }
-}
-
-// Validate values
-if (scope && !['global', 'project'].includes(scope)) {
-  console.log("Invalid scope. Use 'global' or 'project'.")
-  return
-}
-if (dimension && !['specs', 'personal'].includes(dimension)) {
-  console.log("Invalid dimension. Use 'specs' or 'personal'.")
-  return
-}
-if (type && !['bug', 'pattern', 'decision', 'rule'].includes(type)) {
-  console.log("Invalid type. Use 'bug', 'pattern', 'decision', or 'rule'.")
-  return
-}
-// Tags are freeform [\w-]+, no validation needed
-```
-
-### Step 2: Determine Mode
-
-```javascript
-const useInteractiveWizard = isInteractive || !summaryText
-```
-
-### Path A: Interactive Wizard
-
-**If dimension not specified**:
-```javascript
-if (!dimension) {
-  const dimensionAnswer = AskUserQuestion({
-    questions: [{
-      question: "What type of spec do you want to create?",
-      header: "Dimension",
-      multiSelect: false,
-      options: [
-        {
-          label: "Project Spec",
-          description: "Knowledge entries for this project (stored in .ccw/specs/)"
-        },
-        {
-          label: "Personal Spec",
-          description: "Personal preferences across projects (stored in ~/.ccw/personal/)"
-        }
-      ]
-    }]
-  })
-  dimension = dimensionAnswer.answers["Dimension"] === "Project Spec" ? "specs" : "personal"
-}
-```
-
-**If personal dimension and scope not specified**:
-```javascript
-if (dimension === 'personal' && !scope) {
-  const scopeAnswer = AskUserQuestion({
-    questions: [{
-      question: "Where should this personal spec be stored?",
-      header: "Scope",
-      multiSelect: false,
-      options: [
-        {
-          label: "Global (Recommended)",
-          description: "Apply to ALL projects (~/.ccw/personal/)"
-        },
-        {
-          label: "Project-only",
-          description: "Apply only to this project (.ccw/personal/)"
-        }
-      ]
-    }]
-  })
-  scope = scopeAnswer.answers["Scope"].includes("Global") ? "global" : "project"
-}
-```
-
-**Ask type (if not specified)**:
-```javascript
-if (!type) {
-  const typeAnswer = AskUserQuestion({
-    questions: [{
-      question: "What type of knowledge entry is this?",
-      header: "Type",
-      multiSelect: false,
-      options: [
-        {
-          label: "Bug",
-          description: "Debugging experience: symptoms, root cause, fix (e.g., API 502 caused by...)"
-        },
-        {
-          label: "Pattern",
-          description: "Reusable code pattern or reference implementation (e.g., adding API routes)"
-        },
-        {
-          label: "Decision",
-          description: "Architecture or design decision with rationale (e.g., chose PostgreSQL because...)"
-        },
-        {
-          label: "Rule",
-          description: "Hard constraint, convention, or general insight (e.g., no direct DB access)"
-        }
-      ]
-    }]
-  })
-  const typeLabel = typeAnswer.answers["Type"]
-  type = typeLabel.includes("Bug") ? "bug"
-    : typeLabel.includes("Pattern") ? "pattern"
-    : typeLabel.includes("Decision") ? "decision"
-    : "rule"
-}
-```
-
-**Ask tag (if not specified)**:
-```javascript
-if (!tag) {
-  const tagAnswer = AskUserQuestion({
-    questions: [{
-      question: "What domain does this entry belong to?",
-      header: "Tag",
-      multiSelect: false,
-      options: [
-        { label: "api", description: "API endpoints, HTTP, REST, routing" },
-        { label: "arch", description: "Architecture, design patterns, module structure" },
-        { label: "security", description: "Authentication, authorization, input validation" },
-        { label: "perf", description: "Performance, caching, optimization" }
-      ]
-    }]
-  })
-  tag = tagAnswer.answers["Tag"].toLowerCase().replace(/\s+/g, '-')
-}
-```
-
-**Ask summary (entry text)**:
-```javascript
-if (!summaryText) {
-  const contentAnswer = AskUserQuestion({
-    questions: [{
-      question: "Enter the summary text for this entry:",
-      header: "Summary",
-      multiSelect: false,
-      options: [
-        { label: "Custom text", description: "Type your summary using the 'Other' option below" },
-        { label: "Skip", description: "Cancel adding an entry" }
-      ]
-    }]
-  })
-  if (contentAnswer.answers["Summary"] === "Skip") return
-  summaryText = contentAnswer.answers["Summary"]
-}
-```
-
-**Ask extended fields (if bug/pattern/decision)**:
-```javascript
-let extendedFields = {}
-
-if (type === 'bug') {
-  // Core fields: 原因, 修复
-  const bugAnswer = AskUserQuestion({
-    questions: [
-      {
-        question: "Root cause of the bug (原因):",
-        header: "Cause",
-        multiSelect: false,
-        options: [
-          { label: "Enter cause", description: "Type root cause via 'Other' option" },
-          { label: "Skip", description: "Add later by editing the file" }
-        ]
-      },
-      {
-        question: "How was it fixed (修复):",
-        header: "Fix",
-        multiSelect: false,
-        options: [
-          { label: "Enter fix", description: "Type fix description via 'Other' option" },
-          { label: "Skip", description: "Add later by editing the file" }
-        ]
-      }
-    ]
-  })
-  if (bugAnswer.answers["Cause"] !== "Skip") extendedFields['原因'] = bugAnswer.answers["Cause"]
-  if (bugAnswer.answers["Fix"] !== "Skip") extendedFields['修复'] = bugAnswer.answers["Fix"]
-
-} else if (type === 'pattern') {
-  // Core field: 场景
-  const patternAnswer = AskUserQuestion({
-    questions: [{
-      question: "When should this pattern be used (场景):",
-      header: "UseCase",
-      multiSelect: false,
-      options: [
-        { label: "Enter use case", description: "Type applicable scenario via 'Other' option" },
-        { label: "Skip", description: "Add later by editing the file" }
-      ]
-    }]
-  })
-  if (patternAnswer.answers["UseCase"] !== "Skip") extendedFields['场景'] = patternAnswer.answers["UseCase"]
-
-} else if (type === 'decision') {
-  // Core fields: 决策, 理由
-  const decisionAnswer = AskUserQuestion({
-    questions: [
-      {
-        question: "What was decided (决策):",
-        header: "Decision",
-        multiSelect: false,
-        options: [
-          { label: "Enter decision", description: "Type the decision via 'Other' option" },
-          { label: "Skip", description: "Add later by editing the file" }
-        ]
-      },
-      {
-        question: "Why was this chosen (理由):",
-        header: "Rationale",
-        multiSelect: false,
-        options: [
-          { label: "Enter rationale", description: "Type the reasoning via 'Other' option" },
-          { label: "Skip", description: "Add later by editing the file" }
-        ]
-      }
-    ]
-  })
-  if (decisionAnswer.answers["Decision"] !== "Skip") extendedFields['决策'] = decisionAnswer.answers["Decision"]
-  if (decisionAnswer.answers["Rationale"] !== "Skip") extendedFields['理由'] = decisionAnswer.answers["Rationale"]
-}
-```
-
-### Path B: Direct Mode
-
-**Auto-detect type if not specified**:
-```javascript
-function detectType(text) {
-  const t = text.toLowerCase()
-
-  // Bug indicators
-  if (/\b(bug|fix|错误|报错|502|404|500|crash|失败|异常|undefined|null pointer)\b/.test(t)) {
-    return 'bug'
-  }
-
-  // Pattern indicators
-  if (/\b(pattern|模式|模板|标准流程|how to|步骤|参考)\b/.test(t)) {
-    return 'pattern'
-  }
-
-  // Decision indicators
-  if (/\b(决定|选用|采用|decision|chose|选择|替代|vs|比较)\b/.test(t)) {
-    return 'decision'
-  }
-
-  // Default to rule
-  return 'rule'
-}
-
-function detectTag(text) {
-  const t = text.toLowerCase()
-
-  if (/\b(api|http|rest|endpoint|路由|routing|proxy)\b/.test(t)) return 'api'
-  if (/\b(security|auth|permission|密钥|xss|sql|注入)\b/.test(t)) return 'security'
-  if (/\b(database|db|sql|postgres|mysql|mongo|数据库)\b/.test(t)) return 'db'
-  if (/\b(react|component|hook|组件|jsx|tsx)\b/.test(t)) return 'react'
-  if (/\b(performance|perf|cache|缓存|slow|慢|优化)\b/.test(t)) return 'perf'
-  if (/\b(test|testing|jest|vitest|测试|coverage)\b/.test(t)) return 'testing'
-  if (/\b(architecture|arch|layer|模块|module|依赖)\b/.test(t)) return 'arch'
-  if (/\b(build|webpack|vite|compile|构建|打包)\b/.test(t)) return 'build'
-  if (/\b(deploy|ci|cd|docker|部署)\b/.test(t)) return 'deploy'
-  if (/\b(style|naming|命名|格式|lint|eslint)\b/.test(t)) return 'style'
-  if (/\b(schema|migration|迁移|版本)\b/.test(t)) return 'schema'
-  if (/\b(error|exception|错误处理|异常处理)\b/.test(t)) return 'error'
-  if (/\b(ui|css|layout|样式|界面)\b/.test(t)) return 'ui'
-  if (/\b(file|path|路径|目录|文件)\b/.test(t)) return 'file'
-  if (/\b(doc|comment|文档|注释)\b/.test(t)) return 'doc'
-
-  return 'general'
-}
-
-if (!type) {
-  type = detectType(summaryText)
-}
-if (!tag) {
-  tag = detectTag(summaryText)
-}
-if (!dimension) {
-  dimension = 'specs'  // Default to project specs in direct mode
-}
-```
-
-### Step 3: Ensure Guidelines File Exists
-
-**Uses .ccw/specs/ directory (same as frontend/backend spec-index-builder)**
-
-```bash
-bash(test -f .ccw/specs/coding-conventions.md && echo "EXISTS" || echo "NOT_FOUND")
-```
-
-**If NOT_FOUND**, initialize spec system:
-
-```bash
-Bash('ccw spec init')
-Bash('ccw spec rebuild')
-```
-
-### Step 4: Determine Target File
-
-```javascript
-const path = require('path')
-const os = require('os')
-
-let targetFile
-let targetDir
-
-if (dimension === 'specs') {
-  targetDir = '.ccw/specs'
-
-  if (type === 'bug') {
-    targetFile = path.join(targetDir, 'learnings.md')
-  } else if (type === 'decision') {
-    targetFile = path.join(targetDir, 'architecture-constraints.md')
-  } else if (type === 'pattern') {
-    targetFile = path.join(targetDir, 'coding-conventions.md')
-  } else {
-    // rule: route by content and tag
-    const isConstraint = /\b(禁止|no|never|must not|forbidden|不得|不允许)\b/i.test(summaryText)
-    const isQuality = /\b(test|coverage|lint|eslint|质量|测试覆盖|pre-commit|tsc|type.check)\b/i.test(summaryText)
-      || ['testing', 'quality', 'lint'].includes(tag)
-    if (isQuality) {
-      targetFile = path.join(targetDir, 'quality-rules.md')
-    } else if (isConstraint) {
-      targetFile = path.join(targetDir, 'architecture-constraints.md')
-    } else {
-      targetFile = path.join(targetDir, 'coding-conventions.md')
-    }
-  }
-} else {
-  // Personal specs
-  if (scope === 'global') {
-    targetDir = path.join(os.homedir(), '.ccw', 'personal')
-  } else {
-    targetDir = path.join('.ccw', 'personal')
-  }
-
-  // Type-based filename
-  const fileMap = { bug: 'learnings', pattern: 'conventions', decision: 'constraints', rule: 'conventions' }
-  targetFile = path.join(targetDir, `${fileMap[type]}.md`)
-}
-```
-
-### Step 5: Build Entry
-
-```javascript
-function buildEntry(summary, type, tag, extendedFields) {
-  const date = new Date().toISOString().split('T')[0]
-  const needsDate = ['bug', 'pattern', 'decision'].includes(type)
-
-  // Entry line
-  let entry = `- [${type}:${tag}] ${summary}`
-  if (needsDate) {
-    entry += ` (${date})`
-  }
-
-  // Extended fields (indented with 4 spaces)
-  if (extendedFields && Object.keys(extendedFields).length > 0) {
-    for (const [key, value] of Object.entries(extendedFields)) {
-      entry += `\n    - ${key}: ${value}`
-    }
-  }
-
-  return entry
-}
-```
-
-### Step 6: Write Spec
-
-```javascript
-const fs = require('fs')
-const matter = require('gray-matter')  // YAML frontmatter parser
-
-// Ensure directory exists
-if (!fs.existsSync(targetDir)) {
-  fs.mkdirSync(targetDir, { recursive: true })
-}
-
-// ── Frontmatter check & repair ──
-// Handles 3 cases:
-//   A) File doesn't exist → create with frontmatter
-//   B) File exists but no frontmatter → prepend frontmatter
-//   C) File exists with frontmatter → ensure keywords include current tag
-
-const titleMap = {
-  'coding-conventions': 'Coding Conventions',
-  'architecture-constraints': 'Architecture Constraints',
-  'learnings': 'Learnings',
-  'quality-rules': 'Quality Rules',
-  'conventions': 'Personal Conventions',
-  'constraints': 'Personal Constraints'
-}
-
-function ensureFrontmatter(filePath, dim, sc, t, ty) {
-  const basename = path.basename(filePath, '.md')
-  const title = titleMap[basename] || basename
-
-  if (!fs.existsSync(filePath)) {
-    // Case A: Create new file with frontmatter
-    const content = `---
-title: ${title}
-readMode: optional
-priority: medium
-scope: ${dim === 'personal' ? sc : 'project'}
-dimension: ${dim}
-keywords: [${t}, ${ty}]
----
-
-# ${title}
-
-`
-    fs.writeFileSync(filePath, content, 'utf8')
-    return
-  }
-
-  // File exists — read and check frontmatter
-  const raw = fs.readFileSync(filePath, 'utf8')
-  let parsed
-  try {
-    parsed = matter(raw)
-  } catch {
-    parsed = { data: {}, content: raw }
-  }
-
-  const hasFrontmatter = raw.trimStart().startsWith('---')
-
-  if (!hasFrontmatter) {
-    // Case B: File exists but no frontmatter → prepend
-    const fm = `---
-title: ${title}
-readMode: optional
-priority: medium
-scope: ${dim === 'personal' ? sc : 'project'}
-dimension: ${dim}
-keywords: [${t}, ${ty}]
----
-
-`
-    fs.writeFileSync(filePath, fm + raw, 'utf8')
-    return
-  }
-
-  // Case C: Frontmatter exists → ensure keywords include current tag
-  const existingKeywords = parsed.data.keywords || []
-  const newKeywords = [...new Set([...existingKeywords, t, ty])]
-
-  if (newKeywords.length !== existingKeywords.length) {
-    // Keywords changed — update frontmatter
-    parsed.data.keywords = newKeywords
-    const updated = matter.stringify(parsed.content, parsed.data)
-    fs.writeFileSync(filePath, updated, 'utf8')
-  }
-}
-
-ensureFrontmatter(targetFile, dimension, scope, tag, type)
-
-// Read existing content
-let content = fs.readFileSync(targetFile, 'utf8')
-
-// Deduplicate: skip if summary text already exists in the file
-if (content.includes(summaryText)) {
-  console.log(`
-Entry already exists in ${targetFile}
-Text: "${summaryText}"
-`)
-  return
-}
-
-// Build the entry
-const newEntry = buildEntry(summaryText, type, tag, extendedFields)
-
-// Append the entry
-content = content.trimEnd() + '\n' + newEntry + '\n'
-fs.writeFileSync(targetFile, content, 'utf8')
-
-// Rebuild spec index
-Bash('ccw spec rebuild')
-```
-
-### Step 7: Display Confirmation
-
-**If `-y`/`--yes` (auto mode)**:
-```
-Spec added: [${type}:${tag}] "${summaryText}" -> ${targetFile}
-```
-
-**Otherwise (full confirmation)**:
-```
-Entry created successfully
-
-Type: ${type}
-Tag: ${tag}
-Summary: "${summaryText}"
-Dimension: ${dimension}
-Scope: ${dimension === 'personal' ? scope : 'project'}
-${Object.keys(extendedFields).length > 0 ? `Extended fields: ${Object.keys(extendedFields).join(', ')}` : ''}
-
-Location: ${targetFile}
-
-Use 'ccw spec list' to view all specs
-Tip: Edit ${targetFile} to add code examples or additional details
-```
-
-## Target File Resolution
-
-### Project Specs (dimension: specs)
-```
-.ccw/specs/
-|- coding-conventions.md       <- pattern, rule (conventions)
-|- architecture-constraints.md <- decision, rule (constraints)
-|- learnings.md                <- bug (debugging experience)
-+- quality-rules.md            <- quality rules
-```
-
-### Personal Specs (dimension: personal)
-```
-# Global (~/.ccw/personal/)
-~/.ccw/personal/
-|- conventions.md              <- pattern, rule (all projects)
-|- constraints.md              <- decision, rule (all projects)
-+- learnings.md                <- bug (all projects)
-
-# Project-local (.ccw/personal/)
-.ccw/personal/
-|- conventions.md              <- pattern, rule (this project only)
-|- constraints.md              <- decision, rule (this project only)
-+- learnings.md                <- bug (this project only)
-```
-
-## Examples
-
-### Interactive Wizard
-```bash
-/workflow:spec:add --interactive
-# Prompts for: dimension -> scope (if personal) -> type -> tag -> summary -> extended fields
-```
-
-### Add a Bug Fix Experience
-```bash
-/workflow:spec:add --type bug --tag api "API 返回 502 Bad Gateway"
-```
-
-Result in `.ccw/specs/learnings.md`:
-```markdown
-- [bug:api] API 返回 502 Bad Gateway (2026-03-09)
-```
-
-With interactive extended fields:
-```markdown
-- [bug:api] API 返回 502 Bad Gateway (2026-03-09)
-    - 原因: 路由处理器未在 server.ts 路由分发中注册
-    - 修复: 在路由分发逻辑中导入并调用 app.use(newRouter)
-```
-
-### Add a Code Pattern
-```bash
-/workflow:spec:add --type pattern --tag routing "添加新 API 路由标准流程"
-```
-
-Result in `.ccw/specs/coding-conventions.md`:
-```markdown
-- [pattern:routing] 添加新 API 路由标准流程 (2026-03-09)
-    - 场景: Express 应用新增业务接口
-```
-
-### Add an Architecture Decision
-```bash
-/workflow:spec:add --type decision --tag db "选用 PostgreSQL 作为主数据库"
-```
-
-Result in `.ccw/specs/architecture-constraints.md`:
-```markdown
-- [decision:db] 选用 PostgreSQL 作为主数据库 (2026-03-09)
-    - 决策: 使用 PostgreSQL 15
-    - 理由: JSONB 支持完善，PostGIS 扩展成熟
-```
-
-### Add a Rule (Direct, Auto-detect)
-```bash
-/workflow:spec:add "Use async/await instead of callbacks"
-```
-
-Result in `.ccw/specs/coding-conventions.md`:
-```markdown
-- [rule:style] Use async/await instead of callbacks
-```
-
-### Add a Constraint Rule
-```bash
-/workflow:spec:add -y "No direct DB access from controllers" --type rule --tag arch
-```
-
-Result in `.ccw/specs/architecture-constraints.md`:
-```markdown
-- [rule:arch] No direct DB access from controllers
-```
-
-### Legacy Compatibility
-```bash
-# Old syntax still works
-/workflow:spec:add "No ORM allowed" --type constraint --category architecture
-# Internally maps to: --type rule --tag architecture
-```
-
-Result:
-```markdown
-- [rule:architecture] No ORM allowed
-```
-
-### Personal Spec
-```bash
-/workflow:spec:add --scope global --dimension personal --type rule --tag style "Prefer descriptive variable names"
-```
-
-Result in `~/.ccw/personal/conventions.md`:
-```markdown
-- [rule:style] Prefer descriptive variable names
-```
-
-## Error Handling
-
-- **Duplicate Entry**: Warn and skip if summary text already exists in target file
-- **Invalid Type**: Exit with error - must be 'bug', 'pattern', 'decision', or 'rule'
-- **Invalid Scope**: Exit with error - must be 'global' or 'project'
-- **Invalid Dimension**: Exit with error - must be 'specs' or 'personal'
-- **Legacy Type**: Auto-map convention→rule, constraint→rule, learning→auto-detect
-- **File not writable**: Check permissions, suggest manual creation
-- **File Corruption**: Backup existing file before modification
-
-## Related Commands
-
-- `/workflow:spec:setup` - Initialize project with specs scaffold
-- `/workflow:session:sync` - Quick-sync session work to specs and project-tech
-- `/workflow:session:start` - Start a session
-- `/workflow:session:complete` - Complete session (prompts for learnings)
-- `ccw spec list` - View all specs
-- `ccw spec load --category <cat>` - Load filtered specs
-- `ccw spec rebuild` - Rebuild spec index

.claude/commands/workflow/spec/load.md

@@ -1,392 +0,0 @@
----
-name: load
-description: Interactive spec loader - ask what user needs, then load relevant specs by keyword routing
-argument-hint: "[--all] [--type <bug|pattern|decision|rule>] [--tag <tag>] [\"keyword query\"]"
-examples:
-  - /workflow:spec:load
-  - /workflow:spec:load "api routing"
-  - /workflow:spec:load --type bug
-  - /workflow:spec:load --all
-  - /workflow:spec:load --tag security
----
-
-# Spec Load Command (/workflow:spec:load)
-
-## Overview
-
-Interactive entry point for loading and browsing project specs. Asks the user what they need, then routes to the appropriate spec content based on keywords, type filters, or tag filters.
-
-**Design**: Menu-driven → keyword match → load & display. No file modifications.
-
-**Note**: This command may be called by other workflow commands. Upon completion, return immediately to continue the calling workflow.
-
-## Usage
-```bash
-/workflow:spec:load                    # Interactive menu
-/workflow:spec:load "api routing"      # Direct keyword search
-/workflow:spec:load --type bug         # Filter by knowledge type
-/workflow:spec:load --tag security     # Filter by domain tag
-/workflow:spec:load --all              # Load all specs
-```
-
-## Execution Process
-
-```
-Input Parsing:
-   ├─ Parse --all flag → loadAll = true | false
-   ├─ Parse --type (bug|pattern|decision|rule)
-   ├─ Parse --tag (domain tag)
-   └─ Parse keyword query (positional text)
-
-Decision:
-   ├─ --all → Load all specs (Path C)
-   ├─ --type or --tag or keyword → Direct filter (Path B)
-   └─ No args → Interactive menu (Path A)
-
-Path A: Interactive Menu
-   ├─ Step A1: Ask user intent
-   ├─ Step A2: Route to action
-   └─ Step A3: Display results
-
-Path B: Direct Filter
-   ├─ Step B1: Build filter from args
-   ├─ Step B2: Search specs
-   └─ Step B3: Display results
-
-Path C: Load All
-   └─ Display all spec contents
-
-Output:
-   └─ Formatted spec entries matching user query
-```
-
-## Implementation
-
-### Step 1: Parse Input
-
-```javascript
-const args = $ARGUMENTS
-const argsLower = args.toLowerCase()
-
-const loadAll = argsLower.includes('--all')
-const hasType = argsLower.includes('--type')
-const hasTag = argsLower.includes('--tag')
-
-let type = hasType ? args.match(/--type\s+(\w+)/i)?.[1]?.toLowerCase() : null
-let tag = hasTag ? args.match(/--tag\s+([\w-]+)/i)?.[1]?.toLowerCase() : null
-
-// Extract keyword query (everything that's not a flag)
-let keyword = args
-  .replace(/--type\s+\w+/gi, '')
-  .replace(/--tag\s+[\w-]+/gi, '')
-  .replace(/--all/gi, '')
-  .replace(/^["']|["']$/g, '')
-  .trim()
-
-// Validate type
-if (type && !['bug', 'pattern', 'decision', 'rule'].includes(type)) {
-  console.log("Invalid type. Use 'bug', 'pattern', 'decision', or 'rule'.")
-  return
-}
-```
-
-### Step 2: Determine Mode
-
-```javascript
-const useInteractive = !loadAll && !hasType && !hasTag && !keyword
-```
-
-### Path A: Interactive Menu
-
-```javascript
-if (useInteractive) {
-  const answer = AskUserQuestion({
-    questions: [{
-      question: "What specs would you like to load?",
-      header: "Action",
-      multiSelect: false,
-      options: [
-        {
-          label: "Browse all specs",
-          description: "Load and display all project spec entries"
-        },
-        {
-          label: "Search by keyword",
-          description: "Find specs matching a keyword (e.g., api, security, routing)"
-        },
-        {
-          label: "View bug experiences",
-          description: "Load all [bug:*] debugging experience entries"
-        },
-        {
-          label: "View code patterns",
-          description: "Load all [pattern:*] reusable code pattern entries"
-        }
-      ]
-    }]
-  })
-
-  const choice = answer.answers["Action"]
-
-  if (choice === "Browse all specs") {
-    loadAll = true
-  } else if (choice === "View bug experiences") {
-    type = "bug"
-  } else if (choice === "View code patterns") {
-    type = "pattern"
-  } else if (choice === "Search by keyword") {
-    // Ask for keyword
-    const kwAnswer = AskUserQuestion({
-      questions: [{
-        question: "Enter keyword(s) to search for:",
-        header: "Keyword",
-        multiSelect: false,
-        options: [
-          { label: "api", description: "API endpoints, HTTP, REST, routing" },
-          { label: "security", description: "Authentication, authorization, input validation" },
-          { label: "arch", description: "Architecture, design patterns, module structure" },
-          { label: "perf", description: "Performance, caching, optimization" }
-        ]
-      }]
-    })
-    keyword = kwAnswer.answers["Keyword"].toLowerCase()
-  } else {
-    // "Other" — user typed custom input, use as keyword
-    keyword = choice.toLowerCase()
-  }
-}
-```
-
-### Step 3: Load Spec Files
-
-```javascript
-// Discover all spec files
-const specFiles = [
-  '.ccw/specs/coding-conventions.md',
-  '.ccw/specs/architecture-constraints.md',
-  '.ccw/specs/learnings.md',
-  '.ccw/specs/quality-rules.md'
-]
-
-// Also check personal specs
-const personalFiles = [
-  '~/.ccw/personal/conventions.md',
-  '~/.ccw/personal/constraints.md',
-  '~/.ccw/personal/learnings.md',
-  '.ccw/personal/conventions.md',
-  '.ccw/personal/constraints.md',
-  '.ccw/personal/learnings.md'
-]
-
-// Read all existing spec files
-const allEntries = []
-
-for (const file of [...specFiles, ...personalFiles]) {
-  if (!file_exists(file)) continue
-  const content = Read(file)
-
-  // Extract entries using unified format regex
-  // Entry line: - [type:tag] summary (date)
-  // Extended:       - key: value
-  const lines = content.split('\n')
-  let currentEntry = null
-
-  for (const line of lines) {
-    const entryMatch = line.match(/^- \[(\w+):([\w-]+)\] (.*?)(?:\s+\((\d{4}-\d{2}-\d{2})\))?$/)
-    if (entryMatch) {
-      if (currentEntry) allEntries.push(currentEntry)
-      currentEntry = {
-        type: entryMatch[1],
-        tag: entryMatch[2],
-        summary: entryMatch[3],
-        date: entryMatch[4] || null,
-        extended: {},
-        source: file,
-        raw: line
-      }
-    } else if (currentEntry && /^\s{4}- ([\w-]+):\s?(.*)/.test(line)) {
-      const fieldMatch = line.match(/^\s{4}- ([\w-]+):\s?(.*)/)
-      currentEntry.extended[fieldMatch[1]] = fieldMatch[2]
-    } else if (currentEntry && !/^\s{4}/.test(line) && line.trim() !== '') {
-      // Non-indented non-empty line = end of current entry
-      allEntries.push(currentEntry)
-      currentEntry = null
-    }
-
-    // Also handle legacy format: - [tag] text (learned: date)
-    const legacyMatch = line.match(/^- \[([\w-]+)\] (.+?)(?:\s+\(learned: (\d{4}-\d{2}-\d{2})\))?$/)
-    if (!entryMatch && legacyMatch) {
-      if (currentEntry) allEntries.push(currentEntry)
-      currentEntry = {
-        type: 'rule',
-        tag: legacyMatch[1],
-        summary: legacyMatch[2],
-        date: legacyMatch[3] || null,
-        extended: {},
-        source: file,
-        raw: line,
-        legacy: true
-      }
-    }
-  }
-  if (currentEntry) allEntries.push(currentEntry)
-}
-```
-
-### Step 4: Filter Entries
-
-```javascript
-let filtered = allEntries
-
-// Filter by type
-if (type) {
-  filtered = filtered.filter(e => e.type === type)
-}
-
-// Filter by tag
-if (tag) {
-  filtered = filtered.filter(e => e.tag === tag)
-}
-
-// Filter by keyword (search in tag, summary, and extended fields)
-if (keyword) {
-  const kw = keyword.toLowerCase()
-  const kwTerms = kw.split(/\s+/)
-
-  filtered = filtered.filter(e => {
-    const searchText = [
-      e.type, e.tag, e.summary,
-      ...Object.values(e.extended)
-    ].join(' ').toLowerCase()
-
-    return kwTerms.every(term => searchText.includes(term))
-  })
-}
-
-// If --all, keep everything (no filter)
-```
-
-### Step 5: Display Results
-
-```javascript
-if (filtered.length === 0) {
-  const filterDesc = []
-  if (type) filterDesc.push(`type=${type}`)
-  if (tag) filterDesc.push(`tag=${tag}`)
-  if (keyword) filterDesc.push(`keyword="${keyword}"`)
-
-  console.log(`
-No specs found matching: ${filterDesc.join(', ') || '(all)'}
-
-Available spec files:
-${specFiles.filter(f => file_exists(f)).map(f => `  - ${f}`).join('\n') || '  (none)'}
-
-Suggestions:
-- Use /workflow:spec:setup to initialize specs
-- Use /workflow:spec:add to add new entries
-- Use /workflow:spec:load --all to see everything
-`)
-  return
-}
-
-// Group by source file
-const grouped = {}
-for (const entry of filtered) {
-  if (!grouped[entry.source]) grouped[entry.source] = []
-  grouped[entry.source].push(entry)
-}
-
-// Display
-console.log(`
-## Specs Loaded (${filtered.length} entries)
-${type ? `Type: ${type}` : ''}${tag ? ` Tag: ${tag}` : ''}${keyword ? ` Keyword: "${keyword}"` : ''}
-`)
-
-for (const [source, entries] of Object.entries(grouped)) {
-  console.log(`### ${source}`)
-  console.log('')
-
-  for (const entry of entries) {
-    // Render entry
-    const datePart = entry.date ? ` (${entry.date})` : ''
-    console.log(`- [${entry.type}:${entry.tag}] ${entry.summary}${datePart}`)
-
-    // Render extended fields
-    for (const [key, value] of Object.entries(entry.extended)) {
-      console.log(`    - ${key}: ${value}`)
-    }
-  }
-  console.log('')
-}
-
-// Summary footer
-const typeCounts = {}
-for (const e of filtered) {
-  typeCounts[e.type] = (typeCounts[e.type] || 0) + 1
-}
-const typeBreakdown = Object.entries(typeCounts)
-  .map(([t, c]) => `${t}: ${c}`)
-  .join(', ')
-
-console.log(`---`)
-console.log(`Total: ${filtered.length} entries (${typeBreakdown})`)
-console.log(`Sources: ${Object.keys(grouped).join(', ')}`)
-```
-
-## Examples
-
-### Interactive Browse
-```bash
-/workflow:spec:load
-# → Menu: "What specs would you like to load?"
-# → User selects "Browse all specs"
-# → Displays all entries grouped by file
-```
-
-### Keyword Search
-```bash
-/workflow:spec:load "api routing"
-# → Filters entries where tag/summary/extended contains "api" AND "routing"
-# → Displays matching entries
-```
-
-### Type Filter
-```bash
-/workflow:spec:load --type bug
-# → Shows all [bug:*] entries from learnings.md
-```
-
-### Tag Filter
-```bash
-/workflow:spec:load --tag security
-# → Shows all [*:security] entries across all spec files
-```
-
-### Combined Filters
-```bash
-/workflow:spec:load --type rule --tag api
-# → Shows all [rule:api] entries
-```
-
-### Load All
-```bash
-/workflow:spec:load --all
-# → Displays every entry from every spec file
-```
-
-## Error Handling
-
-| Error | Resolution |
-|-------|------------|
-| No spec files found | Suggest `/workflow:spec:setup` to initialize |
-| No matching entries | Show available files and suggest alternatives |
-| Invalid type | Exit with valid type list |
-| Corrupt entry format | Skip unparseable lines, continue loading |
-
-## Related Commands
-
-- `/workflow:spec:setup` - Initialize project with specs scaffold
-- `/workflow:spec:add` - Add knowledge entries (bug/pattern/decision/rule) with unified [type:tag] format
-- `/workflow:session:sync` - Quick-sync session work to specs and project-tech
-- `ccw spec list` - View spec file index
-- `ccw spec load` - CLI-level spec loading (used by hooks)

.claude/commands/workflow/spec/setup.md

@@ -1,710 +0,0 @@
----
-name: setup
-description: Initialize project-level state and configure specs via interactive questionnaire using cli-explore-agent
-argument-hint: "[--regenerate] [--skip-specs] [--reset]"
-examples:
-  - /workflow:spec:setup
-  - /workflow:spec:setup --regenerate
-  - /workflow:spec:setup --skip-specs
-  - /workflow:spec:setup --reset
----
-
-# Workflow Spec Setup Command (/workflow:spec:setup)
-
-## Overview
-
-Initialize `.workflow/project-tech.json` and `.ccw/specs/*.md` with comprehensive project understanding by delegating analysis to **cli-explore-agent**, then interactively configure project guidelines through a multi-round questionnaire.
-
-**Dual File System**:
-- `project-tech.json`: Auto-generated technical analysis (stack, architecture, components)
-- `specs/*.md`: User-maintained rules and constraints (created and populated interactively)
-
-**Design Principle**: Questions are dynamically generated based on the project's tech stack, architecture, and patterns — not generic boilerplate.
-
-**Note**: This command may be called by other workflow commands. Upon completion, return immediately to continue the calling workflow without interrupting the task flow.
-
-## Usage
-```bash
-/workflow:spec:setup                 # Initialize (skip if exists)
-/workflow:spec:setup --regenerate    # Force regeneration of project-tech.json
-/workflow:spec:setup --skip-specs    # Initialize project-tech only, skip spec initialization and questionnaire
-/workflow:spec:setup --reset         # Reset specs content before questionnaire
-```
-
-## Execution Process
-
-```
-Input Parsing:
-   ├─ Parse --regenerate flag → regenerate = true | false
-   ├─ Parse --skip-specs flag → skipSpecs = true | false
-   └─ Parse --reset flag → reset = true | false
-
-Decision:
-   ├─ BOTH_EXIST + no --regenerate + no --reset → Exit: "Already initialized"
-   ├─ EXISTS + --regenerate → Backup existing → Continue analysis
-   ├─ EXISTS + --reset → Reset specs, keep project-tech → Skip to questionnaire
-   └─ NOT_FOUND → Continue full flow
-
-Full Flow:
-   ├─ Step 1: Parse input and check existing state
-   ├─ Step 2: Get project metadata (name, root)
-   ├─ Step 3: Invoke cli-explore-agent
-   │   ├─ Structural scan (get_modules_by_depth.sh, find, wc)
-   │   ├─ Semantic analysis (Gemini CLI)
-   │   ├─ Synthesis and merge
-   │   └─ Write .workflow/project-tech.json
-   ├─ Step 4: Initialize Spec System (if not --skip-specs)
-   │   ├─ Check if specs/*.md exist
-   │   ├─ If NOT_FOUND → Run ccw spec init
-   │   └─ Run ccw spec rebuild
-   ├─ Step 5: Multi-Round Interactive Questionnaire (if not --skip-specs)
-   │   ├─ Check if guidelines already populated → Ask: "Append / Reset / Cancel"
-   │   ├─ Load project context from project-tech.json
-   │   ├─ Round 1: Coding Conventions (coding_style, naming_patterns)
-   │   ├─ Round 2: File & Documentation Conventions (file_structure, documentation)
-   │   ├─ Round 3: Architecture & Tech Constraints (architecture, tech_stack)
-   │   ├─ Round 4: Performance & Security Constraints (performance, security)
-   │   └─ Round 5: Quality Rules (quality_rules)
-   ├─ Step 6: Write specs/*.md (if not --skip-specs)
-   └─ Step 7: Display Summary
-
-Output:
-   ├─ .workflow/project-tech.json (+ .backup if regenerate)
-   └─ .ccw/specs/*.md (scaffold or configured, unless --skip-specs)
-```
-
-## Implementation
-
-### Step 1: Parse Input and Check Existing State
-
-**Parse flags**:
-```javascript
-const regenerate = $ARGUMENTS.includes('--regenerate')
-const skipSpecs = $ARGUMENTS.includes('--skip-specs')
-const reset = $ARGUMENTS.includes('--reset')
-```
-
-**Check existing state**:
-
-```bash
-bash(test -f .workflow/project-tech.json && echo "TECH_EXISTS" || echo "TECH_NOT_FOUND")
-bash(test -f .ccw/specs/coding-conventions.md && echo "SPECS_EXISTS" || echo "SPECS_NOT_FOUND")
-```
-
-**If BOTH_EXIST and no --regenerate and no --reset**: Exit early
-```
-Project already initialized:
-- Tech analysis: .workflow/project-tech.json
-- Guidelines: .ccw/specs/*.md
-
-Use /workflow:spec:setup --regenerate to rebuild tech analysis
-Use /workflow:spec:setup --reset to reconfigure guidelines
-Use /workflow:spec:add to add individual rules
-Use /workflow:status --project to view state
-```
-
-### Step 2: Get Project Metadata
-
-```bash
-bash(basename "$(git rev-parse --show-toplevel 2>/dev/null || pwd)")
-bash(git rev-parse --show-toplevel 2>/dev/null || pwd)
-bash(mkdir -p .workflow)
-```
-
-### Step 3: Invoke cli-explore-agent
-
-**For --regenerate**: Backup and preserve existing data
-```bash
-bash(cp .workflow/project-tech.json .workflow/project-tech.json.backup)
-```
-
-**Delegate analysis to agent**:
-
-```javascript
-Task(
-  subagent_type="cli-explore-agent",
-  run_in_background=false,
-  description="Deep project analysis",
-  prompt=`
-Analyze project for workflow initialization and generate .workflow/project-tech.json.
-
-## MANDATORY FIRST STEPS
-1. Execute: ccw tool exec json_builder '{"cmd":"info","schema":"tech"}' (get schema summary)
-2. Execute: ccw tool exec get_modules_by_depth '{}' (get project structure)
-
-## Task
-Generate complete project-tech.json following the schema structure:
-- project_name: "${projectName}"
-- initialized_at: ISO 8601 timestamp
-- overview: {
-    description: "Brief project description",
-    technology_stack: {
-      languages: [{name, file_count, primary}],
-      frameworks: ["string"],
-      build_tools: ["string"],
-      test_frameworks: ["string"]
-    },
-    architecture: {style, layers: [], patterns: []},
-    key_components: [{name, path, description, importance}]
-  }
-- features: []
-- development_index: ${regenerate ? 'preserve from backup' : '{feature: [], enhancement: [], bugfix: [], refactor: [], docs: []}'}
-- statistics: ${regenerate ? 'preserve from backup' : '{total_features: 0, total_sessions: 0, last_updated: ISO timestamp}'}
-- _metadata: {initialized_by: "cli-explore-agent", analysis_timestamp: ISO timestamp, analysis_mode: "deep-scan"}
-
-## Analysis Requirements
-
-**Technology Stack**:
-- Languages: File counts, mark primary
-- Frameworks: From package.json, requirements.txt, go.mod, etc.
-- Build tools: npm, cargo, maven, webpack, vite
-- Test frameworks: jest, pytest, go test, junit
-
-**Architecture**:
-- Style: MVC, microservices, layered (from structure & imports)
-- Layers: presentation, business-logic, data-access
-- Patterns: singleton, factory, repository
-- Key components: 5-10 modules {name, path, description, importance}
-
-## Execution
-1. Structural scan: get_modules_by_depth.sh, find, wc -l
-2. Semantic analysis: Gemini for patterns/architecture
-3. Synthesis: Merge findings
-4. ${regenerate ? 'Merge with preserved development_index and statistics from .workflow/project-tech.json.backup' : ''}
-5. Write JSON: Write('.workflow/project-tech.json', jsonContent)
-6. Report: Return brief completion summary
-
-Project root: ${projectRoot}
-`
-)
-```
-
-### Step 4: Initialize Spec System (if not --skip-specs)
-
-```javascript
-// Skip spec initialization if --skip-specs flag is provided
-if (!skipSpecs) {
-  // Initialize spec system if not already initialized
-  const specsCheck = Bash('test -f .ccw/specs/coding-conventions.md && echo EXISTS || echo NOT_FOUND')
-  if (specsCheck.includes('NOT_FOUND')) {
-    console.log('Initializing spec system...')
-    Bash('ccw spec init')
-    Bash('ccw spec rebuild')
-  }
-} else {
-  console.log('Skipping spec initialization and questionnaire (--skip-specs)')
-}
-```
-
-If `--skip-specs` is provided, skip directly to Step 7 (Display Summary) with limited output.
-
-### Step 5: Multi-Round Interactive Questionnaire (if not --skip-specs)
-
-#### Step 5.0: Check Existing Guidelines
-
-If guidelines already have content, ask the user how to proceed:
-
-```javascript
-// Check if specs already have content via ccw spec list
-const specsList = Bash('ccw spec list --json 2>/dev/null || echo "{}"')
-const specsData = JSON.parse(specsList)
-const isPopulated = (specsData.total || 0) > 5  // More than seed docs
-
-if (isPopulated && !reset) {
-  AskUserQuestion({
-    questions: [{
-      question: "Project guidelines already contain entries. How would you like to proceed?",
-      header: "Mode",
-      multiSelect: false,
-      options: [
-        { label: "Append", description: "Keep existing entries and add new ones from the wizard" },
-        { label: "Reset", description: "Clear all existing entries and start fresh" },
-        { label: "Cancel", description: "Exit without changes" }
-      ]
-    }]
-  })
-  // If Cancel → exit
-  // If Reset → clear all arrays before proceeding
-  // If Append → keep existing, wizard adds to them
-}
-
-// If --reset flag was provided, clear existing entries before proceeding
-if (reset) {
-  // Reset specs content
-  console.log('Resetting existing guidelines...')
-}
-```
-
-#### Step 5.1: Load Project Context
-
-```javascript
-// Load project context via ccw spec load for planning context
-const projectContext = Bash('ccw spec load --category planning 2>/dev/null || echo "{}"')
-const specData = JSON.parse(projectContext)
-
-// Extract key info from loaded specs for generating smart questions
-const languages = specData.overview?.technology_stack?.languages || []
-const primaryLang = languages.find(l => l.primary)?.name || languages[0]?.name || 'Unknown'
-const frameworks = specData.overview?.technology_stack?.frameworks || []
-const testFrameworks = specData.overview?.technology_stack?.test_frameworks || []
-const archStyle = specData.overview?.architecture?.style || 'Unknown'
-const archPatterns = specData.overview?.architecture?.patterns || []
-const buildTools = specData.overview?.technology_stack?.build_tools || []
-```
-
-#### Step 5.2: Multi-Round Questionnaire
-
-Each round uses `AskUserQuestion` with project-aware options. The user can always select "Other" to provide custom input.
-
-**CRITICAL**: After each round, collect the user's answers and convert them into guideline entries. Do NOT batch all rounds — process each round's answers before proceeding to the next.
-
----
-
-##### Round 1: Coding Conventions
-
-Generate options dynamically based on detected language/framework:
-
-```javascript
-// Build language-specific coding style options
-const codingStyleOptions = []
-
-if (['TypeScript', 'JavaScript'].includes(primaryLang)) {
-  codingStyleOptions.push(
-    { label: "Strict TypeScript", description: "Use strict mode, no 'any' type, explicit return types for public APIs" },
-    { label: "Functional style", description: "Prefer pure functions, immutability, avoid class-based patterns where possible" },
-    { label: "Const over let", description: "Always use const; only use let when reassignment is truly needed" }
-  )
-} else if (primaryLang === 'Python') {
-  codingStyleOptions.push(
-    { label: "Type hints", description: "Use type hints for all function signatures and class attributes" },
-    { label: "Functional style", description: "Prefer pure functions, list comprehensions, avoid mutable state" },
-    { label: "PEP 8 strict", description: "Strict PEP 8 compliance with max line length 88 (Black formatter)" }
-  )
-} else if (primaryLang === 'Go') {
-  codingStyleOptions.push(
-    { label: "Error wrapping", description: "Always wrap errors with context using fmt.Errorf with %w" },
-    { label: "Interface first", description: "Define interfaces at the consumer side, not the provider" },
-    { label: "Table-driven tests", description: "Use table-driven test pattern for all unit tests" }
-  )
-}
-// Add universal options
-codingStyleOptions.push(
-  { label: "Early returns", description: "Prefer early returns / guard clauses over deep nesting" }
-)
-
-AskUserQuestion({
-  questions: [
-    {
-      question: `Your project uses ${primaryLang}. Which coding style conventions do you follow?`,
-      header: "Coding Style",
-      multiSelect: true,
-      options: codingStyleOptions.slice(0, 4) // Max 4 options
-    },
-    {
-      question: `What naming conventions does your ${primaryLang} project use?`,
-      header: "Naming",
-      multiSelect: true,
-      options: [
-        { label: "camelCase variables", description: "Variables and functions use camelCase (e.g., getUserName)" },
-        { label: "PascalCase types", description: "Classes, interfaces, type aliases use PascalCase (e.g., UserService)" },
-        { label: "UPPER_SNAKE constants", description: "Constants use UPPER_SNAKE_CASE (e.g., MAX_RETRIES)" },
-        { label: "Prefix interfaces", description: "Prefix interfaces with 'I' (e.g., IUserService)" }
-      ]
-    }
-  ]
-})
-```
-
-**Process Round 1 answers** -> add to `conventions.coding_style` and `conventions.naming_patterns` arrays.
-
----
-
-##### Round 2: File Structure & Documentation
-
-```javascript
-AskUserQuestion({
-  questions: [
-    {
-      question: `Your project has a ${archStyle} architecture. What file organization rules apply?`,
-      header: "File Structure",
-      multiSelect: true,
-      options: [
-        { label: "Co-located tests", description: "Test files live next to source files (e.g., foo.ts + foo.test.ts)" },
-        { label: "Separate test dir", description: "Tests in a dedicated __tests__ or tests/ directory" },
-        { label: "One export per file", description: "Each file exports a single main component/class/function" },
-        { label: "Index barrels", description: "Use index.ts barrel files for clean imports from directories" }
-      ]
-    },
-    {
-      question: "What documentation standards does your project follow?",
-      header: "Documentation",
-      multiSelect: true,
-      options: [
-        { label: "JSDoc/docstring public APIs", description: "All public functions and classes must have JSDoc/docstrings" },
-        { label: "README per module", description: "Each major module/package has its own README" },
-        { label: "Inline comments for why", description: "Comments explain 'why', not 'what' — code should be self-documenting" },
-        { label: "No comment requirement", description: "Code should be self-explanatory; comments only for non-obvious logic" }
-      ]
-    }
-  ]
-})
-```
-
-**Process Round 2 answers** -> add to `conventions.file_structure` and `conventions.documentation`.
-
----
-
-##### Round 3: Architecture & Tech Stack Constraints
-
-```javascript
-// Build architecture-specific options
-const archOptions = []
-
-if (archStyle.toLowerCase().includes('monolith')) {
-  archOptions.push(
-    { label: "No circular deps", description: "Modules must not have circular dependencies" },
-    { label: "Layer boundaries", description: "Strict layer separation: UI → Service → Data (no skipping layers)" }
-  )
-} else if (archStyle.toLowerCase().includes('microservice')) {
-  archOptions.push(
-    { label: "Service isolation", description: "Services must not share databases or internal state" },
-    { label: "API contracts", description: "All inter-service communication through versioned API contracts" }
-  )
-}
-archOptions.push(
-  { label: "Stateless services", description: "Service/business logic must be stateless (state in DB/cache only)" },
-  { label: "Dependency injection", description: "Use dependency injection for testability, no hardcoded dependencies" }
-)
-
-AskUserQuestion({
-  questions: [
-    {
-      question: `Your ${archStyle} architecture uses ${archPatterns.join(', ') || 'various'} patterns. What architecture constraints apply?`,
-      header: "Architecture",
-      multiSelect: true,
-      options: archOptions.slice(0, 4)
-    },
-    {
-      question: `Tech stack: ${frameworks.join(', ')}. What technology constraints apply?`,
-      header: "Tech Stack",
-      multiSelect: true,
-      options: [
-        { label: "No new deps without review", description: "Adding new dependencies requires explicit justification and review" },
-        { label: "Pin dependency versions", description: "All dependencies must use exact versions, not ranges" },
-        { label: "Prefer native APIs", description: "Use built-in/native APIs over third-party libraries when possible" },
-        { label: "Framework conventions", description: `Follow official ${frameworks[0] || 'framework'} conventions and best practices` }
-      ]
-    }
-  ]
-})
-```
-
-**Process Round 3 answers** -> add to `constraints.architecture` and `constraints.tech_stack`.
-
----
-
-##### Round 4: Performance & Security Constraints
-
-```javascript
-AskUserQuestion({
-  questions: [
-    {
-      question: "What performance requirements does your project have?",
-      header: "Performance",
-      multiSelect: true,
-      options: [
-        { label: "API response time", description: "API endpoints must respond within 200ms (p95)" },
-        { label: "Bundle size limit", description: "Frontend bundle size must stay under 500KB gzipped" },
-        { label: "Lazy loading", description: "Large modules/routes must use lazy loading / code splitting" },
-        { label: "No N+1 queries", description: "Database access must avoid N+1 query patterns" }
-      ]
-    },
-    {
-      question: "What security requirements does your project enforce?",
-      header: "Security",
-      multiSelect: true,
-      options: [
-        { label: "Input sanitization", description: "All user input must be validated and sanitized before use" },
-        { label: "No secrets in code", description: "No API keys, passwords, or tokens in source code — use env vars" },
-        { label: "Auth on all endpoints", description: "All API endpoints require authentication unless explicitly public" },
-        { label: "Parameterized queries", description: "All database queries must use parameterized/prepared statements" }
-      ]
-    }
-  ]
-})
-```
-
-**Process Round 4 answers** -> add to `constraints.performance` and `constraints.security`.
-
----
-
-##### Round 5: Quality Rules
-
-```javascript
-AskUserQuestion({
-  questions: [
-    {
-      question: `Testing with ${testFrameworks.join(', ') || 'your test framework'}. What quality rules apply?`,
-      header: "Quality",
-      multiSelect: true,
-      options: [
-        { label: "Min test coverage", description: "Minimum 80% code coverage for new code; no merging below threshold" },
-        { label: "No skipped tests", description: "Tests must not be skipped (.skip/.only) in committed code" },
-        { label: "Lint must pass", description: "All code must pass linter checks before commit (enforced by pre-commit)" },
-        { label: "Type check must pass", description: "Full type checking (tsc --noEmit) must pass with zero errors" }
-      ]
-    }
-  ]
-})
-```
-
-**Process Round 5 answers** -> add to `quality_rules` array as `{ rule, scope, enforced_by }` objects.
-
-### Step 6: Write specs/*.md (if not --skip-specs)
-
-For each category of collected answers, append rules to the corresponding spec MD file. Each spec file uses YAML frontmatter with `readMode`, `priority`, `category`, and `keywords`.
-
-**Category Assignment**: Based on the round and question type:
-- Round 1-2 (conventions): `category: general` (applies to all stages)
-- Round 3 (architecture/tech): `category: planning` (planning phase)
-- Round 4 (performance/security): `category: execution` (implementation phase)
-- Round 5 (quality): `category: execution` (testing phase)
-
-```javascript
-const matter = require('gray-matter')  // YAML frontmatter parser
-
-// ── Frontmatter check & repair helper ──
-// Ensures target spec file has valid YAML frontmatter with keywords
-// Uses gray-matter for robust parsing (handles malformed frontmatter, missing fields)
-function ensureSpecFrontmatter(filePath, extraKeywords = []) {
-  const titleMap = {
-    'coding-conventions': 'Coding Conventions',
-    'architecture-constraints': 'Architecture Constraints',
-    'learnings': 'Learnings',
-    'quality-rules': 'Quality Rules'
-  }
-  const basename = filePath.split('/').pop().replace('.md', '')
-  const title = titleMap[basename] || basename
-  const defaultKw = filePath.includes('conventions') ? 'convention'
-    : filePath.includes('constraints') ? 'constraint' : 'quality'
-  const defaultFm = {
-    title,
-    readMode: 'optional',
-    priority: 'medium',
-    category: 'general',
-    scope: 'project',
-    dimension: 'specs',
-    keywords: [...new Set([defaultKw, ...extraKeywords])]
-  }
-
-  if (!file_exists(filePath)) {
-    // Case A: Create new file with frontmatter
-    const specDir = path.dirname(filePath)
-    if (!fs.existsSync(specDir)) {
-      fs.mkdirSync(specDir, { recursive: true })
-    }
-    Write(filePath, matter.stringify(`\n# ${title}\n\n`, defaultFm))
-    return
-  }
-
-  const raw = Read(filePath)
-  let parsed
-  try {
-    parsed = matter(raw)
-  } catch {
-    parsed = { data: {}, content: raw }
-  }
-
-  const hasFrontmatter = raw.trimStart().startsWith('---')
-
-  if (!hasFrontmatter) {
-    // Case B: File exists but no frontmatter → prepend
-    Write(filePath, matter.stringify(raw, defaultFm))
-    return
-  }
-
-  // Case C: Frontmatter exists → ensure keywords include extras
-  const existingKeywords = parsed.data.keywords || []
-  const newKeywords = [...new Set([...existingKeywords, defaultKw, ...extraKeywords])]
-
-  if (newKeywords.length !== existingKeywords.length) {
-    parsed.data.keywords = newKeywords
-    Write(filePath, matter.stringify(parsed.content, parsed.data))
-  }
-}
-
-// Helper: append rules to a spec MD file with category support
-// Uses .ccw/specs/ directory (same as frontend/backend spec-index-builder)
-function appendRulesToSpecFile(filePath, rules, defaultCategory = 'general') {
-  if (rules.length === 0) return
-
-  // Extract domain tags from rules for keyword accumulation
-  const ruleTags = rules
-    .map(r => r.match(/\[[\w]+:([\w-]+)\]/)?.[1])
-    .filter(Boolean)
-
-  // Ensure frontmatter exists and keywords include rule tags
-  ensureSpecFrontmatter(filePath, [...new Set(ruleTags)])
-
-  const existing = Read(filePath)
-  // Append new rules as markdown list items - rules are already in [type:tag] format from caller
-  const newContent = existing.trimEnd() + '\n' + rules.map(r => {
-    // If rule already has - prefix or [type:tag] format, use as-is
-    if (/^- /.test(r)) return r
-    if (/^\[[\w]+:[\w-]+\]/.test(r)) return `- ${r}`
-    return `- [rule:${defaultCategory}] ${r}`
-  }).join('\n') + '\n'
-  Write(filePath, newContent)
-}
-
-// Helper: infer domain tag from rule content
-function inferTag(text) {
-  const t = text.toLowerCase()
-  if (/\b(api|http|rest|endpoint|routing)\b/.test(t)) return 'api'
-  if (/\b(security|auth|permission|xss|sql|sanitize)\b/.test(t)) return 'security'
-  if (/\b(database|db|sql|postgres|mysql)\b/.test(t)) return 'db'
-  if (/\b(react|component|hook|jsx|tsx)\b/.test(t)) return 'react'
-  if (/\b(performance|cache|lazy|async|slow)\b/.test(t)) return 'perf'
-  if (/\b(test|coverage|mock|jest|vitest)\b/.test(t)) return 'testing'
-  if (/\b(architecture|layer|module|dependency)\b/.test(t)) return 'arch'
-  if (/\b(naming|camel|pascal|prefix|suffix)\b/.test(t)) return 'naming'
-  if (/\b(file|folder|directory|structure)\b/.test(t)) return 'file'
-  if (/\b(doc|comment|jsdoc|readme)\b/.test(t)) return 'doc'
-  if (/\b(build|webpack|vite|compile)\b/.test(t)) return 'build'
-  if (/\b(deploy|ci|cd|docker)\b/.test(t)) return 'deploy'
-  if (/\b(lint|eslint|prettier|format)\b/.test(t)) return 'lint'
-  if (/\b(type|typescript|strict|any)\b/.test(t)) return 'typing'
-  return 'style' // fallback for coding conventions
-}
-
-// Write conventions - infer domain tags from content
-appendRulesToSpecFile('.ccw/specs/coding-conventions.md',
-  [...newCodingStyle, ...newNamingPatterns, ...newFileStructure, ...newDocumentation]
-    .map(r => /^\[[\w]+:[\w-]+\]/.test(r) ? r : `[rule:${inferTag(r)}] ${r}`),
-  'style')
-
-// Write constraints - infer domain tags from content
-appendRulesToSpecFile('.ccw/specs/architecture-constraints.md',
-  [...newArchitecture, ...newTechStack, ...newPerformance, ...newSecurity]
-    .map(r => /^\[[\w]+:[\w-]+\]/.test(r) ? r : `[rule:${inferTag(r)}] ${r}`),
-  'arch')
-
-// Write quality rules (execution category)
-if (newQualityRules.length > 0) {
-  const qualityPath = '.ccw/specs/quality-rules.md'
-  // ensureSpecFrontmatter handles create/repair/keyword-update
-  ensureSpecFrontmatter(qualityPath, ['quality', 'testing', 'coverage', 'lint'])
-  appendRulesToSpecFile(qualityPath,
-    newQualityRules.map(q => `${q.rule} (scope: ${q.scope}, enforced by: ${q.enforced_by})`),
-    'execution')
-}
-
-// Rebuild spec index after writing
-Bash('ccw spec rebuild')
-```
-
-#### Answer Processing Rules
-
-When converting user selections to guideline entries:
-
-1. **Selected option** -> Use the option's `description` as the guideline string (it's more precise than the label)
-2. **"Other" with custom text** -> Use the user's text directly as the guideline string
-3. **Deduplication** -> Skip entries that already exist in the guidelines (exact string match)
-4. **Quality rules** -> Convert to `{ rule: description, scope: "all", enforced_by: "code-review" }` format
-
-### Step 7: Display Summary
-
-```javascript
-const projectTech = JSON.parse(Read('.workflow/project-tech.json'));
-
-if (skipSpecs) {
-  // Minimal summary for --skip-specs mode
-  console.log(`
-Project initialized successfully (tech analysis only)
-
-## Project Overview
-Name: ${projectTech.project_name}
-Description: ${projectTech.overview.description}
-
-### Technology Stack
-Languages: ${projectTech.overview.technology_stack.languages.map(l => l.name).join(', ')}
-Frameworks: ${projectTech.overview.technology_stack.frameworks.join(', ')}
-
-### Architecture
-Style: ${projectTech.overview.architecture.style}
-Components: ${projectTech.overview.key_components.length} core modules
-
----
-Files created:
-- Tech analysis: .workflow/project-tech.json
-- Specs: (skipped via --skip-specs)
-${regenerate ? '- Backup: .workflow/project-tech.json.backup' : ''}
-
-Next steps:
-- Use /workflow:spec:setup (without --skip-specs) to configure guidelines
-- Use /workflow:spec:add to create individual specs
-- Use workflow-plan skill to start planning
-`);
-} else {
-  // Full summary with guidelines stats
-  const countConventions = newCodingStyle.length + newNamingPatterns.length
-    + newFileStructure.length + newDocumentation.length
-  const countConstraints = newArchitecture.length + newTechStack.length
-    + newPerformance.length + newSecurity.length
-  const countQuality = newQualityRules.length
-
-  // Get updated spec list
-  const specsList = Bash('ccw spec list --json 2>/dev/null || echo "{}"')
-
-  console.log(`
-Project initialized and guidelines configured
-
-## Project Overview
-Name: ${projectTech.project_name}
-Description: ${projectTech.overview.description}
-
-### Technology Stack
-Languages: ${projectTech.overview.technology_stack.languages.map(l => l.name).join(', ')}
-Frameworks: ${projectTech.overview.technology_stack.frameworks.join(', ')}
-
-### Architecture
-Style: ${projectTech.overview.architecture.style}
-Components: ${projectTech.overview.key_components.length} core modules
-
-### Guidelines Summary
-- Conventions: ${countConventions} rules added to coding-conventions.md
-- Constraints: ${countConstraints} rules added to architecture-constraints.md
-- Quality rules: ${countQuality} rules added to quality-rules.md
-
-Spec index rebuilt. Use \`ccw spec list\` to view all specs.
-
----
-Files created:
-- Tech analysis: .workflow/project-tech.json
-- Specs: .ccw/specs/ (configured)
-${regenerate ? '- Backup: .workflow/project-tech.json.backup' : ''}
-
-Next steps:
-- Use /workflow:spec:add to add individual rules later
-- Specs are auto-loaded via hook on each prompt
-- Use workflow-plan skill to start planning
-`);
-}
-```
-
-## Error Handling
-
-**Agent Failure**: Fall back to basic initialization with placeholder overview
-**Missing Tools**: Agent uses Qwen fallback or bash-only
-**Empty Project**: Create minimal JSON with all gaps identified
-**No project-tech.json** (when --reset without prior init): Run full flow from Step 2
-**User cancels mid-wizard**: Save whatever was collected so far (partial is better than nothing)
-**File write failure**: Report error, suggest manual edit
-
-## Related Commands
-
-- `/workflow:spec:add` - Add knowledge entries (bug/pattern/decision/rule) with unified [type:tag] format
-- `/workflow:spec:load` - Interactive spec loader with keyword/type/tag filtering
-- `/workflow:session:sync` - Quick-sync session work to specs and project-tech
-- `workflow-plan` skill - Start planning with initialized project context
-- `/workflow:status --project` - View project state and guidelines

.claude/commands/workflow/ui-design/animation-extract.md

@@ -2,7 +2,7 @@
 name: animation-extract
 description: Extract animation and transition patterns from prompt inference and image references for design system documentation
 argument-hint: "[-y|--yes] [--design-id <id>] [--session <id>] [--images "<glob>"] [--focus "<types>"] [--interactive] [--refine]"
-allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), Bash(*), AskUserQuestion(*), Agent(ui-design-agent)
+allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), Bash(*), AskUserQuestion(*), Task(ui-design-agent)
 ---
 
 ## Auto Mode
@@ -207,14 +207,14 @@ IF has_images:
 
 ### Step 2: Generate Animation Specification Options (Agent Task 1)
 
-**Executor**: `Agent(ui-design-agent)`
+**Executor**: `Task(ui-design-agent)`
 
 **Conditional Logic**: Branch based on `refine_mode` flag
 
 ```javascript
 IF NOT refine_mode:
     // EXPLORATION MODE (default)
-    Agent(ui-design-agent): `
+    Task(ui-design-agent): `
       [ANIMATION_SPECIFICATION_GENERATION_TASK]
       Generate context-aware animation specification questions
 
@@ -308,7 +308,7 @@ IF NOT refine_mode:
 
 ELSE:
     // REFINEMENT MODE
-    Agent(ui-design-agent): `
+    Task(ui-design-agent): `
       [ANIMATION_REFINEMENT_OPTIONS_TASK]
       Generate refinement options for existing animation system
 
@@ -656,7 +656,7 @@ ELSE:
 
 ## Phase 2: Animation System Generation (Agent Task 2)
 
-**Executor**: `Agent(ui-design-agent)` for animation token generation
+**Executor**: `Task(ui-design-agent)` for animation token generation
 
 ### Step 1: Load User Selection or Use Defaults
 
@@ -706,14 +706,14 @@ IF has_images:
 bash(mkdir -p {base_path}/animation-extraction)
 ```
 
-### Step 3: Launch Animation Generation Agent
+### Step 3: Launch Animation Generation Task
 
 **Conditional Task**: Branch based on `refine_mode` flag
 
 ```javascript
 IF NOT refine_mode:
     // EXPLORATION MODE
-    Agent(ui-design-agent): `
+    Task(ui-design-agent): `
       [ANIMATION_SYSTEM_GENERATION_TASK]
       Generate production-ready animation system based on user preferences and CSS extraction
 
@@ -871,7 +871,7 @@ IF NOT refine_mode:
 
 ELSE:
     // REFINEMENT MODE
-    Agent(ui-design-agent): `
+    Task(ui-design-agent): `
       [ANIMATION_SYSTEM_REFINEMENT_TASK]
       Apply selected refinements to existing animation system
 

.claude/commands/workflow/ui-design/design-sync.md

@@ -1,6 +1,6 @@
 ---
 name: design-sync
-description: Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow-plan consumption
+description: Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow:plan consumption
 argument-hint: --session <session_id> [--selected-prototypes "<list>"]
 allowed-tools: Read(*), Write(*), Edit(*), TodoWrite(*), Glob(*), Bash(*)
 ---
@@ -351,10 +351,10 @@ Updated artifacts:
 ✓ {role_count} role analysis.md files - Design system references
 ✓ ui-designer/design-system-reference.md - Design system reference guide
 
-Design system assets ready for /workflow-plan:
+Design system assets ready for /workflow:plan:
 - design-tokens.json | style-guide.md | {prototype_count} reference prototypes
 
-Next: /workflow-plan [--agent] "<task description>"
+Next: /workflow:plan [--agent] "<task description>"
       The plan phase will automatically discover and utilize the design system.
 ```
 
@@ -394,7 +394,7 @@ Next: /workflow-plan [--agent] "<task description>"
 @../../{design_id}/prototypes/{prototype}.html
 ```
 
-## Integration with /workflow-plan
+## Integration with /workflow:plan
 
 After this update, `workflow-plan` skill will discover design assets through:
 

.claude/commands/workflow/ui-design/explore-auto.md

@@ -2,7 +2,7 @@
 name: explore-auto
 description: Interactive exploratory UI design workflow with style-centric batch generation, creates design variants from prompts/images with parallel execution and user selection
 argument-hint: "[--input "<value>"] [--targets "<list>"] [--target-type "page|component"] [--session <id>] [--style-variants <count>] [--layout-variants <count>]"
-allowed-tools: Skill(*), TodoWrite(*), Read(*), Bash(*), Glob(*), Write(*), Agent(conceptual-planning-agent)
+allowed-tools: Skill(*), TodoWrite(*), Read(*), Bash(*), Glob(*), Write(*), Task(conceptual-planning-agent)
 ---
 
 # UI Design Auto Workflow Command

.claude/commands/workflow/ui-design/generate.md

@@ -2,7 +2,7 @@
 name: generate
 description: Assemble UI prototypes by combining layout templates with design tokens (default animation support), pure assembler without new content generation
 argument-hint: [--design-id <id>] [--session <id>]
-allowed-tools: TodoWrite(*), Read(*), Write(*), Agent(ui-design-agent), Bash(*)
+allowed-tools: TodoWrite(*), Read(*), Write(*), Task(ui-design-agent), Bash(*)
 ---
 
 # Generate UI Prototypes (/workflow:ui-design:generate)
@@ -129,7 +129,7 @@ ELSE:
 
 ## Phase 2: Assembly (Agent)
 
-**Executor**: `Agent(ui-design-agent)` grouped by `target × style` (max 10 layouts per agent, max 6 concurrent agents)
+**Executor**: `Task(ui-design-agent)` grouped by `target × style` (max 10 layouts per agent, max 6 concurrent agents)
 
 **⚠️ Core Principle**: **Each agent processes ONLY ONE style** (but can process multiple layouts for that style)
 
@@ -204,7 +204,7 @@ TodoWrite({todos: [
 For each batch (up to 6 parallel agents per batch):
 For each agent group `{target, style_id, layout_ids[]}` in current batch:
 ```javascript
-Agent(ui-design-agent): `
+Task(ui-design-agent): `
   [LAYOUT_STYLE_ASSEMBLY]
   🎯 {target} × Style-{style_id} × Layouts-{layout_ids}
   ⚠️ CONSTRAINT: Use ONLY style-{style_id}/design-tokens.json (never mix styles)

.claude/commands/workflow/ui-design/imitate-auto.md

@@ -606,7 +606,7 @@ Total workflow time: ~{estimate_total_time()} minutes
 
 {IF session_id:
 2. Create implementation tasks:
-   /workflow-plan --session {session_id}
+   /workflow:plan --session {session_id}
 
 3. Generate tests (if needed):
    /workflow:test-gen {session_id}
@@ -741,5 +741,5 @@ Design Quality:
   - Design token driven
   - {generated_count} assembled prototypes
 
-Next: [/workflow-execute] OR [Open compare.html → /workflow-plan]
+Next: [/workflow:execute] OR [Open compare.html → /workflow:plan]
 ```

.claude/commands/workflow/ui-design/import-from-code.md

@@ -2,7 +2,7 @@
 name: workflow:ui-design:import-from-code
 description: Import design system from code files (CSS/JS/HTML/SCSS) with automatic file discovery and parallel agent analysis
 argument-hint: "[--design-id <id>] [--session <id>] [--source <path>]"
-allowed-tools: Read,Write,Bash,Glob,Grep,Agent,TodoWrite
+allowed-tools: Read,Write,Bash,Glob,Grep,Task,TodoWrite
 auto-continue: true
 ---
 

.claude/commands/workflow/ui-design/layout-extract.md

@@ -2,7 +2,7 @@
 name: layout-extract
 description: Extract structural layout information from reference images or text prompts using Claude analysis with variant generation or refinement mode
 argument-hint: "[-y|--yes] [--design-id <id>] [--session <id>] [--images "<glob>"] [--prompt "<desc>"] [--targets "<list>"] [--variants <count>] [--device-type <desktop|mobile|tablet|responsive>] [--interactive] [--refine]"
-allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), Bash(*), AskUserQuestion(*), Agent(ui-design-agent), mcp__exa__web_search_exa(*)
+allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), Bash(*), AskUserQuestion(*), Task(ui-design-agent), mcp__exa__web_search_exa(*)
 ---
 
 ## Auto Mode
@@ -162,7 +162,7 @@ IF refine_mode:
 ```
 
 ### Step 1: Generate Options (Agent Task 1 - Mode-Specific)
-**Executor**: `Agent(ui-design-agent)`
+**Executor**: `Task(ui-design-agent)`
 
 **Exploration Mode** (default): Generate contrasting layout concepts
 **Refinement Mode** (`--refine`): Generate refinement options for existing layouts
@@ -171,7 +171,7 @@ IF refine_mode:
 // Conditional agent task based on refine_mode
 IF NOT refine_mode:
     // EXPLORATION MODE
-    Agent(ui-design-agent): `
+    Task(ui-design-agent): `
       [LAYOUT_CONCEPT_GENERATION_TASK]
       Generate {variants_count} structurally distinct layout concepts for each target
 
@@ -217,7 +217,7 @@ IF NOT refine_mode:
     `
 ELSE:
     // REFINEMENT MODE
-    Agent(ui-design-agent): `
+    Task(ui-design-agent): `
       [LAYOUT_REFINEMENT_OPTIONS_TASK]
       Generate refinement options for existing layout(s)
 
@@ -461,7 +461,7 @@ Proceeding to generate {total_selections} detailed layout template(s)...
 
 ## Phase 2: Layout Template Generation (Agent Task 2)
 
-**Executor**: `Agent(ui-design-agent)` × `Total_Selected_Templates` in **parallel**
+**Executor**: `Task(ui-design-agent)` × `Total_Selected_Templates` in **parallel**
 
 ### Step 1: Load User Selections or Default to All
 ```bash
@@ -512,7 +512,7 @@ REPORT: "Generating {total_tasks} layout templates across {targets.length} targe
 Generate layout templates for ALL selected concepts in parallel:
 ```javascript
 FOR each task in task_list:
-    Agent(ui-design-agent): `
+    Task(ui-design-agent): `
       [LAYOUT_TEMPLATE_GENERATION_TASK #{task.variant_id} for {task.target}]
       Generate detailed layout template based on user-selected concept.
       Focus ONLY on structure and layout. DO NOT concern with visual style (colors, fonts, etc.).

.claude/commands/workflow/ui-design/reference-page-generator.md

@@ -2,7 +2,7 @@
 name: workflow:ui-design:reference-page-generator
 description: Generate multi-component reference pages and documentation from design run extraction
 argument-hint: "[--design-run <path>] [--package-name <name>] [--output-dir <path>]"
-allowed-tools: Read,Write,Bash,Agent,TodoWrite
+allowed-tools: Read,Write,Bash,Task,TodoWrite
 auto-continue: true
 ---
 
@@ -198,7 +198,7 @@ echo "[Phase 1] Component data preparation complete"
 **Agent Task**:
 
 ```javascript
-Agent(ui-design-agent): `
+Task(ui-design-agent): `
   [PREVIEW_SHOWCASE_GENERATION]
   Generate interactive multi-component showcase panel for reference package
 
@@ -210,7 +210,7 @@ Agent(ui-design-agent): `
   2. ${package_dir}/design-tokens.json (design tokens - REQUIRED)
   3. ${package_dir}/animation-tokens.json (optional, if exists)
 
-  ## Generation Agent
+  ## Generation Task
 
   Create interactive showcase with these sections:
 

.claude/commands/workflow/unified-execute-with-file.md

@@ -2,7 +2,7 @@
 name: unified-execute-with-file
 description: Universal execution engine for consuming any planning/brainstorm/analysis output with minimal progress tracking, multi-agent coordination, and incremental execution
 argument-hint: "[-y|--yes] [<path>[,<path2>] | -p|--plan <path>[,<path2>]] [--auto-commit] [--commit-prefix \"prefix\"] [\"execution context or task name\"]"
-allowed-tools: TodoWrite(*), Agent(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
 ---
 
 ## Auto Mode
@@ -34,7 +34,7 @@ When `--yes` or `-y`: Auto-confirm execution decisions, follow plan's DAG depend
 ```
 
 **Execution Methods**:
-- **Agent**: Agent tool with code-developer (recommended for standard tasks)
+- **Agent**: Task tool with code-developer (recommended for standard tasks)
 - **CLI-Codex**: `ccw cli --tool codex` (complex tasks, git-aware)
 - **CLI-Gemini**: `ccw cli --tool gemini` (analysis-heavy tasks)
 - **Auto**: Select based on task complexity (default in `-y` mode)
@@ -99,7 +99,7 @@ Universal execution engine consuming **any** planning output and executing it wi
 │  Phase 5: Per-Task Execution (Agent OR CLI)                             │
 │     ├─ Extract relevant notes from previous tasks                       │
 │     ├─ Inject notes into execution context                              │
-│     ├─ Route to Agent (Agent tool) OR CLI (ccw cli command)              │
+│     ├─ Route to Agent (Task tool) OR CLI (ccw cli command)              │
 │     ├─ Generate structured notes for next task                          │
 │     ├─ Auto-commit if enabled (conventional commit format)              │
 │     └─ Append event to unified log                                      │
@@ -471,26 +471,11 @@ ${recommendations.map(r => \`- ${r}\`).join('\\n')}
 
 2. **Build Execution Context**
 
-   **Load Project Context** (from init.md products):
-   ```javascript
-   // Read project-tech.json (if exists)
-   const projectTech = file_exists('.workflow/project-tech.json')
-     ? JSON.parse(Read('.workflow/project-tech.json')) : null
-   // Read specs/*.md (if exists)
-   const projectGuidelines = file_exists('.ccw/specs/*.md')
-     ? JSON.parse(Read('.ccw/specs/*.md')) : null
-   ```
-
    ```javascript
    const executionContext = `
    ⚠️ Execution Notes from Previous Tasks
    ${relevantNotes}  // Categorized notes with severity
 
-   📋 Project Context (from init.md)
-   - Tech Stack: ${projectTech?.technology_analysis?.technology_stack || 'N/A'}
-   - Architecture: ${projectTech?.technology_analysis?.architecture?.style || 'N/A'}
-   - Constraints: ${projectGuidelines?.constraints || 'None defined'}
-
    Current Task: ${task.id}
    - Original ID: ${task.original_id}
    - Source Plan: ${task.source_plan}
@@ -507,10 +492,10 @@ ${recommendations.map(r => \`- ${r}\`).join('\\n')}
 
    When: `executionMethod === "Agent"` or `Auto + Low Complexity`
 
-   Execute task via Agent tool with code-developer agent:
+   Execute task via Task tool with code-developer agent:
 
    ```javascript
-   Agent({
+   Task({
      subagent_type: "code-developer",  // or other agent types
      run_in_background: false,
      description: task.title,
@@ -658,15 +643,9 @@ ${recommendations.map(r => \`- ${r}\`).join('\\n')}
    - "优化执行" → Analyze execution improvements
    - "完成" → No further action
 
-5. **Sync Session State** (automatic, unless `--dry-run`)
-   - Execute: `/workflow:session:sync -y "Execution complete: ${completedCount}/${totalCount} tasks succeeded"`
-   - Updates specs/*.md with any learnings from execution
-   - Updates project-tech.json with development index entry
-
 **Success Criteria**:
 - [ ] Statistics collected and displayed
 - [ ] execution.md updated with final status
-- [ ] Session state synced via /workflow:session:sync
 - [ ] User informed of completion
 
 ---

.claude/scripts/cleanup-ghost-commands.mjs

@@ -43,19 +43,19 @@ function getExistingCommandSources() {
 // These commands were migrated to skills but references were never updated
 const COMMAND_TO_SKILL_MAP = {
   // workflow commands → skills
-  '/workflow-plan': 'workflow-plan',
-  '/workflow-execute': 'workflow-execute',
-  '/workflow-lite-plan': 'workflow-lite-plan',
+  '/workflow:plan': 'workflow-plan',
+  '/workflow:execute': 'workflow-execute',
+  '/workflow:lite-plan': 'workflow-lite-plan',
   '/workflow:lite-execute': 'workflow-lite-plan',  // lite-execute is part of lite-plan skill
   '/workflow:lite-fix': 'workflow-lite-plan',       // lite-fix is part of lite-plan skill
-  '/workflow-multi-cli-plan': 'workflow-multi-cli-plan',
-  '/workflow-plan-verify': 'workflow-plan',          // plan-verify is a phase of workflow-plan
+  '/workflow:multi-cli-plan': 'workflow-multi-cli-plan',
+  '/workflow:plan-verify': 'workflow-plan',          // plan-verify is a phase of workflow-plan
   '/workflow:replan': 'workflow-plan',               // replan is a phase of workflow-plan
-  '/workflow-tdd-plan': 'workflow-tdd-plan',
-  '/workflow-tdd-verify': 'workflow-tdd-plan',            // tdd-verify is a phase of workflow-tdd-plan
-  '/workflow-test-fix': 'workflow-test-fix',
+  '/workflow:tdd-plan': 'workflow-tdd',
+  '/workflow:tdd-verify': 'workflow-tdd',            // tdd-verify is a phase of workflow-tdd
+  '/workflow:test-fix-gen': 'workflow-test-fix',
   '/workflow:test-gen': 'workflow-test-fix',
-  '/workflow-test-fix': 'workflow-test-fix',
+  '/workflow:test-cycle-execute': 'workflow-test-fix',
   '/workflow:review': 'review-cycle',
   '/workflow:review-session-cycle': 'review-cycle',
   '/workflow:review-module-cycle': 'review-cycle',
@@ -70,8 +70,8 @@ const COMMAND_TO_SKILL_MAP = {
   '/workflow:tools:context-gather': 'workflow-plan',
   '/workflow:tools:conflict-resolution': 'workflow-plan',
   '/workflow:tools:task-generate-agent': 'workflow-plan',
-  '/workflow:tools:task-generate-tdd': 'workflow-tdd-plan',
-  '/workflow:tools:tdd-coverage-analysis': 'workflow-tdd-plan',
+  '/workflow:tools:task-generate-tdd': 'workflow-tdd',
+  '/workflow:tools:tdd-coverage-analysis': 'workflow-tdd',
   '/workflow:tools:test-concept-enhanced': 'workflow-test-fix',
   '/workflow:tools:test-context-gather': 'workflow-test-fix',
   '/workflow:tools:test-task-generate': 'workflow-test-fix',
@@ -319,17 +319,17 @@ function fixBrokenReferences() {
     // Pattern: `/ command:name` references that point to non-existent commands
     // These are documentation references - update to point to skill names
     const proseRefFixes = {
-      '`/workflow-plan`': '`workflow-plan` skill',
-      '`/workflow-execute`': '`workflow-execute` skill',
+      '`/workflow:plan`': '`workflow-plan` skill',
+      '`/workflow:execute`': '`workflow-execute` skill',
       '`/workflow:lite-execute`': '`workflow-lite-plan` skill',
       '`/workflow:lite-fix`': '`workflow-lite-plan` skill',
-      '`/workflow-plan-verify`': '`workflow-plan` skill (plan-verify phase)',
+      '`/workflow:plan-verify`': '`workflow-plan` skill (plan-verify phase)',
       '`/workflow:replan`': '`workflow-plan` skill (replan phase)',
-      '`/workflow-tdd-plan`': '`workflow-tdd-plan` skill',
-      '`/workflow-tdd-verify`': '`workflow-tdd-plan` skill (tdd-verify phase)',
-      '`/workflow-test-fix`': '`workflow-test-fix` skill',
+      '`/workflow:tdd-plan`': '`workflow-tdd` skill',
+      '`/workflow:tdd-verify`': '`workflow-tdd` skill (tdd-verify phase)',
+      '`/workflow:test-fix-gen`': '`workflow-test-fix` skill',
       '`/workflow:test-gen`': '`workflow-test-fix` skill',
-      '`/workflow-test-fix`': '`workflow-test-fix` skill',
+      '`/workflow:test-cycle-execute`': '`workflow-test-fix` skill',
       '`/workflow:review`': '`review-cycle` skill',
       '`/workflow:review-session-cycle`': '`review-cycle` skill',
       '`/workflow:review-module-cycle`': '`review-cycle` skill',
@@ -346,8 +346,8 @@ function fixBrokenReferences() {
       '`/workflow:tools:task-generate`': '`workflow-plan` skill (task-generate phase)',
       '`/workflow:ui-design:auto`': '`/workflow:ui-design:explore-auto`',
       '`/workflow:ui-design:update`': '`/workflow:ui-design:generate`',
-      '`/workflow-multi-cli-plan`': '`workflow-multi-cli-plan` skill',
-      '`/workflow-lite-plan`': '`workflow-lite-plan` skill',
+      '`/workflow:multi-cli-plan`': '`workflow-multi-cli-plan` skill',
+      '`/workflow:lite-plan`': '`workflow-lite-plan` skill',
       '`/cli:plan`': '`workflow-lite-plan` skill',
       '`/test-cycle-execute`': '`workflow-test-fix` skill',
     };

.claude/skills/_shared/COMMAND-TO-SKILL-CONVERSION.md

@@ -83,7 +83,7 @@
 | 内容类型 | 保留要求 | 示例 |
 |---------|---------|------|
 | **Bash命令** | 完整命令，包含所有参数、管道、重定向 | `find . -name "*.json" \| head -1` |
-| **Agent Prompt** | 全文保留，包含OBJECTIVE、TASK、EXPECTED等所有节 | 完整的Agent({prompt: "..."}) |
+| **Agent Prompt** | 全文保留，包含OBJECTIVE、TASK、EXPECTED等所有节 | 完整的Task({prompt: "..."}) |
 | **代码函数** | 完整函数体，所有if/else分支 | `analyzeTaskComplexity()` 全部代码 |
 | **参数表格** | 所有行列，不省略任何参数 | Session Types表格 |
 | **JSON Schema** | 所有字段、类型、required定义 | context-package.json schema |
@@ -95,7 +95,7 @@
 
 1. **将代码替换为描述**
    - ❌ 错误：`Execute context gathering agent`
-   - ✅ 正确：完整的 `Agent({ subagent_type: "context-search-agent", prompt: "...[完整200行prompt]..." })`
+   - ✅ 正确：完整的 `Task({ subagent_type: "context-search-agent", prompt: "...[完整200行prompt]..." })`
 
 2. **省略Prompt内容**
    - ❌ 错误：`Agent prompt for context gathering (see original file)`
@@ -123,7 +123,7 @@
 | **命令调用语法** | 转换为 Phase 文件的相对路径 | `/workflow:session:start` → `phases/01-session-discovery.md` |
 | **命令路径引用** | 转换为 Skill 目录内路径 | `commands/workflow/tools/` → `phases/` |
 | **跨命令引用** | 转换为 Phase 间文件引用 | `workflow-plan` skill (context-gather phase) → `phases/02-context-gathering.md` |
-| **命令参数说明** | 移除或转为 Phase Prerequisites | `usage: /workflow-plan [session-id]` → Phase Prerequisites 中说明 |
+| **命令参数说明** | 移除或转为 Phase Prerequisites | `usage: /workflow:plan [session-id]` → Phase Prerequisites 中说明 |
 
 **转换示例**：
 
@@ -277,7 +277,7 @@ commands/                              skills/
 ---
 name: {skill-name}
 description: {简短描述}. Triggers on "{trigger-phrase}".
-allowed-tools: Agent, AskUserQuestion, TodoWrite, Read, Write, Edit, Bash, Glob, Grep
+allowed-tools: Task, AskUserQuestion, TodoWrite, Read, Write, Edit, Bash, Glob, Grep
 ---
 ```
 
@@ -440,7 +440,7 @@ Complete: IMPL_PLAN.md + Task JSONs
 |--------|---------|---------|
 | **代码块数量** | 计数 ` ```bash ` 和 ` ```javascript ` | 与原文件相等 |
 | **表格数量** | 计数 ` \| ` 开头的行 | 与原文件相等 |
-| **Agent Prompt** | 搜索 `Agent({` | 完整的prompt参数内容 |
+| **Agent Prompt** | 搜索 `Task({` | 完整的prompt参数内容 |
 | **步骤编号** | 检查 `### Step` | 编号序列与原文件一致 |
 | **文件行数** | `wc -l` | ±20%以内 |
 | **关键函数** | 搜索函数名 | 所有函数完整保留 |
@@ -492,10 +492,10 @@ Execute the context-search-agent to gather project context.
 ### Step 2: Run context gathering
 
 ```javascript
-Agent({
+Task({
   subagent_type: "context-search-agent",
   prompt: `
-## Context Search Agent
+## Context Search Task
 
 ### OBJECTIVE
 Gather comprehensive context for planning session ${sessionId}
@@ -535,7 +535,7 @@ Gather comprehensive context for planning session ${sessionId}
 │       └─→ 数量应相等                                            │
 │                                                                  │
 │  Step 3: 关键内容抽查                                            │
-│       - 搜索 Agent({ → Agent Prompt 完整性                        │
+│       - 搜索 Task({ → Agent Prompt 完整性                        │
 │       - 搜索函数名 → 函数体完整性                                │
 │       - 搜索表格标记 → 表格完整性                                │
 │                                                                  │
@@ -562,8 +562,8 @@ grep -c '^|' commands/workflow/tools/context-gather.md
 grep -c '^|' skills/workflow-plan/phases/02-context-gathering.md
 
 # 4. Agent Prompt检查
-grep -c 'Agent({' commands/workflow/tools/context-gather.md
-grep -c 'Agent({' skills/workflow-plan/phases/02-context-gathering.md
+grep -c 'Task({' commands/workflow/tools/context-gather.md
+grep -c 'Task({' skills/workflow-plan/phases/02-context-gathering.md
 
 # 5. 函数定义检查
 grep -E '^(function|const.*=.*=>|async function)' commands/workflow/tools/context-gather.md

.claude/skills/_shared/SKILL-DESIGN-SPEC.md

@@ -18,8 +18,6 @@
 10. [质量控制规范](#10-质量控制规范)
 11. [最佳实践清单](#11-最佳实践清单)
 12. [示例模板](#12-示例模板)
-13. [Completion Status Protocol](#13-completion-status-protocol)
-14. [Escalation Protocol](#14-escalation-protocol)
 
 ---
 
@@ -142,7 +140,7 @@ graph TD
 ---
 name: {skill-name}
 description: {一句话描述}. {触发关键词}. Triggers on "{关键词1}", "{关键词2}".
-allowed-tools: Agent, AskUserQuestion, Read, Bash, Glob, Grep, Write, {其他MCP工具}
+allowed-tools: Task, AskUserQuestion, Read, Bash, Glob, Grep, Write, {其他MCP工具}
 ---
 
 # {Skill 标题}
@@ -194,7 +192,7 @@ description: |                # 必需：描述 + 触发词
   Generate XXX documents. 
   Triggers on "keyword1", "keyword2".
 allowed-tools: |              # 必需：允许使用的工具
-  Agent, AskUserQuestion, Read, Bash,
+  Task, AskUserQuestion, Read, Bash, 
   Glob, Grep, Write, mcp__chrome__*
 ---
 ```
@@ -643,7 +641,7 @@ touch my-skill/templates/agent-base.md
 ---
 name: my-skill
 description: Generate XXX. Triggers on "keyword1", "keyword2".
-allowed-tools: Agent, AskUserQuestion, Read, Bash, Glob, Grep, Write
+allowed-tools: Task, AskUserQuestion, Read, Bash, Glob, Grep, Write
 ---
 
 # My Skill
@@ -667,144 +665,6 @@ Generate XXX through multi-phase analysis.
 
 ---
 
-## 13. Completion Status Protocol
-
-### 13.1 Status Definitions
-
-Every Skill execution MUST terminate with one of the following four statuses:
-
-| Status | Exit Code | Definition |
-|--------|-----------|------------|
-| **DONE** | 0 | All acceptance criteria met, outputs generated successfully |
-| **DONE_WITH_CONCERNS** | 0 | Completed but with warnings or non-blocking issues |
-| **BLOCKED** | 1 | Cannot proceed, requires external action or resource |
-| **NEEDS_CONTEXT** | 2 | Missing information needed to make a decision |
-
-### 13.2 When to Use
-
-| Status | Use When |
-|--------|----------|
-| **DONE** | All phases completed, quality gates passed, outputs validated |
-| **DONE_WITH_CONCERNS** | Core task completed but: deprecation warnings found, quality score 60-79%, non-critical checks failed, partial data used as fallback |
-| **BLOCKED** | Required file/service unavailable, dependency not installed, permission denied, prerequisite task not completed |
-| **NEEDS_CONTEXT** | Ambiguous user requirement, multiple valid interpretations, missing configuration value, unclear scope boundary |
-
-### 13.3 Output Format
-
-Each status MUST use the following structured output at the end of Skill execution:
-
-```
-## STATUS: {DONE|DONE_WITH_CONCERNS|BLOCKED|NEEDS_CONTEXT}
-
-**Summary**: {one-line description of outcome}
-
-### Details
-{status-specific content — see below}
-
-### Outputs
-- {list of files created/modified, if any}
-```
-
-**DONE details**:
-```
-### Details
-- Phases completed: {N}/{N}
-- Quality score: {score}%
-- Key outputs: {list of primary deliverables}
-```
-
-**DONE_WITH_CONCERNS details**:
-```
-### Details
-- Phases completed: {N}/{N}
-- Concerns:
-  1. {concern description} — Impact: {low|medium} — Suggested fix: {action}
-  2. ...
-```
-
-**BLOCKED details**:
-```
-### Details
-- Blocked at: Phase {N}, Step {M}
-- Blocker: {specific description of what is blocking}
-- Need: {specific action or resource required to unblock}
-- Attempted: {what was tried before declaring blocked}
-```
-
-**NEEDS_CONTEXT details**:
-```
-### Details
-- Paused at: Phase {N}, Step {M}
-- Questions:
-  1. {specific question requiring user/caller input}
-  2. ...
-- Context available: {what is already known}
-- Impact: {what cannot proceed without answers}
-```
-
----
-
-## 14. Escalation Protocol
-
-### 14.1 Three-Strike Rule
-
-When a Skill encounters consecutive failures on the **same step**, the following escalation applies:
-
-| Strike | Action |
-|--------|--------|
-| 1st failure | Log error, retry with adjusted approach |
-| 2nd failure | Log error, try alternative strategy |
-| 3rd failure | **STOP execution immediately**, output diagnostic dump, request human intervention |
-
-### 14.2 Failure Tracking
-
-Track failures per step, not globally. A success on any step resets that step's failure counter.
-
-```
-Step failure counter:
-  Phase 2, Step 3: [fail] [fail] [STOP]  → escalate
-  Phase 2, Step 4: [fail] [success]       → counter reset, continue
-```
-
-### 14.3 Diagnostic Dump Format
-
-On the 3rd consecutive failure, output the following diagnostic block:
-
-```
-## ESCALATION: 3-Strike Limit Reached
-
-### Failed Step
-- Phase: {phase_number} — {phase_name}
-- Step: {step_number} — {step_name}
-
-### Error History
-1. Attempt 1: {error message or description}
-   Strategy: {what was tried}
-2. Attempt 2: {error message or description}
-   Strategy: {alternative approach tried}
-3. Attempt 3: {error message or description}
-   Strategy: {final approach tried}
-
-### Current State
-- Last successful phase/step: {phase.step}
-- Files generated so far: {list}
-- Files touched in failed attempts: {list}
-
-### Diagnosis
-- Likely root cause: {assessment}
-- Suggested human action: {specific recommendation}
-```
-
-### 14.4 Post-Escalation Behavior
-
-After outputting the diagnostic dump:
-1. Set Skill status to **BLOCKED** (see Section 13)
-2. Do NOT attempt further retries
-3. Preserve all intermediate outputs for debugging
-4. Wait for human intervention before resuming
-
----
-
 ## 附录 A: 设计对比
 
 | 设计点 | software-manual | copyright-docs |
@@ -820,7 +680,7 @@ After outputting the diagnostic dump:
 
 | 工具 | 用途 | 适用 Skill |
 |------|------|------------|
-| `Agent` | 启动子 Agent | 所有 |
+| `Task` | 启动子 Agent | 所有 |
 | `AskUserQuestion` | 用户交互 | 所有 |
 | `Read/Write/Glob/Grep` | 文件操作 | 所有 |
 | `Bash` | 脚本执行 | 需要自动化 |

.claude/skills/_shared/mermaid-utils.md

@@ -0,0 +1,584 @@
+# Mermaid Utilities Library
+
+Shared utilities for generating and validating Mermaid diagrams across all analysis skills.
+
+## Sanitization Functions
+
+### sanitizeId
+
+Convert any text to a valid Mermaid node ID.
+
+```javascript
+/**
+ * Sanitize text to valid Mermaid node ID
+ * - Only alphanumeric and underscore allowed
+ * - Cannot start with number
+ * - Truncates to 50 chars max
+ * 
+ * @param {string} text - Input text
+ * @returns {string} - Valid Mermaid ID
+ */
+function sanitizeId(text) {
+  if (!text) return '_empty';
+  return text
+    .replace(/[^a-zA-Z0-9_\u4e00-\u9fa5]/g, '_')  // Allow Chinese chars
+    .replace(/^[0-9]/, '_$&')                      // Prefix number with _
+    .replace(/_+/g, '_')                           // Collapse multiple _
+    .substring(0, 50);                             // Limit length
+}
+
+// Examples:
+// sanitizeId("User-Service") → "User_Service"
+// sanitizeId("3rdParty") → "_3rdParty"
+// sanitizeId("用户服务") → "用户服务"
+```
+
+### escapeLabel
+
+Escape special characters for Mermaid labels.
+
+```javascript
+/**
+ * Escape special characters in Mermaid labels
+ * Uses HTML entity encoding for problematic chars
+ * 
+ * @param {string} text - Label text
+ * @returns {string} - Escaped label
+ */
+function escapeLabel(text) {
+  if (!text) return '';
+  return text
+    .replace(/"/g, "'")                            // Avoid quote issues
+    .replace(/\(/g, '#40;')                        // (
+    .replace(/\)/g, '#41;')                        // )
+    .replace(/\{/g, '#123;')                       // {
+    .replace(/\}/g, '#125;')                       // }
+    .replace(/\[/g, '#91;')                        // [
+    .replace(/\]/g, '#93;')                        // ]
+    .replace(/</g, '#60;')                         // <
+    .replace(/>/g, '#62;')                         // >
+    .replace(/\|/g, '#124;')                       // |
+    .substring(0, 80);                             // Limit length
+}
+
+// Examples:
+// escapeLabel("Process(data)") → "Process#40;data#41;"
+// escapeLabel("Check {valid?}") → "Check #123;valid?#125;"
+```
+
+### sanitizeType
+
+Sanitize type names for class diagrams.
+
+```javascript
+/**
+ * Sanitize type names for Mermaid classDiagram
+ * Removes generics syntax that causes issues
+ * 
+ * @param {string} type - Type name
+ * @returns {string} - Sanitized type
+ */
+function sanitizeType(type) {
+  if (!type) return 'any';
+  return type
+    .replace(/<[^>]*>/g, '')           // Remove generics <T>
+    .replace(/\|/g, ' or ')            // Union types
+    .replace(/&/g, ' and ')            // Intersection types
+    .replace(/\[\]/g, 'Array')         // Array notation
+    .substring(0, 30);
+}
+
+// Examples:
+// sanitizeType("Array<string>") → "Array"
+// sanitizeType("string | number") → "string or number"
+```
+
+## Diagram Generation Functions
+
+### generateFlowchartNode
+
+Generate a flowchart node with proper shape.
+
+```javascript
+/**
+ * Generate flowchart node with shape
+ * 
+ * @param {string} id - Node ID
+ * @param {string} label - Display label
+ * @param {string} type - Node type: start|end|process|decision|io|subroutine
+ * @returns {string} - Mermaid node definition
+ */
+function generateFlowchartNode(id, label, type = 'process') {
+  const safeId = sanitizeId(id);
+  const safeLabel = escapeLabel(label);
+  
+  const shapes = {
+    start: `${safeId}(["${safeLabel}"])`,           // Stadium shape
+    end: `${safeId}(["${safeLabel}"])`,             // Stadium shape
+    process: `${safeId}["${safeLabel}"]`,           // Rectangle
+    decision: `${safeId}{"${safeLabel}"}`,          // Diamond
+    io: `${safeId}[/"${safeLabel}"/]`,              // Parallelogram
+    subroutine: `${safeId}[["${safeLabel}"]]`,      // Subroutine
+    database: `${safeId}[("${safeLabel}")]`,        // Cylinder
+    manual: `${safeId}[/"${safeLabel}"\\]`          // Trapezoid
+  };
+  
+  return shapes[type] || shapes.process;
+}
+```
+
+### generateFlowchartEdge
+
+Generate a flowchart edge with optional label.
+
+```javascript
+/**
+ * Generate flowchart edge
+ * 
+ * @param {string} from - Source node ID
+ * @param {string} to - Target node ID
+ * @param {string} label - Edge label (optional)
+ * @param {string} style - Edge style: solid|dashed|thick
+ * @returns {string} - Mermaid edge definition
+ */
+function generateFlowchartEdge(from, to, label = '', style = 'solid') {
+  const safeFrom = sanitizeId(from);
+  const safeTo = sanitizeId(to);
+  const safeLabel = label ? `|"${escapeLabel(label)}"|` : '';
+  
+  const arrows = {
+    solid: '-->',
+    dashed: '-.->',
+    thick: '==>'
+  };
+  
+  const arrow = arrows[style] || arrows.solid;
+  return `    ${safeFrom} ${arrow}${safeLabel} ${safeTo}`;
+}
+```
+
+### generateAlgorithmFlowchart (Enhanced)
+
+Generate algorithm flowchart with branch/loop support.
+
+```javascript
+/**
+ * Generate algorithm flowchart with decision support
+ * 
+ * @param {Object} algorithm - Algorithm definition
+ *   - name: Algorithm name
+ *   - inputs: [{name, type}]
+ *   - outputs: [{name, type}]
+ *   - steps: [{id, description, type, next: [id], conditions: [text]}]
+ * @returns {string} - Complete Mermaid flowchart
+ */
+function generateAlgorithmFlowchart(algorithm) {
+  let mermaid = 'flowchart TD\n';
+  
+  // Start node
+  mermaid += `    START(["开始: ${escapeLabel(algorithm.name)}"])\n`;
+  
+  // Input node (if has inputs)
+  if (algorithm.inputs?.length > 0) {
+    const inputList = algorithm.inputs.map(i => `${i.name}: ${i.type}`).join(', ');
+    mermaid += `    INPUT[/"输入: ${escapeLabel(inputList)}"/]\n`;
+    mermaid += `    START --> INPUT\n`;
+  }
+  
+  // Process nodes
+  const steps = algorithm.steps || [];
+  for (const step of steps) {
+    const nodeId = sanitizeId(step.id || `STEP_${step.step_num}`);
+    
+    if (step.type === 'decision') {
+      mermaid += `    ${nodeId}{"${escapeLabel(step.description)}"}\n`;
+    } else if (step.type === 'io') {
+      mermaid += `    ${nodeId}[/"${escapeLabel(step.description)}"/]\n`;
+    } else if (step.type === 'loop_start') {
+      mermaid += `    ${nodeId}[["循环: ${escapeLabel(step.description)}"]]\n`;
+    } else {
+      mermaid += `    ${nodeId}["${escapeLabel(step.description)}"]\n`;
+    }
+  }
+  
+  // Output node
+  const outputDesc = algorithm.outputs?.map(o => o.name).join(', ') || '结果';
+  mermaid += `    OUTPUT[/"输出: ${escapeLabel(outputDesc)}"/]\n`;
+  mermaid += `    END_(["结束"])\n`;
+  
+  // Connect first step to input/start
+  if (steps.length > 0) {
+    const firstStep = sanitizeId(steps[0].id || 'STEP_1');
+    if (algorithm.inputs?.length > 0) {
+      mermaid += `    INPUT --> ${firstStep}\n`;
+    } else {
+      mermaid += `    START --> ${firstStep}\n`;
+    }
+  }
+  
+  // Connect steps based on next array
+  for (const step of steps) {
+    const nodeId = sanitizeId(step.id || `STEP_${step.step_num}`);
+    
+    if (step.next && step.next.length > 0) {
+      step.next.forEach((nextId, index) => {
+        const safeNextId = sanitizeId(nextId);
+        const condition = step.conditions?.[index];
+        
+        if (condition) {
+          mermaid += `    ${nodeId} -->|"${escapeLabel(condition)}"| ${safeNextId}\n`;
+        } else {
+          mermaid += `    ${nodeId} --> ${safeNextId}\n`;
+        }
+      });
+    } else if (!step.type?.includes('end')) {
+      // Default: connect to next step or output
+      const stepIndex = steps.indexOf(step);
+      if (stepIndex < steps.length - 1) {
+        const nextStep = sanitizeId(steps[stepIndex + 1].id || `STEP_${stepIndex + 2}`);
+        mermaid += `    ${nodeId} --> ${nextStep}\n`;
+      } else {
+        mermaid += `    ${nodeId} --> OUTPUT\n`;
+      }
+    }
+  }
+  
+  // Connect output to end
+  mermaid += `    OUTPUT --> END_\n`;
+  
+  return mermaid;
+}
+```
+
+## Diagram Validation
+
+### validateMermaidSyntax
+
+Comprehensive Mermaid syntax validation.
+
+```javascript
+/**
+ * Validate Mermaid diagram syntax
+ * 
+ * @param {string} content - Mermaid diagram content
+ * @returns {Object} - {valid: boolean, issues: string[]}
+ */
+function validateMermaidSyntax(content) {
+  const issues = [];
+  
+  // Check 1: Diagram type declaration
+  if (!content.match(/^(graph|flowchart|classDiagram|sequenceDiagram|stateDiagram|erDiagram|gantt|pie|mindmap)/m)) {
+    issues.push('Missing diagram type declaration');
+  }
+  
+  // Check 2: Undefined values
+  if (content.includes('undefined') || content.includes('null')) {
+    issues.push('Contains undefined/null values');
+  }
+  
+  // Check 3: Invalid arrow syntax
+  if (content.match(/-->\s*-->/)) {
+    issues.push('Double arrow syntax error');
+  }
+  
+  // Check 4: Unescaped special characters in labels
+  const labelMatches = content.match(/\["[^"]*[(){}[\]<>][^"]*"\]/g);
+  if (labelMatches?.some(m => !m.includes('#'))) {
+    issues.push('Unescaped special characters in labels');
+  }
+  
+  // Check 5: Node ID starts with number
+  if (content.match(/\n\s*[0-9][a-zA-Z0-9_]*[\[\({]/)) {
+    issues.push('Node ID cannot start with number');
+  }
+  
+  // Check 6: Nested subgraph syntax error
+  if (content.match(/subgraph\s+\S+\s*\n[^e]*subgraph/)) {
+    // This is actually valid, only flag if brackets don't match
+    const subgraphCount = (content.match(/subgraph/g) || []).length;
+    const endCount = (content.match(/\bend\b/g) || []).length;
+    if (subgraphCount > endCount) {
+      issues.push('Unbalanced subgraph/end blocks');
+    }
+  }
+  
+  // Check 7: Invalid arrow type for diagram type
+  const diagramType = content.match(/^(graph|flowchart|classDiagram|sequenceDiagram)/m)?.[1];
+  if (diagramType === 'classDiagram' && content.includes('-->|')) {
+    issues.push('Invalid edge label syntax for classDiagram');
+  }
+  
+  // Check 8: Empty node labels
+  if (content.match(/\[""\]|\{\}|\(\)/)) {
+    issues.push('Empty node labels detected');
+  }
+  
+  // Check 9: Reserved keywords as IDs
+  const reserved = ['end', 'graph', 'subgraph', 'direction', 'class', 'click'];
+  for (const keyword of reserved) {
+    const pattern = new RegExp(`\\n\\s*${keyword}\\s*[\\[\\(\\{]`, 'i');
+    if (content.match(pattern)) {
+      issues.push(`Reserved keyword "${keyword}" used as node ID`);
+    }
+  }
+  
+  // Check 10: Line length (Mermaid has issues with very long lines)
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].length > 500) {
+      issues.push(`Line ${i + 1} exceeds 500 characters`);
+    }
+  }
+  
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+```
+
+### validateDiagramDirectory
+
+Validate all diagrams in a directory.
+
+```javascript
+/**
+ * Validate all Mermaid diagrams in directory
+ * 
+ * @param {string} diagramDir - Path to diagrams directory
+ * @returns {Object[]} - Array of {file, valid, issues}
+ */
+function validateDiagramDirectory(diagramDir) {
+  const files = Glob(`${diagramDir}/*.mmd`);
+  const results = [];
+
+  for (const file of files) {
+    const content = Read(file);
+    const validation = validateMermaidSyntax(content);
+    
+    results.push({
+      file: file.split('/').pop(),
+      path: file,
+      valid: validation.valid,
+      issues: validation.issues,
+      lines: content.split('\n').length
+    });
+  }
+
+  return results;
+}
+```
+
+## Class Diagram Utilities
+
+### generateClassDiagram
+
+Generate class diagram with relationships.
+
+```javascript
+/**
+ * Generate class diagram from analysis data
+ * 
+ * @param {Object} analysis - Data structure analysis
+ *   - entities: [{name, type, properties, methods}]
+ *   - relationships: [{from, to, type, label}]
+ * @param {Object} options - Generation options
+ *   - maxClasses: Max classes to include (default: 15)
+ *   - maxProperties: Max properties per class (default: 8)
+ *   - maxMethods: Max methods per class (default: 6)
+ * @returns {string} - Mermaid classDiagram
+ */
+function generateClassDiagram(analysis, options = {}) {
+  const maxClasses = options.maxClasses || 15;
+  const maxProperties = options.maxProperties || 8;
+  const maxMethods = options.maxMethods || 6;
+  
+  let mermaid = 'classDiagram\n';
+
+  const entities = (analysis.entities || []).slice(0, maxClasses);
+  
+  // Generate classes
+  for (const entity of entities) {
+    const className = sanitizeId(entity.name);
+    mermaid += `    class ${className} {\n`;
+
+    // Properties
+    for (const prop of (entity.properties || []).slice(0, maxProperties)) {
+      const vis = {public: '+', private: '-', protected: '#'}[prop.visibility] || '+';
+      const type = sanitizeType(prop.type);
+      mermaid += `        ${vis}${type} ${prop.name}\n`;
+    }
+
+    // Methods
+    for (const method of (entity.methods || []).slice(0, maxMethods)) {
+      const vis = {public: '+', private: '-', protected: '#'}[method.visibility] || '+';
+      const params = (method.params || []).map(p => p.name).join(', ');
+      const returnType = sanitizeType(method.returnType || 'void');
+      mermaid += `        ${vis}${method.name}(${params}) ${returnType}\n`;
+    }
+
+    mermaid += '    }\n';
+    
+    // Add stereotype if applicable
+    if (entity.type === 'interface') {
+      mermaid += `    <<interface>> ${className}\n`;
+    } else if (entity.type === 'abstract') {
+      mermaid += `    <<abstract>> ${className}\n`;
+    }
+  }
+
+  // Generate relationships
+  const arrows = {
+    inheritance: '--|>',
+    implementation: '..|>',
+    composition: '*--',
+    aggregation: 'o--',
+    association: '-->',
+    dependency: '..>'
+  };
+
+  for (const rel of (analysis.relationships || [])) {
+    const from = sanitizeId(rel.from);
+    const to = sanitizeId(rel.to);
+    const arrow = arrows[rel.type] || '-->';
+    const label = rel.label ? ` : ${escapeLabel(rel.label)}` : '';
+    
+    // Only include if both entities exist
+    if (entities.some(e => sanitizeId(e.name) === from) && 
+        entities.some(e => sanitizeId(e.name) === to)) {
+      mermaid += `    ${from} ${arrow} ${to}${label}\n`;
+    }
+  }
+
+  return mermaid;
+}
+```
+
+## Sequence Diagram Utilities
+
+### generateSequenceDiagram
+
+Generate sequence diagram from scenario.
+
+```javascript
+/**
+ * Generate sequence diagram from scenario
+ * 
+ * @param {Object} scenario - Sequence scenario
+ *   - name: Scenario name
+ *   - actors: [{id, name, type}]
+ *   - messages: [{from, to, description, type}]
+ *   - blocks: [{type, condition, messages}]
+ * @returns {string} - Mermaid sequenceDiagram
+ */
+function generateSequenceDiagram(scenario) {
+  let mermaid = 'sequenceDiagram\n';
+
+  // Title
+  if (scenario.name) {
+    mermaid += `    title ${escapeLabel(scenario.name)}\n`;
+  }
+
+  // Participants
+  for (const actor of scenario.actors || []) {
+    const actorType = actor.type === 'external' ? 'actor' : 'participant';
+    mermaid += `    ${actorType} ${sanitizeId(actor.id)} as ${escapeLabel(actor.name)}\n`;
+  }
+
+  mermaid += '\n';
+
+  // Messages
+  for (const msg of scenario.messages || []) {
+    const from = sanitizeId(msg.from);
+    const to = sanitizeId(msg.to);
+    const desc = escapeLabel(msg.description);
+    
+    let arrow;
+    switch (msg.type) {
+      case 'async': arrow = '->>'; break;
+      case 'response': arrow = '-->>'; break;
+      case 'create': arrow = '->>+'; break;
+      case 'destroy': arrow = '->>-'; break;
+      case 'self': arrow = '->>'; break;
+      default: arrow = '->>';
+    }
+
+    mermaid += `    ${from}${arrow}${to}: ${desc}\n`;
+
+    // Activation
+    if (msg.activate) {
+      mermaid += `    activate ${to}\n`;
+    }
+    if (msg.deactivate) {
+      mermaid += `    deactivate ${from}\n`;
+    }
+
+    // Notes
+    if (msg.note) {
+      mermaid += `    Note over ${to}: ${escapeLabel(msg.note)}\n`;
+    }
+  }
+
+  // Blocks (loops, alt, opt)
+  for (const block of scenario.blocks || []) {
+    switch (block.type) {
+      case 'loop':
+        mermaid += `    loop ${escapeLabel(block.condition)}\n`;
+        break;
+      case 'alt':
+        mermaid += `    alt ${escapeLabel(block.condition)}\n`;
+        break;
+      case 'opt':
+        mermaid += `    opt ${escapeLabel(block.condition)}\n`;
+        break;
+    }
+    
+    for (const m of block.messages || []) {
+      mermaid += `        ${sanitizeId(m.from)}->>${sanitizeId(m.to)}: ${escapeLabel(m.description)}\n`;
+    }
+    
+    mermaid += '    end\n';
+  }
+
+  return mermaid;
+}
+```
+
+## Usage Examples
+
+### Example 1: Algorithm with Branches
+
+```javascript
+const algorithm = {
+  name: "用户认证流程",
+  inputs: [{name: "credentials", type: "Object"}],
+  outputs: [{name: "token", type: "JWT"}],
+  steps: [
+    {id: "validate", description: "验证输入格式", type: "process"},
+    {id: "check_user", description: "用户是否存在?", type: "decision", 
+     next: ["verify_pwd", "error_user"], conditions: ["是", "否"]},
+    {id: "verify_pwd", description: "验证密码", type: "process"},
+    {id: "pwd_ok", description: "密码正确?", type: "decision",
+     next: ["gen_token", "error_pwd"], conditions: ["是", "否"]},
+    {id: "gen_token", description: "生成 JWT Token", type: "process"},
+    {id: "error_user", description: "返回用户不存在", type: "io"},
+    {id: "error_pwd", description: "返回密码错误", type: "io"}
+  ]
+};
+
+const flowchart = generateAlgorithmFlowchart(algorithm);
+```
+
+### Example 2: Validate Before Output
+
+```javascript
+const diagram = generateClassDiagram(analysis);
+const validation = validateMermaidSyntax(diagram);
+
+if (!validation.valid) {
+  console.log("Diagram has issues:", validation.issues);
+  // Fix issues or regenerate
+} else {
+  Write(`${outputDir}/class-diagram.mmd`, diagram);
+}
+```

.claude/skills/brainstorm/README.md

@@ -1,177 +0,0 @@
-# Brainstorm Skill
-
-Unified brainstorming skill combining interactive framework generation, multi-role parallel analysis, and cross-role synthesis into a single entry point with two operational modes.
-
-## Key Features
-
-- **Dual-Mode Operation**: Auto mode (full pipeline) and single role mode (individual analysis)
-- **Interactive Framework Generation**: Seven-phase workflow for guidance specification
-- **Parallel Role Analysis**: Concurrent execution of multiple role perspectives
-- **Cross-Role Synthesis**: Integration of insights into feature specifications
-- **SPEC.md Quality Standards**: Guidance specification includes Concepts & Terminology, Non-Goals, RFC 2119 constraints
-- **Template-Driven Role Analysis**: system-architect produces Data Model, State Machine, Error Handling, Observability, Configuration Model, Boundary Scenarios
-- **Automated Quality Gates**: Validation agents ensure outputs meet quality standards
-- **Session Continuity**: All phases share state via workflow-session.json
-- **Progressive Loading**: Phase documents loaded on-demand via Ref markers
-
-## Architecture
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                    /brainstorm                                │
-│         Unified Entry Point + Interactive Routing             │
-└───────────────────────┬─────────────────────────────────────┘
-                        │
-              ┌─────────┴─────────┐
-              ↓                   ↓
-    ┌─────────────────┐  ┌──────────────────┐
-    │   Auto Mode     │  │ Single Role Mode │
-    │  (自动模式)      │  │ (单角色分析模式)   │
-    └────────┬────────┘  └────────┬─────────┘
-             │                    │
-    ┌────────┼────────┐          │
-    ↓        ↓        ↓          ↓
- Phase 2  Phase 3  Phase 4    Phase 3
-Artifacts  N×Role  Synthesis  1×Role
- (7步)    Analysis  (8步)    Analysis
-           并行               (4步)
-```
-
-### Execution Flow
-
-**Auto Mode**:
-1. **Phase 1**: Mode detection and parameter parsing
-2. **Phase 1.5**: Terminology & Boundary Definition (extract terms, collect Non-Goals)
-3. **Phase 2**: Interactive Framework Generation (7 sub-phases)
-   - Context collection → Topic analysis → Role selection → Role questions → Conflict resolution → Final check → Generate specification
-   - **Phase 5**: Generate guidance-specification.md with Concepts & Terminology, Non-Goals, RFC 2119 constraints
-4. **Phase 3**: Parallel Role Analysis (N concurrent role analyses)
-   - Template-driven analysis with quality validation
-   - system-architect includes: Data Model, State Machine, Error Handling, Observability, Configuration Model, Boundary Scenarios
-5. **Phase 4**: Synthesis Integration (6 sub-phases)
-   - Discovery → File discovery → Cross-role analysis → User interaction → Spec generation → Finalization
-
-**Single Role Mode**:
-1. **Phase 1**: Mode detection and parameter parsing
-2. **Phase 3**: Single role analysis (4 sub-phases)
-   - Detection → Context → Agent → Validation
-
-## Usage
-
-### Auto Mode
-
-```bash
-# Full pipeline with default settings
-/brainstorm "Build real-time collaboration platform"
-
-# Auto-select mode with specific role count
-/brainstorm -y "GOAL: Build platform SCOPE: 100 users" --count 5
-
-# With style skill for UI designer
-/brainstorm "Design payment system" --style-skill material-design
-```
-
-### Single Role Mode
-
-```bash
-# Analyze with specific role
-/brainstorm system-architect --session WFS-xxx
-
-# With interactive questions
-/brainstorm ux-expert --include-questions
-
-# Update existing analysis
-/brainstorm ui-designer --session WFS-xxx --update --style-skill material-design
-
-# Skip questions (use defaults)
-/brainstorm product-manager --skip-questions
-```
-
-## Available Roles
-
-| Role ID | Title | Focus Area |
-|---------|-------|------------|
-| `data-architect` | 数据架构师 | Data models, storage strategies, data flow |
-| `product-manager` | 产品经理 | Product strategy, roadmap, prioritization |
-| `product-owner` | 产品负责人 | Backlog management, user stories, acceptance criteria |
-| `scrum-master` | 敏捷教练 | Process facilitation, impediment removal |
-| `subject-matter-expert` | 领域专家 | Domain knowledge, business rules, compliance |
-| `system-architect` | 系统架构师 | Technical architecture, scalability, integration |
-| `test-strategist` | 测试策略师 | Test strategy, quality assurance |
-| `ui-designer` | UI设计师 | Visual design, mockups, design systems |
-| `ux-expert` | UX专家 | User research, information architecture, journey |
-
-## Output Files
-
-```
-.workflow/active/WFS-{topic}/
-├── workflow-session.json              # Session metadata
-├── .process/
-│   └── context-package.json           # Phase 0 output
-└── .brainstorming/
-    ├── guidance-specification.md      # Framework with terminology, non-goals
-    ├── feature-index.json             # Feature index
-    ├── synthesis-changelog.md         # Synthesis decisions
-    ├── feature-specs/                 # Feature specifications
-    │   ├── F-001-{slug}.md
-    │   └── F-00N-{slug}.md
-    ├── specs/
-    │   └── terminology-template.json  # Terminology glossary schema
-    ├── templates/
-    │   └── role-templates/
-    │       └── system-architect-template.md  # System architect analysis template
-    ├── agents/
-    │   └── role-analysis-reviewer-agent.md   # Role analysis validation agent
-    ├── {role}/                        # Role analyses (immutable)
-    │   ├── {role}-context.md          # Q&A responses
-    │   ├── analysis.md                # Main document
-    │   ├── analysis-cross-cutting.md  # Cross-feature
-    │   └── analysis-F-{id}-{slug}.md  # Per-feature
-    └── synthesis-specification.md     # Integration
-```
-
-## Quality Standards
-
-### Guidance Specification
-- **Section 2**: Concepts & Terminology (5-10 core terms with definitions, aliases, categories)
-- **Section 3**: Non-Goals (Out of Scope) with rationale
-- **RFC 2119 Keywords**: All requirements use MUST, SHOULD, MAY
-
-### Role Analysis (system-architect)
-1. **Architecture Overview**: High-level system design
-2. **Data Model**: 3-5 core entities with precise field definitions
-3. **State Machine**: Lifecycle for 1-2 entities with complex workflows
-4. **Error Handling Strategy**: Global + per-component recovery
-5. **Observability Requirements**: Metrics, logs, health checks
-6. **Configuration Model**: All configurable parameters with validation
-7. **Boundary Scenarios**: Concurrency, rate limiting, shutdown, cleanup, scalability, DR
-
-### Quality Validation
-- Template compliance checking
-- RFC 2119 keyword usage verification
-- Diagram syntax validation
-- Section completeness scoring
-
-## Parameters
-
-| Parameter | Description | Default |
-|-----------|-------------|---------|
-| `--yes`, `-y` | Auto mode, skip all questions | - |
-| `--count N` | Number of roles to select | 3 |
-| `--session ID` | Use existing session | - |
-| `--update` | Update existing analysis | - |
-| `--include-questions` | Interactive context gathering | - |
-| `--skip-questions` | Use default answers | - |
-| `--style-skill PKG` | Style package for ui-designer | - |
-
-## Follow-up Commands
-
-After brainstorm completes:
-- `/workflow-plan --session {sessionId}` - Generate implementation plan
-- `/workflow:brainstorm:synthesis --session {sessionId}` - Run synthesis standalone
-
-## Related Documentation
-
-- **Template Source**: `~/.ccw/workflows/cli-templates/planning-roles/`
-- **Style SKILL Packages**: `.claude/skills/style-{package-name}/`
-- **Phase Documents**: `phases/01-mode-routing.md`, `phases/02-artifacts.md`, `phases/03-role-analysis.md`, `phases/04-synthesis.md`

.claude/skills/brainstorm/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: brainstorm
-description: Unified brainstorming skill with dual-mode operation — auto mode (framework generation, parallel multi-role analysis, cross-role synthesis) and single role analysis. Triggers on "brainstorm", "头脑风暴".
-allowed-tools: Skill(*), Agent(conceptual-planning-agent, context-search-agent), AskUserQuestion(*), TodoWrite(*), Read(*), Write(*), Edit(*), Glob(*), Bash(*)
+description: Unified brainstorming skill with dual-mode operation - auto pipeline and single role analysis. Triggers on "brainstorm", "头脑风暴".
+allowed-tools: Skill(*), Task(conceptual-planning-agent, context-search-agent), AskUserQuestion(*), TodoWrite(*), Read(*), Write(*), Edit(*), Glob(*), Bash(*)
 ---
 
 # Brainstorm
@@ -49,9 +49,6 @@ Single Role Mode:
 3. **Task Attachment/Collapse**: Sub-tasks attached during phase execution, collapsed after completion
 4. **Session Continuity**: All phases share session state via workflow-session.json
 5. **Auto-Continue Execution**: Phases chain automatically without user intervention between them
-6. **SPEC.md Quality Alignment**: Guidance specification and role analysis follow SPEC.md standards (Concepts & Terminology, Non-Goals, Data Model, State Machine, RFC 2119 constraints)
-7. **Template-Driven Analysis**: Role-specific templates (e.g., system-architect) ensure consistent, high-quality outputs
-8. **Quality Gates**: Automated validation of guidance specification and role analysis against quality standards
 
 ## Auto Mode
 
@@ -76,19 +73,13 @@ Parse arguments, detect mode from flags/parameters, or ask user via AskUserQuest
 
 ### Auto Mode Execution (execution_mode = "auto")
 
-**Phase 1.5: Terminology & Boundary Definition**
-   - Extract 5-10 core domain terms from user input and Phase 1 context
-   - Generate terminology table (term, definition, aliases, category)
-   - Collect Non-Goals via AskUserQuestion (明确排除的范围)
-   - Store to `session.terminology` and `session.non_goals`
-
 #### Phase 2: Interactive Framework Generation
    Ref: phases/02-artifacts.md
 
 Seven-phase interactive workflow: Context collection → Topic analysis → Role selection → Role questions → Conflict resolution → Final check → Generate specification.
 
 **Input**: topic description, --count N, --yes flag
-**Output**: guidance-specification.md (with Concepts & Terminology, Non-Goals, RFC 2119 constraints), workflow-session.json (selected_roles[], session_id)
+**Output**: guidance-specification.md, workflow-session.json (selected_roles[], session_id)
 
 **TodoWrite**: Attach 7 sub-tasks (Phase 0-5), execute sequentially, collapse on completion.
 
@@ -104,16 +95,6 @@ Execute role analysis for EACH selected role in parallel.
 
 For ui-designer: append `--style-skill {package}` if provided.
 
-**Template-Driven Analysis**:
-- Load role-specific template if exists (e.g., `templates/role-templates/system-architect-template.md`)
-- Inject template into agent prompt as required structure
-- For system-architect: MUST include Data Model, State Machine, Error Handling, Observability, Configuration Model, Boundary Scenarios
-
-**Quality Validation**:
-- After analysis generation, invoke `role-analysis-reviewer-agent` to validate against template
-- Check MUST have sections (blocking), SHOULD have sections (warning), quality checks (RFC keywords, valid diagrams)
-- Output validation report with score and recommendations
-
 **TodoWrite**: Attach N parallel sub-tasks, execute concurrently, collapse on completion.
 
 #### Phase 4: Synthesis Integration
@@ -346,13 +327,6 @@ Initial → Phase 1 Mode Routing (completed)
     ├── feature-specs/                 # Feature specs (Phase 4, auto mode, feature_mode)
     │   ├── F-001-{slug}.md
     │   └── F-00N-{slug}.md
-    ├── specs/
-    │   └── terminology-template.json  # Terminology schema
-    ├── templates/
-    │   └── role-templates/
-    │       └── system-architect-template.md  # System architect analysis template
-    ├── agents/
-    │   └── role-analysis-reviewer-agent.md   # Role analysis validation agent
     ├── {role}/                        # Role analyses (IMMUTABLE after Phase 3)
     │   ├── {role}-context.md          # Interactive Q&A responses
     │   ├── analysis.md                # Main/index document
@@ -399,7 +373,7 @@ Initial → Phase 1 Mode Routing (completed)
 - `/workflow:session:start` - Start a new workflow session (optional, brainstorm creates its own)
 
 **Follow-ups** (after brainstorm completes):
-- `/workflow-plan --session {sessionId}` - Generate implementation plan
+- `/workflow:plan --session {sessionId}` - Generate implementation plan
 - `/workflow:brainstorm:synthesis --session {sessionId}` - Run synthesis standalone (if skipped)
 
 ## Reference Information

.claude/skills/brainstorm/phases/02-artifacts.md

@@ -117,73 +117,6 @@ AskUserQuestion({
 
 **⚠️ CRITICAL**: Questions MUST reference topic keywords. Generic "Project type?" violates dynamic generation.
 
-### Phase 1.5: Terminology & Boundary Definition
-
-**Goal**: Extract core terminology and define scope boundaries (Non-Goals)
-
-**Steps**:
-1. Analyze Phase 1 user responses and topic description
-2. Extract 5-10 core domain terms that will be used throughout the specification
-3. Generate terminology clarification questions if needed
-4. Define scope boundaries by identifying what is explicitly OUT of scope
-
-**Terminology Extraction**:
-```javascript
-// Based on Phase 1 context and user input
-const coreTerms = extractTerminology({
-  topic: session.topic,
-  userResponses: session.intent_context,
-  contextPackage: contextPackage // from Phase 0
-});
-
-// Generate terminology table
-const terminologyTable = coreTerms.map(term => ({
-  term: term.canonical,
-  definition: term.definition,
-  aliases: term.alternatives,
-  category: term.category // core|technical|business
-}));
-```
-
-**Non-Goals Definition**:
-```javascript
-AskUserQuestion({
-  questions: [{
-    question: "以下哪些是明确 NOT 包含在本次项目范围内的？（可多选）",
-    header: "范围边界 (Non-Goals)",
-    multiSelect: true,
-    options: [
-      { label: "移动端应用", description: "本次只做 Web 端，移动端后续考虑" },
-      { label: "多语言支持", description: "MVP 阶段只支持中文" },
-      { label: "第三方集成", description: "暂不集成外部系统" },
-      { label: "高级分析功能", description: "基础功能优先，分析功能 v2" },
-      { label: "其他（请在后续补充）", description: "用户自定义排除项" }
-    ]
-  }]
-});
-
-// If user selects "其他", follow up with:
-if (selectedNonGoals.includes("其他")) {
-  AskUserQuestion({
-    questions: [{
-      question: "请描述其他明确排除的功能或范围",
-      header: "补充 Non-Goals",
-      multiSelect: false,
-      freeText: true
-    }]
-  });
-}
-
-// Store to session
-session.terminology = terminologyTable;
-session.non_goals = selectedNonGoals.map(ng => ({
-  item: ng.label,
-  rationale: ng.description
-}));
-```
-
-**Output**: Updated `workflow-session.json` with `terminology` and `non_goals` fields
-
 ### Phase 2: Role Selection
 
 **Goal**: User selects roles from intelligent recommendations
@@ -370,26 +303,11 @@ After final clarification, extract implementable feature units from all Phase 1-
 ### Phase 5: Generate Specification
 
 **Steps**:
-1. Load all decisions: `intent_context` + `selected_roles` + `role_decisions` + `cross_role_decisions` + `additional_decisions` + `feature_list` + `terminology` + `non_goals`
+1. Load all decisions: `intent_context` + `selected_roles` + `role_decisions` + `cross_role_decisions` + `additional_decisions` + `feature_list`
 2. Transform Q&A to declarative: Questions → Headers, Answers → CONFIRMED/SELECTED statements
-3. Apply RFC 2119 keywords (MUST, SHOULD, MAY, MUST NOT, SHOULD NOT) to all behavioral requirements
-4. Generate `guidance-specification.md` with Concepts & Terminology and Non-Goals sections
-5. Update `workflow-session.json` (metadata only)
-6. Validate: No interrogative sentences, all decisions traceable, RFC keywords applied
-
-**RFC 2119 Compliance**:
-
-All behavioral requirements and constraints MUST be expressed using RFC 2119 keywords:
-- **MUST**: Absolute requirement, non-negotiable
-- **MUST NOT**: Absolute prohibition
-- **SHOULD**: Strong recommendation, may be ignored with valid reason
-- **SHOULD NOT**: Strong discouragement
-- **MAY**: Optional, implementer's choice
-
-Example transformations:
-- "用户需要登录" → "The system MUST authenticate users before granting access"
-- "建议使用缓存" → "The system SHOULD cache frequently accessed data"
-- "可以支持 OAuth" → "The system MAY support OAuth2 authentication"
+3. Generate `guidance-specification.md`
+4. Update `workflow-session.json` (metadata only)
+5. Validate: No interrogative sentences, all decisions traceable
 
 ## Question Guidelines
 
@@ -448,43 +366,15 @@ for (let i = 0; i < allQuestions.length; i += BATCH_SIZE) {
 **CONFIRMED Objectives**: [from topic + Phase 1]
 **CONFIRMED Success Criteria**: [from Phase 1 answers]
 
-## 2. Concepts & Terminology
-
-**Core Terms**: The following terms are used consistently throughout this specification.
-
-| Term | Definition | Aliases | Category |
-|------|------------|---------|----------|
-${session.terminology.map(t => `| ${t.term} | ${t.definition} | ${t.aliases.join(', ')} | ${t.category} |`).join('\n')}
-
-**Usage Rules**:
-- All documents MUST use the canonical term
-- Aliases are for reference only
-- New terms introduced in role analysis MUST be added to this glossary
-
-## 3. Non-Goals (Out of Scope)
-
-The following are explicitly OUT of scope for this project:
-
-${session.non_goals.map(ng => `- **${ng.item}**: ${ng.rationale}`).join('\n')}
-
-**Rationale**: These exclusions help maintain focus on core objectives and prevent scope creep.
-
-## 4-N. [Role] Decisions
+## 2-N. [Role] Decisions
 ### SELECTED Choices
-**[Question topic]**: [User's answer with RFC 2119 keywords]
+**[Question topic]**: [User's answer]
 - **Rationale**: [From option description]
-- **Impact**: [Implications with RFC keywords]
-- **Requirement Level**: [MUST/SHOULD/MAY based on criticality]
-
-**Example**:
-- The system MUST authenticate users within 200ms (P99)
-- The system SHOULD cache frequently accessed data
-- The system MAY support OAuth2 providers (Google, GitHub)
+- **Impact**: [Implications]
 
 ### Cross-Role Considerations
-**[Conflict resolved]**: [Resolution from Phase 4 with RFC keywords]
+**[Conflict resolved]**: [Resolution from Phase 4]
 - **Affected Roles**: [Roles involved]
-- **Decision**: [MUST/SHOULD/MAY statement]
 
 ## Cross-Role Integration
 **CONFIRMED Integration Points**: [API/Data/Auth from multiple roles]

.claude/skills/brainstorm/phases/03-role-analysis.md

@@ -301,14 +301,6 @@ const agentContext = {
   original_topic: original_topic,
   session_id: session_id
 };
-
-// Load role-specific template if exists
-let roleTemplate = null;
-try {
-  roleTemplate = Read(`templates/role-templates/${role_name}-template.md`);
-} catch (e) {
-  // No template, use generic analysis
-}
 ```
 
 **Step 3.3.3: Execute Conceptual Planning Agent**
@@ -370,13 +362,6 @@ UPDATE_MODE: ${update_mode}
    - Command: Read(${brainstorm_dir}/${role_name}/${role_name}-context.md)
    - Output: user_context_answers
 
-${roleTemplate ? `
-5. **load_role_template**
-   - Action: Load role-specific analysis template
-   - Command: Read(templates/role-templates/${role_name}-template.md)
-   - Output: role_specific_template
-` : ''}
-
 5. **${update_mode ? 'load_existing_analysis' : 'skip'}**
    ${update_mode ? `
    - Action: Load existing analysis for incremental update
@@ -393,21 +378,6 @@ ${featureListBlock}
 **Role Focus**: ${roleConfig[role_name].focus_area}
 **Template Integration**: Apply role template guidelines within framework structure
 ${feature_mode ? `**Feature Organization**: Organize analysis by feature points - each feature gets its own sub-document. Cross-cutting concerns go into analysis-cross-cutting.md.` : ''}
-**RFC 2119 Compliance**: Use RFC 2119 keywords (MUST, SHOULD, MAY, MUST NOT, SHOULD NOT) to define all behavioral constraints and recommendations. Every technical decision MUST be expressed with appropriate RFC keyword. Distinguish between absolute requirements (MUST) and recommendations (SHOULD).
-
-${roleTemplate ? `
-**ROLE-SPECIFIC TEMPLATE (MUST follow this structure)**:
-${roleTemplate}
-
-Your analysis MUST include all Required Sections from the template above.
-` : ''}
-
-**For system-architect role specifically**:
-- MUST define Data Model for 3-5 core entities with fields, types, constraints, relationships
-- MUST create State Machine for at least 1 entity with complex lifecycle (ASCII diagram + transition table)
-- MUST define Error Handling Strategy with error classification and recovery mechanisms
-- MUST specify Observability Requirements with metrics (at least 5), log events, and health checks
-- All constraints MUST use RFC 2119 keywords (MUST, SHOULD, MAY)
 
 ## Expected Deliverables
 ${feature_mode ? `
@@ -499,7 +469,7 @@ ${selected_roles.length > 1 ? `
   - Run synthesis: /brainstorm --session ${session_id} (auto mode)
 ` : `
   - Clarify insights: /brainstorm --session ${session_id} (auto mode)
-  - Generate plan: /workflow-plan --session ${session_id}
+  - Generate plan: /workflow:plan --session ${session_id}
 `}
 ```
 

.claude/skills/brainstorm/phases/04-synthesis.md

@@ -531,32 +531,22 @@ ${feature_mode ? `
 **Status**: Draft (from synthesis)
 
 ## 1. Requirements Summary
-[Consolidated requirements from all role perspectives using RFC 2119 keywords]
-- Functional requirements (from product-manager, product-owner) - use MUST/SHOULD/MAY
-- User experience requirements (from ux-expert, ui-designer) - use MUST/SHOULD/MAY
-- Technical requirements (from system-architect, data-architect, api-designer) - use MUST/SHOULD/MAY
-- Domain requirements (from subject-matter-expert) - use MUST/SHOULD/MAY
-
-**Example**:
-- The feature MUST support user authentication via email/password
-- The UI SHOULD provide real-time feedback within 100ms
-- The system MAY cache user preferences for offline access
+[Consolidated requirements from all role perspectives]
+- Functional requirements (from product-manager, product-owner)
+- User experience requirements (from ux-expert, ui-designer)
+- Technical requirements (from system-architect, data-architect, api-designer)
+- Domain requirements (from subject-matter-expert)
 
 ## 2. Design Decisions [CORE SECTION]
 [Key architectural and design decisions with rationale - 40%+ of word count]
 For each decision:
-- **Decision**: [What was decided - MUST use RFC 2119 keywords]
+- **Decision**: [What was decided]
 - **Context**: [Why this decision was needed]
 - **Options Considered**: [Alternatives from different roles]
-- **Chosen Approach**: [Selected option with rationale using MUST/SHOULD/MAY]
+- **Chosen Approach**: [Selected option with rationale]
 - **Trade-offs**: [What we gain vs. what we sacrifice]
 - **Source**: [Which role(s) drove this decision]
 
-**RFC 2119 Examples**:
-- "The system MUST authenticate users before granting access"
-- "The feature SHOULD cache frequently accessed data for performance"
-- "The component MAY support OAuth2 authentication as an optional enhancement"
-
 ## 3. Interface Contract
 [API endpoints, data models, component interfaces]
 - External interfaces (API contracts from api-designer)
@@ -754,7 +744,7 @@ Write(context_pkg_path, JSON.stringify(context_pkg))
 **Changelog**: .brainstorming/synthesis-changelog.md
 
 ### Next Steps
-PROCEED: `/workflow-plan --session {session-id}`
+PROCEED: `/workflow:plan --session {session-id}`
 ```
 
 ## Output

.claude/skills/brainstorm/specs/terminology-template.json

@@ -1,22 +0,0 @@
-{
-  "version": "1.0",
-  "description": "Terminology glossary schema for brainstorm guidance-specification",
-  "schema": {
-    "terminology": {
-      "type": "array",
-      "items": {
-        "term": "string (required) - canonical term",
-        "definition": "string (required) - concise definition",
-        "aliases": "array of strings - alternative names",
-        "category": "enum: core|technical|business (required)",
-        "first_used_in": "string - source document"
-      }
-    }
-  },
-  "validation_rules": {
-    "min_terms": 5,
-    "max_terms": 20,
-    "term_format": "lowercase, alphanumeric + hyphens",
-    "definition_max_length": 200
-  }
-}

.claude/skills/ccw-help/SKILL.md

@@ -1,18 +1,18 @@
 ---
 name: ccw-help
-description: CCW command help system. Search, browse, recommend commands, skills, teams. Triggers "ccw-help", "ccw-issue".
+description: CCW command help system. Search, browse, recommend commands. Triggers "ccw-help", "ccw-issue".
 allowed-tools: Read, Grep, Glob, AskUserQuestion
-version: 8.0.0
+version: 7.0.0
 ---
 
 # CCW-Help Skill
 
-CCW 命令帮助系统，提供命令搜索、推荐、文档查看、Skill/Team 浏览功能。
+CCW 命令帮助系统，提供命令搜索、推荐、文档查看功能。
 
 ## Trigger Conditions
 
-- 关键词: "ccw-help", "ccw-issue", "帮助", "命令", "怎么用", "ccw 怎么用", "工作流", "skill", "team"
-- 场景: 询问命令用法、搜索命令、请求下一步建议、询问任务应该用哪个工作流、浏览 Skill/Team 目录
+- 关键词: "ccw-help", "ccw-issue", "帮助", "命令", "怎么用", "ccw 怎么用", "工作流"
+- 场景: 询问命令用法、搜索命令、请求下一步建议、询问任务应该用哪个工作流
 
 ## Operation Modes
 
@@ -61,7 +61,7 @@ CCW 命令帮助系统，提供命令搜索、推荐、文档查看、Skill/Team
 4. Get user confirmation
 5. Execute chain with TODO tracking
 
-**Supported Workflows** (参考 [ccw.md](../../commands/ccw.md)):
+**Supported Workflows**:
 - **Level 1** (Lite-Lite-Lite): Ultra-simple quick tasks
 - **Level 2** (Rapid/Hotfix): Bug fixes, simple features, documentation
 - **Level 2.5** (Rapid-to-Issue): Bridge from quick planning to issue workflow
@@ -71,17 +71,12 @@ CCW 命令帮助系统，提供命令搜索、推荐、文档查看、Skill/Team
   - Test-fix workflows (debug failing tests)
   - Review workflows (code review and fixes)
   - UI design workflows
-  - Multi-CLI collaborative workflows
-  - Cycle workflows (integration-test, refactor)
 - **Level 4** (Full): Exploratory tasks with brainstorming
 - **With-File Workflows**: Documented exploration with multi-CLI collaboration
-  - `brainstorm-with-file`: Multi-perspective ideation → workflow-plan → workflow-execute
-  - `debug-with-file`: Hypothesis-driven debugging (standalone)
-  - `analyze-with-file`: Collaborative analysis → workflow-lite-plan
-  - `collaborative-plan-with-file`: Multi-agent planning → unified-execute
-  - `roadmap-with-file`: Strategic requirement roadmap → team-planex
+  - `brainstorm-with-file`: Multi-perspective ideation
+  - `debug-with-file`: Hypothesis-driven debugging
+  - `analyze-with-file`: Collaborative analysis
 - **Issue Workflow**: Batch issue discovery, planning, queueing, execution
-- **Team Workflow**: team-planex wave pipeline for parallel execution
 
 ### Mode 6: Issue Reporting
 
@@ -91,16 +86,6 @@ CCW 命令帮助系统，提供命令搜索、推荐、文档查看、Skill/Team
 1. Use AskUserQuestion to gather context
 2. Generate structured issue template
 
-### Mode 7: Skill & Team Browsing
-
-**Triggers**: "skill", "team", "技能", "团队", "有哪些 skill", "team 怎么用"
-
-**Process**:
-1. Query `command.json` skills array
-2. Filter by category: workflow / team / review / meta / utility / standalone
-3. Present categorized skill list with descriptions
-4. For team skills, explain team architecture and usage patterns
-
 ## Data Source
 
 Single source of truth: **[command.json](command.json)**
@@ -109,9 +94,8 @@ Single source of truth: **[command.json](command.json)**
 |-------|---------|
 | `commands[]` | Flat command list with metadata |
 | `commands[].flow` | Relationships (next_steps, prerequisites) |
+| `commands[].essential` | Essential flag for onboarding |
 | `agents[]` | Agent directory |
-| `skills[]` | Skill directory with categories |
-| `skills[].is_team` | Whether skill uses team architecture |
 | `essential_commands[]` | Core commands list |
 
 ### Source Path Format
@@ -125,77 +109,6 @@ Single source of truth: **[command.json](command.json)**
 }
 ```
 
-## Skill Catalog
-
-### Workflow Skills (核心工作流)
-
-| Skill | 内部流水线 | 触发词 |
-|-------|-----------|--------|
-| `workflow-lite-plan` | explore → plan → confirm → execute | "lite-plan", 快速任务 |
-| `workflow-plan` | session → context → convention → gen → verify | "workflow-plan", 正式规划 |
-| `workflow-execute` | session discovery → task processing → commit | "workflow-execute", 执行 |
-| `workflow-tdd-plan` | 6-phase TDD plan → verify | "tdd-plan", TDD 开发 |
-| `workflow-test-fix` | session → context → analysis → gen → cycle | "test-fix", 测试修复 |
-| `workflow-multi-cli-plan` | ACE context → CLI discussion → plan → execute | "multi-cli", 多CLI协作 |
-| `workflow-skill-designer` | Meta-skill for designing workflow skills | "skill-designer" |
-
-### Team Skills (团队协作)
-
-Team Skills 使用 `team-worker` agent 架构，Coordinator 编排流水线，Workers 是加载了 role-spec 的 `team-worker` agents。
-
-| Skill | 用途 | 架构 |
-|-------|------|------|
-| `team-planex` | 规划+执行 wave pipeline | planner + executor, 适合清晰 issue/roadmap |
-| `team-lifecycle` | 完整生命周期 (spec/impl/test) | team-worker agents with role-specs |
-| `team-lifecycle-v4` | 优化版生命周期 | Optimized pipeline |
-| `team-lifecycle-v3` | 基础版生命周期 | All roles invoke unified skill |
-| `team-coordinate` | 通用动态团队协调 | 运行时动态生成 role-specs |
-| `team-coordinate` | 通用团队协调 v1 | Dynamic role generation |
-| `team-brainstorm` | 团队头脑风暴 | Multi-perspective analysis |
-| `team-frontend` | 前端开发团队 | Frontend specialists |
-| `team-issue` | Issue 解决团队 | Issue resolution pipeline |
-| `team-iterdev` | 迭代开发团队 | Iterative development |
-| `team-review` | 代码扫描/漏洞审查 | Scanning + vulnerability review |
-| `team-roadmap-dev` | Roadmap 驱动开发 | Requirement → implementation |
-| `team-tech-debt` | 技术债务清理 | Debt identification + cleanup |
-| `team-testing` | 测试团队 | Test planning + execution |
-| `team-quality-assurance` | QA 团队 | Quality assurance pipeline |
-| `team-uidesign` | UI 设计团队 | Design system + prototyping |
-| `team-ultra-analyze` | 深度协作分析 | Deep collaborative analysis |
-| `team-executor` | 轻量执行 (恢复会话) | Resume existing sessions |
-| `team-executor` | 轻量执行 v2 | Improved session resumption |
-
-### Standalone Skills (独立技能)
-
-| Skill | 用途 |
-|-------|------|
-| `brainstorm` | 双模头脑风暴 (auto pipeline / single role) |
-| `review-code` | 多维度代码审查 |
-| `review-cycle` | 审查+自动修复编排 |
-| `spec-generator` | 6阶段规格文档链 (product-brief → PRD → architecture → epics) |
-| `issue-manage` | 交互式 Issue 管理 (CRUD) |
-| `memory-capture` | 统一记忆捕获 (session compact / quick tip) |
-| `memory-manage` | 统一记忆管理 (CLAUDE.md + documentation) |
-| `command-generator` | 命令文件生成器 |
-| `skill-generator` | Meta-skill: 创建新 Skill |
-| `skill-tuning` | Skill 诊断与优化 |
-
-## Workflow Mapping (CCW Auto-Route)
-
-CCW 根据任务意图自动选择工作流级别（参考 [ccw.md](../../commands/ccw.md)）：
-
-| 输入示例 | 类型 | 级别 | 流水线 |
-|---------|------|------|--------|
-| "Add API endpoint" | feature (low) | 2 | workflow-lite-plan → workflow-test-fix |
-| "Fix login timeout" | bugfix | 2 | workflow-lite-plan → workflow-test-fix |
-| "协作分析: 认证架构" | analyze-file | 3 | analyze-with-file → workflow-lite-plan |
-| "重构 auth 模块" | refactor | 3 | workflow:refactor-cycle |
-| "multi-cli: API设计" | multi-cli | 3 | workflow-multi-cli-plan → workflow-test-fix |
-| "头脑风暴: 通知系统" | brainstorm | 4 | brainstorm-with-file → workflow-plan → workflow-execute |
-| "roadmap: OAuth + 2FA" | roadmap | 4 | roadmap-with-file → team-planex |
-| "specification: 用户系统" | spec-driven | 4 | spec-generator → workflow-plan → workflow-execute |
-| "team planex: 用户系统" | team-planex | Team | team-planex |
-
 ## Slash Commands
 
 ```bash
@@ -203,8 +116,6 @@ CCW 根据任务意图自动选择工作流级别（参考 [ccw.md](../../comman
 /ccw-help                        # General help entry
 /ccw-help search <keyword>       # Search commands
 /ccw-help next <command>         # Get next step suggestions
-/ccw-help skills                 # Browse skill catalog
-/ccw-help teams                  # Browse team skills
 /ccw-issue                       # Issue reporting
 ```
 
@@ -217,9 +128,6 @@ CCW 根据任务意图自动选择工作流级别（参考 [ccw.md](../../comman
 /ccw "头脑风暴: 用户通知系统"          # → detect brainstorm, use brainstorm-with-file
 /ccw "深度调试: 系统随机崩溃"          # → detect debug-file, use debug-with-file
 /ccw "协作分析: 认证架构设计"          # → detect analyze-file, use analyze-with-file
-/ccw "roadmap: OAuth + 2FA 路线图"     # → roadmap-with-file → team-planex
-/ccw "集成测试: 支付流程"              # → integration-test-cycle
-/ccw "重构 auth 模块"                  # → refactor-cycle
 ```
 
 ## Maintenance
@@ -227,7 +135,6 @@ CCW 根据任务意图自动选择工作流级别（参考 [ccw.md](../../comman
 ### Update Mechanism
 
 CCW-Help skill supports manual updates through user confirmation dialog.
-Script scans `commands/`, `agents/`, and `skills/` directories to regenerate all indexes.
 
 #### How to Update
 
@@ -246,33 +153,18 @@ cd D:/Claude_dms3/.claude/skills/ccw-help
 python scripts/auto-update.py
 ```
 
-This runs `analyze_commands.py` to scan commands/, agents/, and skills/ directories and regenerate `command.json` + all index files.
+This runs `analyze_commands.py` to scan commands/ and agents/ directories and regenerate `command.json`.
 
 #### Update Scripts
 
 - **`auto-update.py`**: Simple wrapper that runs analyze_commands.py
-- **`analyze_commands.py`**: Scans directories and generates command/agent/skill indexes
-
-#### Generated Index Files
-
-| File | Content |
-|------|---------|
-| `command.json` | Master index: commands + agents + skills |
-| `index/all-commands.json` | Flat command list |
-| `index/all-agents.json` | Agent directory |
-| `index/all-skills.json` | Skill directory with metadata |
-| `index/skills-by-category.json` | Skills grouped by category |
-| `index/by-category.json` | Commands by category |
-| `index/by-use-case.json` | Commands by usage scenario |
-| `index/essential-commands.json` | Core commands for onboarding |
-| `index/command-relationships.json` | Command flow relationships |
+- **`analyze_commands.py`**: Scans directories and generates command index
 
 ## Statistics
 
 - **Commands**: 50+
-- **Agents**: 22
-- **Skills**: 36+ (7 workflow, 19 team, 10+ standalone/utility)
-- **Workflows**: 6 main levels + 5 with-file variants + 2 cycle variants
+- **Agents**: 16
+- **Workflows**: 6 main levels + 3 with-file variants
 - **Essential**: 10 core commands
 
 ## Core Principle

.claude/skills/ccw-help/index/all-agents.json

@@ -29,11 +29,6 @@
     "description": "|",
     "source": "../../../agents/cli-planning-agent.md"
   },
-  {
-    "name": "cli-roadmap-plan-agent",
-    "description": "|",
-    "source": "../../../agents/cli-roadmap-plan-agent.md"
-  },
   {
     "name": "code-developer",
     "description": "|",
@@ -79,16 +74,6 @@
     "description": "|",
     "source": "../../../agents/tdd-developer.md"
   },
-  {
-    "name": "team-worker",
-    "description": "|",
-    "source": "../../../agents/team-worker.md"
-  },
-  {
-    "name": "test-action-planning-agent",
-    "description": "|",
-    "source": "../../../agents/test-action-planning-agent.md"
-  },
   {
     "name": "test-context-search-agent",
     "description": "|",

.claude/skills/ccw-help/index/all-commands.json

@@ -43,72 +43,6 @@
     "difficulty": "Intermediate",
     "source": "../../../commands/cli/codex-review.md"
   },
-  {
-    "name": "flow-create",
-    "command": "/flow-create",
-    "description": "Flow Template Generator - Generate workflow templates for meta-skill/flow-coordinator with interactive 3-phase workflow",
-    "arguments": "[template-name] [--output <path>]",
-    "category": "general",
-    "subcategory": null,
-    "usage_scenario": "implementation",
-    "difficulty": "Intermediate",
-    "source": "../../../commands/flow-create.md"
-  },
-  {
-    "name": "add",
-    "command": "/idaw:add",
-    "description": "Add IDAW tasks - manual creation or import from ccw issue",
-    "arguments": "[-y|--yes] [--from-issue <id>[,<id>,...]] \\\"description\\\" [--type <task_type>] [--priority <1-5>]",
-    "category": "idaw",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "source": "../../../commands/idaw/add.md"
-  },
-  {
-    "name": "resume",
-    "command": "/idaw:resume",
-    "description": "Resume interrupted IDAW session from last checkpoint",
-    "arguments": "[-y|--yes] [session-id]",
-    "category": "idaw",
-    "subcategory": null,
-    "usage_scenario": "session-management",
-    "difficulty": "Intermediate",
-    "source": "../../../commands/idaw/resume.md"
-  },
-  {
-    "name": "run-coordinate",
-    "command": "/idaw:run-coordinate",
-    "description": "IDAW coordinator - execute task skill chains via external CLI with hook callbacks and git checkpoints",
-    "arguments": "[-y|--yes] [--task <id>[,<id>,...]] [--dry-run] [--tool <tool>]",
-    "category": "idaw",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "source": "../../../commands/idaw/run-coordinate.md"
-  },
-  {
-    "name": "run",
-    "command": "/idaw:run",
-    "description": "IDAW orchestrator - execute task skill chains serially with git checkpoints",
-    "arguments": "[-y|--yes] [--task <id>[,<id>,...]] [--dry-run]",
-    "category": "idaw",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "source": "../../../commands/idaw/run.md"
-  },
-  {
-    "name": "status",
-    "command": "/idaw:status",
-    "description": "View IDAW task and session progress",
-    "arguments": "[session-id]",
-    "category": "idaw",
-    "subcategory": null,
-    "usage_scenario": "session-management",
-    "difficulty": "Beginner",
-    "source": "../../../commands/idaw/status.md"
-  },
   {
     "name": "convert-to-plan",
     "command": "/issue:convert-to-plan",
@@ -197,17 +131,6 @@
     "difficulty": "Intermediate",
     "source": "../../../commands/issue/queue.md"
   },
-  {
-    "name": "prepare",
-    "command": "/memory:prepare",
-    "description": "Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context",
-    "arguments": "[--tool gemini|qwen] \\\"task context description\\",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "source": "../../../commands/memory/prepare.md"
-  },
   {
     "name": "style-skill-memory",
     "command": "/memory:style-skill-memory",
@@ -252,17 +175,6 @@
     "difficulty": "Intermediate",
     "source": "../../../commands/workflow/clean.md"
   },
-  {
-    "name": "workflow:collaborative-plan-with-file",
-    "command": "/workflow:collaborative-plan-with-file",
-    "description": "Collaborative planning with Plan Note - Understanding agent creates shared plan-note.md template, parallel agents fill pre-allocated sections, conflict detection without merge. Outputs executable plan-note.md.",
-    "arguments": "[-y|--yes] <task description> [--max-agents=5]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "source": "../../../commands/workflow/collaborative-plan-with-file.md"
-  },
   {
     "name": "debug-with-file",
     "command": "/workflow:debug-with-file",
@@ -274,72 +186,17 @@
     "difficulty": "Intermediate",
     "source": "../../../commands/workflow/debug-with-file.md"
   },
-  {
-    "name": "init-guidelines",
-    "command": "/workflow:spec:setup -guidelines",
-    "description": "Interactive wizard to fill specs/*.md based on project analysis",
-    "arguments": "[--reset]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "source": "../../../commands/workflow/init-guidelines.md"
-  },
-  {
-    "name": "init-specs",
-    "command": "/workflow:spec:setup -specs",
-    "description": "Interactive wizard to create individual specs or personal constraints with scope selection",
-    "arguments": "[--scope <global|project>] [--dimension <specs|personal>] [--category <general|exploration|planning|execution>]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "source": "../../../commands/workflow/init-specs.md"
-  },
   {
     "name": "init",
-    "command": "/workflow:spec:setup ",
+    "command": "/workflow:init",
     "description": "Initialize project-level state with intelligent project analysis using cli-explore-agent",
-    "arguments": "[--regenerate] [--skip-specs]",
+    "arguments": "[--regenerate]",
     "category": "workflow",
     "subcategory": null,
     "usage_scenario": "general",
     "difficulty": "Intermediate",
     "source": "../../../commands/workflow/init.md"
   },
-  {
-    "name": "integration-test-cycle",
-    "command": "/workflow:integration-test-cycle",
-    "description": "Self-iterating integration test workflow with codebase exploration, test development, autonomous test-fix cycles, and reflection-driven strategy adjustment",
-    "arguments": "[-y|--yes] [-c|--continue] [--max-iterations=N] \\\"module or feature description\\",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "testing",
-    "difficulty": "Intermediate",
-    "source": "../../../commands/workflow/integration-test-cycle.md"
-  },
-  {
-    "name": "refactor-cycle",
-    "command": "/workflow:refactor-cycle",
-    "description": "Tech debt discovery and self-iterating refactoring with multi-dimensional analysis, prioritized execution, regression validation, and reflection-driven adjustment",
-    "arguments": "[-y|--yes] [-c|--continue] [--scope=module|project] \\\"module or refactoring goal\\",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "source": "../../../commands/workflow/refactor-cycle.md"
-  },
-  {
-    "name": "roadmap-with-file",
-    "command": "/workflow:roadmap-with-file",
-    "description": "Strategic requirement roadmap with iterative decomposition and issue creation. Outputs roadmap.md (human-readable, single source) + issues.jsonl (machine-executable). Handoff to team-planex.",
-    "arguments": "[-y|--yes] [-c|--continue] [-m progressive|direct|auto] \\\"requirement description\\",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "source": "../../../commands/workflow/roadmap-with-file.md"
-  },
   {
     "name": "complete",
     "command": "/workflow:session:complete",
@@ -376,8 +233,8 @@
   {
     "name": "solidify",
     "command": "/workflow:session:solidify",
-    "description": "Crystallize session learnings and user-defined constraints into permanent project guidelines, or compress recent memories",
-    "arguments": "[-y|--yes] [--type <convention|constraint|learning|compress>] [--category <category>] [--limit <N>] \\\"rule or insight\\",
+    "description": "Crystallize session learnings and user-defined constraints into permanent project guidelines",
+    "arguments": "[-y|--yes] [--type <convention|constraint|learning>] [--category <category>] \\\"rule or insight\\",
     "category": "workflow",
     "subcategory": "session",
     "usage_scenario": "general",
@@ -395,17 +252,6 @@
     "difficulty": "Intermediate",
     "source": "../../../commands/workflow/session/start.md"
   },
-  {
-    "name": "sync",
-    "command": "/workflow:session:sync",
-    "description": "Quick-sync session work to specs/*.md and project-tech",
-    "arguments": "[-y|--yes] [\\\"what was done\\\"]",
-    "category": "workflow",
-    "subcategory": "session",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "source": "../../../commands/workflow/session/sync.md"
-  },
   {
     "name": "animation-extract",
     "command": "/workflow:ui-design:animation-extract",
@@ -431,7 +277,7 @@
   {
     "name": "design-sync",
     "command": "/workflow:ui-design:design-sync",
-    "description": "Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow-plan consumption",
+    "description": "Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow:plan consumption",
     "arguments": "--session <session_id> [--selected-prototypes \"<list>\"]",
     "category": "workflow",
     "subcategory": "ui-design",
@@ -520,11 +366,11 @@
     "name": "unified-execute-with-file",
     "command": "/workflow:unified-execute-with-file",
     "description": "Universal execution engine for consuming any planning/brainstorm/analysis output with minimal progress tracking, multi-agent coordination, and incremental execution",
-    "arguments": "[-y|--yes] [<path>[,<path2>] | -p|--plan <path>[,<path2>]] [--auto-commit] [--commit-prefix \\\"prefix\\\"] [\\\"execution context or task name\\\"]",
+    "arguments": "[-y|--yes] [-p|--plan <path>] [-m|--mode sequential|parallel] [\\\"execution context or task name\\\"]",
     "category": "workflow",
     "subcategory": null,
     "usage_scenario": "implementation",
     "difficulty": "Intermediate",
     "source": "../../../commands/workflow/unified-execute-with-file.md"
   }
-]
+]

.claude/skills/ccw-help/index/all-skills.json

@@ -1,352 +0,0 @@
-[
-  {
-    "name": "brainstorm",
-    "description": "Unified brainstorming skill with dual-mode operation - auto pipeline and single role analysis. Triggers on \"brainstorm\", \"头脑风暴\".",
-    "category": "standalone",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/brainstorm/SKILL.md"
-  },
-  {
-    "name": "ccw-help",
-    "description": "CCW command help system. Search, browse, recommend commands, skills, teams. Triggers \"ccw-help\", \"ccw-issue\".",
-    "category": "utility",
-    "is_team": false,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "8.0.0",
-    "source": "../../../skills/ccw-help/SKILL.md"
-  },
-  {
-    "name": "command-generator",
-    "description": "Command file generator - 5 phase workflow for creating Claude Code command files with YAML frontmatter. Generates .md command files for project or user scope. Triggers on \"create command\", \"new command\", \"command generator\".",
-    "category": "meta",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/command-generator/SKILL.md"
-  },
-  {
-    "name": "issue-manage",
-    "description": "Interactive issue management with menu-driven CRUD operations. Use when managing issues, viewing issue status, editing issue fields, performing bulk operations, or viewing issue history. Triggers on \"manage issue\", \"list issues\", \"edit issue\", \"delete issue\", \"bulk update\", \"issue dashboard\", \"issue history\", \"completed issues\".",
-    "category": "utility",
-    "is_team": false,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/issue-manage/SKILL.md"
-  },
-  {
-    "name": "memory-capture",
-    "description": "Unified memory capture with routing - session compact or quick tips. Triggers on \"memory capture\", \"compact session\", \"save session\", \"quick tip\", \"memory tips\", \"记录\", \"压缩会话\".",
-    "category": "utility",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/memory-capture/SKILL.md"
-  },
-  {
-    "name": "memory-manage",
-    "description": "Unified memory management - CLAUDE.md updates and documentation generation with interactive routing. Triggers on \"memory manage\", \"update claude\", \"update memory\", \"generate docs\", \"更新记忆\", \"生成文档\".",
-    "category": "utility",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/memory-manage/SKILL.md"
-  },
-  {
-    "name": "review-code",
-    "description": "Multi-dimensional code review with structured reports. Analyzes correctness, readability, performance, security, testing, and architecture. Triggers on \"review code\", \"code review\", \"审查代码\", \"代码审查\".",
-    "category": "review",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/review-code/SKILL.md"
-  },
-  {
-    "name": "review-cycle",
-    "description": "Unified multi-dimensional code review with automated fix orchestration. Routes to session-based (git changes), module-based (path patterns), or fix mode. Triggers on \"workflow:review-cycle\", \"workflow:review-session-cycle\", \"workflow:review-module-cycle\", \"workflow:review-cycle-fix\".",
-    "category": "review",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/review-cycle/SKILL.md"
-  },
-  {
-    "name": "skill-generator",
-    "description": "Meta-skill for creating new Claude Code skills with configurable execution modes. Supports sequential (fixed order) and autonomous (stateless) phase patterns. Use for skill scaffolding, skill creation, or building new workflows. Triggers on \"create skill\", \"new skill\", \"skill generator\".",
-    "category": "meta",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/skill-generator/SKILL.md"
-  },
-  {
-    "name": "skill-tuning",
-    "description": "Universal skill diagnosis and optimization tool. Detect and fix skill execution issues including context explosion, long-tail forgetting, data flow disruption, and agent coordination failures. Supports Gemini CLI for deep analysis. Triggers on \"skill tuning\", \"tune skill\", \"skill diagnosis\", \"optimize skill\", \"skill debug\".",
-    "category": "meta",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/skill-tuning/SKILL.md"
-  },
-  {
-    "name": "spec-generator",
-    "description": "Specification generator - 6 phase document chain producing product brief, PRD, architecture, and epics. Triggers on \"generate spec\", \"create specification\", \"spec generator\", \"workflow:spec\".",
-    "category": "meta",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/spec-generator/SKILL.md"
-  },
-  {
-    "name": "team-arch-opt",
-    "description": "Unified team skill for architecture optimization. Uses team-worker agent architecture with role-spec files for domain logic. Coordinator orchestrates pipeline, workers are team-worker agents. Triggers on \"team arch-opt\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": true,
-    "version": "",
-    "source": "../../../skills/team-arch-opt/SKILL.md"
-  },
-  {
-    "name": "team-brainstorm",
-    "description": "Unified team skill for brainstorming team. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team brainstorm\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/team-brainstorm/SKILL.md"
-  },
-  {
-    "name": "team-coordinate",
-    "description": "Universal team coordination skill with dynamic role generation. Uses team-worker agent architecture with role-spec files. Only coordinator is built-in -- all worker roles are generated at runtime as role-specs and spawned via team-worker agent. Beat/cadence model for orchestration. Triggers on \"Team Coordinate \".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/team-coordinate/SKILL.md"
-  },
-  {
-    "name": "team-executor",
-    "description": "Lightweight session execution skill. Resumes existing team-coordinate sessions for pure execution via team-worker agents. No analysis, no role generation -- only loads and executes. Session path required. Triggers on \"Team Executor\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/team-executor/SKILL.md"
-  },
-  {
-    "name": "team-frontend",
-    "description": "Unified team skill for frontend development team. All roles invoke this skill with --role arg. Built-in ui-ux-pro-max design intelligence. Triggers on \"team frontend\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/team-frontend/SKILL.md"
-  },
-  {
-    "name": "team-issue",
-    "description": "Unified team skill for issue resolution. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team issue\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/team-issue/SKILL.md"
-  },
-  {
-    "name": "team-iterdev",
-    "description": "Unified team skill for iterative development team. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team iterdev\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/team-iterdev/SKILL.md"
-  },
-  {
-    "name": "team-lifecycle",
-    "description": "Unified team skill for full lifecycle - spec/impl/test. Uses team-worker agent architecture with role-spec files for domain logic. Coordinator orchestrates pipeline, workers are team-worker agents loaded with role-specific Phase 2-4 specs. Triggers on \"team lifecycle\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": true,
-    "version": "",
-    "source": "../../../skills/team-lifecycle/SKILL.md"
-  },
-  {
-    "name": "team-perf-opt",
-    "description": "Unified team skill for performance optimization. Uses team-worker agent architecture with role-spec files for domain logic. Coordinator orchestrates pipeline, workers are team-worker agents. Triggers on \"team perf-opt\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": true,
-    "version": "",
-    "source": "../../../skills/team-perf-opt/SKILL.md"
-  },
-  {
-    "name": "team-planex",
-    "description": "Unified team skill for plan-and-execute pipeline. Uses team-worker agent architecture with role-spec files for domain logic. Coordinator orchestrates pipeline, workers are team-worker agents. Triggers on \"team planex\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": true,
-    "version": "",
-    "source": "../../../skills/team-planex/SKILL.md"
-  },
-  {
-    "name": "team-quality-assurance",
-    "description": "Unified team skill for quality assurance team. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team quality-assurance\", \"team qa\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/team-quality-assurance/SKILL.md"
-  },
-  {
-    "name": "team-review",
-    "description": "Unified team skill for code scanning, vulnerability review, optimization suggestions, and automated fix. 4-role team: coordinator, scanner, reviewer, fixer. Triggers on team-review.",
-    "category": "team",
-    "is_team": false,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/team-review/SKILL.md"
-  },
-  {
-    "name": "team-roadmap-dev",
-    "description": "Unified team skill for roadmap-driven development workflow. Coordinator discusses roadmap with user, then dispatches phased execution pipeline (plan -> execute -> verify). All roles invoke this skill with --role arg. Triggers on \"team roadmap-dev\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/team-roadmap-dev/SKILL.md"
-  },
-  {
-    "name": "team-tech-debt",
-    "description": "Unified team skill for tech debt identification and cleanup. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team tech-debt\", \"tech debt cleanup\", \"技术债务\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/team-tech-debt/SKILL.md"
-  },
-  {
-    "name": "team-testing",
-    "description": "Unified team skill for testing team. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team testing\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/team-testing/SKILL.md"
-  },
-  {
-    "name": "team-uidesign",
-    "description": "Unified team skill for UI design team. All roles invoke this skill with --role arg for role-specific execution. CP-9 Dual-Track design+implementation.",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/team-uidesign/SKILL.md"
-  },
-  {
-    "name": "team-ultra-analyze",
-    "description": "Unified team skill for deep collaborative analysis. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team ultra-analyze\", \"team analyze\".",
-    "category": "team",
-    "is_team": true,
-    "has_phases": false,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/team-ultra-analyze/SKILL.md"
-  },
-  {
-    "name": "workflow-execute",
-    "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking. Triggers on \"workflow-execute\".",
-    "category": "workflow",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/workflow-execute/SKILL.md"
-  },
-  {
-    "name": "workflow-lite-plan",
-    "description": "Lightweight planning and execution skill (Phase 1: plan, Phase 2: execute). Triggers on \"workflow-lite-plan\".",
-    "category": "workflow",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/workflow-lite-plan/SKILL.md"
-  },
-  {
-    "name": "workflow-multi-cli-plan",
-    "description": "Multi-CLI collaborative planning and execution skill with integrated execution phase. Triggers on \"workflow-multi-cli-plan\".",
-    "category": "workflow",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/workflow-multi-cli-plan/SKILL.md"
-  },
-  {
-    "name": "workflow-plan",
-    "description": "Unified planning skill - 4-phase planning workflow, plan verification, and interactive replanning. Triggers on \"workflow-plan\", \"workflow-plan-verify\", \"workflow:replan\".",
-    "category": "workflow",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/workflow-plan/SKILL.md"
-  },
-  {
-    "name": "workflow-skill-designer",
-    "description": "Meta-skill for designing orchestrator+phases structured workflow skills. Creates SKILL.md coordinator with progressive phase loading, TodoWrite patterns, and data flow. Triggers on \"design workflow skill\", \"create workflow skill\", \"workflow skill designer\".",
-    "category": "workflow",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/workflow-skill-designer/SKILL.md"
-  },
-  {
-    "name": "workflow-tdd-plan",
-    "description": "Unified TDD workflow skill combining 6-phase TDD planning with Red-Green-Refactor task chain generation, and 4-phase TDD verification with compliance reporting. Triggers on \"workflow-tdd-plan\", \"workflow-tdd-verify\".",
-    "category": "workflow",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/workflow-tdd-plan/SKILL.md"
-  },
-  {
-    "name": "workflow-test-fix",
-    "description": "Unified test-fix pipeline combining test generation (session, context, analysis, task gen) with iterative test-cycle execution (adaptive strategy, progressive testing, CLI fallback). Triggers on \"workflow-test-fix\", \"workflow-test-fix\", \"test fix workflow\".",
-    "category": "workflow",
-    "is_team": false,
-    "has_phases": true,
-    "has_role_specs": false,
-    "version": "",
-    "source": "../../../skills/workflow-test-fix/SKILL.md"
-  }
-]

.claude/skills/ccw-help/index/by-category.json

@@ -22,17 +22,6 @@
         "usage_scenario": "general",
         "difficulty": "Intermediate",
         "source": "../../../commands/ccw.md"
-      },
-      {
-        "name": "flow-create",
-        "command": "/flow-create",
-        "description": "",
-        "arguments": "",
-        "category": "general",
-        "subcategory": null,
-        "usage_scenario": "implementation",
-        "difficulty": "Intermediate",
-        "source": "../../../commands/flow-create.md"
       }
     ]
   },
@@ -62,65 +51,6 @@
       }
     ]
   },
-  "idaw": {
-    "_root": [
-      {
-        "name": "add",
-        "command": "/idaw:add",
-        "description": "Add IDAW tasks - manual creation or import from ccw issue",
-        "arguments": "[-y|--yes] [--from-issue <id>[,<id>,...]] \\\"description\\\" [--type <task_type>] [--priority <1-5>]",
-        "category": "idaw",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "source": "../../../commands/idaw/add.md"
-      },
-      {
-        "name": "resume",
-        "command": "/idaw:resume",
-        "description": "Resume interrupted IDAW session from last checkpoint",
-        "arguments": "[-y|--yes] [session-id]",
-        "category": "idaw",
-        "subcategory": null,
-        "usage_scenario": "session-management",
-        "difficulty": "Intermediate",
-        "source": "../../../commands/idaw/resume.md"
-      },
-      {
-        "name": "run-coordinate",
-        "command": "/idaw:run-coordinate",
-        "description": "IDAW coordinator - execute task skill chains via external CLI with hook callbacks and git checkpoints",
-        "arguments": "[-y|--yes] [--task <id>[,<id>,...]] [--dry-run] [--tool <tool>]",
-        "category": "idaw",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "source": "../../../commands/idaw/run-coordinate.md"
-      },
-      {
-        "name": "run",
-        "command": "/idaw:run",
-        "description": "IDAW orchestrator - execute task skill chains serially with git checkpoints",
-        "arguments": "[-y|--yes] [--task <id>[,<id>,...]] [--dry-run]",
-        "category": "idaw",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "source": "../../../commands/idaw/run.md"
-      },
-      {
-        "name": "status",
-        "command": "/idaw:status",
-        "description": "View IDAW task and session progress",
-        "arguments": "[session-id]",
-        "category": "idaw",
-        "subcategory": null,
-        "usage_scenario": "session-management",
-        "difficulty": "Beginner",
-        "source": "../../../commands/idaw/status.md"
-      }
-    ]
-  },
   "issue": {
     "_root": [
       {
@@ -215,17 +145,6 @@
   },
   "memory": {
     "_root": [
-      {
-        "name": "prepare",
-        "command": "/memory:prepare",
-        "description": "Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context",
-        "arguments": "[--tool gemini|qwen] \\\"task context description\\",
-        "category": "memory",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "source": "../../../commands/memory/prepare.md"
-      },
       {
         "name": "style-skill-memory",
         "command": "/memory:style-skill-memory",
@@ -274,17 +193,6 @@
         "difficulty": "Intermediate",
         "source": "../../../commands/workflow/clean.md"
       },
-      {
-        "name": "workflow:collaborative-plan-with-file",
-        "command": "/workflow:collaborative-plan-with-file",
-        "description": "Collaborative planning with Plan Note - Understanding agent creates shared plan-note.md template, parallel agents fill pre-allocated sections, conflict detection without merge. Outputs executable plan-note.md.",
-        "arguments": "[-y|--yes] <task description> [--max-agents=5]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "planning",
-        "difficulty": "Intermediate",
-        "source": "../../../commands/workflow/collaborative-plan-with-file.md"
-      },
       {
         "name": "debug-with-file",
         "command": "/workflow:debug-with-file",
@@ -296,77 +204,22 @@
         "difficulty": "Intermediate",
         "source": "../../../commands/workflow/debug-with-file.md"
       },
-      {
-        "name": "init-guidelines",
-        "command": "/workflow:spec:setup -guidelines",
-        "description": "Interactive wizard to fill specs/*.md based on project analysis",
-        "arguments": "[--reset]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "source": "../../../commands/workflow/init-guidelines.md"
-      },
-      {
-        "name": "init-specs",
-        "command": "/workflow:spec:setup -specs",
-        "description": "Interactive wizard to create individual specs or personal constraints with scope selection",
-        "arguments": "[--scope <global|project>] [--dimension <specs|personal>] [--category <general|exploration|planning|execution>]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "source": "../../../commands/workflow/init-specs.md"
-      },
       {
         "name": "init",
-        "command": "/workflow:spec:setup ",
+        "command": "/workflow:init",
         "description": "Initialize project-level state with intelligent project analysis using cli-explore-agent",
-        "arguments": "[--regenerate] [--skip-specs]",
+        "arguments": "[--regenerate]",
         "category": "workflow",
         "subcategory": null,
         "usage_scenario": "general",
         "difficulty": "Intermediate",
         "source": "../../../commands/workflow/init.md"
       },
-      {
-        "name": "integration-test-cycle",
-        "command": "/workflow:integration-test-cycle",
-        "description": "Self-iterating integration test workflow with codebase exploration, test development, autonomous test-fix cycles, and reflection-driven strategy adjustment",
-        "arguments": "[-y|--yes] [-c|--continue] [--max-iterations=N] \\\"module or feature description\\",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "testing",
-        "difficulty": "Intermediate",
-        "source": "../../../commands/workflow/integration-test-cycle.md"
-      },
-      {
-        "name": "refactor-cycle",
-        "command": "/workflow:refactor-cycle",
-        "description": "Tech debt discovery and self-iterating refactoring with multi-dimensional analysis, prioritized execution, regression validation, and reflection-driven adjustment",
-        "arguments": "[-y|--yes] [-c|--continue] [--scope=module|project] \\\"module or refactoring goal\\",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "source": "../../../commands/workflow/refactor-cycle.md"
-      },
-      {
-        "name": "roadmap-with-file",
-        "command": "/workflow:roadmap-with-file",
-        "description": "Strategic requirement roadmap with iterative decomposition and issue creation. Outputs roadmap.md (human-readable, single source) + issues.jsonl (machine-executable). Handoff to team-planex.",
-        "arguments": "[-y|--yes] [-c|--continue] [-m progressive|direct|auto] \\\"requirement description\\",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "source": "../../../commands/workflow/roadmap-with-file.md"
-      },
       {
         "name": "unified-execute-with-file",
         "command": "/workflow:unified-execute-with-file",
         "description": "Universal execution engine for consuming any planning/brainstorm/analysis output with minimal progress tracking, multi-agent coordination, and incremental execution",
-        "arguments": "[-y|--yes] [<path>[,<path2>] | -p|--plan <path>[,<path2>]] [--auto-commit] [--commit-prefix \\\"prefix\\\"] [\\\"execution context or task name\\\"]",
+        "arguments": "[-y|--yes] [-p|--plan <path>] [-m|--mode sequential|parallel] [\\\"execution context or task name\\\"]",
         "category": "workflow",
         "subcategory": null,
         "usage_scenario": "implementation",
@@ -411,8 +264,8 @@
       {
         "name": "solidify",
         "command": "/workflow:session:solidify",
-        "description": "Crystallize session learnings and user-defined constraints into permanent project guidelines, or compress recent memories",
-        "arguments": "[-y|--yes] [--type <convention|constraint|learning|compress>] [--category <category>] [--limit <N>] \\\"rule or insight\\",
+        "description": "Crystallize session learnings and user-defined constraints into permanent project guidelines",
+        "arguments": "[-y|--yes] [--type <convention|constraint|learning>] [--category <category>] \\\"rule or insight\\",
         "category": "workflow",
         "subcategory": "session",
         "usage_scenario": "general",
@@ -429,17 +282,6 @@
         "usage_scenario": "general",
         "difficulty": "Intermediate",
         "source": "../../../commands/workflow/session/start.md"
-      },
-      {
-        "name": "sync",
-        "command": "/workflow:session:sync",
-        "description": "Quick-sync session work to specs/*.md and project-tech",
-        "arguments": "[-y|--yes] [\\\"what was done\\\"]",
-        "category": "workflow",
-        "subcategory": "session",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "source": "../../../commands/workflow/session/sync.md"
       }
     ],
     "ui-design": [
@@ -468,7 +310,7 @@
       {
         "name": "design-sync",
         "command": "/workflow:ui-design:design-sync",
-        "description": "Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow-plan consumption",
+        "description": "Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow:plan consumption",
         "arguments": "--session <session_id> [--selected-prototypes \"<list>\"]",
         "category": "workflow",
         "subcategory": "ui-design",
@@ -555,4 +397,4 @@
       }
     ]
   }
-}
+}

.claude/skills/ccw-help/index/by-use-case.json

@@ -33,39 +33,6 @@
       "difficulty": "Intermediate",
       "source": "../../../commands/cli/cli-init.md"
     },
-    {
-      "name": "add",
-      "command": "/idaw:add",
-      "description": "Add IDAW tasks - manual creation or import from ccw issue",
-      "arguments": "[-y|--yes] [--from-issue <id>[,<id>,...]] \\\"description\\\" [--type <task_type>] [--priority <1-5>]",
-      "category": "idaw",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/idaw/add.md"
-    },
-    {
-      "name": "run-coordinate",
-      "command": "/idaw:run-coordinate",
-      "description": "IDAW coordinator - execute task skill chains via external CLI with hook callbacks and git checkpoints",
-      "arguments": "[-y|--yes] [--task <id>[,<id>,...]] [--dry-run] [--tool <tool>]",
-      "category": "idaw",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/idaw/run-coordinate.md"
-    },
-    {
-      "name": "run",
-      "command": "/idaw:run",
-      "description": "IDAW orchestrator - execute task skill chains serially with git checkpoints",
-      "arguments": "[-y|--yes] [--task <id>[,<id>,...]] [--dry-run]",
-      "category": "idaw",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/idaw/run.md"
-    },
     {
       "name": "issue:discover-by-prompt",
       "command": "/issue:discover-by-prompt",
@@ -110,17 +77,6 @@
       "difficulty": "Intermediate",
       "source": "../../../commands/issue/queue.md"
     },
-    {
-      "name": "prepare",
-      "command": "/memory:prepare",
-      "description": "Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context",
-      "arguments": "[--tool gemini|qwen] \\\"task context description\\",
-      "category": "memory",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/memory/prepare.md"
-    },
     {
       "name": "clean",
       "command": "/workflow:clean",
@@ -143,61 +99,17 @@
       "difficulty": "Intermediate",
       "source": "../../../commands/workflow/debug-with-file.md"
     },
-    {
-      "name": "init-guidelines",
-      "command": "/workflow:spec:setup -guidelines",
-      "description": "Interactive wizard to fill specs/*.md based on project analysis",
-      "arguments": "[--reset]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/init-guidelines.md"
-    },
-    {
-      "name": "init-specs",
-      "command": "/workflow:spec:setup -specs",
-      "description": "Interactive wizard to create individual specs or personal constraints with scope selection",
-      "arguments": "[--scope <global|project>] [--dimension <specs|personal>] [--category <general|exploration|planning|execution>]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/init-specs.md"
-    },
     {
       "name": "init",
-      "command": "/workflow:spec:setup ",
+      "command": "/workflow:init",
       "description": "Initialize project-level state with intelligent project analysis using cli-explore-agent",
-      "arguments": "[--regenerate] [--skip-specs]",
+      "arguments": "[--regenerate]",
       "category": "workflow",
       "subcategory": null,
       "usage_scenario": "general",
       "difficulty": "Intermediate",
       "source": "../../../commands/workflow/init.md"
     },
-    {
-      "name": "refactor-cycle",
-      "command": "/workflow:refactor-cycle",
-      "description": "Tech debt discovery and self-iterating refactoring with multi-dimensional analysis, prioritized execution, regression validation, and reflection-driven adjustment",
-      "arguments": "[-y|--yes] [-c|--continue] [--scope=module|project] \\\"module or refactoring goal\\",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/refactor-cycle.md"
-    },
-    {
-      "name": "roadmap-with-file",
-      "command": "/workflow:roadmap-with-file",
-      "description": "Strategic requirement roadmap with iterative decomposition and issue creation. Outputs roadmap.md (human-readable, single source) + issues.jsonl (machine-executable). Handoff to team-planex.",
-      "arguments": "[-y|--yes] [-c|--continue] [-m progressive|direct|auto] \\\"requirement description\\",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/roadmap-with-file.md"
-    },
     {
       "name": "list",
       "command": "/workflow:session:list",
@@ -212,8 +124,8 @@
     {
       "name": "solidify",
       "command": "/workflow:session:solidify",
-      "description": "Crystallize session learnings and user-defined constraints into permanent project guidelines, or compress recent memories",
-      "arguments": "[-y|--yes] [--type <convention|constraint|learning|compress>] [--category <category>] [--limit <N>] \\\"rule or insight\\",
+      "description": "Crystallize session learnings and user-defined constraints into permanent project guidelines",
+      "arguments": "[-y|--yes] [--type <convention|constraint|learning>] [--category <category>] \\\"rule or insight\\",
       "category": "workflow",
       "subcategory": "session",
       "usage_scenario": "general",
@@ -231,17 +143,6 @@
       "difficulty": "Intermediate",
       "source": "../../../commands/workflow/session/start.md"
     },
-    {
-      "name": "sync",
-      "command": "/workflow:session:sync",
-      "description": "Quick-sync session work to specs/*.md and project-tech",
-      "arguments": "[-y|--yes] [\\\"what was done\\\"]",
-      "category": "workflow",
-      "subcategory": "session",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/session/sync.md"
-    },
     {
       "name": "animation-extract",
       "command": "/workflow:ui-design:animation-extract",
@@ -322,98 +223,6 @@
       "source": "../../../commands/workflow/analyze-with-file.md"
     }
   ],
-  "implementation": [
-    {
-      "name": "flow-create",
-      "command": "/flow-create",
-      "description": "",
-      "arguments": "",
-      "category": "general",
-      "subcategory": null,
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/flow-create.md"
-    },
-    {
-      "name": "execute",
-      "command": "/issue:execute",
-      "description": "Execute queue with DAG-based parallel orchestration (one commit per solution)",
-      "arguments": "[-y|--yes] --queue <queue-id> [--worktree [<existing-path>]]",
-      "category": "issue",
-      "subcategory": null,
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/issue/execute.md"
-    },
-    {
-      "name": "generate",
-      "command": "/workflow:ui-design:generate",
-      "description": "Assemble UI prototypes by combining layout templates with design tokens (default animation support), pure assembler without new content generation",
-      "arguments": "[--design-id <id>] [--session <id>]",
-      "category": "workflow",
-      "subcategory": "ui-design",
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/ui-design/generate.md"
-    },
-    {
-      "name": "unified-execute-with-file",
-      "command": "/workflow:unified-execute-with-file",
-      "description": "Universal execution engine for consuming any planning/brainstorm/analysis output with minimal progress tracking, multi-agent coordination, and incremental execution",
-      "arguments": "[-y|--yes] [<path>[,<path2>] | -p|--plan <path>[,<path2>]] [--auto-commit] [--commit-prefix \\\"prefix\\\"] [\\\"execution context or task name\\\"]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/unified-execute-with-file.md"
-    }
-  ],
-  "session-management": [
-    {
-      "name": "resume",
-      "command": "/idaw:resume",
-      "description": "Resume interrupted IDAW session from last checkpoint",
-      "arguments": "[-y|--yes] [session-id]",
-      "category": "idaw",
-      "subcategory": null,
-      "usage_scenario": "session-management",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/idaw/resume.md"
-    },
-    {
-      "name": "status",
-      "command": "/idaw:status",
-      "description": "View IDAW task and session progress",
-      "arguments": "[session-id]",
-      "category": "idaw",
-      "subcategory": null,
-      "usage_scenario": "session-management",
-      "difficulty": "Beginner",
-      "source": "../../../commands/idaw/status.md"
-    },
-    {
-      "name": "complete",
-      "command": "/workflow:session:complete",
-      "description": "Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag",
-      "arguments": "[-y|--yes] [--detailed]",
-      "category": "workflow",
-      "subcategory": "session",
-      "usage_scenario": "session-management",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/session/complete.md"
-    },
-    {
-      "name": "resume",
-      "command": "/workflow:session:resume",
-      "description": "Resume the most recently paused workflow session with automatic session discovery and status update",
-      "arguments": "",
-      "category": "workflow",
-      "subcategory": "session",
-      "usage_scenario": "session-management",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/session/resume.md"
-    }
-  ],
   "planning": [
     {
       "name": "convert-to-plan",
@@ -459,17 +268,6 @@
       "difficulty": "Intermediate",
       "source": "../../../commands/workflow/brainstorm-with-file.md"
     },
-    {
-      "name": "workflow:collaborative-plan-with-file",
-      "command": "/workflow:collaborative-plan-with-file",
-      "description": "Collaborative planning with Plan Note - Understanding agent creates shared plan-note.md template, parallel agents fill pre-allocated sections, conflict detection without merge. Outputs executable plan-note.md.",
-      "arguments": "[-y|--yes] <task description> [--max-agents=5]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/collaborative-plan-with-file.md"
-    },
     {
       "name": "workflow:ui-design:codify-style",
       "command": "/workflow:ui-design:codify-style",
@@ -484,7 +282,7 @@
     {
       "name": "design-sync",
       "command": "/workflow:ui-design:design-sync",
-      "description": "Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow-plan consumption",
+      "description": "Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow:plan consumption",
       "arguments": "--session <session_id> [--selected-prototypes \"<list>\"]",
       "category": "workflow",
       "subcategory": "ui-design",
@@ -515,6 +313,41 @@
       "source": "../../../commands/workflow/ui-design/reference-page-generator.md"
     }
   ],
+  "implementation": [
+    {
+      "name": "execute",
+      "command": "/issue:execute",
+      "description": "Execute queue with DAG-based parallel orchestration (one commit per solution)",
+      "arguments": "[-y|--yes] --queue <queue-id> [--worktree [<existing-path>]]",
+      "category": "issue",
+      "subcategory": null,
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/issue/execute.md"
+    },
+    {
+      "name": "generate",
+      "command": "/workflow:ui-design:generate",
+      "description": "Assemble UI prototypes by combining layout templates with design tokens (default animation support), pure assembler without new content generation",
+      "arguments": "[--design-id <id>] [--session <id>]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/ui-design/generate.md"
+    },
+    {
+      "name": "unified-execute-with-file",
+      "command": "/workflow:unified-execute-with-file",
+      "description": "Universal execution engine for consuming any planning/brainstorm/analysis output with minimal progress tracking, multi-agent coordination, and incremental execution",
+      "arguments": "[-y|--yes] [-p|--plan <path>] [-m|--mode sequential|parallel] [\\\"execution context or task name\\\"]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/unified-execute-with-file.md"
+    }
+  ],
   "documentation": [
     {
       "name": "style-skill-memory",
@@ -528,17 +361,28 @@
       "source": "../../../commands/memory/style-skill-memory.md"
     }
   ],
-  "testing": [
+  "session-management": [
     {
-      "name": "integration-test-cycle",
-      "command": "/workflow:integration-test-cycle",
-      "description": "Self-iterating integration test workflow with codebase exploration, test development, autonomous test-fix cycles, and reflection-driven strategy adjustment",
-      "arguments": "[-y|--yes] [-c|--continue] [--max-iterations=N] \\\"module or feature description\\",
+      "name": "complete",
+      "command": "/workflow:session:complete",
+      "description": "Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag",
+      "arguments": "[-y|--yes] [--detailed]",
       "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "testing",
+      "subcategory": "session",
+      "usage_scenario": "session-management",
       "difficulty": "Intermediate",
-      "source": "../../../commands/workflow/integration-test-cycle.md"
+      "source": "../../../commands/workflow/session/complete.md"
+    },
+    {
+      "name": "resume",
+      "command": "/workflow:session:resume",
+      "description": "Resume the most recently paused workflow session with automatic session discovery and status update",
+      "arguments": "",
+      "category": "workflow",
+      "subcategory": "session",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/session/resume.md"
     }
   ]
-}
+}

.claude/skills/ccw-help/index/command-relationships.json

@@ -1,64 +1,6 @@
 {
-  "workflow-plan": {
-    "calls_internally": [
-      "workflow:session:start"
-    ],
-    "next_steps": [
-      "workflow-plan-verify",
-      "workflow:session:list",
-      "workflow:unified-execute-with-file"
-    ],
-    "alternatives": [],
-    "prerequisites": []
-  },
-  "workflow-tdd-plan": {
-    "calls_internally": [
-      "workflow:session:start"
-    ],
-    "next_steps": [
-      "workflow-tdd-verify",
-      "workflow:session:list",
-      "workflow:unified-execute-with-file"
-    ],
-    "alternatives": [],
-    "prerequisites": []
-  },
-  "workflow:unified-execute-with-file": {
-    "prerequisites": [
-      "workflow-plan",
-      "workflow-tdd-plan"
-    ],
-    "related": [
-      "workflow:session:list",
-      "workflow:session:resume"
-    ],
-    "next_steps": [
-      "review-cycle",
-      "workflow-test-fix"
-    ]
-  },
-  "workflow-plan-verify": {
-    "prerequisites": [
-      "workflow-plan"
-    ],
-    "next_steps": [
-      "workflow:unified-execute-with-file"
-    ],
-    "related": [
-      "workflow:session:list"
-    ]
-  },
-  "workflow-tdd-verify": {
-    "prerequisites": [
-      "workflow:unified-execute-with-file"
-    ],
-    "related": []
-  },
   "workflow:session:start": {
-    "next_steps": [
-      "workflow-plan",
-      "workflow:unified-execute-with-file"
-    ],
+    "next_steps": [],
     "related": [
       "workflow:session:list",
       "workflow:session:resume"
@@ -69,23 +11,5 @@
     "related": [
       "workflow:session:list"
     ]
-  },
-  "workflow-lite-plan": {
-    "calls_internally": [],
-    "next_steps": [
-      "workflow:session:list"
-    ],
-    "alternatives": [
-      "workflow-plan"
-    ],
-    "prerequisites": []
-  },
-  "review-cycle": {
-    "prerequisites": [
-      "workflow:unified-execute-with-file"
-    ],
-    "related": [
-      "workflow-test-fix"
-    ]
   }
 }

.claude/skills/ccw-help/index/essential-commands.json

@@ -10,4 +10,4 @@
     "difficulty": "Intermediate",
     "source": "../../../commands/workflow/session/start.md"
   }
-]
+]

.claude/skills/ccw-help/index/skills-by-category.json

@@ -1,364 +0,0 @@
-{
-  "standalone": [
-    {
-      "name": "brainstorm",
-      "description": "Unified brainstorming skill with dual-mode operation - auto pipeline and single role analysis. Triggers on \"brainstorm\", \"头脑风暴\".",
-      "category": "standalone",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/brainstorm/SKILL.md"
-    }
-  ],
-  "meta": [
-    {
-      "name": "command-generator",
-      "description": "Command file generator - 5 phase workflow for creating Claude Code command files with YAML frontmatter. Generates .md command files for project or user scope. Triggers on \"create command\", \"new command\", \"command generator\".",
-      "category": "meta",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/command-generator/SKILL.md"
-    },
-    {
-      "name": "skill-generator",
-      "description": "Meta-skill for creating new Claude Code skills with configurable execution modes. Supports sequential (fixed order) and autonomous (stateless) phase patterns. Use for skill scaffolding, skill creation, or building new workflows. Triggers on \"create skill\", \"new skill\", \"skill generator\".",
-      "category": "meta",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/skill-generator/SKILL.md"
-    },
-    {
-      "name": "skill-tuning",
-      "description": "Universal skill diagnosis and optimization tool. Detect and fix skill execution issues including context explosion, long-tail forgetting, data flow disruption, and agent coordination failures. Supports Gemini CLI for deep analysis. Triggers on \"skill tuning\", \"tune skill\", \"skill diagnosis\", \"optimize skill\", \"skill debug\".",
-      "category": "meta",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/skill-tuning/SKILL.md"
-    },
-    {
-      "name": "spec-generator",
-      "description": "Specification generator - 6 phase document chain producing product brief, PRD, architecture, and epics. Triggers on \"generate spec\", \"create specification\", \"spec generator\", \"workflow:spec\".",
-      "category": "meta",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/spec-generator/SKILL.md"
-    }
-  ],
-  "utility": [
-    {
-      "name": "ccw-help",
-      "description": "CCW command help system. Search, browse, recommend commands, skills, teams. Triggers \"ccw-help\", \"ccw-issue\".",
-      "category": "utility",
-      "is_team": false,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "8.0.0",
-      "source": "../../../skills/ccw-help/SKILL.md"
-    },
-    {
-      "name": "issue-manage",
-      "description": "Interactive issue management with menu-driven CRUD operations. Use when managing issues, viewing issue status, editing issue fields, performing bulk operations, or viewing issue history. Triggers on \"manage issue\", \"list issues\", \"edit issue\", \"delete issue\", \"bulk update\", \"issue dashboard\", \"issue history\", \"completed issues\".",
-      "category": "utility",
-      "is_team": false,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/issue-manage/SKILL.md"
-    },
-    {
-      "name": "memory-capture",
-      "description": "Unified memory capture with routing - session compact or quick tips. Triggers on \"memory capture\", \"compact session\", \"save session\", \"quick tip\", \"memory tips\", \"记录\", \"压缩会话\".",
-      "category": "utility",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/memory-capture/SKILL.md"
-    },
-    {
-      "name": "memory-manage",
-      "description": "Unified memory management - CLAUDE.md updates and documentation generation with interactive routing. Triggers on \"memory manage\", \"update claude\", \"update memory\", \"generate docs\", \"更新记忆\", \"生成文档\".",
-      "category": "utility",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/memory-manage/SKILL.md"
-    }
-  ],
-  "review": [
-    {
-      "name": "review-code",
-      "description": "Multi-dimensional code review with structured reports. Analyzes correctness, readability, performance, security, testing, and architecture. Triggers on \"review code\", \"code review\", \"审查代码\", \"代码审查\".",
-      "category": "review",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/review-code/SKILL.md"
-    },
-    {
-      "name": "review-cycle",
-      "description": "Unified multi-dimensional code review with automated fix orchestration. Routes to session-based (git changes), module-based (path patterns), or fix mode. Triggers on \"workflow:review-cycle\", \"workflow:review-session-cycle\", \"workflow:review-module-cycle\", \"workflow:review-cycle-fix\".",
-      "category": "review",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/review-cycle/SKILL.md"
-    }
-  ],
-  "team": [
-    {
-      "name": "team-arch-opt",
-      "description": "Unified team skill for architecture optimization. Uses team-worker agent architecture with role-spec files for domain logic. Coordinator orchestrates pipeline, workers are team-worker agents. Triggers on \"team arch-opt\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": true,
-      "version": "",
-      "source": "../../../skills/team-arch-opt/SKILL.md"
-    },
-    {
-      "name": "team-brainstorm",
-      "description": "Unified team skill for brainstorming team. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team brainstorm\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/team-brainstorm/SKILL.md"
-    },
-    {
-      "name": "team-coordinate",
-      "description": "Universal team coordination skill with dynamic role generation. Uses team-worker agent architecture with role-spec files. Only coordinator is built-in -- all worker roles are generated at runtime as role-specs and spawned via team-worker agent. Beat/cadence model for orchestration. Triggers on \"Team Coordinate \".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/team-coordinate/SKILL.md"
-    },
-    {
-      "name": "team-executor",
-      "description": "Lightweight session execution skill. Resumes existing team-coordinate sessions for pure execution via team-worker agents. No analysis, no role generation -- only loads and executes. Session path required. Triggers on \"Team Executor\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/team-executor/SKILL.md"
-    },
-    {
-      "name": "team-frontend",
-      "description": "Unified team skill for frontend development team. All roles invoke this skill with --role arg. Built-in ui-ux-pro-max design intelligence. Triggers on \"team frontend\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/team-frontend/SKILL.md"
-    },
-    {
-      "name": "team-issue",
-      "description": "Unified team skill for issue resolution. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team issue\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/team-issue/SKILL.md"
-    },
-    {
-      "name": "team-iterdev",
-      "description": "Unified team skill for iterative development team. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team iterdev\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/team-iterdev/SKILL.md"
-    },
-    {
-      "name": "team-lifecycle",
-      "description": "Unified team skill for full lifecycle - spec/impl/test. Uses team-worker agent architecture with role-spec files for domain logic. Coordinator orchestrates pipeline, workers are team-worker agents loaded with role-specific Phase 2-4 specs. Triggers on \"team lifecycle\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": true,
-      "version": "",
-      "source": "../../../skills/team-lifecycle/SKILL.md"
-    },
-    {
-      "name": "team-perf-opt",
-      "description": "Unified team skill for performance optimization. Uses team-worker agent architecture with role-spec files for domain logic. Coordinator orchestrates pipeline, workers are team-worker agents. Triggers on \"team perf-opt\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": true,
-      "version": "",
-      "source": "../../../skills/team-perf-opt/SKILL.md"
-    },
-    {
-      "name": "team-planex",
-      "description": "Unified team skill for plan-and-execute pipeline. Uses team-worker agent architecture with role-spec files for domain logic. Coordinator orchestrates pipeline, workers are team-worker agents. Triggers on \"team planex\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": true,
-      "version": "",
-      "source": "../../../skills/team-planex/SKILL.md"
-    },
-    {
-      "name": "team-quality-assurance",
-      "description": "Unified team skill for quality assurance team. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team quality-assurance\", \"team qa\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/team-quality-assurance/SKILL.md"
-    },
-    {
-      "name": "team-review",
-      "description": "Unified team skill for code scanning, vulnerability review, optimization suggestions, and automated fix. 4-role team: coordinator, scanner, reviewer, fixer. Triggers on team-review.",
-      "category": "team",
-      "is_team": false,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/team-review/SKILL.md"
-    },
-    {
-      "name": "team-roadmap-dev",
-      "description": "Unified team skill for roadmap-driven development workflow. Coordinator discusses roadmap with user, then dispatches phased execution pipeline (plan -> execute -> verify). All roles invoke this skill with --role arg. Triggers on \"team roadmap-dev\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/team-roadmap-dev/SKILL.md"
-    },
-    {
-      "name": "team-tech-debt",
-      "description": "Unified team skill for tech debt identification and cleanup. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team tech-debt\", \"tech debt cleanup\", \"技术债务\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/team-tech-debt/SKILL.md"
-    },
-    {
-      "name": "team-testing",
-      "description": "Unified team skill for testing team. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team testing\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/team-testing/SKILL.md"
-    },
-    {
-      "name": "team-uidesign",
-      "description": "Unified team skill for UI design team. All roles invoke this skill with --role arg for role-specific execution. CP-9 Dual-Track design+implementation.",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/team-uidesign/SKILL.md"
-    },
-    {
-      "name": "team-ultra-analyze",
-      "description": "Unified team skill for deep collaborative analysis. All roles invoke this skill with --role arg for role-specific execution. Triggers on \"team ultra-analyze\", \"team analyze\".",
-      "category": "team",
-      "is_team": true,
-      "has_phases": false,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/team-ultra-analyze/SKILL.md"
-    }
-  ],
-  "workflow": [
-    {
-      "name": "workflow-execute",
-      "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking. Triggers on \"workflow-execute\".",
-      "category": "workflow",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/workflow-execute/SKILL.md"
-    },
-    {
-      "name": "workflow-lite-plan",
-      "description": "Lightweight planning and execution skill (Phase 1: plan, Phase 2: execute). Triggers on \"workflow-lite-plan\".",
-      "category": "workflow",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/workflow-lite-plan/SKILL.md"
-    },
-    {
-      "name": "workflow-multi-cli-plan",
-      "description": "Multi-CLI collaborative planning and execution skill with integrated execution phase. Triggers on \"workflow-multi-cli-plan\".",
-      "category": "workflow",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/workflow-multi-cli-plan/SKILL.md"
-    },
-    {
-      "name": "workflow-plan",
-      "description": "Unified planning skill - 4-phase planning workflow, plan verification, and interactive replanning. Triggers on \"workflow-plan\", \"workflow-plan-verify\", \"workflow:replan\".",
-      "category": "workflow",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/workflow-plan/SKILL.md"
-    },
-    {
-      "name": "workflow-skill-designer",
-      "description": "Meta-skill for designing orchestrator+phases structured workflow skills. Creates SKILL.md coordinator with progressive phase loading, TodoWrite patterns, and data flow. Triggers on \"design workflow skill\", \"create workflow skill\", \"workflow skill designer\".",
-      "category": "workflow",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/workflow-skill-designer/SKILL.md"
-    },
-    {
-      "name": "workflow-tdd-plan",
-      "description": "Unified TDD workflow skill combining 6-phase TDD planning with Red-Green-Refactor task chain generation, and 4-phase TDD verification with compliance reporting. Triggers on \"workflow-tdd-plan\", \"workflow-tdd-verify\".",
-      "category": "workflow",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/workflow-tdd-plan/SKILL.md"
-    },
-    {
-      "name": "workflow-test-fix",
-      "description": "Unified test-fix pipeline combining test generation (session, context, analysis, task gen) with iterative test-cycle execution (adaptive strategy, progressive testing, CLI fallback). Triggers on \"workflow-test-fix\", \"workflow-test-fix\", \"test fix workflow\".",
-      "category": "workflow",
-      "is_team": false,
-      "has_phases": true,
-      "has_role_specs": false,
-      "version": "",
-      "source": "../../../skills/workflow-test-fix/SKILL.md"
-    }
-  ]
-}

.claude/skills/ccw-help/scripts/analyze_commands.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
 """
-Analyze all command/agent/skill files and generate index files for ccw-help skill.
+Analyze all command/agent files and generate index files for ccw-help skill.
 Outputs relative paths pointing to source files (no reference folder duplication).
 """
 
 import os
+import re
 import json
 from pathlib import Path
 from collections import defaultdict
@@ -14,13 +15,9 @@ from typing import Dict, List, Any
 BASE_DIR = Path("D:/Claude_dms3/.claude")
 COMMANDS_DIR = BASE_DIR / "commands"
 AGENTS_DIR = BASE_DIR / "agents"
-SKILLS_DIR = BASE_DIR / "skills"
 SKILL_DIR = BASE_DIR / "skills" / "ccw-help"
 INDEX_DIR = SKILL_DIR / "index"
 
-# Skills to skip (internal/shared, not user-facing)
-SKIP_SKILLS = {"_shared", "ccw-help"}
-
 def parse_frontmatter(content: str) -> Dict[str, Any]:
     """Extract YAML frontmatter from markdown content."""
     frontmatter = {}
@@ -142,129 +139,73 @@ def analyze_agent_file(file_path: Path) -> Dict[str, Any]:
         "source": rel_path  # Relative from index/ dir (e.g., "../../../agents/...")
     }
 
-def categorize_skill(name: str, description: str) -> str:
-    """Determine skill category from name and description."""
-    if name.startswith('team-'):
-        return "team"
-    if name.startswith('workflow-'):
-        return "workflow"
-    if name.startswith('review-'):
-        return "review"
-    if name.startswith('spec-') or name.startswith('command-') or name.startswith('skill-'):
-        return "meta"
-    if name.startswith('memory-') or name.startswith('issue-'):
-        return "utility"
-    return "standalone"
-
-
-def analyze_skill_dir(skill_path: Path) -> Dict[str, Any] | None:
-    """Analyze a skill directory and extract metadata from SKILL.md."""
-    skill_md = skill_path / "SKILL.md"
-    if not skill_md.exists():
-        return None
-
-    with open(skill_md, 'r', encoding='utf-8') as f:
-        content = f.read()
-
-    frontmatter = parse_frontmatter(content)
-
-    name = frontmatter.get('name', skill_path.name)
-    description = frontmatter.get('description', '')
-    allowed_tools = frontmatter.get('allowed-tools', '')
-    version = frontmatter.get('version', '')
-
-    category = categorize_skill(name, description)
-
-    # Detect if it's a team skill (uses TeamCreate + SendMessage together)
-    is_team = 'TeamCreate' in allowed_tools and 'SendMessage' in allowed_tools
-
-    # Detect if it has phases
-    phases_dir = skill_path / "phases"
-    has_phases = phases_dir.exists() and any(phases_dir.iterdir()) if phases_dir.exists() else False
-
-    # Detect if it has role-specs
-    role_specs_dir = skill_path / "role-specs"
-    has_role_specs = role_specs_dir.exists() and any(role_specs_dir.iterdir()) if role_specs_dir.exists() else False
-
-    # Build relative path from INDEX_DIR
-    rel_from_base = skill_path.relative_to(BASE_DIR)
-    rel_path = "../../../" + str(rel_from_base).replace('\\', '/') + "/SKILL.md"
-
-    return {
-        "name": name,
-        "description": description,
-        "category": category,
-        "is_team": is_team,
-        "has_phases": has_phases,
-        "has_role_specs": has_role_specs,
-        "version": version,
-        "source": rel_path
-    }
-
-
 def build_command_relationships() -> Dict[str, Any]:
     """Build command relationship mappings."""
     return {
-        "workflow-plan": {
+        "workflow:plan": {
             "calls_internally": ["workflow:session:start", "workflow:tools:context-gather", "workflow:tools:conflict-resolution", "workflow:tools:task-generate-agent"],
-            "next_steps": ["workflow-plan-verify", "workflow:status", "workflow-execute"],
-            "alternatives": ["workflow-tdd-plan"],
+            "next_steps": ["workflow:plan-verify", "workflow:status", "workflow:execute"],
+            "alternatives": ["workflow:tdd-plan"],
             "prerequisites": []
         },
-        "workflow-tdd-plan": {
+        "workflow:tdd-plan": {
             "calls_internally": ["workflow:session:start", "workflow:tools:context-gather", "workflow:tools:task-generate-tdd"],
-            "next_steps": ["workflow-tdd-verify", "workflow:status", "workflow-execute"],
-            "alternatives": ["workflow-plan"],
+            "next_steps": ["workflow:tdd-verify", "workflow:status", "workflow:execute"],
+            "alternatives": ["workflow:plan"],
             "prerequisites": []
         },
-        "workflow-execute": {
-            "prerequisites": ["workflow-plan", "workflow-tdd-plan"],
+        "workflow:execute": {
+            "prerequisites": ["workflow:plan", "workflow:tdd-plan"],
             "related": ["workflow:status", "workflow:resume"],
-            "next_steps": ["workflow:review", "workflow-tdd-verify"]
+            "next_steps": ["workflow:review", "workflow:tdd-verify"]
         },
-        "workflow-plan-verify": {
-            "prerequisites": ["workflow-plan"],
-            "next_steps": ["workflow-execute"],
+        "workflow:plan-verify": {
+            "prerequisites": ["workflow:plan"],
+            "next_steps": ["workflow:execute"],
             "related": ["workflow:status"]
         },
-        "workflow-tdd-verify": {
-            "prerequisites": ["workflow-execute"],
+        "workflow:tdd-verify": {
+            "prerequisites": ["workflow:execute"],
             "related": ["workflow:tools:tdd-coverage-analysis"]
         },
         "workflow:session:start": {
-            "next_steps": ["workflow-plan", "workflow-execute"],
+            "next_steps": ["workflow:plan", "workflow:execute"],
             "related": ["workflow:session:list", "workflow:session:resume"]
         },
         "workflow:session:resume": {
             "alternatives": ["workflow:resume"],
             "related": ["workflow:session:list", "workflow:status"]
         },
-        "workflow-lite-plan": {
-            "calls_internally": [],
-            "next_steps": ["workflow:status"],
-            "alternatives": ["workflow-plan"],
+        "workflow:lite-plan": {
+            "calls_internally": ["workflow:lite-execute"],
+            "next_steps": ["workflow:lite-execute", "workflow:status"],
+            "alternatives": ["workflow:plan"],
             "prerequisites": []
         },
         "workflow:lite-fix": {
-            "next_steps": ["workflow:status"],
-            "alternatives": ["workflow-lite-plan"],
-            "related": ["workflow-test-fix"]
+            "next_steps": ["workflow:lite-execute", "workflow:status"],
+            "alternatives": ["workflow:lite-plan"],
+            "related": ["workflow:test-cycle-execute"]
+        },
+        "workflow:lite-execute": {
+            "prerequisites": ["workflow:lite-plan", "workflow:lite-fix"],
+            "related": ["workflow:execute", "workflow:status"]
         },
         "workflow:review-session-cycle": {
-            "prerequisites": ["workflow-execute"],
+            "prerequisites": ["workflow:execute"],
             "next_steps": ["workflow:review-fix"],
             "related": ["workflow:review-module-cycle"]
         },
         "workflow:review-fix": {
             "prerequisites": ["workflow:review-module-cycle", "workflow:review-session-cycle"],
-            "related": ["workflow-test-fix"]
+            "related": ["workflow:test-cycle-execute"]
         },
         "memory:docs": {
             "calls_internally": ["workflow:session:start", "workflow:tools:context-gather"],
-            "next_steps": ["workflow-execute"]
+            "next_steps": ["workflow:execute"]
         },
         "memory:skill-memory": {
-            "next_steps": ["workflow-plan", "cli:analyze"],
+            "next_steps": ["workflow:plan", "cli:analyze"],
             "related": ["memory:load-skill-memory"]
         }
     }
@@ -272,11 +213,11 @@ def build_command_relationships() -> Dict[str, Any]:
 def identify_essential_commands(all_commands: List[Dict]) -> List[Dict]:
     """Identify the most essential commands for beginners."""
     essential_names = [
-        "workflow-lite-plan", "workflow:lite-fix", "workflow-plan",
-        "workflow-execute", "workflow:status", "workflow:session:start",
+        "workflow:lite-plan", "workflow:lite-fix", "workflow:plan",
+        "workflow:execute", "workflow:status", "workflow:session:start",
         "workflow:review-session-cycle", "cli:analyze", "cli:chat",
         "memory:docs", "workflow:brainstorm:artifacts",
-        "workflow-plan-verify", "workflow:resume", "version"
+        "workflow:plan-verify", "workflow:resume", "version"
     ]
 
     essential = []
@@ -326,24 +267,7 @@ def main():
         except Exception as e:
             print(f"  ERROR analyzing {agent_file}: {e}")
 
-    # Analyze skill directories
-    print("\n=== Analyzing Skill Files ===")
-    skill_dirs = [d for d in SKILLS_DIR.iterdir() if d.is_dir() and d.name not in SKIP_SKILLS]
-    print(f"Found {len(skill_dirs)} skill directories")
-
-    all_skills = []
-    for skill_dir in sorted(skill_dirs):
-        try:
-            metadata = analyze_skill_dir(skill_dir)
-            if metadata:
-                all_skills.append(metadata)
-                print(f"  OK {metadata['name']} [{metadata['category']}]")
-            else:
-                print(f"  SKIP {skill_dir.name} (no SKILL.md)")
-        except Exception as e:
-            print(f"  ERROR analyzing {skill_dir}: {e}")
-
-    print(f"\nAnalyzed {len(all_commands)} commands, {len(all_agents)} agents, {len(all_skills)} skills")
+    print(f"\nAnalyzed {len(all_commands)} commands, {len(all_agents)} agents")
 
     # Generate index files
     INDEX_DIR.mkdir(parents=True, exist_ok=True)
@@ -396,62 +320,15 @@ def main():
         json.dump(relationships, f, indent=2, ensure_ascii=False)
     print(f"OK Generated {relationships_path.name} ({os.path.getsize(relationships_path)} bytes)")
 
-    # 7. all-skills.json
-    all_skills_path = INDEX_DIR / "all-skills.json"
-    with open(all_skills_path, 'w', encoding='utf-8') as f:
-        json.dump(all_skills, f, indent=2, ensure_ascii=False)
-    print(f"OK Generated {all_skills_path.name} ({os.path.getsize(all_skills_path)} bytes)")
-
-    # 8. skills-by-category.json
-    skills_by_cat = defaultdict(list)
-    for skill in all_skills:
-        skills_by_cat[skill['category']].append(skill)
-
-    skills_by_cat_path = INDEX_DIR / "skills-by-category.json"
-    with open(skills_by_cat_path, 'w', encoding='utf-8') as f:
-        json.dump(dict(skills_by_cat), f, indent=2, ensure_ascii=False)
-    print(f"OK Generated {skills_by_cat_path.name} ({os.path.getsize(skills_by_cat_path)} bytes)")
-
-    # Generate master command.json (includes commands, agents, skills)
-    master = {
-        "_metadata": {
-            "version": "4.0.0",
-            "total_commands": len(all_commands),
-            "total_agents": len(all_agents),
-            "total_skills": len(all_skills),
-            "description": "Auto-generated CCW-Help command index from analyze_commands.py",
-            "generated": "Auto-updated - all commands, agents, skills synced from file system",
-            "last_sync": "command.json now stays in sync with CLI definitions"
-        },
-        "essential_commands": [cmd['name'] for cmd in essential],
-        "commands": all_commands,
-        "agents": all_agents,
-        "skills": all_skills,
-        "categories": sorted(set(cmd['category'] for cmd in all_commands)),
-        "skill_categories": sorted(skills_by_cat.keys())
-    }
-
-    master_path = SKILL_DIR / "command.json"
-    with open(master_path, 'w', encoding='utf-8') as f:
-        json.dump(master, f, indent=2, ensure_ascii=False)
-    print(f"\nOK Generated command.json ({os.path.getsize(master_path)} bytes)")
-
     # Print summary
     print("\n=== Summary ===")
     print(f"Commands: {len(all_commands)}")
     print(f"Agents: {len(all_agents)}")
-    print(f"Skills: {len(all_skills)}")
     print(f"Essential: {len(essential)}")
-    print(f"\nCommands by category:")
+    print(f"\nBy category:")
     for cat in sorted(by_category.keys()):
         total = sum(len(cmds) for cmds in by_category[cat].values())
         print(f"  {cat}: {total}")
-    print(f"\nSkills by category:")
-    for cat in sorted(skills_by_cat.keys()):
-        print(f"  {cat}: {len(skills_by_cat[cat])}")
-        for skill in skills_by_cat[cat]:
-            team_tag = " [team]" if skill['is_team'] else ""
-            print(f"    - {skill['name']}{team_tag}")
 
     print(f"\nIndex: {INDEX_DIR}")
     print("=== Complete ===")

.claude/skills/delegation-check/SKILL.md

@@ -1,290 +0,0 @@
----
-name: delegation-check
-description: Check workflow delegation prompts against agent role definitions for content separation violations. Detects conflicts, duplication, boundary leaks, and missing contracts. Triggers on "check delegation", "delegation conflict", "prompt vs role check".
-allowed-tools: Read, Glob, Grep, Bash, AskUserQuestion
----
-
-<purpose>
-Validate that command delegation prompts (Agent() calls) and agent role definitions respect GSD content separation boundaries. Detects 7 conflict dimensions: role re-definition, domain expertise leaking into prompts, quality gate duplication, output format conflicts, process override, scope authority conflicts, and missing contracts.
-
-Invoked when user requests "check delegation", "delegation conflict", "prompt vs role check", or when reviewing workflow skill quality.
-</purpose>
-
-<required_reading>
-- @.claude/skills/delegation-check/specs/separation-rules.md
-</required_reading>
-
-<process>
-
-## 1. Determine Scan Scope
-
-Parse `$ARGUMENTS` to identify what to check.
-
-| Signal | Scope |
-|--------|-------|
-| File path to command `.md` | Single command + its agents |
-| File path to agent `.md` | Single agent + commands that spawn it |
-| Directory path (e.g., `.claude/skills/team-*/`) | All commands + agents in that skill |
-| "all" or no args | Scan all `.claude/commands/`, `.claude/skills/*/`, `.claude/agents/` |
-
-If ambiguous, ask:
-
-```
-AskUserQuestion(
-  header: "Scan Scope",
-  question: "What should I check for delegation conflicts?",
-  options: [
-    { label: "Specific skill", description: "Check one skill directory" },
-    { label: "Specific command+agent pair", description: "Check one command and its spawned agents" },
-    { label: "Full scan", description: "Scan all commands, skills, and agents" }
-  ]
-)
-```
-
-## 2. Discover Command-Agent Pairs
-
-For each command file in scope:
-
-**2a. Extract Agent() calls from commands:**
-
-```bash
-# Search both Agent() (current) and Task() (legacy GSD) patterns
-grep -n "Agent(\|Task(" "$COMMAND_FILE"
-grep -n "subagent_type" "$COMMAND_FILE"
-```
-
-For each `Agent()` call, extract:
-- `subagent_type` → agent name
-- Full prompt content between the prompt markers (the string passed as `prompt=`)
-- Line range of the delegation prompt
-
-**2b. Locate agent definitions:**
-
-For each `subagent_type` found:
-```bash
-# Check standard locations
-ls .claude/agents/${AGENT_NAME}.md 2>/dev/null
-ls .claude/skills/*/agents/${AGENT_NAME}.md 2>/dev/null
-```
-
-**2c. Build pair map:**
-
-```
-$PAIRS = [
-  {
-    command: { path, agent_calls: [{ line, subagent_type, prompt_content }] },
-    agent: { path, role, sections, quality_gate, output_contract }
-  }
-]
-```
-
-If an agent file cannot be found, record as `MISSING_AGENT` — this is itself a finding.
-
-## 3. Parse Delegation Prompts
-
-For each Agent() call, extract structured blocks from the prompt content:
-
-| Block | What It Contains |
-|-------|-----------------|
-| `<objective>` | What to accomplish |
-| `<files_to_read>` | Input file paths |
-| `<additional_context>` / `<planning_context>` / `<verification_context>` | Runtime parameters |
-| `<output>` / `<expected_output>` | Output format/location expectations |
-| `<quality_gate>` | Per-invocation quality checklist |
-| `<deep_work_rules>` / `<instructions>` | Cross-cutting policy or revision instructions |
-| `<downstream_consumer>` | Who consumes the output |
-| `<success_criteria>` | Success conditions |
-| Free-form text | Unstructured instructions |
-
-Also detect ANTI-PATTERNS in prompt content:
-- Role identity statements ("You are a...", "Your role is...")
-- Domain expertise (decision tables, heuristics, comparison examples)
-- Process definitions (numbered steps, step-by-step instructions beyond scope)
-- Philosophy statements ("always prefer...", "never do...")
-- Anti-pattern lists that belong in agent definition
-
-## 4. Parse Agent Definitions
-
-For each agent file, extract:
-
-| Section | Key Content |
-|---------|------------|
-| `<role>` | Identity, spawner, responsibilities, mandatory read |
-| `<philosophy>` | Guiding principles |
-| `<upstream_input>` | How agent interprets input |
-| `<output_contract>` | Return markers (COMPLETE/BLOCKED/CHECKPOINT) |
-| `<quality_gate>` | Self-check criteria |
-| Domain sections | All `<section_name>` tags with their content |
-| YAML frontmatter | name, description, tools |
-
-## 5. Run Conflict Checks (7 Dimensions)
-
-### Dimension 1: Role Re-definition
-
-**Question:** Does the delegation prompt redefine the agent's identity?
-
-**Check:** Scan prompt content for:
-- "You are a..." / "You are the..." / "Your role is..."
-- "Your job is to..." / "Your responsibility is..."
-- "Core responsibilities:" lists
-- Any content that contradicts agent's `<role>` section
-
-**Allowed:** References to mode ("standard mode", "revision mode") that the agent's `<role>` already lists in "Spawned by:".
-
-**Severity:** `error` if prompt redefines role; `warning` if prompt adds responsibilities not in agent's `<role>`.
-
-### Dimension 2: Domain Expertise Leak
-
-**Question:** Does the delegation prompt embed domain knowledge that belongs in the agent?
-
-**Check:** Scan prompt content for:
-- Decision/routing tables (`| Condition | Action |`)
-- Good-vs-bad comparison examples (`| TOO VAGUE | JUST RIGHT |`)
-- Heuristic rules ("If X then Y", "Always prefer Z")
-- Anti-pattern lists ("DO NOT...", "NEVER...")
-- Detailed process steps beyond task scope
-
-**Exception:** `<deep_work_rules>` is an acceptable cross-cutting policy pattern from GSD — flag as `info` only.
-
-**Severity:** `error` if prompt contains domain tables/examples that duplicate agent content; `warning` if prompt contains heuristics not in agent.
-
-### Dimension 3: Quality Gate Duplication
-
-**Question:** Do the prompt's quality checks overlap or conflict with the agent's own `<quality_gate>`?
-
-**Check:** Compare prompt `<quality_gate>` / `<success_criteria>` items against agent's `<quality_gate>` items:
-- **Duplicate:** Same check appears in both → `warning` (redundant, may diverge)
-- **Conflict:** Contradictory criteria (e.g., prompt says "max 3 tasks", agent says "max 5 tasks") → `error`
-- **Missing:** Prompt expects quality checks agent doesn't have → `info`
-
-**Severity:** `error` for contradictions; `warning` for duplicates; `info` for gaps.
-
-### Dimension 4: Output Format Conflict
-
-**Question:** Does the prompt's expected output format conflict with the agent's `<output_contract>`?
-
-**Check:**
-- Prompt `<expected_output>` markers vs agent's `<output_contract>` return markers
-- Prompt expects specific format agent doesn't define
-- Prompt expects file output but agent's contract only defines markers (or vice versa)
-- Return marker names differ (prompt expects `## DONE`, agent returns `## TASK COMPLETE`)
-
-**Severity:** `error` if return markers conflict; `warning` if format expectations unspecified on either side.
-
-### Dimension 5: Process Override
-
-**Question:** Does the delegation prompt dictate HOW the agent should work?
-
-**Check:** Scan prompt for:
-- Numbered step-by-step instructions ("Step 1:", "First..., Then..., Finally...")
-- Process flow definitions beyond `<objective>` scope
-- Tool usage instructions ("Use grep to...", "Run bash command...")
-- Execution ordering that conflicts with agent's own execution flow
-
-**Allowed:** `<instructions>` block for revision mode (telling agent what changed, not how to work).
-
-**Severity:** `error` if prompt overrides agent's process; `warning` if prompt suggests process hints.
-
-### Dimension 6: Scope Authority Conflict
-
-**Question:** Does the prompt make decisions that belong to the agent's domain?
-
-**Check:**
-- Prompt specifies implementation choices (library selection, architecture patterns) when agent's `<philosophy>` or domain sections own these decisions
-- Prompt overrides agent's discretion areas
-- Prompt locks decisions that agent's `<context_fidelity>` says are "Claude's Discretion"
-
-**Allowed:** Passing through user-locked decisions from CONTEXT.md — this is proper delegation, not authority conflict.
-
-**Severity:** `error` if prompt makes domain decisions agent should own; `info` if prompt passes through user decisions (correct behavior).
-
-### Dimension 7: Missing Contracts
-
-**Question:** Are the delegation handoff points properly defined?
-
-**Check:**
-- Agent has `<output_contract>` with return markers → command handles all markers?
-- Command's return handling covers COMPLETE, BLOCKED, CHECKPOINT
-- Agent lists "Spawned by:" — does command actually spawn it?
-- Agent expects `<files_to_read>` — does prompt provide it?
-- Agent has `<upstream_input>` — does prompt provide matching input structure?
-
-**Severity:** `error` if return marker handling is missing; `warning` if agent expects input the prompt doesn't provide.
-
-## 6. Aggregate and Report
-
-### 6a. Per-pair summary
-
-For each command-agent pair, aggregate findings:
-
-```
-{command_path} → {agent_name}
-  Agent() at line {N}:
-    D1 (Role Re-def):      {PASS|WARN|ERROR} — {detail}
-    D2 (Domain Leak):       {PASS|WARN|ERROR} — {detail}
-    D3 (Quality Gate):      {PASS|WARN|ERROR} — {detail}
-    D4 (Output Format):     {PASS|WARN|ERROR} — {detail}
-    D5 (Process Override):  {PASS|WARN|ERROR} — {detail}
-    D6 (Scope Authority):   {PASS|WARN|ERROR} — {detail}
-    D7 (Missing Contract):  {PASS|WARN|ERROR} — {detail}
-```
-
-### 6b. Overall verdict
-
-| Verdict | Condition |
-|---------|-----------|
-| **CLEAN** | 0 errors, 0-2 warnings |
-| **REVIEW** | 0 errors, 3+ warnings |
-| **CONFLICT** | 1+ errors |
-
-### 6c. Fix recommendations
-
-For each finding, provide:
-- **Location:** file:line
-- **What's wrong:** concrete description
-- **Fix:** move content to correct owner (command or agent)
-- **Example:** before/after snippet if applicable
-
-## 7. Present Results
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- DELEGATION-CHECK ► SCAN COMPLETE
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Scope: {description}
-Pairs checked: {N} command-agent pairs
-Findings: {E} errors, {W} warnings, {I} info
-
-Verdict: {CLEAN | REVIEW | CONFLICT}
-
-| Pair | D1 | D2 | D3 | D4 | D5 | D6 | D7 |
-|------|----|----|----|----|----|----|-----|
-| {cmd} → {agent} | ✅ | ⚠️ | ✅ | ✅ | ❌ | ✅ | ✅ |
-| ... | | | | | | | |
-
-{If CONFLICT: detailed findings with fix recommendations}
-
-───────────────────────────────────────────────────────
-
-## Fix Priority
-
-1. {Highest severity fix}
-2. {Next fix}
-...
-
-───────────────────────────────────────────────────────
-```
-
-</process>
-
-<success_criteria>
-- [ ] Scan scope determined and all files discovered
-- [ ] All Agent() calls extracted from commands with full prompt content
-- [ ] All corresponding agent definitions located and parsed
-- [ ] 7 conflict dimensions checked for each command-agent pair
-- [ ] No false positives on legitimate patterns (mode references, user decision passthrough, `<deep_work_rules>`)
-- [ ] Fix recommendations provided for every error/warning
-- [ ] Summary table with per-pair dimension results displayed
-- [ ] Overall verdict determined (CLEAN/REVIEW/CONFLICT)
-</success_criteria>

.claude/skills/delegation-check/specs/separation-rules.md

@@ -1,269 +0,0 @@
-# GSD Content Separation Rules
-
-Rules for validating the boundary between **command delegation prompts** (Agent() calls) and **agent role definitions** (agent `.md` files). Derived from analysis of GSD's `plan-phase.md`, `execute-phase.md`, `research-phase.md` and their corresponding agents (`gsd-planner`, `gsd-plan-checker`, `gsd-executor`, `gsd-phase-researcher`, `gsd-verifier`).
-
-## Core Principle
-
-**Commands own WHEN and WHERE. Agents own WHO and HOW.**
-
-A delegation prompt tells the agent what to do *this time*. The agent definition tells the agent who it *always* is.
-
-## Ownership Matrix
-
-### Command Delegation Prompt Owns
-
-| Concern | XML Block | Example |
-|---------|-----------|---------|
-| What to accomplish | `<objective>` | "Execute plan 3 of phase 2" |
-| Input file paths | `<files_to_read>` | "- {state_path} (Project State)" |
-| Runtime parameters | `<additional_context>` | "Phase: 5, Mode: revision" |
-| Output location | `<output>` | "Write to: {phase_dir}/RESEARCH.md" |
-| Expected return format | `<expected_output>` | "## VERIFICATION PASSED or ## ISSUES FOUND" |
-| Who consumes output | `<downstream_consumer>` | "Output consumed by /gsd:execute-phase" |
-| Revision context | `<instructions>` | "Make targeted updates to address checker issues" |
-| Cross-cutting policy | `<deep_work_rules>` | Anti-shallow execution rules (applies to all agents) |
-| Per-invocation quality | `<quality_gate>` (in prompt) | Invocation-specific checks (e.g., "every task has `<read_first>`") |
-| Flow control | Revision loops, return routing | "If TASK COMPLETE → step 13. If BLOCKED → offer options" |
-| User interaction | `AskUserQuestion` | "Provide context / Skip / Abort" |
-| Banners | Status display | "━━━ GSD ► PLANNING PHASE {X} ━━━" |
-
-### Agent Role Definition Owns
-
-| Concern | XML Section | Example |
-|---------|-------------|---------|
-| Identity | `<role>` | "You are a GSD planner" |
-| Spawner list | `<role>` → Spawned by | "/gsd:plan-phase orchestrator" |
-| Responsibilities | `<role>` → Core responsibilities | "Decompose phases into parallel-optimized plans" |
-| Mandatory read protocol | `<role>` → Mandatory Initial Read | "MUST use Read tool to load every file in `<files_to_read>`" |
-| Project discovery | `<project_context>` | "Read CLAUDE.md, check .claude/skills/" |
-| Guiding principles | `<philosophy>` | Quality degradation curve by context usage |
-| Input interpretation | `<upstream_input>` | "Decisions → LOCKED, Discretion → freedom" |
-| Decision honoring | `<context_fidelity>` | "Locked decisions are NON-NEGOTIABLE" |
-| Core insight | `<core_principle>` | "Plan completeness ≠ Goal achievement" |
-| Domain expertise | Named domain sections | `<verification_dimensions>`, `<task_breakdown>`, `<dependency_graph>` |
-| Return protocol | `<output_contract>` | TASK COMPLETE / TASK BLOCKED / CHECKPOINT REACHED |
-| Self-check | `<quality_gate>` (in agent) | Permanent checks for every invocation |
-| Anti-patterns | `<anti_patterns>` | "DO NOT check code existence" |
-| Examples | `<examples>` | Scope exceeded analysis example |
-
-## Conflict Patterns
-
-### Pattern 1: Role Re-definition
-
-**Symptom:** Delegation prompt contains identity language.
-
-```
-# BAD — prompt redefines role
-Agent({
-  subagent_type: "gsd-plan-checker",
-  prompt: "You are a code quality expert. Your job is to review plans...
-    <objective>Verify phase 5 plans</objective>"
-})
-
-# GOOD — prompt states objective only
-Agent({
-  subagent_type: "gsd-plan-checker",
-  prompt: "<verification_context>
-    <files_to_read>...</files_to_read>
-  </verification_context>
-  <expected_output>## VERIFICATION PASSED or ## ISSUES FOUND</expected_output>"
-})
-```
-
-**Why it's wrong:** The agent's `<role>` section already defines identity. Re-definition in prompt can contradict, confuse, or override the agent's self-understanding.
-
-**Detection:** Regex for `You are a|Your role is|Your job is to|Your responsibility is|Core responsibilities:` in prompt content.
-
-### Pattern 2: Domain Expertise Leak
-
-**Symptom:** Delegation prompt contains decision tables, heuristics, or examples.
-
-```
-# BAD — prompt embeds domain knowledge
-Agent({
-  subagent_type: "gsd-planner",
-  prompt: "<objective>Create plans for phase 3</objective>
-    Remember: tasks should have 2-3 items max.
-    | TOO VAGUE | JUST RIGHT |
-    | 'Add auth' | 'Add JWT auth with refresh rotation' |"
-})
-
-# GOOD — agent's own <task_breakdown> section owns this knowledge
-Agent({
-  subagent_type: "gsd-planner",
-  prompt: "<planning_context>
-    <files_to_read>...</files_to_read>
-  </planning_context>"
-})
-```
-
-**Why it's wrong:** Domain knowledge in prompts duplicates agent content. When agent evolves, prompt doesn't update — they diverge. Agent's domain sections are the single source of truth.
-
-**Exception — `<deep_work_rules>`:** GSD uses this as a cross-cutting policy block (not domain expertise per se) that applies anti-shallow-execution rules across all agents. This is acceptable because:
-1. It's structural policy, not domain knowledge
-2. It applies uniformly to all planning agents
-3. It supplements (not duplicates) agent's own quality gate
-
-**Detection:**
-- Tables with `|` in prompt content (excluding `<files_to_read>` path tables)
-- "Good:" / "Bad:" / "Example:" comparison pairs
-- "Always..." / "Never..." / "Prefer..." heuristic statements
-- Numbered rules lists (>3 items) that aren't revision instructions
-
-### Pattern 3: Quality Gate Duplication
-
-**Symptom:** Same quality check appears in both prompt and agent definition.
-
-```
-# PROMPT quality_gate
-- [ ] Every task has `<read_first>`
-- [ ] Every task has `<acceptance_criteria>`
-- [ ] Dependencies correctly identified
-
-# AGENT quality_gate
-- [ ] Every task has `<read_first>` with at least the file being modified
-- [ ] Every task has `<acceptance_criteria>` with grep-verifiable conditions
-- [ ] Dependencies correctly identified
-```
-
-**Analysis:**
-- "Dependencies correctly identified" → **duplicate** (exact match)
-- "`<read_first>`" in both → **overlap** (prompt is less specific than agent)
-- "`<acceptance_criteria>`" → **overlap** (same check, different specificity)
-
-**When duplication is OK:** Prompt's `<quality_gate>` adds *invocation-specific* checks not in agent's permanent gate (e.g., "Phase requirement IDs all covered" is specific to this phase, not general).
-
-**Detection:** Fuzzy match quality gate items between prompt and agent (>60% token overlap).
-
-### Pattern 4: Output Format Conflict
-
-**Symptom:** Command expects return markers the agent doesn't define.
-
-```
-# COMMAND handles:
-- "## VERIFICATION PASSED" → continue
-- "## ISSUES FOUND" → revision loop
-
-# AGENT <output_contract> defines:
-- "## TASK COMPLETE"
-- "## TASK BLOCKED"
-```
-
-**Why it's wrong:** Command routes on markers. If markers don't match, routing breaks silently — command may hang or misinterpret results.
-
-**Detection:** Extract return marker strings from both sides, compare sets.
-
-### Pattern 5: Process Override
-
-**Symptom:** Prompt dictates step-by-step process.
-
-```
-# BAD — prompt overrides agent's process
-Agent({
-  subagent_type: "gsd-planner",
-  prompt: "Step 1: Read the roadmap. Step 2: Extract requirements.
-    Step 3: Create task breakdown. Step 4: Assign waves..."
-})
-
-# GOOD — prompt states objective, agent decides process
-Agent({
-  subagent_type: "gsd-planner",
-  prompt: "<objective>Create plans for phase 5</objective>
-    <files_to_read>...</files_to_read>"
-})
-```
-
-**Exception — Revision instructions:** `<instructions>` block in revision prompts is acceptable because it tells the agent *what changed* (checker issues), not *how to work*.
-
-```
-# OK — revision context, not process override
-<instructions>
-Make targeted updates to address checker issues.
-Do NOT replan from scratch unless issues are fundamental.
-Return what changed.
-</instructions>
-```
-
-**Detection:** "Step N:" / "First..." / "Then..." / "Finally..." patterns in prompt content outside `<instructions>` blocks.
-
-### Pattern 6: Scope Authority Conflict
-
-**Symptom:** Prompt makes domain decisions the agent should own.
-
-```
-# BAD — prompt decides implementation details
-Agent({
-  subagent_type: "gsd-planner",
-  prompt: "Use React Query for data fetching. Use Zustand for state management.
-    <objective>Plan the frontend architecture</objective>"
-})
-
-# GOOD — user decisions passed through from CONTEXT.md
-Agent({
-  subagent_type: "gsd-planner",
-  prompt: "<planning_context>
-    <files_to_read>
-    - {context_path} (USER DECISIONS - locked: React Query, Zustand)
-    </files_to_read>
-  </planning_context>"
-})
-```
-
-**Key distinction:**
-- **Prompt making decisions** = conflict (command shouldn't have domain opinion)
-- **Prompt passing through user decisions** = correct (user decisions flow through command to agent)
-- **Agent interpreting user decisions** = correct (agent's `<context_fidelity>` handles locked/deferred/discretion)
-
-**Detection:** Technical nouns (library names, architecture patterns) in prompt free text (not inside `<files_to_read>` path descriptions).
-
-### Pattern 7: Missing Contracts
-
-**Symptom:** Handoff points between command and agent are incomplete.
-
-| Missing Element | Impact |
-|-----------------|--------|
-| Agent has no `<output_contract>` | Command can't route on return markers |
-| Command doesn't handle all agent return markers | BLOCKED/CHECKPOINT silently ignored |
-| Agent expects `<files_to_read>` but prompt doesn't provide it | Agent starts without context |
-| Agent's "Spawned by:" doesn't list this command | Agent may not expect this invocation pattern |
-| Agent has `<upstream_input>` but prompt doesn't match structure | Agent misinterprets input |
-
-**Detection:** Cross-reference both sides for completeness.
-
-## The `<deep_work_rules>` Exception
-
-GSD's plan-phase uses `<deep_work_rules>` in delegation prompts. This is a deliberate design choice, not a violation:
-
-1. **It's cross-cutting policy**: applies to ALL planning agents equally
-2. **It's structural**: defines required fields (`<read_first>`, `<acceptance_criteria>`, `<action>` concreteness) — not domain expertise
-3. **It supplements agent quality**: agent's own `<quality_gate>` is self-check; deep_work_rules is command-imposed minimum standard
-4. **It's invocation-specific context**: different commands might impose different work rules
-
-**Rule:** `<deep_work_rules>` in a delegation prompt is `info` level, not error. Flag only if its content duplicates agent's domain sections verbatim.
-
-## Severity Classification
-
-| Severity | When | Action Required |
-|----------|------|-----------------|
-| `error` | Actual conflict: contradictory content between prompt and agent | Must fix — move content to correct owner |
-| `warning` | Duplication or boundary blur without contradiction | Should fix — consolidate to single source of truth |
-| `info` | Acceptable pattern that looks like violation but isn't | No action — document why it's OK |
-
-## Quick Reference: Is This Content in the Right Place?
-
-| Content | In Prompt? | In Agent? |
-|---------|-----------|-----------|
-| "You are a..." | ❌ Never | ✅ Always |
-| File paths for this invocation | ✅ Yes | ❌ No |
-| Phase number, mode | ✅ Yes | ❌ No |
-| Decision tables | ❌ Never | ✅ Always |
-| Good/bad examples | ❌ Never | ✅ Always |
-| "Write to: {path}" | ✅ Yes | ❌ No |
-| Return markers handling | ✅ Yes (routing) | ✅ Yes (definition) |
-| Quality gate | ✅ Per-invocation | ✅ Permanent self-check |
-| "MUST read files first" | ❌ Agent's `<role>` owns this | ✅ Always |
-| Anti-shallow rules | ⚠️ OK as cross-cutting policy | ✅ Preferred |
-| Revision instructions | ✅ Yes (what changed) | ❌ No |
-| Heuristics / philosophy | ❌ Never | ✅ Always |
-| Banner display | ✅ Yes | ❌ Never |
-| AskUserQuestion | ✅ Yes | ❌ Never |

.claude/skills/investigate/SKILL.md

@@ -1,110 +0,0 @@
----
-name: investigate
-description: Systematic debugging with Iron Law methodology. 5-phase investigation from evidence collection to verified fix. Triggers on "investigate", "debug", "root cause".
-allowed-tools: Bash, Read, Write, Edit, Glob, Grep
----
-
-# Investigate
-
-Systematic debugging skill that enforces the Iron Law: never fix without a confirmed root cause. Produces a structured debug report with full evidence chain, minimal fix, and regression test.
-
-## Iron Law Principle
-
-**No fix without confirmed root cause.** Every investigation follows a strict evidence chain:
-1. Reproduce the bug with concrete evidence
-2. Analyze patterns to assess scope
-3. Form and test hypotheses (max 3 strikes)
-4. Implement minimal fix ONLY after root cause is confirmed
-5. Verify fix and generate structured report
-
-Violation of the Iron Law (skipping to Phase 4 without Phase 3 confirmation) is prohibited.
-
-## Key Design Principles
-
-1. **Evidence-First**: Collect before theorizing. Logs, stack traces, and reproduction steps are mandatory inputs.
-2. **Minimal Fix**: Change only what is necessary. Refactoring is not debugging.
-3. **3-Strike Escalation**: If 3 consecutive hypothesis tests fail, STOP and escalate with a diagnostic dump.
-4. **Regression Coverage**: Every fix must include a test that fails without the fix and passes with it.
-5. **Structured Output**: All findings are recorded in machine-readable JSON for future reference.
-
-## Execution Flow
-
-```
-Phase 1: Root Cause Investigation
-  Reproduce bug, collect evidence (errors, logs, traces)
-  Use ccw cli --tool gemini --mode analysis for initial diagnosis
-  Output: investigation-report.json
-      |
-      v
-Phase 2: Pattern Analysis
-  Search codebase for similar patterns (same error, module, antipattern)
-  Assess scope: isolated vs systemic
-  Output: pattern-analysis section in report
-      |
-      v
-Phase 3: Hypothesis Testing
-  Form max 3 hypotheses from evidence
-  Test each with minimal read-only probes
-  3-strike rule: STOP and escalate on 3 consecutive failures
-  Output: confirmed root cause with evidence chain
-      |
-      v
-Phase 4: Implementation  [GATE: requires Phase 3 confirmed root cause]
-  Implement minimal fix
-  Add regression test
-  Verify fix resolves reproduction case
-      |
-      v
-Phase 5: Verification & Report
-  Run full test suite
-  Check for regressions
-  Generate structured debug report to .workflow/.debug/
-```
-
-## Directory Setup
-
-```bash
-mkdir -p .workflow/.debug
-```
-
-## Output Structure
-
-```
-.workflow/.debug/
-  debug-report-{YYYY-MM-DD}-{slug}.json    # Structured debug report
-```
-
-## Completion Status Protocol
-
-This skill follows the Completion Status Protocol defined in `_shared/SKILL-DESIGN-SPEC.md` sections 13-14.
-
-| Status | When |
-|--------|------|
-| **DONE** | Root cause confirmed, fix applied, regression test passes, no regressions |
-| **DONE_WITH_CONCERNS** | Fix applied but partial test coverage or minor warnings |
-| **BLOCKED** | Cannot reproduce bug, or 3-strike escalation triggered in Phase 3 |
-| **NEEDS_CONTEXT** | Missing reproduction steps, unclear error conditions |
-
-## Reference Documents
-
-| Document | Purpose |
-|----------|---------|
-| [phases/01-root-cause-investigation.md](phases/01-root-cause-investigation.md) | Evidence collection and reproduction |
-| [phases/02-pattern-analysis.md](phases/02-pattern-analysis.md) | Codebase pattern search and scope assessment |
-| [phases/03-hypothesis-testing.md](phases/03-hypothesis-testing.md) | Hypothesis formation, testing, and 3-strike rule |
-| [phases/04-implementation.md](phases/04-implementation.md) | Minimal fix with Iron Law gate |
-| [phases/05-verification-report.md](phases/05-verification-report.md) | Test suite, regression check, report generation |
-| [specs/iron-law.md](specs/iron-law.md) | Iron Law rules definition |
-| [specs/debug-report-format.md](specs/debug-report-format.md) | Structured debug report JSON schema |
-
-## CLI Integration
-
-This skill leverages `ccw cli` for multi-model analysis at key points:
-
-| Phase | CLI Usage | Mode |
-|-------|-----------|------|
-| Phase 1 | Initial diagnosis from error evidence | `--mode analysis` |
-| Phase 2 | Cross-file pattern search | `--mode analysis` |
-| Phase 3 | Hypothesis validation assistance | `--mode analysis` |
-
-All CLI calls use `--mode analysis` (read-only). No write-mode CLI calls during investigation phases 1-3.