cokit-cli 1.3.0 → 1.4.0

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

@@ -1,110 +0,0 @@
-# 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-ci.md

@@ -1,28 +0,0 @@
-# CI/CD Fix Workflow
-
-For GitHub Actions failures and CI/CD pipeline issues.
-
-## Prerequisites
-- `gh` CLI installed and authorized
-- GitHub Actions URL or run ID
-
-## Workflow
-
-1. **Fetch logs** with `debugger` agent:
-   ```bash
-   gh run view <run-id> --log-failed
-   gh run view <run-id> --log
-   ```
-
-2. **Analyze** root cause from logs
-
-3. **Implement fix** based on analysis
-
-4. **Test locally** with `tester` agent before pushing
-
-5. **Iterate** if tests fail, repeat from step 3
-
-## Notes
-- If `gh` unavailable, instruct user to install: `gh auth login`
-- Check both failed step and preceding steps for context
-- Common issues: env vars, dependencies, permissions, timeouts

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

@@ -1,154 +0,0 @@
-# Deep Workflow
-
-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: 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 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.
-
-`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.
-
-`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
-
-`TaskUpdate(T3, status="completed")`
-**Output:** `✓ Step 3: Research complete - [key findings]`
-
-### Step 4: Brainstorm
-`TaskUpdate(T4, status="in_progress")` — auto-unblocks when T1 + T2 + T3 complete.
-Activate `brainstorm` skill.
-
-- Evaluate multiple approaches using scout + diagnosis + research findings
-- Consider trade-offs
-- Get user input on preferred direction
-
-`TaskUpdate(T4, status="completed")`
-**Output:** `✓ Step 4: Approach selected - [chosen approach]`
-
-### 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
-
-`TaskUpdate(T5, status="completed")`
-**Output:** `✓ Step 5: Plan created - [N] phases`
-
-### Step 6: Implement
-`TaskUpdate(T6, status="in_progress")`
-Implement per plan. Use `context-engineering`, `sequential-thinking`, `problem-solving`.
-
-- 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")`
-
-**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.
-
-**If verification fails:** Loop back to Step 2 (re-diagnose). Max 3 attempts → question architecture.
-
-See `references/prevention-gate.md` for prevention requirements.
-
-`TaskUpdate(T7, status="completed")`
-**Output:** `✓ Step 7: Verified + Prevented - [before/after], [N] tests, [M] guards`
-
-### Step 8: Code Review
-`TaskUpdate(T8, status="in_progress")`
-Use `code-reviewer` subagent.
-
-See `references/review-cycle.md` for mode-specific handling.
-
-`TaskUpdate(T8, status="completed")`
-**Output:** `✓ Step 8: Review [score]/10 - [status]`
-
-### 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`
-
-`TaskUpdate(T9, status="completed")`
-**Output:** `✓ Step 9: Complete - [actions taken]`
-
-## Skills/Subagents Activated
-
-| Step | Skills/Subagents |
-|------|------------------|
-| 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 `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,72 +0,0 @@
-# Log Analysis Fix Workflow
-
-For fixing issues from application logs. Uses native Tasks for phase tracking.
-
-## Prerequisites
-- Log file at `./logs.txt` or similar
-
-## Setup (if logs missing)
-
-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
-
-### 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.
-
-`TaskUpdate(T3, status="completed")`
-
-### Step 4: Implement
-`TaskUpdate(T4, status="in_progress")`
-Implement the fix.
-
-`TaskUpdate(T4, status="completed")`
-
-### Step 5: Test
-`TaskUpdate(T5, status="in_progress")`
-Use `tester` agent. If issues remain → keep T5 `in_progress`, loop back to Step 2.
-
-`TaskUpdate(T5, status="completed")`
-
-### Step 6: Review
-`TaskUpdate(T6, status="in_progress")`
-Use `code-reviewer` agent.
-
-`TaskUpdate(T6, status="completed")`
-
-## Tips
-- Focus on last N lines first (most recent errors)
-- Look for stack traces, error codes, timestamps
-- Check for patterns/repeated errors

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

@@ -1,82 +0,0 @@
-# Quick Workflow
-
-Fast scout-diagnose-fix-verify cycle for simple issues.
-
-## Steps
-
-### Step 1: Scout (Minimal)
-Locate affected file(s) and their direct dependencies only.
-- Read error message → identify file path
-- Check direct imports/dependencies of affected file
-- Skip full codebase mapping
-
-**Output:** `✓ Step 1: Scouted - [file], [N] direct deps`
-
-### Step 2: Diagnose (Abbreviated)
-Activate `debug` skill. Activate `sequential-thinking` for structured analysis.
-
-- Read error message/logs
-- **Capture pre-fix state:** Record exact error output (this is your verification baseline)
-- Identify root cause (usually obvious for simple issues)
-- Skip parallel hypothesis testing for trivial cases
-
-**Output:** `✓ Step 2: Diagnosed - Root cause: [brief description]`
-
-### Step 3: Fix & Verify
-Implement the fix directly.
-- Make minimal changes
-- Follow existing patterns
-
-**Parallel Verification:**
-Launch `Bash` agents in parallel:
-```
-Task("Bash", "Run typecheck", "Verify types")
-Task("Bash", "Run lint", "Verify lint")
-```
-
-**Before/After comparison:** Re-run the EXACT command from pre-fix state capture. Compare output.
-
-See `references/parallel-exploration.md` for patterns.
-
-**Output:** `✓ Step 3: Fixed - [N] files, verified (types/lint passed)`
-
-### Step 4: Review + Prevent
-Use `code-reviewer` subagent for quick review.
-
-Prompt: "Quick review of fix for [issue]. Check: correctness, security, no regressions. Score X/10."
-
-**Prevention (abbreviated for Quick):**
-- Type errors/lint: type system IS the test → regression test optional
-- Bug fixes: add at least 1 test covering the fixed scenario
-- Still require before/after comparison of verification output
-
-**Review handling:** See `references/review-cycle.md`
-
-**Output:** `✓ Step 4: Review [score]/10 - [prevention measures]`
-
-### Step 5: Complete
-Report summary to user.
-
-**If autonomous mode:** Ask to commit via `git-manager` subagent if score >= 9.0
-**If HITL mode:** Ask user next action
-
-**Output:** `✓ Step 5: Complete - [action]`
-
-## Skills/Subagents Activated
-
-| Step | Skills/Subagents |
-|------|------------------|
-| 1 | `scout` (minimal) or direct file read |
-| 2 | `debug`, `sequential-thinking` |
-| 3 | Parallel `Bash` for verification |
-| 4 | `code-reviewer` subagent |
-| 5 | `git-manager` subagent |
-
-**Extra:** `context-engineering` if dealing with AI/LLM code
-
-## Notes
-
-- Skip if review fails → escalate to Standard workflow
-- Total steps: 5
-- No planning phase needed
-- Pre-fix state capture is STILL mandatory (even for quick fixes)

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

@@ -1,120 +0,0 @@
-# Standard Workflow
-
-Full pipeline for moderate complexity issues. Uses native Tasks for phase tracking.
-
-## Task Setup (Before Starting)
-
-Create all phase tasks upfront with dependencies. See `references/task-orchestration.md`.
-
-```
-T1 = TaskCreate(subject="Scout codebase",        activeForm="Scouting codebase")
-T2 = TaskCreate(subject="Diagnose root cause",    activeForm="Diagnosing root cause")
-T3 = TaskCreate(subject="Implement fix",          activeForm="Implementing fix",    addBlockedBy=[T1, T2])
-T4 = TaskCreate(subject="Verify + prevent",       activeForm="Verifying fix",       addBlockedBy=[T3])
-T5 = TaskCreate(subject="Code review",            activeForm="Reviewing code",      addBlockedBy=[T4])
-T6 = TaskCreate(subject="Finalize",               activeForm="Finalizing",          addBlockedBy=[T5])
-```
-
-## Steps
-
-### Step 1: Scout Codebase
-`TaskUpdate(T1, status="in_progress")`
-
-**Mandatory skill chain:**
-1. Activate `scout` skill OR launch 2-3 parallel `Explore` subagents.
-2. Map: affected files, module boundaries, dependencies, related tests, recent git changes.
-
-**Pattern:** In SINGLE message, launch 2-3 Explore agents:
-```
-Task("Explore", "Find [area1] files related to issue", "Scout area1")
-Task("Explore", "Find [area2] patterns/usage", "Scout area2")
-Task("Explore", "Find [area3] tests/dependencies", "Scout area3")
-```
-
-See `references/parallel-exploration.md` for patterns.
-
-`TaskUpdate(T1, status="completed")`
-**Output:** `✓ Step 1: Scouted [N] areas - [M] files, [K] tests found`
-
-### Step 2: Diagnose Root Cause
-`TaskUpdate(T2, status="in_progress")`
-
-**Mandatory skill chain:**
-1. **Capture pre-fix state:** Record exact error messages, failing test output, stack traces.
-2. Activate `debug` skill. Use `debugger` subagent if needed.
-3. Activate `sequential-thinking` — form hypotheses through structured reasoning.
-4. Spawn parallel `Explore` subagents to test hypotheses against codebase evidence.
-5. If 2+ hypotheses fail → auto-activate `problem-solving`.
-6. Trace backward to root cause (not just symptom location).
-
-See `references/diagnosis-protocol.md` for full methodology.
-
-`TaskUpdate(T2, status="completed")`
-**Output:** `✓ Step 2: Diagnosed - Root cause: [summary], Evidence: [brief], Scope: [N files]`
-
-### Step 3: Implement Fix
-`TaskUpdate(T3, status="in_progress")` — auto-unblocked when T1 + T2 complete.
-
-Fix the ROOT CAUSE per diagnosis findings. Not symptoms.
-
-- Apply `problem-solving` skill if stuck
-- Use `sequential-thinking` for complex logic
-- Minimal changes. Follow existing patterns.
-
-`TaskUpdate(T3, status="completed")`
-**Output:** `✓ Step 3: Implemented - [N] files changed`
-
-### Step 4: Verify + Prevent
-`TaskUpdate(T4, status="in_progress")`
-
-**Mandatory skill chain:**
-1. **Iron-law verify:** Re-run the EXACT commands from pre-fix state capture. Compare before/after.
-2. **Regression test:** Add/update test(s) covering the fixed issue. Test MUST fail without fix, pass with fix.
-3. **Defense-in-depth:** Apply prevention layers where applicable (see `references/prevention-gate.md`).
-4. **Parallel verification:** Launch `Bash` agents:
-```
-Task("Bash", "Run typecheck", "Verify types")
-Task("Bash", "Run lint", "Verify lint")
-Task("Bash", "Run build", "Verify build")
-Task("Bash", "Run tests", "Verify tests")
-```
-
-**If verification fails:** Loop back to Step 2 (re-diagnose). Max 3 attempts.
-
-`TaskUpdate(T4, status="completed")`
-**Output:** `✓ Step 4: Verified + Prevented - [before/after], [N] tests added, [M] guards`
-
-### Step 5: Code Review
-`TaskUpdate(T5, status="in_progress")`
-Use `code-reviewer` subagent.
-
-See `references/review-cycle.md` for mode-specific handling.
-
-`TaskUpdate(T5, status="completed")`
-**Output:** `✓ Step 5: Review [score]/10 - [status]`
-
-### Step 6: Finalize
-`TaskUpdate(T6, status="in_progress")`
-- Report summary: root cause, changes, prevention measures, confidence score
-- Activate `project-management` for task sync-back and plan status updates
-- Update docs if needed via `docs-manager`
-- Ask to commit via `git-manager` subagent
-- Run `/ck-journal`
-
-`TaskUpdate(T6, status="completed")`
-**Output:** `✓ Step 6: Complete - [action]`
-
-## Skills/Subagents Activated
-
-| Step | Skills/Subagents |
-|------|------------------|
-| 1 | `scout` OR parallel `Explore` subagents |
-| 2 | `debug`, `sequential-thinking`, `debugger` subagent, parallel `Explore`, (`problem-solving` auto) |
-| 3 | `problem-solving` (if stuck), `sequential-thinking` (complex logic) |
-| 4 | `tester` subagent, parallel `Bash` verification |
-| 5 | `code-reviewer` subagent |
-| 6 | `project-management`, `git-manager`, `docs-manager` subagents |
-
-**Rules:** Don't skip steps. Validate before proceeding. One phase at a time.
-**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-test.md

@@ -1,75 +0,0 @@
-# Test Failure Fix Workflow
-
-For fixing failing tests and test suite issues. Uses native Tasks for phase tracking.
-
-## Task Setup (Before Starting)
-
-```
-T1 = TaskCreate(subject="Compile & collect failures", activeForm="Compiling and collecting failures")
-T2 = TaskCreate(subject="Debug root causes",          activeForm="Debugging test failures",       addBlockedBy=[T1])
-T3 = TaskCreate(subject="Plan fixes",                 activeForm="Planning fixes",                addBlockedBy=[T2])
-T4 = TaskCreate(subject="Implement fixes",             activeForm="Implementing fixes",            addBlockedBy=[T3])
-T5 = TaskCreate(subject="Re-test",                     activeForm="Re-running tests",              addBlockedBy=[T4])
-T6 = TaskCreate(subject="Code review",                 activeForm="Reviewing code",                addBlockedBy=[T5])
-```
-
-## Workflow
-
-### Step 1: Compile & Collect Failures
-`TaskUpdate(T1, status="in_progress")`
-Use `tester` agent. Fix all syntax errors before running tests.
-
-- Run full test suite, collect all failures
-- Group failures by module/area
-
-`TaskUpdate(T1, status="completed")`
-
-### Step 2: Debug
-`TaskUpdate(T2, status="in_progress")`
-Use `debugger` agent for root cause analysis.
-
-- Analyze each failure group
-- Identify shared root causes across failures
-
-`TaskUpdate(T2, status="completed")`
-
-### Step 3: Plan
-`TaskUpdate(T3, status="in_progress")`
-Use `planner` agent for fix strategy.
-
-- Prioritize fixes (shared root causes first)
-- Identify dependencies between fixes
-
-`TaskUpdate(T3, status="completed")`
-
-### Step 4: Implement
-`TaskUpdate(T4, status="in_progress")`
-Implement fixes step by step per plan.
-
-`TaskUpdate(T4, status="completed")`
-
-### Step 5: Re-test
-`TaskUpdate(T5, status="in_progress")`
-Use `tester` agent. If tests still fail → keep T5 `in_progress`, loop back to Step 2.
-
-`TaskUpdate(T5, status="completed")`
-
-### Step 6: Review
-`TaskUpdate(T6, status="in_progress")`
-Use `code-reviewer` agent.
-
-`TaskUpdate(T6, status="completed")`
-
-## Common Commands
-```bash
-npm test
-bun test
-pytest
-go test ./...
-```
-
-## Tips
-- Run single failing test first for faster iteration
-- Check test assertions vs actual behavior
-- Verify test fixtures/mocks are correct
-- Don't modify tests to pass unless test is wrong