cokit-cli 1.3.0 → 1.4.0

package/skills/fix/references/diagnosis-protocol.md

@@ -1,133 +0,0 @@
-# Diagnosis Protocol
-
-Structured root cause analysis methodology. Replaces ad-hoc guessing with evidence-based investigation.
-
-## Core Principle
-
-**NEVER guess root causes.** Form hypotheses through structured reasoning and test them against evidence.
-
-## Pre-Diagnosis: Capture State (MANDATORY)
-
-Before any investigation, capture the current broken state as baseline:
-
-```
-1. Record exact error messages (copy-paste, not paraphrase)
-2. Record failing test output (full command + output)
-3. Record relevant stack traces
-4. Record relevant log snippets with timestamps
-5. Record git status / recent changes: git log --oneline -10
-```
-
-This baseline is required for Step 5 (Verify) — you MUST compare before/after.
-
-## Diagnosis Chain (Follow in Order)
-
-### Phase 1: Observe — What is actually happening?
-
-Read, don't assume. Use `debug` (systematic-debugging Phase 1).
-
-- What is the exact error message?
-- Where does it occur? (file, line, function)
-- When did it start? (check `git log`, `git bisect`)
-- Can it be reproduced consistently?
-- What is the expected vs actual behavior?
-
-### Phase 2: Hypothesize — Why might this happen?
-
-Activate `sequential-thinking` skill. Form hypotheses through structured reasoning.
-
-**Structured hypothesis formation:**
-```
-For each hypothesis:
-  1. State the hypothesis clearly
-  2. What evidence would CONFIRM it?
-  3. What evidence would REFUTE it?
-  4. How to test it quickly?
-```
-
-**Common hypothesis categories:**
-- Recent code change introduced regression (`git log`, `git diff`)
-- Data/state mismatch (wrong input, stale cache, race condition)
-- Environment difference (deps version, config, platform)
-- Missing validation (null check, type guard, boundary)
-- Incorrect assumption (API contract, data shape, ordering)
-
-### Phase 3: Test — Verify hypotheses against evidence
-
-Spawn parallel `Explore` subagents to test each hypothesis simultaneously:
-
-```
-// Launch in SINGLE message — max 3 parallel agents
-Task("Explore", "Test hypothesis A: [specific search/check]", "Verify H-A")
-Task("Explore", "Test hypothesis B: [specific search/check]", "Verify H-B")
-Task("Explore", "Test hypothesis C: [specific search/check]", "Verify H-C")
-```
-
-**For each hypothesis result:**
-- CONFIRMED: Evidence supports this as root cause → proceed to root cause tracing
-- REFUTED: Evidence contradicts → discard, note why
-- INCONCLUSIVE: Need more data → refine hypothesis or gather more evidence
-
-### Phase 4: Trace — Follow the root cause chain
-
-Use `debug` (root-cause-tracing technique). Trace backward:
-
-```
-Symptom (where error appears)
-  ↑ Immediate cause (what triggered the error)
-    ↑ Contributing factor (what set up the bad state)
-      ↑ ROOT CAUSE (the original trigger that must be fixed)
-```
-
-**Rule:** NEVER fix where the error appears. Trace back to the source.
-
-### Phase 5: Escalate — When hypotheses fail
-
-If 2+ hypotheses are REFUTED:
-1. Auto-activate `problem-solving` skill
-2. Apply Inversion Exercise: "What would CAUSE this bug intentionally?"
-3. Apply Scale Game: "Does this fail with 1 item? 100? 10000?"
-4. Consider environmental factors (timing, concurrency, platform)
-
-If 3+ fix attempts fail after diagnosis:
-1. STOP immediately
-2. Question the architecture — is the design fundamentally flawed?
-3. Discuss with user before attempting more
-
-## Diagnosis Report Format
-
-```markdown
-## Diagnosis Report
-
-**Issue:** [one-line description]
-**Pre-fix state captured:** Yes/No
-
-### Root Cause
-[Clear explanation of the root cause, traced back to origin]
-
-### Evidence Chain
-1. [Observation] → led to hypothesis [X]
-2. [Test result] → confirmed/refuted [X]
-3. [Trace] → root cause at [file:line]
-
-### Affected Scope
-- Files: [list]
-- Functions: [list]
-- Dependencies: [list]
-
-### Recommended Fix
-[What to change and why — addressing root cause, not symptoms]
-
-### Prevention Needed
-[What guards/tests to add to prevent recurrence]
-```
-
-## Quick Mode Diagnosis
-
-For trivial issues (type errors, lint, syntax), abbreviated diagnosis:
-
-1. Read error message
-2. Locate affected file(s) via scout results
-3. Identify root cause (usually obvious for simple issues)
-4. Skip parallel hypothesis testing
-5. Still capture pre-fix state for verification

package/skills/fix/references/prevention-gate.md

@@ -1,87 +0,0 @@
-# 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/skills/fix/references/skill-activation-matrix.md

@@ -1,98 +0,0 @@
-# Skill Activation Matrix
-
-When to activate each skill and tool during fixing workflows.
-
-## Always Activate (ALL Workflows)
-
-| 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 |
-|-------|---------------|
-| `brainstorm` | Multiple valid fix approaches, architecture decision (Deep only) |
-| `context-engineering` | Fixing AI/LLM/agent code, context window issues |
-| `ai-multimodal` (if available) | UI issues, screenshots provided, visual bugs |
-| `project-management` | Moderate+ workflows — task hydration, sync-back, progress tracking |
-
-## Subagent Usage
-
-| Subagent | Activate When |
-|----------|---------------|
-| `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
-
-See `references/parallel-exploration.md` for detailed patterns.
-
-| When | Parallel Strategy |
-|------|-------------------|
-| 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 (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 | `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
-
-| Keyword/Pattern | Skill to Consider |
-|-----------------|-------------------|
-| "AI", "LLM", "agent", "context" | `context-engineering` |
-| "stuck", "tried everything" | `problem-solving` |
-| "complex", "multi-step" | `sequential-thinking` |
-| "which approach", "options" | `brainstorm` |
-| "latest docs", "best practice" | `researcher` subagent |
-| Screenshot attached | `ai-multimodal` (if available) |

package/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/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/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/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