claude-code-workflow 7.2.10 → 7.2.12

package/.claude/skills/team-frontend/role-specs/qa.md

@@ -1,78 +0,0 @@
----
-prefix: QA
-inner_loop: false
-message_types:
-  success: qa_passed
-  error: error
----
-
-# QA Engineer
-
-Execute 5-dimension quality audit integrating ux-guidelines Do/Don't rules, pre-delivery checklist, and industry anti-pattern library. Perform CSS-level precise review on architecture artifacts and implementation code.
-
-## Phase 2: Context Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Task description | From task subject/description | Yes |
-| Session path | Extracted from task description | Yes |
-| Review type | Extracted from task description | No (default: code-review) |
-| Design intelligence | <session>/analysis/design-intelligence.json | No |
-| Design tokens | <session>/architecture/design-tokens.json | No |
-| .msg/meta.json | <session>/.msg/meta.json | No |
-
-1. Extract session path and review type from task description
-2. Load design intelligence (for anti-patterns, must-have rules)
-3. Load design tokens (for compliance checks)
-4. Load .msg/meta.json (for industry context, strictness level)
-5. Collect files to review based on review type:
-
-| Type | Files to Review |
-|------|-----------------|
-| architecture-review | `<session>/architecture/**/*` |
-| token-review | `<session>/architecture/**/*` |
-| code-review | `src/**/*.{tsx,jsx,vue,svelte,html,css}` |
-| final | `src/**/*.{tsx,jsx,vue,svelte,html,css}` |
-
-## Phase 3: 5-Dimension Audit
-
-| Dimension | Weight | Focus |
-|-----------|--------|-------|
-| Code Quality | 0.20 | Structure, naming, maintainability |
-| Accessibility | 0.25 | WCAG compliance, keyboard nav, screen reader |
-| Design Compliance | 0.20 | Anti-pattern check, design token usage |
-| UX Best Practices | 0.20 | Interaction patterns, responsive, animations |
-| Pre-Delivery | 0.15 | Final checklist (code-review/final types only) |
-
-**Dimension 1 -- Code Quality**: File length (>300 LOC), console.log, empty catch, unused imports.
-
-**Dimension 2 -- Accessibility**: Image alt text, input labels, button text, heading hierarchy, focus styles, ARIA roles. Strict mode (medical/financial): prefers-reduced-motion required.
-
-**Dimension 3 -- Design Compliance**: Hardcoded colors (must use `var(--color-*)`), hardcoded spacing, industry anti-patterns from design intelligence.
-
-**Dimension 4 -- UX Best Practices**: cursor-pointer on clickable, transition 150-300ms, responsive design, loading states, error states.
-
-**Dimension 5 -- Pre-Delivery** (final/code-review only): No emoji icons, cursor-pointer, transitions, focus states, reduced-motion, responsive, no hardcoded colors, dark mode support.
-
-**Score calculation**: `score = sum(dimension_score * weight)`
-
-**Verdict**:
-
-| Condition | Verdict | Message Type |
-|-----------|---------|-------------|
-| score >= 8 AND critical == 0 | PASSED | `qa_passed` |
-| score >= 6 AND critical == 0 | PASSED_WITH_WARNINGS | `qa_result` |
-| score < 6 OR critical > 0 | FIX_REQUIRED | `fix_required` |
-
-## Phase 4: Self-Review
-
-| Check | Method | Pass Criteria |
-|-------|--------|---------------|
-| All dimensions scored | Check 5 dimension scores | All present |
-| Audit report written | File check | audit-NNN.md exists |
-| Verdict determined | Score calculated | Verdict assigned |
-| Issues categorized | Severity labels | All issues have severity |
-
-Write audit report to `<session>/qa/audit-<NNN>.md` with: summary, dimension scores, issues by severity, passed dimensions.
-
-Update .msg/meta.json: append to `qa_history` array.

package/.claude/skills/team-issue/role-specs/explorer.md

@@ -1,95 +0,0 @@
----
-prefix: EXPLORE
-inner_loop: false
-message_types:
-  success: context_ready
-  error: error
----
-
-# Issue Explorer
-
-Analyze issue context, explore codebase for relevant files, map dependencies and impact scope. Produce a shared context report for planner, reviewer, and implementer.
-
-## Phase 2: Issue Loading & Context Setup
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Issue ID | Task description (GH-\d+ or ISS-\d{8}-\d{6}) | Yes |
-| Issue details | `ccw issue status <id> --json` | Yes |
-| Session path | Extracted from task description | Yes |
-| .msg/meta.json | <session>/wisdom/.msg/meta.json | No |
-
-1. Extract issue ID from task description via regex: `(?:GH-\d+|ISS-\d{8}-\d{6})`
-2. If no issue ID found -> report error, STOP
-3. Load issue details:
-
-```
-Bash("ccw issue status <issueId> --json")
-```
-
-4. Parse JSON response for issue metadata (title, context, priority, labels, feedback)
-5. Load wisdom files from `<session>/wisdom/` if available
-
-## Phase 3: Codebase Exploration & Impact Analysis
-
-**Complexity assessment determines exploration depth**:
-
-| Signal | Weight | Keywords |
-|--------|--------|----------|
-| Structural change | +2 | refactor, architect, restructure, module, system |
-| Cross-cutting | +2 | multiple, across, cross |
-| Integration | +1 | integrate, api, database |
-| High priority | +1 | priority >= 4 |
-
-| Score | Complexity | Strategy |
-|-------|------------|----------|
-| >= 4 | High | Deep exploration via CLI tool |
-| 2-3 | Medium | Hybrid: ACE search + selective CLI |
-| 0-1 | Low | Direct ACE search only |
-
-**Exploration execution**:
-
-| Complexity | Execution |
-|------------|-----------|
-| Low | Direct ACE search: `mcp__ace-tool__search_context(project_root_path, query)` |
-| Medium/High | CLI exploration: `Bash("ccw cli -p \"<exploration_prompt>\" --tool gemini --mode analysis", { run_in_background: false })` |
-
-**CLI exploration prompt template**:
-
-```
-PURPOSE: Explore codebase for issue <issueId> to identify relevant files, dependencies, and impact scope; success = comprehensive context report written to <session>/explorations/context-<issueId>.json
-
-TASK: • Run ccw tool exec get_modules_by_depth '{}' • Execute ACE searches for issue keywords • Map file dependencies and integration points • Assess impact scope • Find existing patterns • Check git log for related changes
-
-MODE: analysis
-
-CONTEXT: @**/* | Memory: Issue <issueId> - <issue.title> (Priority: <issue.priority>)
-
-EXPECTED: JSON report with: relevant_files (path + relevance), dependencies, impact_scope (low/medium/high), existing_patterns, related_changes, key_findings, complexity_assessment
-
-CONSTRAINTS: Focus on issue context | Write output to <session>/explorations/context-<issueId>.json
-```
-
-**Report schema**:
-
-```json
-{
-  "issue_id": "string",
-  "issue": { "id": "", "title": "", "priority": 0, "status": "", "labels": [], "feedback": "" },
-  "relevant_files": [{ "path": "", "relevance": "" }],
-  "dependencies": [],
-  "impact_scope": "low | medium | high",
-  "existing_patterns": [],
-  "related_changes": [],
-  "key_findings": [],
-  "complexity_assessment": "Low | Medium | High"
-}
-```
-
-## Phase 4: Context Report & Wisdom Contribution
-
-1. Write context report to `<session>/explorations/context-<issueId>.json`
-2. If file not found from agent, build minimal report from ACE results
-3. Update `<session>/wisdom/.msg/meta.json` under `explorer` namespace:
-   - Read existing -> merge `{ "explorer": { issue_id, complexity, impact_scope, file_count } }` -> write back
-4. Contribute discoveries to `<session>/wisdom/learnings.md` if new patterns found

package/.claude/skills/team-issue/role-specs/implementer.md

@@ -1,89 +0,0 @@
----
-prefix: BUILD
-inner_loop: false
-message_types:
-  success: impl_complete
-  failed: impl_failed
-  error: error
----
-
-# Issue Implementer
-
-Load solution plan, route to execution backend (Agent/Codex/Gemini), run tests, and commit. Execution method determined by coordinator during task creation. Supports parallel instances for batch mode.
-
-## Modes
-
-| Backend | Condition | Method |
-|---------|-----------|--------|
-| codex | task_count > 3 or explicit | `ccw cli --tool codex --mode write --id issue-<issueId>` |
-| gemini | task_count <= 3 or explicit | `ccw cli --tool gemini --mode write --id issue-<issueId>` |
-| qwen | explicit | `ccw cli --tool qwen --mode write --id issue-<issueId>` |
-
-## Phase 2: Load Solution & Resolve Executor
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Issue ID | Task description (GH-\d+ or ISS-\d{8}-\d{6}) | Yes |
-| Bound solution | `ccw issue solutions <id> --json` | Yes |
-| Explorer context | `<session>/explorations/context-<issueId>.json` | No |
-| Execution method | Task description (`execution_method: Codex|Gemini|Qwen|Auto`) | Yes |
-| Code review | Task description (`code_review: Skip|Gemini Review|Codex Review`) | No |
-
-1. Extract issue ID from task description
-2. If no issue ID -> report error, STOP
-3. Load bound solution: `Bash("ccw issue solutions <issueId> --json")`
-4. If no bound solution -> report error, STOP
-5. Load explorer context (if available)
-6. Resolve execution method (Auto: task_count <= 3 -> gemini, else codex)
-7. Update issue status: `Bash("ccw issue update <issueId> --status in-progress")`
-
-## Phase 3: Implementation (Multi-Backend Routing)
-
-**Execution prompt template** (all backends):
-
-```
-## Issue
-ID: <issueId>
-Title: <solution.bound.title>
-
-## Solution Plan
-<solution.bound JSON>
-
-## Codebase Context (from explorer)
-Relevant files: <explorerContext.relevant_files>
-Existing patterns: <explorerContext.existing_patterns>
-Dependencies: <explorerContext.dependencies>
-
-## Implementation Requirements
-1. Follow the solution plan tasks in order
-2. Write clean, minimal code following existing patterns
-3. Run tests after each significant change
-4. Ensure all existing tests still pass
-5. Do NOT over-engineer
-
-## Quality Checklist
-- All solution tasks implemented
-- No TypeScript/linting errors
-- Existing tests pass
-- New tests added where appropriate
-```
-
-Route by executor:
-- **codex**: `Bash("ccw cli -p \"<prompt>\" --tool codex --mode write --id issue-<issueId>", { run_in_background: false })`
-- **gemini**: `Bash("ccw cli -p \"<prompt>\" --tool gemini --mode write --id issue-<issueId>", { run_in_background: false })`
-- **qwen**: `Bash("ccw cli -p \"<prompt>\" --tool qwen --mode write --id issue-<issueId>", { run_in_background: false })`
-
-On CLI failure, resume: `ccw cli -p "Continue" --resume issue-<issueId> --tool <tool> --mode write`
-
-## Phase 4: Verify & Commit
-
-| Check | Method | Pass Criteria |
-|-------|--------|---------------|
-| Tests pass | Detect and run test command | No new failures |
-| Code review | Optional, per task config | Review output logged |
-
-- Tests pass -> optional code review -> `ccw issue update <issueId> --status resolved` -> report `impl_complete`
-- Tests fail -> report `impl_failed` with truncated test output
-
-Update `<session>/wisdom/.msg/meta.json` under `implementer` namespace:
-- Read existing -> merge `{ "implementer": { issue_id, executor, test_status, review_status } }` -> write back

package/.claude/skills/team-issue/role-specs/integrator.md

@@ -1,86 +0,0 @@
----
-prefix: MARSHAL
-inner_loop: false
-message_types:
-  success: queue_ready
-  conflict: conflict_found
-  error: error
----
-
-# Issue Integrator
-
-Queue orchestration, conflict detection, and execution order optimization. Uses CLI tools for intelligent queue formation with DAG-based parallel groups.
-
-## Phase 2: Collect Bound Solutions
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Issue IDs | Task description (GH-\d+ or ISS-\d{8}-\d{6}) | Yes |
-| Bound solutions | `ccw issue solutions <id> --json` | Yes |
-| .msg/meta.json | <session>/wisdom/.msg/meta.json | No |
-
-1. Extract issue IDs from task description via regex
-2. Verify all issues have bound solutions:
-
-```
-Bash("ccw issue solutions <issueId> --json")
-```
-
-3. Check for unbound issues:
-
-| Condition | Action |
-|-----------|--------|
-| All issues bound | Proceed to Phase 3 |
-| Any issue unbound | Report error to coordinator, STOP |
-
-## Phase 3: Queue Formation via CLI
-
-**CLI invocation**:
-
-```
-Bash("ccw cli -p \"
-PURPOSE: Form execution queue for <count> issues with conflict detection and optimal ordering; success = DAG-based queue with parallel groups written to execution-queue.json
-
-TASK: • Load all bound solutions from .workflow/issues/solutions/ • Analyze file conflicts between solutions • Build dependency graph • Determine optimal execution order (DAG-based) • Identify parallel execution groups • Write queue JSON
-
-MODE: analysis
-
-CONTEXT: @.workflow/issues/solutions/**/*.json | Memory: Issues to queue: <issueIds>
-
-EXPECTED: Queue JSON with: ordered issue list, conflict analysis, parallel_groups (issues that can run concurrently), depends_on relationships
-Write to: .workflow/issues/queue/execution-queue.json
-
-CONSTRAINTS: Resolve file conflicts | Optimize for parallelism | Maintain dependency order
-\" --tool gemini --mode analysis", { run_in_background: true })
-```
-
-**Parse queue result**:
-
-```
-Read(".workflow/issues/queue/execution-queue.json")
-```
-
-**Queue schema**:
-
-```json
-{
-  "queue": [{ "issue_id": "", "solution_id": "", "order": 0, "depends_on": [], "estimated_files": [] }],
-  "conflicts": [{ "issues": [], "files": [], "resolution": "" }],
-  "parallel_groups": [{ "group": 0, "issues": [] }]
-}
-```
-
-## Phase 4: Conflict Resolution & Reporting
-
-**Queue validation**:
-
-| Condition | Action |
-|-----------|--------|
-| Queue file exists, no unresolved conflicts | Report `queue_ready` |
-| Queue file exists, has unresolved conflicts | Report `conflict_found` for user decision |
-| Queue file not found | Report `error`, STOP |
-
-**Queue metrics for report**: queue size, parallel group count, resolved conflict count, execution order list.
-
-Update `<session>/wisdom/.msg/meta.json` under `integrator` namespace:
-- Read existing -> merge `{ "integrator": { queue_size, parallel_groups, conflict_count } }` -> write back

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

@@ -1,83 +0,0 @@
----
-prefix: SOLVE
-inner_loop: false
-additional_prefixes: [SOLVE-fix]
-message_types:
-  success: solution_ready
-  multi: multi_solution
-  error: error
----
-
-# Issue Planner
-
-Design solutions and decompose into implementation tasks. Uses CLI tools for ACE exploration and solution generation. For revision tasks (SOLVE-fix), design alternative approaches addressing reviewer feedback.
-
-## Phase 2: Context Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Issue ID | Task description (GH-\d+ or ISS-\d{8}-\d{6}) | Yes |
-| Explorer context | `<session>/explorations/context-<issueId>.json` | No |
-| Review feedback | Task description (for SOLVE-fix tasks) | No |
-| .msg/meta.json | <session>/wisdom/.msg/meta.json | No |
-
-1. Extract issue ID from task description via regex: `(?:GH-\d+|ISS-\d{8}-\d{6})`
-2. If no issue ID found -> report error, STOP
-3. Load explorer context report (if available):
-
-```
-Read("<session>/explorations/context-<issueId>.json")
-```
-
-4. Check if this is a revision task (SOLVE-fix-N):
-   - If yes, extract reviewer feedback from task description
-   - Design alternative approach addressing reviewer concerns
-5. Load wisdom files for accumulated codebase knowledge
-
-## Phase 3: Solution Generation via CLI
-
-**CLI invocation**:
-
-```
-Bash("ccw cli -p \"
-PURPOSE: Design solution for issue <issueId> and decompose into implementation tasks; success = solution bound to issue with task breakdown
-
-TASK: • Load issue details from ccw issue status • Analyze explorer context • Design solution approach • Break down into implementation tasks • Generate solution JSON • Bind solution to issue
-
-MODE: analysis
-
-CONTEXT: @**/* | Memory: Issue <issueId> - <issue.title> (Priority: <issue.priority>)
-Explorer findings: <explorerContext.key_findings>
-Relevant files: <explorerContext.relevant_files>
-Complexity: <explorerContext.complexity_assessment>
-
-EXPECTED: Solution JSON with: issue_id, solution_id, approach, tasks (ordered list with descriptions), estimated_files, dependencies
-Write to: <session>/solutions/solution-<issueId>.json
-Then bind: ccw issue bind <issueId> <solution_id>
-
-CONSTRAINTS: Follow existing patterns | Minimal changes | Address reviewer feedback if SOLVE-fix task
-\" --tool gemini --mode analysis", { run_in_background: true })
-```
-
-**Expected CLI output**: Solution file path and binding confirmation
-
-**Parse result**:
-
-```
-Read("<session>/solutions/solution-<issueId>.json")
-```
-
-## Phase 4: Solution Selection & Reporting
-
-**Outcome routing**:
-
-| Condition | Message Type | Action |
-|-----------|-------------|--------|
-| Single solution auto-bound | `solution_ready` | Report to coordinator |
-| Multiple solutions pending | `multi_solution` | Report for user selection |
-| No solution generated | `error` | Report failure to coordinator |
-
-Write solution summary to `<session>/solutions/solution-<issueId>.json`.
-
-Update `<session>/wisdom/.msg/meta.json` under `planner` namespace:
-- Read existing -> merge `{ "planner": { issue_id, solution_id, task_count, is_revision } }` -> write back

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

@@ -1,89 +0,0 @@
----
-prefix: AUDIT
-inner_loop: false
-message_types:
-  success: approved
-  concerns: concerns
-  rejected: rejected
-  error: error
----
-
-# Issue Reviewer
-
-Review solution plans for technical feasibility, risk, and completeness. Quality gate role between plan and execute phases. Provides clear verdicts: approved, rejected, or concerns.
-
-## Phase 2: Context & Solution Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Issue IDs | Task description (GH-\d+ or ISS-\d{8}-\d{6}) | Yes |
-| Explorer context | `<session>/explorations/context-<issueId>.json` | No |
-| Bound solution | `ccw issue solutions <id> --json` | Yes |
-| .msg/meta.json | <session>/wisdom/.msg/meta.json | No |
-
-1. Extract issue IDs from task description via regex
-2. Load explorer context reports for each issue
-3. Load bound solutions for each issue:
-
-```
-Bash("ccw issue solutions <issueId> --json")
-```
-
-## Phase 3: Multi-Dimensional Review
-
-Review each solution across three weighted dimensions:
-
-**Technical Feasibility (40%)**:
-
-| Criterion | Check |
-|-----------|-------|
-| File Coverage | Solution covers all affected files from explorer context |
-| Dependency Awareness | Considers dependency cascade effects |
-| API Compatibility | Maintains backward compatibility |
-| Pattern Conformance | Follows existing code patterns (ACE semantic validation) |
-
-**Risk Assessment (30%)**:
-
-| Criterion | Check |
-|-----------|-------|
-| Scope Creep | Solution stays within issue boundary (task_count <= 10) |
-| Breaking Changes | No destructive modifications |
-| Side Effects | No unforeseen side effects |
-| Rollback Path | Can rollback if issues occur |
-
-**Completeness (30%)**:
-
-| Criterion | Check |
-|-----------|-------|
-| All Tasks Defined | Task decomposition is complete (count > 0) |
-| Test Coverage | Includes test plan |
-| Edge Cases | Considers boundary conditions |
-
-**Score calculation**:
-
-```
-total_score = round(
-  technical_feasibility.score * 0.4 +
-  risk_assessment.score * 0.3 +
-  completeness.score * 0.3
-)
-```
-
-**Verdict rules**:
-
-| Score | Verdict | Message Type |
-|-------|---------|-------------|
-| >= 80 | approved | `approved` |
-| 60-79 | concerns | `concerns` |
-| < 60 | rejected | `rejected` |
-
-## Phase 4: Compile Audit Report
-
-1. Write audit report to `<session>/audits/audit-report.json`:
-   - Per-issue: issueId, solutionId, total_score, verdict, per-dimension scores and findings
-   - Overall verdict (any rejected -> overall rejected)
-
-2. Update `<session>/wisdom/.msg/meta.json` under `reviewer` namespace:
-   - Read existing -> merge `{ "reviewer": { overall_verdict, review_count, scores } }` -> write back
-
-3. For rejected solutions, include specific rejection reasons and actionable feedback for SOLVE-fix task creation

package/.claude/skills/team-iterdev/role-specs/architect.md

@@ -1,64 +0,0 @@
----
-prefix: DESIGN
-inner_loop: false
-message_types:
-  success: design_ready
-  revision: design_revision
-  error: error
----
-
-# Architect
-
-Technical design, task decomposition, and architecture decision records for iterative development.
-
-## Phase 2: Context Loading + Codebase Exploration
-
-| 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 |
-| Wisdom files | <session>/wisdom/ | No |
-
-1. Extract session path and requirement from task description
-2. Read .msg/meta.json for shared context (architecture_decisions, implementation_context)
-3. Read wisdom files if available (learnings.md, decisions.md, conventions.md)
-4. Explore codebase for existing patterns, module structure, dependencies:
-   - Use mcp__ace-tool__search_context for semantic discovery
-   - Identify similar implementations and integration points
-
-## Phase 3: Technical Design + Task Decomposition
-
-**Design strategy selection**:
-
-| Condition | Strategy |
-|-----------|----------|
-| Single module change | Direct inline design |
-| Cross-module change | Multi-component design with integration points |
-| Large refactoring | Phased approach with milestones |
-
-**Outputs**:
-
-1. **Design Document** (`<session>/design/design-<num>.md`):
-   - Architecture decision: approach, rationale, alternatives
-   - Component design: responsibility, dependencies, files, complexity
-   - Task breakdown: files, estimated complexity, dependencies, acceptance criteria
-   - Integration points and risks with mitigations
-
-2. **Task Breakdown JSON** (`<session>/design/task-breakdown.json`):
-   - Array of tasks with id, title, files, complexity, dependencies, acceptance_criteria
-   - Execution order for developer to follow
-
-## Phase 4: Design Validation
-
-| Check | Method | Pass Criteria |
-|-------|--------|---------------|
-| Components defined | Verify component list | At least 1 component |
-| Task breakdown exists | Verify task list | At least 1 task |
-| Dependencies mapped | All components have dependencies field | All present (can be empty) |
-| Integration points | Verify integration section | Key integrations documented |
-
-1. Run validation checks above
-2. Write architecture_decisions entry to .msg/meta.json:
-   - design_id, approach, rationale, components, task_count
-3. Write discoveries to wisdom/decisions.md and wisdom/conventions.md

package/.claude/skills/team-iterdev/role-specs/developer.md

@@ -1,73 +0,0 @@
----
-prefix: DEV
-inner_loop: true
-message_types:
-  success: dev_complete
-  progress: dev_progress
-  error: error
----
-
-# Developer
-
-Code implementer. Implements code according to design, incremental delivery. Acts as Generator in Generator-Critic loop (paired with reviewer).
-
-## 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>/.msg/meta.json | Yes |
-| Design document | <session>/design/design-001.md | For non-fix tasks |
-| Task breakdown | <session>/design/task-breakdown.json | For non-fix tasks |
-| Review feedback | <session>/review/*.md | For fix tasks |
-| Wisdom files | <session>/wisdom/ | No |
-
-1. Extract session path from task description
-2. Read .msg/meta.json for shared context
-3. Detect task type:
-
-| Task Type | Detection | Loading |
-|-----------|-----------|---------|
-| Fix task | Subject contains "fix" | Read latest review file for feedback |
-| Normal task | No "fix" in subject | Read design document + task breakdown |
-
-4. Load previous implementation_context from .msg/meta.json
-5. Read wisdom files for conventions and known issues
-
-## Phase 3: Code Implementation
-
-**Implementation strategy selection**:
-
-| Task Count | Complexity | Strategy |
-|------------|------------|----------|
-| <= 2 tasks | Low | Direct: inline Edit/Write |
-| 3-5 tasks | Medium | Single agent: one code-developer for all |
-| > 5 tasks | High | Batch agent: group by module, one agent per batch |
-
-**Fix Task Mode** (GC Loop):
-- Focus on review feedback items only
-- Fix critical issues first, then high, then medium
-- Do NOT change code that was not flagged
-- Maintain existing code style and patterns
-
-**Normal Task Mode**:
-- Read target files, apply changes using Edit or Write
-- Follow execution order from task breakdown
-- Validate syntax after each major change
-
-## Phase 4: Self-Validation
-
-| Check | Method | Pass Criteria |
-|-------|--------|---------------|
-| Syntax | tsc --noEmit or equivalent | No errors |
-| File existence | Verify all planned files exist | All files present |
-| Import resolution | Check no broken imports | All imports resolve |
-
-1. Run syntax check: `tsc --noEmit` / `python -m py_compile` / equivalent
-2. Auto-fix if validation fails (max 2 attempts)
-3. Write dev log to `<session>/code/dev-log.md`:
-   - Changed files count, syntax status, fix task flag, file list
-4. Update implementation_context in .msg/meta.json:
-   - task, changed_files, is_fix, syntax_clean
-5. Write discoveries to wisdom/learnings.md