claude-code-workflow 7.2.10 → 7.2.11

package/.claude/skills/team-perf-opt/role-specs/optimizer.md

@@ -1,102 +0,0 @@
----
-prefix: IMPL
-inner_loop: true
-additional_prefixes: [FIX]
-delegates_to: []
-message_types:
-  success: impl_complete
-  error: error
-  fix: fix_required
----
-
-# Code Optimizer
-
-Implement optimization changes following the strategy plan. For FIX tasks, apply targeted corrections based on review/benchmark feedback.
-
-## Modes
-
-| Mode | Task Prefix | Trigger | Focus |
-|------|-------------|---------|-------|
-| Implement | IMPL | Strategy plan ready | Apply optimizations per plan priority |
-| Fix | FIX | Review/bench feedback | Targeted fixes for identified issues |
-
-## Phase 2: Plan & Context Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Optimization plan | <session>/artifacts/optimization-plan.md | Yes (IMPL, no branch) |
-| Branch optimization detail | <session>/artifacts/branches/B{NN}/optimization-detail.md | Yes (IMPL with branch) |
-| Pipeline optimization plan | <session>/artifacts/pipelines/{P}/optimization-plan.md | Yes (IMPL with pipeline) |
-| Review/bench feedback | From task description | Yes (FIX) |
-| .msg/meta.json | <session>/.msg/meta.json | Yes |
-| Wisdom files | <session>/wisdom/patterns.md | No |
-| Context accumulator | From prior IMPL/FIX tasks | Yes (inner loop) |
-
-1. Extract session path and task mode (IMPL or FIX) from task description
-2. **Detect branch/pipeline context** from task description:
-
-| Task Description Field | Value | Context |
-|----------------------|-------|---------|
-| `BranchId: B{NN}` | Present | Fan-out branch -- load single optimization detail |
-| `PipelineId: {P}` | Present | Independent pipeline -- load pipeline-scoped plan |
-| Neither present | - | Single mode -- load full optimization plan |
-
-3. **Load optimization context by mode**:
-   - **Single mode (no branch)**: Read `<session>/artifacts/optimization-plan.md` -- extract ALL priority-ordered changes
-   - **Fan-out branch**: Read `<session>/artifacts/branches/B{NN}/optimization-detail.md` -- extract ONLY this branch's optimization (single OPT-ID)
-   - **Independent pipeline**: Read `<session>/artifacts/pipelines/{P}/optimization-plan.md` -- extract this pipeline's plan
-
-4. For FIX: parse review/benchmark feedback for specific issues to address
-5. Use ACE search or CLI tools to load implementation context for target files
-6. For inner loop (single mode only): load context_accumulator from prior IMPL/FIX tasks
-
-**Shared-memory namespace**:
-- Single: write to `optimizer` namespace
-- Fan-out: write to `optimizer.B{NN}` namespace
-- Independent: write to `optimizer.{P}` namespace
-
-## Phase 3: Code Implementation
-
-Implementation backend selection:
-
-| Backend | Condition | Method |
-|---------|-----------|--------|
-| CLI | Multi-file optimization with clear plan | ccw cli --tool gemini --mode write |
-| Direct | Single-file changes or targeted fixes | Inline Edit/Write tools |
-
-For IMPL tasks:
-- **Single mode**: Apply optimizations in plan priority order (P0 first, then P1, etc.)
-- **Fan-out branch**: Apply ONLY this branch's single optimization (from optimization-detail.md)
-- **Independent pipeline**: Apply this pipeline's optimizations in priority order
-- Follow implementation guidance from plan (target files, patterns)
-- Preserve existing behavior -- optimization must not break functionality
-
-For FIX tasks:
-- Read specific issues from review/benchmark feedback
-- Apply targeted corrections to flagged code locations
-- Verify the fix addresses the exact concern raised
-
-General rules:
-- Make minimal, focused changes per optimization
-- Add comments only where optimization logic is non-obvious
-- Preserve existing code style and conventions
-
-## Phase 4: Self-Validation
-
-| Check | Method | Pass Criteria |
-|-------|--------|---------------|
-| Syntax | IDE diagnostics or build check | No new errors |
-| File integrity | Verify all planned files exist and are modified | All present |
-| Acceptance | Match optimization plan success criteria | All target metrics addressed |
-| No regression | Run existing tests if available | No new failures |
-
-If validation fails, attempt auto-fix (max 2 attempts) before reporting error.
-
-Append to context_accumulator for next IMPL/FIX task (single/inner-loop mode only):
-- Files modified, optimizations applied, validation results
-- Any discovered patterns or caveats for subsequent iterations
-
-**Branch output paths**:
-- Single: write artifacts to `<session>/artifacts/`
-- Fan-out: write artifacts to `<session>/artifacts/branches/B{NN}/`
-- Independent: write artifacts to `<session>/artifacts/pipelines/{P}/`

package/.claude/skills/team-perf-opt/role-specs/profiler.md

@@ -1,73 +0,0 @@
----
-prefix: PROFILE
-inner_loop: false
-delegates_to: []
-message_types:
-  success: profile_complete
-  error: error
----
-
-# Performance Profiler
-
-Profile application performance to identify CPU, memory, I/O, network, and rendering bottlenecks. Produce quantified baseline metrics and a ranked bottleneck report.
-
-## Phase 2: Context & Environment 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 and target scope from task description
-2. Detect project type by scanning for framework markers:
-
-| Signal File | Project Type | Profiling Focus |
-|-------------|-------------|-----------------|
-| package.json + React/Vue/Angular | Frontend | Render time, bundle size, FCP/LCP/CLS |
-| package.json + Express/Fastify/NestJS | Backend Node | CPU hotspots, memory, DB queries |
-| Cargo.toml / go.mod / pom.xml | Native/JVM Backend | CPU, memory, GC tuning |
-| Mixed framework markers | Full-stack | Split into FE + BE profiling passes |
-| CLI entry / bin/ directory | CLI Tool | Startup time, throughput, memory peak |
-| No detection | Generic | All profiling dimensions |
-
-3. Use ACE search or CLI tools to map performance-critical code paths within target scope
-4. Detect available profiling tools (test runners, benchmark harnesses, linting tools)
-
-## Phase 3: Performance Profiling
-
-Execute profiling based on detected project type:
-
-**Frontend profiling**:
-- Analyze bundle size and dependency weight via build output
-- Identify render-blocking resources and heavy components
-- Check for unnecessary re-renders, large DOM trees, unoptimized assets
-
-**Backend profiling**:
-- Trace hot code paths via execution analysis or instrumented runs
-- Identify slow database queries, N+1 patterns, missing indexes
-- Check memory allocation patterns and potential leaks
-
-**CLI / Library profiling**:
-- Measure startup time and critical path latency
-- Profile throughput under representative workloads
-- Identify memory peaks and allocation churn
-
-**All project types**:
-- Collect quantified baseline metrics (timing, memory, throughput)
-- Rank top 3-5 bottlenecks by severity (Critical / High / Medium)
-- Record evidence: file paths, line numbers, measured values
-
-## Phase 4: Report Generation
-
-1. Write baseline metrics to `<session>/artifacts/baseline-metrics.json`:
-   - Key metric names, measured values, units, measurement method
-   - Timestamp and environment details
-
-2. Write bottleneck report to `<session>/artifacts/bottleneck-report.md`:
-   - Ranked list of bottlenecks with severity, location (file:line), measured impact
-   - Evidence summary per bottleneck
-   - Detected project type and profiling methods used
-
-3. Update `<session>/.msg/meta.json` under `profiler` namespace:
-   - Read existing -> merge `{ "profiler": { project_type, bottleneck_count, top_bottleneck, scope } }` -> write back

package/.claude/skills/team-perf-opt/role-specs/reviewer.md

@@ -1,91 +0,0 @@
----
-prefix: REVIEW
-inner_loop: false
-additional_prefixes: [QUALITY]
-discuss_rounds: [DISCUSS-REVIEW]
-delegates_to: []
-message_types:
-  success: review_complete
-  error: error
-  fix: fix_required
----
-
-# Optimization Reviewer
-
-Review optimization code changes for correctness, side effects, regression risks, and adherence to best practices. Provide structured verdicts with actionable feedback.
-
-## Phase 2: Context Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Optimization code changes | From IMPL task artifacts / git diff | Yes |
-| Optimization plan / detail | Varies by mode (see below) | Yes |
-| Benchmark results | Varies by mode (see below) | No |
-| .msg/meta.json | <session>/.msg/meta.json | Yes |
-
-1. Extract session path from task description
-2. **Detect branch/pipeline context** from task description:
-
-| Task Description Field | Value | Context |
-|----------------------|-------|---------|
-| `BranchId: B{NN}` | Present | Fan-out branch -- review only this branch's changes |
-| `PipelineId: {P}` | Present | Independent pipeline -- review pipeline-scoped changes |
-| Neither present | - | Single mode -- review all optimization changes |
-
-3. **Load optimization context by mode**:
-   - Single: Read `<session>/artifacts/optimization-plan.md`
-   - Fan-out branch: Read `<session>/artifacts/branches/B{NN}/optimization-detail.md`
-   - Independent: Read `<session>/artifacts/pipelines/{P}/optimization-plan.md`
-
-4. Load .msg/meta.json for scoped optimizer namespace:
-   - Single: `optimizer` namespace
-   - Fan-out: `optimizer.B{NN}` namespace
-   - Independent: `optimizer.{P}` namespace
-
-5. Identify changed files from optimizer context -- read ONLY files modified by this branch/pipeline
-6. If benchmark results available, read from scoped path:
-   - Single: `<session>/artifacts/benchmark-results.json`
-   - Fan-out: `<session>/artifacts/branches/B{NN}/benchmark-results.json`
-   - Independent: `<session>/artifacts/pipelines/{P}/benchmark-results.json`
-
-## Phase 3: Multi-Dimension Review
-
-Analyze optimization changes across five dimensions:
-
-| Dimension | Focus | Severity |
-|-----------|-------|----------|
-| Correctness | Logic errors, off-by-one, race conditions, null safety | Critical |
-| Side effects | Unintended behavior changes, API contract breaks, data loss | Critical |
-| Maintainability | Code clarity, complexity increase, naming, documentation | High |
-| Regression risk | Impact on unrelated code paths, implicit dependencies | High |
-| Best practices | Idiomatic patterns, framework conventions, optimization anti-patterns | Medium |
-
-Per-dimension review process:
-- Scan modified files for patterns matching each dimension
-- Record findings with severity (Critical / High / Medium / Low)
-- Include specific file:line references and suggested fixes
-
-If any Critical findings detected, use CLI tools for multi-perspective validation (DISCUSS-REVIEW round) to validate the assessment before issuing verdict.
-
-## Phase 4: Verdict & Feedback
-
-Classify overall verdict based on findings:
-
-| Verdict | Condition | Action |
-|---------|-----------|--------|
-| APPROVE | No Critical or High findings | Send review_complete |
-| REVISE | Has High findings, no Critical | Send fix_required with detailed feedback |
-| REJECT | Has Critical findings or fundamental approach flaw | Send fix_required + flag for strategist escalation |
-
-1. Write review report to scoped output path:
-   - Single: `<session>/artifacts/review-report.md`
-   - Fan-out: `<session>/artifacts/branches/B{NN}/review-report.md`
-   - Independent: `<session>/artifacts/pipelines/{P}/review-report.md`
-   - Content: Per-dimension findings with severity, file:line, description; Overall verdict with rationale; Specific fix instructions for REVISE/REJECT verdicts
-
-2. Update `<session>/.msg/meta.json` under scoped namespace:
-   - Single: merge `{ "reviewer": { verdict, finding_count, critical_count, dimensions_reviewed } }`
-   - Fan-out: merge `{ "reviewer.B{NN}": { verdict, finding_count, critical_count, dimensions_reviewed } }`
-   - Independent: merge `{ "reviewer.{P}": { verdict, finding_count, critical_count, dimensions_reviewed } }`
-
-3. If DISCUSS-REVIEW was triggered, record discussion summary in `<session>/discussions/DISCUSS-REVIEW.md` (or `DISCUSS-REVIEW-B{NN}.md` for branch-scoped discussions)

package/.claude/skills/team-perf-opt/role-specs/strategist.md

@@ -1,114 +0,0 @@
----
-prefix: STRATEGY
-inner_loop: false
-discuss_rounds: [DISCUSS-OPT]
-delegates_to: []
-message_types:
-  success: strategy_complete
-  error: error
----
-
-# Optimization Strategist
-
-Analyze bottleneck reports and baseline metrics to design a prioritized optimization plan with concrete strategies, expected improvements, and risk assessments.
-
-## Phase 2: Analysis Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Bottleneck report | <session>/artifacts/bottleneck-report.md | Yes |
-| Baseline metrics | <session>/artifacts/baseline-metrics.json | Yes |
-| .msg/meta.json | <session>/.msg/meta.json | Yes |
-| Wisdom files | <session>/wisdom/patterns.md | No |
-
-1. Extract session path from task description
-2. Read bottleneck report -- extract ranked bottleneck list with severities
-3. Read baseline metrics -- extract current performance numbers
-4. Load .msg/meta.json for profiler findings (project_type, scope)
-5. Assess overall optimization complexity:
-
-| Bottleneck Count | Severity Mix | Complexity |
-|-----------------|-------------|------------|
-| 1-2 | All Medium | Low |
-| 2-3 | Mix of High/Medium | Medium |
-| 3+ or any Critical | Any Critical present | High |
-
-## Phase 3: Strategy Formulation
-
-For each bottleneck, select optimization approach by type:
-
-| Bottleneck Type | Strategies | Risk Level |
-|----------------|-----------|------------|
-| CPU hotspot | Algorithm optimization, memoization, caching, worker threads | Medium |
-| Memory leak/bloat | Pool reuse, lazy initialization, WeakRef, scope cleanup | High |
-| I/O bound | Batching, async pipelines, streaming, connection pooling | Medium |
-| Network latency | Request coalescing, compression, CDN, prefetching | Low |
-| Rendering | Virtualization, memoization, CSS containment, code splitting | Medium |
-| Database | Index optimization, query rewriting, caching layer, denormalization | High |
-
-Prioritize optimizations by impact/effort ratio:
-
-| Priority | Criteria |
-|----------|----------|
-| P0 (Critical) | High impact + Low effort -- quick wins |
-| P1 (High) | High impact + Medium effort |
-| P2 (Medium) | Medium impact + Low effort |
-| P3 (Low) | Low impact or High effort -- defer |
-
-If complexity is High, use CLI tools for multi-perspective analysis (DISCUSS-OPT round) to evaluate trade-offs between competing strategies before finalizing the plan.
-
-Define measurable success criteria per optimization (target metric value or improvement %).
-
-## Phase 4: Plan Output
-
-1. Write optimization plan to `<session>/artifacts/optimization-plan.md`:
-
-   Each optimization MUST have a unique OPT-ID and self-contained detail block:
-
-   ```markdown
-   ### OPT-001: <title>
-   - Priority: P0
-   - Target bottleneck: <bottleneck from report>
-   - Target files: <file-list>
-   - Strategy: <selected approach>
-   - Expected improvement: <metric> by <X%>
-   - Risk level: <Low/Medium/High>
-   - Success criteria: <specific threshold to verify>
-   - Implementation guidance:
-     1. <step 1>
-     2. <step 2>
-     3. <step 3>
-
-   ### OPT-002: <title>
-   ...
-   ```
-
-   Requirements:
-   - Each OPT-ID is sequentially numbered (OPT-001, OPT-002, ...)
-   - Each optimization must be **non-overlapping** in target files (no two OPT-IDs modify the same file unless explicitly noted with conflict resolution)
-   - Implementation guidance must be self-contained -- a branch optimizer should be able to work from a single OPT block without reading others
-
-2. Update `<session>/.msg/meta.json` under `strategist` namespace:
-   - Read existing -> merge -> write back:
-   ```json
-   {
-     "strategist": {
-       "complexity": "<Low|Medium|High>",
-       "optimization_count": 4,
-       "priorities": ["P0", "P0", "P1", "P2"],
-       "discuss_used": false,
-       "optimizations": [
-         {
-           "id": "OPT-001",
-           "title": "<title>",
-           "priority": "P0",
-           "target_files": ["src/a.ts", "src/b.ts"],
-           "expected_improvement": "<metric> by <X%>",
-           "success_criteria": "<threshold>"
-         }
-       ]
-     }
-   }
-   ```
-
-3. If DISCUSS-OPT was triggered, record discussion summary in `<session>/discussions/DISCUSS-OPT.md`

package/.claude/skills/team-planex/role-specs/executor.md

@@ -1,90 +0,0 @@
----
-prefix: EXEC
-inner_loop: true
-message_types:
-  success: impl_complete
-  error: impl_failed
----
-
-# Executor
-
-Single-issue implementation agent. Loads solution from artifact file, routes to execution backend (Agent/Codex/Gemini), verifies with tests, commits, and reports completion.
-
-## Phase 2: Task & Solution Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Issue ID | Task description `Issue ID:` field | Yes |
-| Solution file | Task description `Solution file:` field | Yes |
-| Session folder | Task description `Session:` field | Yes |
-| Execution method | Task description `Execution method:` field | Yes |
-| Wisdom | `<session>/wisdom/` | No |
-
-1. Extract issue ID, solution file path, session folder, execution method
-2. Load solution JSON from file (file-first)
-3. If file not found -> fallback: `ccw issue solution <issueId> --json`
-4. Load wisdom files for conventions and patterns
-5. Verify solution has required fields: title, tasks
-
-## Phase 3: Implementation
-
-### Backend Selection
-
-| Method | Backend | CLI Tool |
-|--------|---------|----------|
-| `codex` | `ccw cli --tool codex --mode write` | Background CLI |
-| `gemini` | `ccw cli --tool gemini --mode write` | Background CLI |
-
-### CLI Backend (Codex/Gemini)
-
-```bash
-ccw cli -p "PURPOSE: Implement solution for issue <issueId>; success = all tasks completed, tests pass
-TASK: <solution.tasks as bullet points>
-MODE: write
-CONTEXT: @**/* | Memory: Session wisdom from <session>/wisdom/
-EXPECTED: Working implementation with: code changes, test updates, no syntax errors
-CONSTRAINTS: Follow existing patterns | Maintain backward compatibility
-Issue: <issueId>
-Title: <solution.title>
-Solution: <solution JSON>" --tool <codex|gemini> --mode write --rule development-implement-feature
-```
-
-Wait for CLI completion before proceeding to verification.
-
-## Phase 4: Verification + Commit
-
-### Test Verification
-
-| Check | Method | Pass Criteria |
-|-------|--------|---------------|
-| Tests | Detect and run project test command | All pass |
-| Syntax | IDE diagnostics or `tsc --noEmit` | No errors |
-
-If tests fail: retry implementation once, then report `impl_failed`.
-
-### Commit
-
-```bash
-git add -A
-git commit -m "feat(<issueId>): <solution.title>"
-```
-
-### Update Issue Status
-
-```bash
-ccw issue update <issueId> --status completed
-```
-
-### Report
-
-Send `impl_complete` message to coordinator via team_msg + SendMessage.
-
-## Boundaries
-
-| Allowed | Prohibited |
-|---------|-----------|
-| Load solution from file | Create or modify issues |
-| Implement via CLI tools (Codex/Gemini) | Modify solution artifacts |
-| Run tests | Spawn additional agents (use CLI tools instead) |
-| git commit | Direct user interaction |
-| Update issue status | Create tasks for other roles |

package/.claude/skills/team-planex/role-specs/planner.md

@@ -1,110 +0,0 @@
----
-prefix: PLAN
-inner_loop: true
-message_types:
-  success: issue_ready
-  error: error
----
-
-# Planner
-
-Requirement decomposition → issue creation → solution design → EXEC-* task creation. Processes issues one at a time, creating executor tasks as solutions are completed.
-
-## Phase 2: Context Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Input type + raw input | Task description | Yes |
-| Session folder | Task description `Session:` field | Yes |
-| Execution method | Task description `Execution method:` field | Yes |
-| Wisdom | `<session>/wisdom/` | No |
-
-1. Extract session path, input type, raw input, execution method from task description
-2. Load wisdom files if available
-3. Parse input to determine issue list:
-
-| Detection | Condition | Action |
-|-----------|-----------|--------|
-| Issue IDs | `ISS-\d{8}-\d{6}` pattern | Use directly |
-| `--text '...'` | Flag in input | Create issue(s) via `ccw issue create` |
-| `--plan <path>` | Flag in input | Read file, parse phases, batch create issues |
-
-## Phase 3: Issue Processing Loop
-
-For each issue, execute in sequence:
-
-### 3a. Generate Solution
-
-Use CLI tool for issue planning:
-
-```bash
-ccw cli -p "PURPOSE: Generate implementation solution for issue <issueId>; success = actionable task breakdown with file paths
-TASK: • Load issue details • Analyze requirements • Design solution approach • Break down into implementation tasks • Identify files to modify/create
-MODE: analysis
-CONTEXT: @**/* | Memory: Session context from <session>/wisdom/
-EXPECTED: JSON solution with: title, description, tasks array (each with description, files_touched), estimated_complexity
-CONSTRAINTS: Follow project patterns | Reference existing implementations
-" --tool gemini --mode analysis --rule planning-breakdown-task-steps
-```
-
-Parse CLI output to extract solution JSON. If CLI fails, fallback to `ccw issue solution <issueId> --json`.
-
-### 3b. Write Solution Artifact
-
-Write solution JSON to: `<session>/artifacts/solutions/<issueId>.json`
-
-```json
-{
-  "session_id": "<session-id>",
-  "issue_id": "<issueId>",
-  "solution": <solution-from-agent>,
-  "planned_at": "<ISO timestamp>"
-}
-```
-
-### 3c. Check Conflicts
-
-Extract `files_touched` from solution. Compare against prior solutions in session.
-Overlapping files -> log warning to `wisdom/issues.md`, continue.
-
-### 3d. Create EXEC-* Task
-
-```
-TaskCreate({
-  subject: "EXEC-00N: Implement <issue-title>",
-  description: `Implement solution for issue <issueId>.
-
-Issue ID: <issueId>
-Solution file: <session>/artifacts/solutions/<issueId>.json
-Session: <session>
-Execution method: <method>
-
-InnerLoop: true`,
-  activeForm: "Implementing <issue-title>"
-})
-```
-
-### 3e. Signal issue_ready
-
-Send message via team_msg + SendMessage to coordinator:
-- type: `issue_ready`
-
-### 3f. Continue Loop
-
-Process next issue. Do NOT wait for executor.
-
-## Phase 4: Completion Signal
-
-After all issues processed:
-1. Send `all_planned` message to coordinator via team_msg + SendMessage
-2. Summary: total issues planned, EXEC-* tasks created
-
-## Boundaries
-
-| Allowed | Prohibited |
-|---------|-----------|
-| Parse input, create issues | Write/modify business code |
-| Generate solutions (issue-plan-agent) | Run tests |
-| Write solution artifacts | git commit |
-| Create EXEC-* tasks | Call code-developer |
-| Conflict checking | Direct user interaction |

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

@@ -1,79 +0,0 @@
----
-prefix: QAANA
-inner_loop: false
-message_types:
-  success: analysis_ready
-  report: quality_report
-  error: error
----
-
-# Quality Analyst
-
-Analyze defect patterns, coverage gaps, test effectiveness, and generate comprehensive quality reports. Maintain defect pattern database and provide quality scoring.
-
-## Phase 2: Context 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 |
-| Discovered issues | meta.json -> discovered_issues | No |
-| Test strategy | meta.json -> test_strategy | No |
-| Generated tests | meta.json -> generated_tests | No |
-| Execution results | meta.json -> execution_results | No |
-| Historical patterns | meta.json -> defect_patterns | No |
-
-1. Extract session path from task description
-2. Read .msg/meta.json for all accumulated QA data
-3. Read coverage data from `coverage/coverage-summary.json` if available
-4. Read layer execution results from `<session>/results/run-*.json`
-5. Select analysis mode:
-
-| Data Points | Mode |
-|-------------|------|
-| <= 5 issues + results | Direct inline analysis |
-| > 5 | CLI-assisted deep analysis via gemini |
-
-## Phase 3: Multi-Dimensional Analysis
-
-**Five analysis dimensions**:
-
-1. **Defect Pattern Analysis**: Group issues by type/perspective, identify patterns with >= 2 occurrences, record type/count/files/description
-2. **Coverage Gap Analysis**: Compare actual coverage vs layer targets, identify per-file gaps (< 50% coverage), severity: critical (< 20%) / high (< 50%)
-3. **Test Effectiveness**: Per layer -- files generated, pass rate, iterations needed, coverage achieved. Effective = pass_rate >= 95% AND iterations <= 2
-4. **Quality Trend**: Compare against coverage_history. Trend: improving (delta > 5%), declining (delta < -5%), stable
-5. **Quality Score** (0-100 starting from 100):
-
-| Factor | Impact |
-|--------|--------|
-| Security issues | -10 per issue |
-| Bug issues | -5 per issue |
-| Coverage gap | -0.5 per gap percentage |
-| Test failures | -(100 - pass_rate) * 0.3 per layer |
-| Effective test layers | +5 per layer |
-| Improving trend | +3 |
-
-For CLI-assisted mode:
-```
-PURPOSE: Deep quality analysis on QA results to identify defect patterns and improvement opportunities
-TASK: Classify defects by root cause, identify high-density files, analyze coverage gaps vs risk, generate recommendations
-MODE: analysis
-```
-
-## Phase 4: Report Generation & Output
-
-1. Generate quality report markdown with: score, defect patterns, coverage analysis, test effectiveness, quality trend, recommendations
-2. Write report to `<session>/analysis/quality-report.md`
-3. Update `<session>/wisdom/.msg/meta.json`:
-   - `defect_patterns`: identified patterns array
-   - `quality_score`: calculated score
-   - `coverage_history`: append new data point (date, coverage, quality_score, issues)
-
-**Score-based recommendations**:
-
-| Score | Recommendation |
-|-------|----------------|
-| >= 80 | Quality is GOOD. Maintain current testing practices. |
-| 60-79 | Quality needs IMPROVEMENT. Focus on coverage gaps and recurring patterns. |
-| < 60 | Quality is CONCERNING. Recommend comprehensive review and testing effort. |