cokit-cli 1.2.6 → 1.3.0

package/templates/repo/.github/skills/fix/references/prevention-gate.md

@@ -0,0 +1,87 @@
+# Prevention Gate
+
+After fixing a bug, prevent the same class of issues from recurring. This step is MANDATORY.
+
+## Core Principle
+
+A fix without prevention is incomplete. The same bug pattern WILL recur if you only patch the symptom.
+
+## Prevention Requirements (Check All That Apply)
+
+### 1. Regression Test (ALWAYS required)
+
+Every fix MUST have a test that:
+- **Fails** without the fix applied (proves the test catches the bug)
+- **Passes** with the fix applied (proves the fix works)
+
+```
+If no test framework exists:
+  → Add inline verification or assertion at minimum
+  → Note in report: "No test framework — added runtime assertion"
+```
+
+### 2. Defense-in-Depth Validation (When applicable)
+
+Apply layered validation from `debug` defense-in-depth technique:
+
+| Layer | Apply When | Example |
+|-------|-----------|---------|
+| **Entry point validation** | Fix involves user/external input | Reject invalid input at API boundary |
+| **Business logic validation** | Fix involves data processing | Assert data makes sense for operation |
+| **Environment guards** | Fix involves env-sensitive operations | Prevent dangerous ops in wrong context |
+| **Debug instrumentation** | Fix was hard to diagnose | Add logging/context capture for forensics |
+
+**Rule:** Not every fix needs all 4 layers. Apply what's relevant. But ALWAYS consider each.
+
+### 3. Type Safety (When applicable)
+
+| Scenario | Prevention |
+|----------|-----------|
+| Null/undefined caused the bug | Add strict null checks, use `??` or `?.` |
+| Wrong type passed | Add type guard or runtime validation |
+| Missing property | Add required field to interface/type |
+| Implicit any | Add explicit types |
+
+### 4. Error Handling (When applicable)
+
+| Scenario | Prevention |
+|----------|-----------|
+| Unhandled promise rejection | Add `.catch()` or try/catch |
+| Missing error boundary | Add error boundary component |
+| Silent failure | Add explicit error logging |
+| No fallback for external dependency | Add timeout + fallback |
+
+## Verification Checklist (Before Completing Step 5)
+
+```
+□ Pre-fix state captured? (error messages, test output)
+□ Fix applied to ROOT CAUSE (not symptom)?
+□ Fresh verification run? (exact same commands as pre-fix)
+□ Before/after comparison documented?
+□ Regression test added? (fails without fix, passes with fix)
+□ Defense-in-depth layers considered? (applied where relevant)
+□ No new warnings/errors introduced?
+□ Parallel verification passed? (typecheck + lint + build + test)
+```
+
+## Output Format
+
+```
+Prevention measures applied:
+- Regression test: [test file:line] — covers [specific scenario]
+- Guard added: [file:line] — [description of guard]
+- Type safety: [file:line] — [what was strengthened]
+- Error handling: [file:line] — [what was added]
+
+Before/After comparison:
+- Before: [exact error/failure]
+- After: [exact success output]
+```
+
+## Quick Mode Prevention
+
+For trivial issues (type errors, lint), abbreviated prevention:
+- Regression test: optional (type system IS the test)
+- Parallel verification: typecheck + lint only
+- Defense-in-depth: skip (not applicable for type fixes)
+- Still require before/after comparison of typecheck output

package/templates/repo/.github/skills/fix/references/review-cycle.md

@@ -20,9 +20,9 @@ LOOP:
      → cycle++, GOTO LOOP
 
   4. ELSE IF cycle >= 3:
-     → ESCALATE to user directly in response
+     → ESCALATE to user via asking the user
      → Display findings
-     → Ask: "Fix manually" / "Approve anyway" / "Abort" — wait for response
+     → Options: "Fix manually" / "Approve anyway" / "Abort"
 
   5. ELSE (score < 9.5, no critical):
      → Output: "✓ Review [score]/10 - Approved with [N] warnings"
@@ -44,7 +44,7 @@ ALWAYS:
      │ Suggestions ([N]): [list]           │
      └─────────────────────────────────────┘
 
-  3. Ask user directly in response, then wait for answer:
+  3. Use asking the user:
      IF critical_count > 0:
        - "Fix critical issues"
        - "Fix all issues"

package/templates/repo/.github/skills/fix/references/skill-activation-matrix.md

@@ -1,37 +1,57 @@
 # Skill Activation Matrix
 
-When to activate each skill during fixing workflows.
+When to activate each skill and tool during fixing workflows.
 
-## Always Activate
+## Always Activate (ALL Workflows)
 
-| Skill | Reason |
-|-------|--------|
-| `debug` | Core to all fix workflows - find root cause first |
+| Skill/Tool | Step | Reason |
+|------------|------|--------|
+| `scout` OR parallel `Explore` | Step 1 | Understand codebase context before diagnosing |
+| `debug` | Step 2 | Systematic root cause investigation |
+| `sequential-thinking` | Step 2 | Structured hypothesis formation — NO guessing |
+
+## Task Orchestration (Moderate+ Only)
+
+| Tool | Activate When |
+|------|---------------|
+| `TaskCreate` | After complexity assessment, create all phase tasks upfront |
+| `TaskUpdate` | At start/completion of each phase |
+| `TaskList` | Check available unblocked work, coordinate parallel agents |
+| `TaskGet` | Retrieve full task details before starting work |
+
+Skip Tasks for Quick workflow (< 3 steps). See `references/task-orchestration.md`.
+
+## Auto-Triggered Activation
+
+| Skill | Auto-Trigger Condition |
+|-------|------------------------|
+| `problem-solving` | 2+ hypotheses REFUTED in Step 2 diagnosis |
+| `sequential-thinking` | Always in Step 2 (mandatory for hypothesis formation) |
 
 ## Conditional Activation
 
 | Skill | Activate When |
 |-------|---------------|
-| `problem-solving` | Stuck on approach, multiple failed attempts |
-| `sequential-thinking` | Complex logic chain, multi-step reasoning needed |
-| `brainstorming` | Multiple valid approaches, architecture decision |
+| `brainstorm` | Multiple valid fix approaches, architecture decision (Deep only) |
 | `context-engineering` | Fixing AI/LLM/agent code, context window issues |
-| ImageMagick/FFmpeg | Image/video processing, visual asset manipulation |
+| `ai-multimodal` (if available) | UI issues, screenshots provided, visual bugs |
+| `project-management` | Moderate+ workflows — task hydration, sync-back, progress tracking |
 
-## Agent Usage
+## Subagent Usage
 
-| Agent | Activate When |
+| Subagent | Activate When |
 |----------|---------------|
-| `debugger` | Root cause unclear, need deep investigation |
-| `Explore` (parallel) | Scout multiple areas simultaneously |
-| `Bash` (parallel) | Verify implementation (typecheck, lint, build) |
-| `researcher` | External docs needed, latest best practices |
-| `planner` | Complex fix needs breakdown, multiple phases |
-| `tester` | After implementation, verify fix works |
-| `code-reviewer` | After fix, verify quality and security |
-| `git-manager` | After approval, commit changes |
-| `docs-manager` | API/behavior changes need doc updates |
-| `project-manager` | Major fix impacts roadmap/plan status |
+| `debugger` | Root cause unclear, need deep investigation (Step 2) |
+| `Explore` (parallel) | Scout multiple areas simultaneously (Step 1), test hypotheses (Step 2) |
+| `Bash` (parallel) | Verify implementation: typecheck, lint, build, test (Step 5) |
+| `researcher` | External docs needed, latest best practices (Deep only) |
+| `planner` | Complex fix needs breakdown, multiple phases (Deep only) |
+| `tester` | After implementation, verify fix works (Step 5) |
+| `code-review` | After fix, verify quality and security (Step 5) |
+| `git-manager` | After approval, commit changes (Step 6) |
+| `docs-manager` | API/behavior changes need doc updates (Step 6) |
+| `project-manager` | Major fix impacts roadmap/plan status (Step 6) |
+| `fullstack-developer` | Parallel independent issues (each gets own agent) |
 
 ## Parallel Patterns
 
@@ -39,19 +59,32 @@ See `references/parallel-exploration.md` for detailed patterns.
 
 | When | Parallel Strategy |
 |------|-------------------|
-| Root cause unclear | 2-3 `Explore` agents on different areas |
+| Scouting (Step 1) | 2-3 `Explore` agents on different areas |
+| Testing hypotheses (Step 2) | 2-3 `Explore` agents per hypothesis |
 | Multi-module fix | `Explore` each module in parallel |
-| After implementation | `Bash` agents: typecheck + lint + build |
-| Before commit | `Bash` agents: test + build + lint |
+| After implementation (Step 5) | `Bash` agents: typecheck + lint + build + test |
+| 2+ independent issues | Task trees + `fullstack-developer` agents per issue |
 
 ## Workflow → Skills Map
 
 | Workflow | Skills Activated |
 |----------|------------------|
-| Quick | `debug`, `code-reviewer`, parallel `Bash` verification |
-| Standard | Above + `problem-solving`, `sequential-thinking`, `tester`, parallel `Explore` |
-| Deep | All above + `brainstorming`, `context-engineering`, `researcher`, `planner` |
-| Parallel | Per-issue workflow + coordination via parallel agents |
+| Quick | `scout` (minimal), `debug`, `sequential-thinking`, `code-review`, parallel `Bash` verification |
+| Standard | Above + Tasks, `problem-solving` (auto), `project-management`, `tester`, parallel `Explore` |
+| Deep | All above + `brainstorm`, `context-engineering`, `researcher`, `planner` |
+| Parallel | Per-issue Task trees + `project-management` + `fullstack-developer` agents + coordination via `TaskList` |
+
+## Step → Skills Chain (Mandatory Order)
+
+| Step | Mandatory Chain |
+|------|----------------|
+| Step 0: Mode | asking the user (unless auto/quick detected) |
+| Step 1: Scout | `scout` OR 2-3 parallel `Explore` → map files, deps, tests |
+| Step 2: Diagnose | Capture pre-fix state → `debug` → `sequential-thinking` → parallel `Explore` hypotheses → (`problem-solving` if 2+ fail) |
+| Step 3: Assess | Classify complexity → create Tasks (moderate+) |
+| Step 4: Fix | Implement per workflow → follow root cause |
+| Step 5: Verify+Prevent | Iron-law verify → regression test → defense-in-depth → parallel `Bash` verify |
+| Step 6: Finalize | Report → `docs-manager` → `TaskUpdate` → `git-manager` → `/ck-journal` |
 
 ## Detection Triggers
 
@@ -60,6 +93,6 @@ See `references/parallel-exploration.md` for detailed patterns.
 | "AI", "LLM", "agent", "context" | `context-engineering` |
 | "stuck", "tried everything" | `problem-solving` |
 | "complex", "multi-step" | `sequential-thinking` |
-| "which approach", "options" | `brainstorming` |
-| "latest docs", "best practice" | `researcher` agent |
-| Screenshot attached | Visual analysis |
+| "which approach", "options" | `brainstorm` |
+| "latest docs", "best practice" | `researcher` subagent |
+| Screenshot attached | `ai-multimodal` (if available) |

package/templates/repo/.github/skills/fix/references/task-orchestration.md

@@ -0,0 +1,110 @@
+# Task Orchestration
+
+Native Task tools for tracking and coordinating fix workflows.
+
+**Skill:** Activate `project-management` for advanced task orchestration — provides hydration (plan checkboxes → Tasks), sync-back (Tasks → plan checkboxes), cross-session resume, and progress tracking patterns.
+
+**Tool Availability:** `TaskCreate`, `TaskUpdate`, `TaskGet`, `TaskList` are **CLI-only** — disabled in VSCode extension (`isTTY` check). If these tools error, use `TodoWrite` for progress tracking instead. Fix workflow remains fully functional — Tasks add visibility and coordination, not core functionality.
+
+## When to Use Tasks
+
+| Complexity | Use Tasks? | Reason |
+|-----------|-----------|--------|
+| Simple/Quick | No | < 3 steps, overhead exceeds benefit |
+| Moderate (Standard) | Yes | 6 steps, multi-subagent coordination |
+| Complex (Deep) | Yes | 9 steps, dependency chains, parallel agents |
+| Parallel | Yes | Multiple independent issue trees |
+
+## Task Tools
+
+- `TaskCreate(subject, description, activeForm, metadata)` - Create task
+- `TaskUpdate(taskId, status, addBlockedBy, addBlocks)` - Update status/deps
+- `TaskGet(taskId)` - Get full task details
+- `TaskList()` - List all tasks with status
+
+**Lifecycle:** `pending` → `in_progress` → `completed`
+
+## Standard Workflow Tasks (6 phases)
+
+Create all tasks upfront, then work through them:
+
+```
+T1 = TaskCreate(subject="Scout codebase",       activeForm="Scouting codebase",     metadata={step: 1, phase: "investigate"})
+T2 = TaskCreate(subject="Diagnose root cause",   activeForm="Diagnosing root cause", metadata={step: 2, phase: "investigate"})
+T3 = TaskCreate(subject="Implement fix",         activeForm="Implementing fix",      metadata={step: 3, phase: "implement"},  addBlockedBy=[T1, T2])
+T4 = TaskCreate(subject="Verify + prevent",      activeForm="Verifying fix",         metadata={step: 4, phase: "verify"},     addBlockedBy=[T3])
+T5 = TaskCreate(subject="Code review",           activeForm="Reviewing code",        metadata={step: 5, phase: "verify"},     addBlockedBy=[T4])
+T6 = TaskCreate(subject="Finalize",              activeForm="Finalizing",            metadata={step: 6, phase: "finalize"},   addBlockedBy=[T5])
+```
+
+Update as work progresses:
+```
+TaskUpdate(taskId=T1, status="in_progress")
+// ... scout codebase ...
+TaskUpdate(taskId=T1, status="completed")
+// T3 auto-unblocks when T1 + T2 complete
+```
+
+## Deep Workflow Tasks (9 phases)
+
+Steps 1+2+3 run in parallel (scout + diagnose + research).
+
+```
+T1 = TaskCreate(subject="Scout codebase",           metadata={step: 1, phase: "investigate"})
+T2 = TaskCreate(subject="Diagnose root cause",       metadata={step: 2, phase: "investigate"})
+T3 = TaskCreate(subject="Research solutions",         metadata={step: 3, phase: "investigate"})
+T4 = TaskCreate(subject="Brainstorm approaches",      metadata={step: 4, phase: "design"},     addBlockedBy=[T1, T2, T3])
+T5 = TaskCreate(subject="Create implementation plan", metadata={step: 5, phase: "design"},     addBlockedBy=[T4])
+T6 = TaskCreate(subject="Implement fix",              metadata={step: 6, phase: "implement"},  addBlockedBy=[T5])
+T7 = TaskCreate(subject="Verify + prevent",           metadata={step: 7, phase: "verify"},     addBlockedBy=[T6])
+T8 = TaskCreate(subject="Code review",                metadata={step: 8, phase: "verify"},     addBlockedBy=[T7])
+T9 = TaskCreate(subject="Finalize & docs",            metadata={step: 9, phase: "finalize"},   addBlockedBy=[T8])
+```
+
+**Note:** Steps 1, 2, and 3 run in parallel (scout + diagnose + research simultaneously).
+
+## Parallel Issue Coordination
+
+For 2+ independent issues, create separate task trees per issue:
+
+```
+// Issue A tree
+TaskCreate(subject="[Issue A] Scout",      metadata={issue: "A", step: 1})
+TaskCreate(subject="[Issue A] Diagnose",   metadata={issue: "A", step: 2})
+TaskCreate(subject="[Issue A] Fix",        metadata={issue: "A", step: 3}, addBlockedBy=[A-step1, A-step2])
+TaskCreate(subject="[Issue A] Verify",     metadata={issue: "A", step: 4}, addBlockedBy=[A-step3])
+
+// Issue B tree
+TaskCreate(subject="[Issue B] Scout",      metadata={issue: "B", step: 1})
+TaskCreate(subject="[Issue B] Diagnose",   metadata={issue: "B", step: 2})
+TaskCreate(subject="[Issue B] Fix",        metadata={issue: "B", step: 3}, addBlockedBy=[B-step1, B-step2])
+TaskCreate(subject="[Issue B] Verify",     metadata={issue: "B", step: 4}, addBlockedBy=[B-step3])
+
+// Final shared task
+TaskCreate(subject="Integration verify",   addBlockedBy=[A-step4, B-step4])
+```
+
+Spawn `fullstack-developer` subagents per issue tree. Each agent:
+1. Claims tasks via `TaskUpdate(status="in_progress")`
+2. Completes tasks via `TaskUpdate(status="completed")`
+3. Blocked tasks auto-unblock when dependencies resolve
+
+## Subagent Task Assignment
+
+Assign tasks to subagents via `owner` field:
+
+```
+TaskUpdate(taskId=taskA, owner="agent-scout")
+TaskUpdate(taskId=taskB, owner="agent-diagnose")
+```
+
+Check available work: `TaskList()` → filter by `status=pending`, `blockedBy=[]`, `owner=null`
+
+## Rules
+
+- Create tasks BEFORE starting work (upfront planning)
+- Only 1 task `in_progress` per agent at a time
+- Mark complete IMMEDIATELY after finishing (don't batch)
+- Use `metadata` for filtering: `{step, phase, issue, severity}`
+- If task fails → keep `in_progress`, create subtask for blocker
+- Skip Tasks entirely for Quick workflow (< 3 steps)

package/templates/repo/.github/skills/fix/references/workflow-deep.md

@@ -1,91 +1,154 @@
 # Deep Workflow
 
-Full pipeline with research, brainstorming, and planning for complex issues.
+Full pipeline with research, brainstorming, and planning for complex issues. Uses native Tasks with dependency chains.
+
+## Task Setup (Before Starting)
+
+Create all phase tasks upfront. Steps 1+2+3 run in parallel (scout + diagnose + research).
+
+```
+T1 = TaskCreate(subject="Scout codebase",              activeForm="Scouting codebase",          metadata={phase: "investigate"})
+T2 = TaskCreate(subject="Diagnose root cause",          activeForm="Diagnosing root cause",      metadata={phase: "investigate"})
+T3 = TaskCreate(subject="Research solutions",            activeForm="Researching solutions",      metadata={phase: "investigate"})
+T4 = TaskCreate(subject="Brainstorm approaches",         activeForm="Brainstorming",              metadata={phase: "design"},       addBlockedBy=[T1, T2, T3])
+T5 = TaskCreate(subject="Create implementation plan",    activeForm="Planning implementation",    metadata={phase: "design"},       addBlockedBy=[T4])
+T6 = TaskCreate(subject="Implement fix",                 activeForm="Implementing fix",           metadata={phase: "implement"},    addBlockedBy=[T5])
+T7 = TaskCreate(subject="Verify + prevent",              activeForm="Verifying fix",              metadata={phase: "verify"},       addBlockedBy=[T6])
+T8 = TaskCreate(subject="Code review",                   activeForm="Reviewing code",             metadata={phase: "verify"},       addBlockedBy=[T7])
+T9 = TaskCreate(subject="Finalize & docs",               activeForm="Finalizing",                 metadata={phase: "finalize"},     addBlockedBy=[T8])
+```
 
 ## Steps
 
-### Step 1: Debug & Parallel Investigation
-Activate `debug` skill. Launch 2-3 `Explore` agents in parallel:
+### Step 1: Scout Codebase (parallel with Steps 2+3)
+`TaskUpdate(T1, status="in_progress")`
+
+**Mandatory:** Activate `scout` skill or launch 2-3 `Explore` subagents in parallel:
 ```
-Task("Explore", "Find error origin", "Trace error")
-Task("Explore", "Find affected components", "Map deps")
-Task("Explore", "Find similar patterns", "Find patterns")
+Task("Explore", "Find error origin and affected components", "Trace error")
+Task("Explore", "Find module boundaries and dependencies", "Map deps")
+Task("Explore", "Find related tests and similar patterns", "Find patterns")
 ```
+
+Map: all affected files, module boundaries, call chains, test coverage gaps.
+
 See `references/parallel-exploration.md` for patterns.
 
-**Output:** `✓ Step 1: Root cause - [summary], system impact: [scope]`
+`TaskUpdate(T1, status="completed")`
+**Output:** `✓ Step 1: Scouted - [N] files, system impact: [scope]`
+
+### Step 2: Diagnose Root Cause (parallel with Steps 1+3)
+`TaskUpdate(T2, status="in_progress")`
+
+**Mandatory skill chain:**
+1. **Capture pre-fix state:** Record ALL error messages, failing tests, stack traces, logs.
+2. Activate `debug` skill (systematic-debugging + root-cause-tracing).
+3. Activate `sequential-thinking` — structured hypothesis formation.
+4. Spawn parallel `Explore` subagents to test each hypothesis.
+5. If 2+ hypotheses fail → auto-activate `problem-solving`.
+6. Trace backward through call chain to ROOT CAUSE origin.
+
+See `references/diagnosis-protocol.md` for full methodology.
 
-### Step 2: Research
-Use `researcher` agent for external knowledge.
+`TaskUpdate(T2, status="completed")`
+**Output:** `✓ Step 2: Diagnosed - Root cause: [summary], Evidence: [chain]`
+
+### Step 3: Research (parallel with Steps 1+2)
+`TaskUpdate(T3, status="in_progress")`
+Use `researcher` subagent for external knowledge.
 
 - Search latest docs, best practices
 - Find similar issues/solutions
 - Gather security advisories if relevant
 
-**Output:** `✓ Step 2: Research complete - [key findings]`
+`TaskUpdate(T3, status="completed")`
+**Output:** `✓ Step 3: Research complete - [key findings]`
 
-### Step 3: Brainstorm
-Activate `brainstorming` skill.
+### Step 4: Brainstorm
+`TaskUpdate(T4, status="in_progress")` — auto-unblocks when T1 + T2 + T3 complete.
+Activate `brainstorm` skill.
 
-- Evaluate multiple approaches
+- Evaluate multiple approaches using scout + diagnosis + research findings
 - Consider trade-offs
 - Get user input on preferred direction
 
-**Output:** `✓ Step 3: Approach selected - [chosen approach]`
+`TaskUpdate(T4, status="completed")`
+**Output:** `✓ Step 4: Approach selected - [chosen approach]`
 
-### Step 4: Plan
-Use `planner` agent to create implementation plan.
+### Step 5: Plan
+`TaskUpdate(T5, status="in_progress")`
+Use `planner` subagent to create implementation plan.
 
 - Break down into phases
 - Identify dependencies
 - Define success criteria
+- Include prevention measures in plan
 
-**Output:** `✓ Step 4: Plan created - [N] phases`
+`TaskUpdate(T5, status="completed")`
+**Output:** `✓ Step 5: Plan created - [N] phases`
 
-### Step 5: Implement
+### Step 6: Implement
+`TaskUpdate(T6, status="in_progress")`
 Implement per plan. Use `context-engineering`, `sequential-thinking`, `problem-solving`.
 
-**Parallel Verification:** Launch `Bash` agents: typecheck + lint + build
-See `references/parallel-exploration.md`
+- Fix ROOT CAUSE per diagnosis — not symptoms
+- Follow plan phases
+- Minimal changes per phase
+
+`TaskUpdate(T6, status="completed")`
+**Output:** `✓ Step 6: Implemented - [N] files, [M] phases`
+
+### Step 7: Verify + Prevent
+`TaskUpdate(T7, status="in_progress")`
 
-**Output:** `✓ Step 5: Implemented - [N] files, [M] phases, verified`
+**Mandatory skill chain:**
+1. **Iron-law verify:** Re-run EXACT commands from pre-fix state. Compare before/after.
+2. **Regression test:** Add comprehensive tests. Tests MUST fail without fix, pass with fix.
+3. **Defense-in-depth:** Apply all relevant prevention layers (see `references/prevention-gate.md`).
+4. **Parallel verification:** Launch `Bash` agents: typecheck + lint + build + test.
+5. **Edge cases:** Test boundary conditions, security implications, performance impact.
 
-### Step 6: Test
-Use `tester` agent.
+**If verification fails:** Loop back to Step 2 (re-diagnose). Max 3 attempts → question architecture.
 
-- Comprehensive testing
-- Edge cases, security, performance
-- If fail → debug, fix, repeat
+See `references/prevention-gate.md` for prevention requirements.
 
-**Output:** `✓ Step 6: Tests [X/X passed]`
+`TaskUpdate(T7, status="completed")`
+**Output:** `✓ Step 7: Verified + Prevented - [before/after], [N] tests, [M] guards`
 
-### Step 7: Review
-Use `code-reviewer` agent.
+### Step 8: Code Review
+`TaskUpdate(T8, status="in_progress")`
+Use `code-reviewer` subagent.
 
 See `references/review-cycle.md` for mode-specific handling.
 
-**Output:** `✓ Step 7: Review [score]/10 - [status]`
+`TaskUpdate(T8, status="completed")`
+**Output:** `✓ Step 8: Review [score]/10 - [status]`
 
-### Step 8: Finalize
-- Use `project-manager` agent to update roadmap
-- Use `docs-manager` agent for documentation
-- Use `git-manager` agent for commit
+### Step 9: Finalize
+`TaskUpdate(T9, status="in_progress")`
+- Report summary: root cause, evidence chain, changes, prevention measures, confidence score
+- Activate `project-management` for task sync-back, plan status updates, and progress tracking
+- Use `docs-manager` subagent for documentation
+- Use `git-manager` subagent for commit
+- Run `/ck-journal`
 
-**Output:** `✓ Step 8: Complete - [actions taken]`
+`TaskUpdate(T9, status="completed")`
+**Output:** `✓ Step 9: Complete - [actions taken]`
 
-## Skills/Agents Activated
+## Skills/Subagents Activated
 
-| Step | Skills/Agents |
+| Step | Skills/Subagents |
 |------|------------------|
-| 1 | `debug`, parallel `Explore` agents for investigation |
-| 2 | `researcher` |
-| 3 | `brainstorm` |
-| 4 | `planner` |
-| 5 | `problem-solving`, `sequential-thinking`, `context-engineering`, parallel `Bash` |
-| 6 | `tester` |
-| 7 | `code-reviewer` |
-| 8 | `project-manager`, `docs-manager`, `Bash` |
+| 1 | `scout` OR parallel `Explore` subagents |
+| 2 | `debug`, `sequential-thinking`, parallel `Explore`, (`problem-solving` auto) |
+| 3 | `researcher` (runs parallel with steps 1+2) |
+| 4 | `brainstorm` |
+| 5 | `planner` |
+| 6 | `problem-solving`, `sequential-thinking`, `context-engineering` |
+| 7 | `tester`, parallel `Bash` verification |
+| 8 | `code-reviewer` |
+| 9 | `project-management`, `docs-manager`, `git-manager` |
 
 **Rules:** Don't skip steps. Validate before proceeding. One phase at a time.
-**Frontend:** Use `agent-browser` or browser automation tools to verify.
-**Visual Assets:** Use ImageMagick/FFmpeg CLI for image/video processing.
+**Frontend:** Use `chrome`, `chrome-devtools` (if available) or any relevant skills/tools to verify.
+**Visual Assets:** Use `ai-multimodal` (if available) for visual assets generation, analysis and verification.

package/templates/repo/.github/skills/fix/references/workflow-logs.md

@@ -1,6 +1,6 @@
 # Log Analysis Fix Workflow
 
-For fixing issues from application logs.
+For fixing issues from application logs. Uses native Tasks for phase tracking.
 
 ## Prerequisites
 - Log file at `./logs.txt` or similar
@@ -11,24 +11,60 @@ Add permanent log piping to project config:
 - **Bash/Unix**: `command 2>&1 | tee logs.txt`
 - **PowerShell**: `command *>&1 | Tee-Object logs.txt`
 
+## Task Setup (Before Starting)
+
+```
+T1 = TaskCreate(subject="Read & analyze logs",  activeForm="Analyzing logs")
+T2 = TaskCreate(subject="Scout codebase",        activeForm="Scouting codebase",    addBlockedBy=[T1])
+T3 = TaskCreate(subject="Plan fix",              activeForm="Planning fix",          addBlockedBy=[T1, T2])
+T4 = TaskCreate(subject="Implement fix",         activeForm="Implementing fix",      addBlockedBy=[T3])
+T5 = TaskCreate(subject="Test fix",              activeForm="Testing fix",           addBlockedBy=[T4])
+T6 = TaskCreate(subject="Code review",           activeForm="Reviewing code",        addBlockedBy=[T5])
+```
+
 ## Workflow
 
-1. **Read logs** with `Grep` (use `head_limit: 30` initially)
-   - Increase limit if insufficient context
+### Step 1: Read & Analyze Logs
+`TaskUpdate(T1, status="in_progress")`
+
+- Read logs with `Grep` (use `head_limit: 30` initially, increase if needed)
+- Use `debugger` agent for root cause analysis
+- Focus on last N lines first (most recent errors)
+- Look for stack traces, error codes, timestamps, repeated patterns
+
+`TaskUpdate(T1, status="completed")`
+
+### Step 2: Scout Codebase
+`TaskUpdate(T2, status="in_progress")`
+Use `scout` agent or parallel `Explore` subagents to find issue locations.
+
+See `references/parallel-exploration.md` for patterns.
+
+`TaskUpdate(T2, status="completed")`
+
+### Step 3: Plan Fix
+`TaskUpdate(T3, status="in_progress")` — auto-unblocks when T1 + T2 complete.
+Use `planner` agent.
 
-2. **Analyze** with `debugger` agent for root causes
+`TaskUpdate(T3, status="completed")`
 
-3. **Scout** codebase with `scout` agent for issue locations
+### Step 4: Implement
+`TaskUpdate(T4, status="in_progress")`
+Implement the fix.
 
-4. **Plan** fix with `planner` agent
+`TaskUpdate(T4, status="completed")`
 
-5. **Implement** the fix
+### Step 5: Test
+`TaskUpdate(T5, status="in_progress")`
+Use `tester` agent. If issues remain → keep T5 `in_progress`, loop back to Step 2.
 
-6. **Test** with `tester` agent
+`TaskUpdate(T5, status="completed")`
 
-7. **Review** with `code-reviewer` agent
+### Step 6: Review
+`TaskUpdate(T6, status="in_progress")`
+Use `code-reviewer` agent.
 
-8. **Iterate** if issues remain, repeat from step 3
+`TaskUpdate(T6, status="completed")`
 
 ## Tips
 - Focus on last N lines first (most recent errors)