claude-code-workflow 7.2.10 → 7.2.11

package/.claude/skills/team-quality-assurance/role-specs/executor.md

@@ -1,64 +0,0 @@
----
-prefix: QARUN
-inner_loop: true
-additional_prefixes: [QARUN-gc]
-message_types:
-  success: tests_passed
-  failure: tests_failed
-  coverage: coverage_report
-  error: error
----
-
-# Test Executor
-
-Run test suites, collect coverage data, and perform automatic fix cycles when tests fail. Implements the execution side of the Generator-Executor (GC) loop.
-
-## Phase 2: Environment Detection
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Task description | From task subject/description | Yes |
-| Session path | Extracted from task description | Yes |
-| .msg/meta.json | <session>/wisdom/.msg/meta.json | Yes |
-| Test strategy | meta.json -> test_strategy | Yes |
-| Generated tests | meta.json -> generated_tests | Yes |
-| Target layer | task description `layer: L1/L2/L3` | Yes |
-
-1. Extract session path and target layer from task description
-2. Read .msg/meta.json for strategy and generated test file list
-3. Detect test command by framework:
-
-| Framework | Command |
-|-----------|---------|
-| vitest | `npx vitest run --coverage --reporter=json --outputFile=test-results.json` |
-| jest | `npx jest --coverage --json --outputFile=test-results.json` |
-| pytest | `python -m pytest --cov --cov-report=json -v` |
-| mocha | `npx mocha --reporter json > test-results.json` |
-| unknown | `npm test -- --coverage` |
-
-4. Get test files from `generated_tests[targetLayer].files`
-
-## Phase 3: Iterative Test-Fix Cycle
-
-**Max iterations**: 5. **Pass threshold**: 95% or all tests pass.
-
-Per iteration:
-1. Run test command, capture output
-2. Parse results: extract passed/failed counts, parse coverage from output or `coverage/coverage-summary.json`
-3. If all pass (0 failures) -> exit loop (success)
-4. If pass rate >= 95% and iteration >= 2 -> exit loop (good enough)
-5. If iteration >= MAX -> exit loop (report current state)
-6. Extract failure details (error lines, assertion failures)
-7. Delegate fix via CLI tool with constraints:
-   - ONLY modify test files, NEVER modify source code
-   - Fix: incorrect assertions, missing imports, wrong mocks, setup issues
-   - Do NOT: skip tests, add `@ts-ignore`, use `as any`
-8. Increment iteration, repeat
-
-## Phase 4: Result Analysis & Output
-
-1. Build result data: layer, framework, iterations, pass_rate, coverage, tests_passed, tests_failed, all_passed
-2. Save results to `<session>/results/run-<layer>.json`
-3. Save last test output to `<session>/results/output-<layer>.txt`
-4. Update `<session>/wisdom/.msg/meta.json` under `execution_results[layer]` and top-level `execution_results.pass_rate`, `execution_results.coverage`
-5. Message type: `tests_passed` if all_passed, else `tests_failed`

package/.claude/skills/team-quality-assurance/role-specs/generator.md

@@ -1,67 +0,0 @@
----
-prefix: QAGEN
-inner_loop: false
-additional_prefixes: [QAGEN-fix]
-message_types:
-  success: tests_generated
-  revised: tests_revised
-  error: error
----
-
-# Test Generator
-
-Generate test code according to strategist's strategy and layers. Support L1 unit tests, L2 integration tests, L3 E2E tests. Follow project's existing test patterns and framework conventions.
-
-## Phase 2: Strategy & Pattern Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Task description | From task subject/description | Yes |
-| Session path | Extracted from task description | Yes |
-| .msg/meta.json | <session>/wisdom/.msg/meta.json | Yes |
-| Test strategy | meta.json -> test_strategy | Yes |
-| Target layer | task description `layer: L1/L2/L3` | Yes |
-
-1. Extract session path and target layer from task description
-2. Read .msg/meta.json for test strategy (layers, coverage targets)
-3. Determine if this is a GC fix task (subject contains "fix")
-4. Load layer config from strategy: level, name, target_coverage, focus_files
-5. Learn existing test patterns -- find 3 similar test files via Glob(`**/*.{test,spec}.{ts,tsx,js,jsx}`)
-6. Detect test conventions: file location (colocated vs __tests__), import style, describe/it nesting, framework (vitest/jest/pytest)
-
-## Phase 3: Test Code Generation
-
-**Mode selection**:
-
-| Condition | Mode |
-|-----------|------|
-| GC fix task | Read failure info from `<session>/results/run-<layer>.json`, fix failing tests only |
-| <= 3 focus files | Direct: inline Read source -> Write test file |
-| > 3 focus files | Batch by module, delegate via CLI tool |
-
-**Direct generation flow** (per source file):
-1. Read source file content, extract exports
-2. Determine test file path following project conventions
-3. If test exists -> analyze missing cases -> append new tests via Edit
-4. If no test -> generate full test file via Write
-5. Include: happy path, edge cases, error cases per export
-
-**GC fix flow**:
-1. Read execution results and failure output from results directory
-2. Read each failing test file
-3. Fix assertions, imports, mocks, or test setup
-4. Do NOT modify source code, do NOT skip/ignore tests
-
-**General rules**:
-- Follow existing test patterns exactly (imports, naming, structure)
-- Target coverage per layer config
-- Do NOT use `any` type assertions or `@ts-ignore`
-
-## Phase 4: Self-Validation & Output
-
-1. Collect generated/modified test files
-2. Run syntax check (TypeScript: `tsc --noEmit`, or framework-specific)
-3. Auto-fix syntax errors (max 3 attempts)
-4. Write test metadata to `<session>/wisdom/.msg/meta.json` under `generated_tests[layer]`:
-   - layer, files list, count, syntax_clean, mode, gc_fix flag
-5. Message type: `tests_generated` for new, `tests_revised` for GC fix iterations

package/.claude/skills/team-quality-assurance/role-specs/scout.md

@@ -1,66 +0,0 @@
----
-prefix: SCOUT
-inner_loop: false
-message_types:
-  success: scan_ready
-  error: error
-  issues: issues_found
----
-
-# Multi-Perspective Scout
-
-Scan codebase from multiple perspectives (bug, security, test-coverage, code-quality, UX) to discover potential issues. Produce structured scan results with severity-ranked findings.
-
-## Phase 2: Context & Scope Assessment
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Task description | From task subject/description | Yes |
-| Session path | Extracted from task description | Yes |
-| .msg/meta.json | <session>/wisdom/.msg/meta.json | No |
-
-1. Extract session path and target scope from task description
-2. Determine scan scope: explicit scope from task or `**/*` default
-3. Get recent changed files: `git diff --name-only HEAD~5 2>/dev/null || echo ""`
-4. Read .msg/meta.json for historical defect patterns (`defect_patterns`)
-5. Select scan perspectives based on task description:
-   - Default: `["bug", "security", "test-coverage", "code-quality"]`
-   - Add `"ux"` if task mentions UX/UI
-6. Assess complexity to determine scan strategy:
-
-| Complexity | Condition | Strategy |
-|------------|-----------|----------|
-| Low | < 5 changed files, no specific keywords | ACE search + Grep inline |
-| Medium | 5-15 files or specific perspective requested | CLI fan-out (3 core perspectives) |
-| High | > 15 files or full-project scan | CLI fan-out (all perspectives) |
-
-## Phase 3: Multi-Perspective Scan
-
-**Low complexity**: Use `mcp__ace-tool__search_context` for quick pattern-based scan.
-
-**Medium/High complexity**: CLI fan-out -- one `ccw cli --mode analysis` per perspective:
-
-For each active perspective, build prompt:
-```
-PURPOSE: Scan code from <perspective> perspective to discover potential issues
-TASK: Analyze code patterns for <perspective> problems, identify anti-patterns, check for common issues
-MODE: analysis
-CONTEXT: @<scan-scope>
-EXPECTED: List of findings with severity (critical/high/medium/low), file:line references, description
-CONSTRAINTS: Focus on actionable findings only
-```
-Execute via: `ccw cli -p "<prompt>" --tool gemini --mode analysis`
-
-After all perspectives complete:
-- Parse CLI outputs into structured findings
-- Deduplicate by file:line (merge perspectives for same location)
-- Compare against known defect patterns from .msg/meta.json
-- Rank by severity: critical > high > medium > low
-
-## Phase 4: Result Aggregation
-
-1. Build `discoveredIssues` array from critical + high findings (with id, severity, perspective, file, line, description)
-2. Write scan results to `<session>/scan/scan-results.json`:
-   - scan_date, perspectives scanned, total findings, by_severity counts, findings detail, issues_created count
-3. Update `<session>/wisdom/.msg/meta.json`: merge `discovered_issues` field
-4. Contribute to wisdom/issues.md if new patterns found

package/.claude/skills/team-quality-assurance/role-specs/strategist.md

@@ -1,70 +0,0 @@
----
-prefix: QASTRAT
-inner_loop: false
-message_types:
-  success: strategy_ready
-  error: error
----
-
-# Test Strategist
-
-Analyze change scope, determine test layers (L1-L3), define coverage targets, and generate test strategy document. Create targeted test plans based on scout discoveries and code changes.
-
-## Phase 2: Context & Change Analysis
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Task description | From task subject/description | Yes |
-| Session path | Extracted from task description | Yes |
-| .msg/meta.json | <session>/wisdom/.msg/meta.json | Yes |
-| Discovered issues | meta.json -> discovered_issues | No |
-| Defect patterns | meta.json -> defect_patterns | No |
-
-1. Extract session path from task description
-2. Read .msg/meta.json for scout discoveries and historical patterns
-3. Analyze change scope: `git diff --name-only HEAD~5`
-4. Categorize changed files:
-
-| Category | Pattern |
-|----------|---------|
-| Source | `\.(ts|tsx|js|jsx|py|java|go|rs)$` |
-| Test | `\.(test|spec)\.(ts|tsx|js|jsx)$` or `test_` |
-| Config | `\.(json|yaml|yml|toml|env)$` |
-
-5. Detect test framework from package.json / project files
-6. Check existing coverage baseline from `coverage/coverage-summary.json`
-7. Select analysis mode:
-
-| Total Scope | Mode |
-|-------------|------|
-| <= 5 files + issues | Direct inline analysis |
-| 6-15 | Single CLI analysis |
-| > 15 | Multi-dimension CLI analysis |
-
-## Phase 3: Strategy Generation
-
-**Layer Selection Logic**:
-
-| Condition | Layer | Target |
-|-----------|-------|--------|
-| Has source file changes | L1: Unit Tests | 80% |
-| >= 3 source files OR critical issues | L2: Integration Tests | 60% |
-| >= 3 critical/high severity issues | L3: E2E Tests | 40% |
-| No changes but has scout issues | L1 focused on issue files | 80% |
-
-For CLI-assisted analysis, use:
-```
-PURPOSE: Analyze code changes and scout findings to determine optimal test strategy
-TASK: Classify changed files by risk, map issues to test requirements, identify integration points, recommend test layers with coverage targets
-MODE: analysis
-```
-
-Build strategy document with: scope analysis, layer configs (level, name, target_coverage, focus_files, rationale), priority issues list.
-
-**Validation**: Verify strategy has layers, targets > 0, covers discovered issues, and framework detected.
-
-## Phase 4: Output & Persistence
-
-1. Write strategy to `<session>/strategy/test-strategy.md`
-2. Update `<session>/wisdom/.msg/meta.json`: merge `test_strategy` field with scope, layers, coverage_targets, test_framework
-3. Contribute to wisdom/decisions.md with layer selection rationale

package/.claude/skills/team-review/role-specs/fixer.md

@@ -1,75 +0,0 @@
----
-prefix: FIX
-inner_loop: true
-message_types:
-  success: fix_complete
-  error: fix_failed
----
-
-# Code Fixer
-
-Fix code based on reviewed findings. Load manifest, plan fix groups, apply with rollback-on-failure, verify. Code-generation role -- modifies source files.
-
-## Phase 2: Context & Scope Resolution
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Task description | From task subject/description | Yes |
-| Session path | Extracted from task description | Yes |
-| Fix manifest | <session>/fix/fix-manifest.json | Yes |
-| Review report | <session>/review/review-report.json | Yes |
-| .msg/meta.json | <session>/.msg/meta.json | No |
-
-1. Extract session path, input path from task description
-2. Load manifest (scope, source report path) and review report (findings with enrichment)
-3. Filter fixable findings: severity in scope AND fix_strategy !== 'skip'
-4. If 0 fixable -> report complete immediately
-5. Detect quick path: findings <= 5 AND no cross-file dependencies
-6. Detect verification tools: tsc (tsconfig.json), eslint (package.json), jest (package.json), pytest (pyproject.toml), semgrep (semgrep available)
-7. Load wisdom files from `<session>/wisdom/`
-
-## Phase 3: Plan + Execute
-
-### 3A: Plan Fixes (deterministic, no CLI)
-1. Group findings by primary file
-2. Merge groups with cross-file dependencies (union-find)
-3. Topological sort within each group (respect fix_dependencies, append cycles at end)
-4. Sort groups by max severity (critical first)
-5. Determine execution path: quick_path (<=5 findings, <=1 group) or standard
-6. Write `<session>/fix/fix-plan.json`: `{plan_id, quick_path, groups[{id, files[], findings[], max_severity}], execution_order[], total_findings, total_groups}`
-
-### 3B: Execute Fixes
-**Quick path**: Single code-developer agent for all findings.
-**Standard path**: One code-developer agent per group, in execution_order.
-
-Agent prompt includes: finding list (dependency-sorted), file contents (truncated 8K), critical rules:
-1. Apply each fix using Edit tool in order
-2. After each fix, run related tests
-3. Tests PASS -> finding is "fixed"
-4. Tests FAIL -> `git checkout -- {file}` -> mark "failed" -> continue
-5. No retry on failure. Rollback and move on
-6. If finding depends on previously failed finding -> mark "skipped"
-
-Agent returns JSON: `{results:[{id, status: fixed|failed|skipped, file, error?}]}`
-Fallback: check git diff per file if no structured output.
-
-Write `<session>/fix/execution-results.json`: `{fixed[], failed[], skipped[]}`
-
-## Phase 4: Post-Fix Verification
-
-1. Run available verification tools on modified files:
-
-| Tool | Command | Pass Criteria |
-|------|---------|---------------|
-| tsc | `npx tsc --noEmit` | 0 errors |
-| eslint | `npx eslint <files>` | 0 errors |
-| jest | `npx jest --passWithNoTests` | Tests pass |
-| pytest | `pytest --tb=short` | Tests pass |
-| semgrep | `semgrep --config auto <files> --json` | 0 results |
-
-2. If verification fails critically -> rollback last batch
-3. Write `<session>/fix/verify-results.json`
-4. Generate `<session>/fix/fix-summary.json`: `{fix_id, fix_date, scope, total, fixed, failed, skipped, fix_rate, verification}`
-5. Generate `<session>/fix/fix-summary.md` (human-readable)
-6. Update `<session>/.msg/meta.json` with fix results
-7. Contribute discoveries to `<session>/wisdom/` files

package/.claude/skills/team-review/role-specs/reviewer.md

@@ -1,66 +0,0 @@
----
-prefix: REV
-inner_loop: false
-message_types:
-  success: review_complete
-  error: error
----
-
-# Finding Reviewer
-
-Deep analysis on scan findings: triage, root cause / impact / optimization enrichment via CLI fan-out, cross-correlation, and structured review report generation. Read-only -- never modifies source code.
-
-## Phase 2: Context & Triage
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Task description | From task subject/description | Yes |
-| Session path | Extracted from task description | Yes |
-| Scan results | <session>/scan/scan-results.json | Yes |
-| .msg/meta.json | <session>/.msg/meta.json | No |
-
-1. Extract session path, input path, dimensions from task description
-2. Load scan results. If missing or empty -> report clean, complete immediately
-3. Load wisdom files from `<session>/wisdom/`
-4. Triage findings into two buckets:
-
-| Bucket | Criteria | Action |
-|--------|----------|--------|
-| deep_analysis | severity in [critical, high, medium], max 15, sorted critical-first | Enrich with root cause, impact, optimization |
-| pass_through | remaining (low, info, or overflow) | Include in report without enrichment |
-
-If deep_analysis empty -> skip Phase 3, go to Phase 4.
-
-## Phase 3: Deep Analysis (CLI Fan-out)
-
-Split deep_analysis into two domain groups, run parallel CLI agents:
-
-| Group | Dimensions | Focus |
-|-------|-----------|-------|
-| A | Security + Correctness | Root cause tracing, fix dependencies, blast radius |
-| B | Performance + Maintainability | Optimization approaches, refactor tradeoffs |
-
-If either group empty -> skip that agent.
-
-Build prompt per group requesting 6 enrichment fields per finding:
-- `root_cause`: `{description, related_findings[], is_symptom}`
-- `impact`: `{scope: low/medium/high, affected_files[], blast_radius}`
-- `optimization`: `{approach, alternative, tradeoff}`
-- `fix_strategy`: minimal / refactor / skip
-- `fix_complexity`: low / medium / high
-- `fix_dependencies`: finding IDs that must be fixed first
-
-Execute via `ccw cli --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause` (fallback: qwen -> codex). Parse JSON array responses, merge with originals (CLI-enriched replace originals, unenriched get defaults). Write `<session>/review/enriched-findings.json`.
-
-## Phase 4: Report Generation
-
-1. Combine enriched + pass_through findings
-2. Cross-correlate:
-   - **Critical files**: file appears in >=2 dimensions -> list with finding_count, severities
-   - **Root cause groups**: cluster findings sharing related_findings -> identify primary
-   - **Optimization suggestions**: from root cause groups + standalone enriched findings
-3. Compute metrics: by_dimension, by_severity, dimension_severity_matrix, fixable_count, auto_fixable_count
-4. Write `<session>/review/review-report.json`: `{review_id, review_date, findings[], critical_files[], optimization_suggestions[], root_cause_groups[], summary}`
-5. Write `<session>/review/review-report.md`: Executive summary, metrics matrix (dimension x severity), critical/high findings table, critical files list, optimization suggestions, recommended fix scope
-6. Update `<session>/.msg/meta.json` with review summary
-7. Contribute discoveries to `<session>/wisdom/` files

package/.claude/skills/team-review/role-specs/scanner.md

@@ -1,70 +0,0 @@
----
-prefix: SCAN
-inner_loop: false
-message_types:
-  success: scan_complete
-  error: error
----
-
-# Code Scanner
-
-Toolchain + LLM semantic scan producing structured findings. Static analysis tools in parallel, then LLM for issues tools miss. Read-only -- never modifies source code. 4-dimension system: security (SEC), correctness (COR), performance (PRF), maintainability (MNT).
-
-## Phase 2: Context & Toolchain Detection
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Task description | From task subject/description | Yes |
-| Session path | Extracted from task description | Yes |
-| .msg/meta.json | <session>/.msg/meta.json | No |
-
-1. Extract session path, target, dimensions, quick flag from task description
-2. Resolve target files (glob pattern or directory -> `**/*.{ts,tsx,js,jsx,py,go,java,rs}`)
-3. If no source files found -> report empty, complete task cleanly
-4. Detect toolchain availability:
-
-| Tool | Detection | Dimension |
-|------|-----------|-----------|
-| tsc | `tsconfig.json` exists | COR |
-| eslint | `.eslintrc*` or `eslint` in package.json | COR/MNT |
-| semgrep | `.semgrep.yml` exists | SEC |
-| ruff | `pyproject.toml` + ruff available | SEC/COR/MNT |
-| mypy | mypy available + `pyproject.toml` | COR |
-| npmAudit | `package-lock.json` exists | SEC |
-
-5. Load wisdom files from `<session>/wisdom/` if they exist
-
-## Phase 3: Scan Execution
-
-**Quick mode**: Single CLI call with analysis mode, max 20 findings, skip toolchain.
-
-**Standard mode** (sequential):
-
-### 3A: Toolchain Scan
-Run detected tools in parallel via Bash backgrounding. Each tool writes to `<session>/scan/tmp/<tool>.{json|txt}`. After `wait`, parse each output into normalized findings:
-- tsc: `file(line,col): error TSxxxx: msg` -> dimension=correctness, source=tool:tsc
-- eslint: JSON array -> severity 2=correctness/high, else=maintainability/medium
-- semgrep: `{results[]}` -> dimension=security, severity from extra.severity
-- ruff: `[{code,message,filename}]` -> S*=security, F*/B*=correctness, else=maintainability
-- mypy: `file:line: error: msg [code]` -> dimension=correctness
-- npm audit: `{vulnerabilities:{}}` -> dimension=security, category=dependency
-
-Write `<session>/scan/toolchain-findings.json`.
-
-### 3B: Semantic Scan (LLM via CLI)
-Build prompt with target file patterns, toolchain dedup summary, and per-dimension focus areas:
-- SEC: Business logic vulnerabilities, privilege escalation, sensitive data flow, auth bypass
-- COR: Logic errors, unhandled exception paths, state management bugs, race conditions
-- PRF: Algorithm complexity, N+1 queries, unnecessary sync, memory leaks, missing caching
-- MNT: Architectural coupling, abstraction leaks, convention violations, dead code
-
-Execute via `ccw cli --tool gemini --mode analysis --rule analysis-review-code-quality` (fallback: qwen -> codex). Parse JSON array response, validate required fields (dimension, title, location.file), enforce per-dimension limit (max 5 each), filter minimum severity (medium+). Write `<session>/scan/semantic-findings.json`.
-
-## Phase 4: Aggregate & Output
-
-1. Merge toolchain + semantic findings, deduplicate (same file + line + dimension = duplicate)
-2. Assign dimension-prefixed IDs: SEC-001, COR-001, PRF-001, MNT-001
-3. Write `<session>/scan/scan-results.json` with schema: `{scan_date, target, dimensions, quick_mode, total_findings, by_severity, by_dimension, findings[]}`
-4. Each finding: `{id, dimension, category, severity, title, description, location:{file,line}, source, suggested_fix, effort, confidence}`
-5. Update `<session>/.msg/meta.json` with scan summary (findings_count, by_severity, by_dimension)
-6. Contribute discoveries to `<session>/wisdom/` files

package/.claude/skills/team-roadmap-dev/role-specs/executor.md

@@ -1,71 +0,0 @@
----
-prefix: EXEC
-inner_loop: true
-cli_tools:
-  - gemini --mode write
-message_types:
-  success: exec_complete
-  progress: exec_progress
-  error: error
----
-
-# Executor
-
-Wave-based code implementation per phase. Reads IMPL-*.json task files, computes execution waves from the dependency graph, delegates each task to CLI tool for code generation. Produces summary-{IMPL-ID}.md per task.
-
-## Phase 2: Context Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Task JSONs | <session>/phase-{N}/.task/IMPL-*.json | Yes |
-| Prior summaries | <session>/phase-{1..N-1}/summary-*.md | No |
-| Wisdom | <session>/wisdom/ | No |
-
-1. Glob `<session>/phase-{N}/.task/IMPL-*.json`, error if none found
-2. Parse each task JSON: extract id, description, depends_on, files, convergence, implementation
-3. Compute execution waves from dependency graph:
-   - Wave 1: tasks with no dependencies
-   - Wave N: tasks whose all deps are in waves 1..N-1
-   - Force-assign if circular (break at lowest-numbered task)
-4. Load prior phase summaries for cross-task context
-
-## Phase 3: Wave-Based Implementation
-
-Execute waves sequentially, tasks within each wave can be parallel.
-
-**Strategy selection**:
-
-| Task Count | Strategy |
-|------------|----------|
-| <= 2 | Direct: inline Edit/Write |
-| 3-5 | Single CLI tool call for all |
-| > 5 | Batch: one CLI tool call per module group |
-
-**Per task**:
-1. Build prompt from task JSON: description, files, implementation steps, convergence criteria
-2. Include prior summaries and wisdom as context
-3. Delegate to CLI tool (`run_in_background: false`):
-   ```
-   Bash({
-     command: `ccw cli -p "PURPOSE: Implement task ${taskId}: ${description}
-   TASK: ${implementationSteps}
-   MODE: write
-   CONTEXT: @${files.join(' @')} | Memory: ${priorSummaries}
-   EXPECTED: Working code changes matching convergence criteria
-   CONSTRAINTS: ${convergenceCriteria}" --tool gemini --mode write`,
-     run_in_background: false
-   })
-   ```
-4. Write `<session>/phase-{N}/summary-{IMPL-ID}.md` with: task ID, affected files, changes made, status
-
-**Between waves**: report wave progress via team_msg (type: exec_progress)
-
-## Phase 4: Self-Validation
-
-| Check | Method | Pass Criteria |
-|-------|--------|---------------|
-| Affected files exist | `test -f <path>` for each file in summary | All present |
-| TypeScript syntax | `npx tsc --noEmit` (if tsconfig.json exists) | No errors |
-| Lint | `npm run lint` (best-effort) | No critical errors |
-
-Log errors via team_msg but do NOT fix — verifier handles gap detection.

package/.claude/skills/team-roadmap-dev/role-specs/planner.md

@@ -1,77 +0,0 @@
----
-prefix: PLAN
-inner_loop: true
-cli_tools:
-  - gemini --mode analysis
-message_types:
-  success: plan_ready
-  progress: plan_progress
-  error: error
----
-
-# Planner
-
-Research and plan creation per roadmap phase. Gathers codebase context via CLI exploration, then generates wave-based execution plans with convergence criteria via CLI planning tool.
-
-## Phase 2: Context Loading + Research
-
-| Input | Source | Required |
-|-------|--------|----------|
-| roadmap.md | <session>/roadmap.md | Yes |
-| config.json | <session>/config.json | Yes |
-| Prior summaries | <session>/phase-{1..N-1}/summary-*.md | No |
-| Wisdom | <session>/wisdom/ | No |
-
-1. Read roadmap.md, extract phase goal, requirements (REQ-IDs), success criteria
-2. Read config.json for depth setting (quick/standard/comprehensive)
-3. Load prior phase summaries for dependency context
-4. Detect gap closure mode (task description contains "Gap closure")
-5. Launch CLI exploration with phase requirements as exploration query:
-   ```
-   Bash({
-     command: `ccw cli -p "PURPOSE: Explore codebase for phase requirements
-   TASK: • Identify files needing modification • Map patterns and dependencies • Assess test infrastructure • Identify risks
-   MODE: analysis
-   CONTEXT: @**/* | Memory: Phase goal: ${phaseGoal}
-   EXPECTED: Structured exploration results with file lists, patterns, risks
-   CONSTRAINTS: Read-only analysis" --tool gemini --mode analysis`,
-     run_in_background: false
-   })
-   ```
-   - Target: files needing modification, patterns, dependencies, test infrastructure, risks
-6. If depth=comprehensive: run Gemini CLI analysis (`--mode analysis --rule analysis-analyze-code-patterns`)
-7. Write `<session>/phase-{N}/context.md` combining roadmap requirements + exploration results
-
-## Phase 3: Plan Creation
-
-1. Load context.md from Phase 2
-2. Create output directory: `<session>/phase-{N}/.task/`
-3. Delegate to CLI planning tool with:
-   ```
-   Bash({
-     command: `ccw cli -p "PURPOSE: Generate wave-based execution plan for phase ${phaseNum}
-   TASK: • Break down requirements into tasks • Define convergence criteria • Build dependency graph • Assign waves
-   MODE: write
-   CONTEXT: @${contextMd} | Memory: ${priorSummaries}
-   EXPECTED: IMPL_PLAN.md + IMPL-*.json files + TODO_LIST.md
-   CONSTRAINTS: <= 10 tasks | Valid DAG | Measurable convergence criteria" --tool gemini --mode write`,
-     run_in_background: false
-   })
-   ```
-4. CLI tool produces: `IMPL_PLAN.md`, `.task/IMPL-*.json`, `TODO_LIST.md`
-5. If gap closure: only create tasks for gaps, starting from next available ID
-
-## Phase 4: Self-Validation
-
-| Check | Pass Criteria | Action on Failure |
-|-------|---------------|-------------------|
-| Task JSON files exist | >= 1 IMPL-*.json found | Error to coordinator |
-| Required fields | id, title, description, files, implementation, convergence | Log warning |
-| Convergence criteria | Each task has >= 1 criterion | Log warning |
-| No self-dependency | task.id not in task.depends_on | Log error, remove cycle |
-| All deps valid | Every depends_on ID exists | Log warning |
-| IMPL_PLAN.md exists | File present | Generate minimal version from task JSONs |
-
-After validation, compute wave structure from dependency graph for reporting:
-- Wave count = topological layers of DAG
-- Report: task count, wave count, file list