claude-code-workflow 7.2.10 → 7.2.12

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

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

@@ -1,73 +0,0 @@
----
-prefix: VERIFY
-inner_loop: true
-cli_tools:
-  - gemini --mode analysis
-message_types:
-  success: verify_passed
-  failure: gaps_found
-  error: error
----
-
-# Verifier
-
-Goal-backward verification per phase. Reads convergence criteria from IMPL-*.json task files and checks against actual codebase state. Read-only — never modifies code. Produces verification.md with pass/fail and structured gap lists.
-
-## Phase 2: Context Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Task JSONs | <session>/phase-{N}/.task/IMPL-*.json | Yes |
-| Summaries | <session>/phase-{N}/summary-*.md | Yes |
-| Wisdom | <session>/wisdom/ | No |
-
-1. Glob IMPL-*.json files, extract convergence criteria from each task
-2. Glob summary-*.md files, parse frontmatter (task, affects, provides)
-3. If no task JSONs or summaries found → error to coordinator
-
-## Phase 3: Goal-Backward Verification
-
-For each task's convergence criteria, execute appropriate check:
-
-| Criteria Type | Method |
-|---------------|--------|
-| File existence | `test -f <path>` |
-| Command execution | Run command, check exit code |
-| Pattern match | Grep for pattern in specified files |
-| Semantic check | Optional: Gemini CLI (`--mode analysis --rule analysis-review-code-quality`) |
-
-**Per task scoring**:
-
-| Result | Condition |
-|--------|-----------|
-| pass | All criteria met |
-| partial | Some criteria met |
-| fail | No criteria met or critical check failed |
-
-Collect all gaps from partial/failed tasks with structured format:
-- task ID, criteria type, expected value, actual value
-
-## Phase 4: Compile Results
-
-1. Aggregate per-task results: count passed, partial, failed
-2. Determine overall status:
-   - `passed` if gaps.length === 0
-   - `gaps_found` otherwise
-3. Write `<session>/phase-{N}/verification.md`:
-
-```yaml
----
-phase: <N>
-status: passed | gaps_found
-tasks_checked: <count>
-tasks_passed: <count>
-gaps:
-  - task: "<task-id>"
-    type: "<criteria-type>"
-    item: "<description>"
-    expected: "<expected>"
-    actual: "<actual>"
----
-```
-
-4. Update .msg/meta.json with verification summary

package/.claude/skills/team-tech-debt/role-specs/assessor.md

@@ -1,70 +0,0 @@
----
-prefix: TDEVAL
-inner_loop: false
-message_types:
-  success: assessment_complete
-  error: error
----
-
-# Tech Debt Assessor
-
-Quantitative evaluator for tech debt items. Score each debt item on business impact (1-5) and fix cost (1-5), classify into priority quadrants, produce priority-matrix.json.
-
-## Phase 2: Load Debt Inventory
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Session path | task description (regex: `session:\s*(.+)`) | Yes |
-| .msg/meta.json | <session>/.msg/meta.json | Yes |
-| Debt inventory | meta.json:debt_inventory OR <session>/scan/debt-inventory.json | Yes |
-
-1. Extract session path from task description
-2. Read .msg/meta.json for team context
-3. Load debt_inventory from shared memory or fallback to debt-inventory.json file
-4. If debt_inventory is empty -> report empty assessment and exit
-
-## Phase 3: Evaluate Each Item
-
-**Strategy selection**:
-
-| Item Count | Strategy |
-|------------|----------|
-| <= 10 | Heuristic: severity-based impact + effort-based cost |
-| 11-50 | CLI batch: single gemini analysis call |
-| > 50 | CLI chunked: batches of 25 items |
-
-**Impact Score Mapping** (heuristic):
-
-| Severity | Impact Score |
-|----------|-------------|
-| critical | 5 |
-| high | 4 |
-| medium | 3 |
-| low | 1 |
-
-**Cost Score Mapping** (heuristic):
-
-| Estimated Effort | Cost Score |
-|------------------|------------|
-| small | 1 |
-| medium | 3 |
-| large | 5 |
-| unknown | 3 |
-
-**Priority Quadrant Classification**:
-
-| Impact | Cost | Quadrant |
-|--------|------|----------|
-| >= 4 | <= 2 | quick-win |
-| >= 4 | >= 3 | strategic |
-| <= 3 | <= 2 | backlog |
-| <= 3 | >= 3 | defer |
-
-For CLI mode, prompt gemini with full debt summary requesting JSON array of `{id, impact_score, cost_score, risk_if_unfixed, priority_quadrant}`. Unevaluated items fall back to heuristic scoring.
-
-## Phase 4: Generate Priority Matrix
-
-1. Build matrix structure: evaluation_date, total_items, by_quadrant (grouped), summary (counts per quadrant)
-2. Sort within each quadrant by impact_score descending
-3. Write `<session>/assessment/priority-matrix.json`
-4. Update .msg/meta.json with `priority_matrix` summary and evaluated `debt_inventory`

package/.claude/skills/team-tech-debt/role-specs/executor.md

@@ -1,80 +0,0 @@
----
-prefix: TDFIX
-inner_loop: true
-cli_tools:
-  - gemini --mode write
-message_types:
-  success: fix_complete
-  progress: fix_progress
-  error: error
----
-
-# Tech Debt Executor
-
-Debt cleanup executor. Apply remediation plan actions in worktree: refactor code, update dependencies, add tests, add documentation. Batch-delegate to CLI tools, self-validate after each batch.
-
-## Phase 2: Load Remediation Plan
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Session path | task description (regex: `session:\s*(.+)`) | Yes |
-| .msg/meta.json | <session>/.msg/meta.json | Yes |
-| Remediation plan | <session>/plan/remediation-plan.json | Yes |
-| Worktree info | meta.json:worktree.path, worktree.branch | Yes |
-| Context accumulator | From prior TDFIX tasks (inner loop) | Yes (inner loop) |
-
-1. Extract session path from task description
-2. Read .msg/meta.json for worktree path and branch
-3. Read remediation-plan.json, extract all actions from plan phases
-4. Group actions by type: refactor, restructure, add-tests, update-deps, add-docs
-5. Split large groups (> 10 items) into sub-batches of 10
-6. For inner loop (fix-verify cycle): load context_accumulator from prior TDFIX tasks, parse review/validation feedback for specific issues
-
-**Batch order**: refactor -> update-deps -> add-tests -> add-docs -> restructure
-
-## Phase 3: Execute Fixes
-
-For each batch, use CLI tool for implementation:
-
-**Worktree constraint**: ALL file operations and commands must execute within worktree path. Use `cd "<worktree-path>" && ...` prefix for all Bash commands.
-
-**Per-batch delegation**:
-
-```bash
-ccw cli -p "PURPOSE: Apply tech debt fixes in batch; success = all items fixed without breaking changes
-TASK: <batch-type-specific-tasks>
-MODE: write
-CONTEXT: @<worktree-path>/**/* | Memory: Remediation plan context
-EXPECTED: Code changes that fix debt items, maintain backward compatibility, pass existing tests
-CONSTRAINTS: Minimal changes only | No new features | No suppressions | Read files before modifying
-Batch type: <refactor|update-deps|add-tests|add-docs|restructure>
-Items: <list-of-items-with-file-paths-and-descriptions>" --tool gemini --mode write --cd "<worktree-path>"
-```
-
-Wait for CLI completion before proceeding to next batch.
-
-**Fix Results Tracking**:
-
-| Field | Description |
-|-------|-------------|
-| items_fixed | Count of successfully fixed items |
-| items_failed | Count of failed items |
-| items_remaining | Remaining items count |
-| batches_completed | Completed batch count |
-| files_modified | Array of modified file paths |
-| errors | Array of error messages |
-
-After each batch, verify file modifications via `git diff --name-only` in worktree.
-
-## Phase 4: Self-Validation
-
-All commands in worktree:
-
-| Check | Command | Pass Criteria |
-|-------|---------|---------------|
-| Syntax | `tsc --noEmit` or `python -m py_compile` | No new errors |
-| Lint | `eslint --no-error-on-unmatched-pattern` | No new errors |
-
-Write `<session>/fixes/fix-log.json` with fix results. Update .msg/meta.json with `fix_results`.
-
-Append to context_accumulator for next TDFIX task (inner loop): files modified, fixes applied, validation results, discovered caveats.

package/.claude/skills/team-tech-debt/role-specs/planner.md

@@ -1,71 +0,0 @@
----
-prefix: TDPLAN
-inner_loop: false
-message_types:
-  success: plan_ready
-  revision: plan_revision
-  error: error
----
-
-# Tech Debt Planner
-
-Remediation plan designer. Create phased remediation plan from priority matrix: Phase 1 quick-wins (immediate), Phase 2 systematic (medium-term), Phase 3 prevention (long-term). Produce remediation-plan.md.
-
-## Phase 2: Load Assessment Data
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Session path | task description (regex: `session:\s*(.+)`) | Yes |
-| .msg/meta.json | <session>/.msg/meta.json | Yes |
-| Priority matrix | <session>/assessment/priority-matrix.json | Yes |
-
-1. Extract session path from task description
-2. Read .msg/meta.json for debt_inventory
-3. Read priority-matrix.json for quadrant groupings
-4. Group items: quickWins (quick-win), strategic (strategic), backlog (backlog), deferred (defer)
-
-## Phase 3: Create Remediation Plan
-
-**Strategy selection**:
-
-| Item Count (quick-win + strategic) | Strategy |
-|------------------------------------|----------|
-| <= 5 | Inline: generate steps from item data |
-| > 5 | CLI-assisted: gemini generates detailed remediation steps |
-
-**3-Phase Plan Structure**:
-
-| Phase | Name | Source Items | Focus |
-|-------|------|-------------|-------|
-| 1 | Quick Wins | quick-win quadrant | High impact, low cost -- immediate execution |
-| 2 | Systematic | strategic quadrant | High impact, high cost -- structured refactoring |
-| 3 | Prevention | Generated from dimension patterns | Long-term prevention mechanisms |
-
-**Action Type Mapping**:
-
-| Dimension | Action Type |
-|-----------|-------------|
-| code | refactor |
-| architecture | restructure |
-| testing | add-tests |
-| dependency | update-deps |
-| documentation | add-docs |
-
-**Prevention Actions** (generated when dimension has >= 3 items):
-
-| Dimension | Prevention Action |
-|-----------|-------------------|
-| code | Add linting rules for complexity thresholds and code smell detection |
-| architecture | Introduce module boundary checks in CI pipeline |
-| testing | Set minimum coverage thresholds in CI and add pre-commit test hooks |
-| dependency | Configure automated dependency update bot (Renovate/Dependabot) |
-| documentation | Add JSDoc/docstring enforcement in linting rules |
-
-For CLI-assisted mode, prompt gemini with debt summary requesting specific fix steps per item, grouped into phases, with dependencies and estimated time.
-
-## Phase 4: Validate & Save
-
-1. Calculate validation metrics: total_actions, total_effort, files_affected, has_quick_wins, has_prevention
-2. Write `<session>/plan/remediation-plan.md` (markdown with per-item checklists)
-3. Write `<session>/plan/remediation-plan.json` (machine-readable)
-4. Update .msg/meta.json with `remediation_plan` summary

package/.claude/skills/team-tech-debt/role-specs/scanner.md

@@ -1,85 +0,0 @@
----
-prefix: TDSCAN
-inner_loop: false
-cli_tools:
-  - gemini --mode analysis
-message_types:
-  success: scan_complete
-  error: error
-  info: debt_items_found
----
-
-# Tech Debt Scanner
-
-Multi-dimension tech debt scanner. Scan codebase across 5 dimensions (code, architecture, testing, dependency, documentation), produce structured debt inventory with severity rankings.
-
-## Phase 2: Context & Environment Detection
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Scan scope | task description (regex: `scope:\s*(.+)`) | No (default: `**/*`) |
-| Session path | task description (regex: `session:\s*(.+)`) | Yes |
-| .msg/meta.json | <session>/.msg/meta.json | Yes |
-
-1. Extract session path and scan scope from task description
-2. Read .msg/meta.json for team context
-3. Detect project type and framework:
-
-| Signal File | Project Type |
-|-------------|-------------|
-| package.json + React/Vue/Angular | Frontend Node |
-| package.json + Express/Fastify/NestJS | Backend Node |
-| pyproject.toml / requirements.txt | Python |
-| go.mod | Go |
-| No detection | Generic |
-
-4. Determine scan dimensions (default: code, architecture, testing, dependency, documentation)
-5. Detect perspectives from task description:
-
-| Condition | Perspective |
-|-----------|-------------|
-| `security\|auth\|inject\|xss` | security |
-| `performance\|speed\|optimize` | performance |
-| `quality\|clean\|maintain\|debt` | code-quality |
-| `architect\|pattern\|structure` | architecture |
-| Default | code-quality + architecture |
-
-6. Assess complexity:
-
-| Score | Complexity | Strategy |
-|-------|------------|----------|
-| >= 4 | High | Triple Fan-out: CLI explore + CLI 5 dimensions + multi-perspective Gemini |
-| 2-3 | Medium | Dual Fan-out: CLI explore + CLI 3 dimensions |
-| 0-1 | Low | Inline: ACE search + Grep |
-
-## Phase 3: Multi-Dimension Scan
-
-**Low Complexity** (inline):
-- Use `mcp__ace-tool__search_context` for code smells, TODO/FIXME, deprecated APIs, complex functions, dead code, missing tests
-- Classify findings into dimensions
-
-**Medium/High Complexity** (Fan-out):
-- Fan-out A: CLI exploration (structure, patterns, dependencies angles) via `ccw cli --tool gemini --mode analysis`
-- Fan-out B: CLI dimension analysis (parallel gemini per dimension -- code, architecture, testing, dependency, documentation)
-- Fan-out C (High only): Multi-perspective Gemini analysis (security, performance, code-quality, architecture)
-- Fan-in: Merge results, cross-deduplicate by file:line, boost severity for multi-source findings
-
-**Standardize each finding**:
-
-| Field | Description |
-|-------|-------------|
-| `id` | `TD-NNN` (sequential) |
-| `dimension` | code, architecture, testing, dependency, documentation |
-| `severity` | critical, high, medium, low |
-| `file` | File path |
-| `line` | Line number |
-| `description` | Issue description |
-| `suggestion` | Fix suggestion |
-| `estimated_effort` | small, medium, large, unknown |
-
-## Phase 4: Aggregate & Save
-
-1. Deduplicate findings across Fan-out layers (file:line key), merge cross-references
-2. Sort by severity (cross-referenced items boosted)
-3. Write `<session>/scan/debt-inventory.json` with scan_date, dimensions, total_items, by_dimension, by_severity, items
-4. Update .msg/meta.json with `debt_inventory` array and `debt_score_before` count