english/.opencode/skills/cook/references/workflow-steps.md

Unified Workflow Steps

All modes share core steps with mode-specific variations.

Task Tool Fallback: TaskCreate/TaskUpdate/TaskGet/TaskList are CLI-only — unavailable in VSCode extension. If they error, use TodoWrite for progress tracking. All workflow steps remain functional without Task tools.

Step 0: Intent Detection & Setup

1. Parse input with intent-detection.md rules
2. Log detected mode: ✓ Step 0: Mode [X] - [reason]
3. If mode=code: detect plan path, set active plan
4. Use TaskCreate to create workflow step tasks (with dependencies if complex)

Output: ✓ Step 0: Mode [interactive|auto|fast|parallel|no-test|code] - [detection reason]

Step 1: Research (skip if fast/code mode)

Interactive/Auto:

• Spawn multiple researcher agents in parallel
• Use /ck:scout ext or scout agent for codebase search
• Keep reports ≤150 lines

Parallel:

• Optional: max 2 researchers if complex

Output: ✓ Step 1: Research complete - [N] reports gathered

[Review Gate 1] Post-Research (skip if auto mode)

• Present research summary to user
• Use AskUserQuestion to ask: "Proceed to planning?" / "Request more research" / "Abort"
• Auto mode: Skip this gate

Step 2: Planning

Interactive/Auto/No-test:

• Use planner agent with research context
• Create plan.md + phase-XX-*.md files

Fast:

• Use /ck:plan --fast with scout results only
• Minimal planning, focus on action

Parallel:

• Use /ck:plan --parallel for dependency graph + file ownership matrix

Code:

• Skip - plan already exists
• Parse existing plan for phases

Output: ✓ Step 2: Plan created - [N] phases

[Review Gate 2] Post-Plan (skip if auto mode)

• Present plan overview with phases
• Use AskUserQuestion to ask: "Validate the plan or approve plan to start implementation?" - "Validate" / "Approve" / "Abort" / "Other" ("Request revisions")
  • "Validate": run /ck:plan validate skill invocation
  • "Approve": continue to implementation
  • "Abort": stop the workflow
  • "Other": revise the plan based on user's feedback
• Auto mode: Skip this gate

Step 3: Implementation

IMPORTANT:

1. TaskList first — check for existing tasks (hydrated by planning skill in same session)
2. If tasks exist → pick them up, skip re-creation
3. If no tasks → read plan phases, TaskCreate for each unchecked [ ] item with priority order and metadata (phase, planDir, phaseFile)
4. Tasks can be blocked by other tasks via addBlockedBy

All modes:

• Use TaskUpdate to mark tasks as in_progress immediately.
• Execute phase tasks sequentially (Step 3.1, 3.2, etc.)
• Use ui-ux-designer for frontend
• Use ck:ai-multimodal for image assets
• Run type checking after each file

Parallel mode:

• Utilize all tools of Claude Tasks: TaskCreate, TaskUpdate, TaskGet and TaskList
• Launch multiple fullstack-developer agents
• When agents pick up a task, use TaskUpdate to assign task to agent and mark tasks as in_progress immediately.
• Respect file ownership boundaries
• Wait for parallel group before next

Output: ✓ Step 3: Implemented [N] files - [X/Y] tasks complete

[Review Gate 3] Post-Implementation (skip if auto mode)

• Present implementation summary (files changed, key changes)
• Use AskUserQuestion to ask: "Proceed to testing?" / "Request implementation changes" / "Abort"
• Auto mode: Skip this gate

Step 4: Testing (skip if no-test mode)

All modes (except no-test):

• Write tests: happy path, edge cases, errors
• MUST spawn tester subagent: Task(subagent_type="tester", prompt="Run test suite", description="Run tests")
• If failures: MUST spawn debugger subagent → fix → repeat
• Forbidden: fake mocks, commented tests, changed assertions, skipping subagent delegation

Output: ✓ Step 4: Tests [X/X passed] - tester subagent invoked

[Review Gate 4] Post-Testing (skip if auto mode)

• Present test results summary
• Use AskUserQuestion to ask: "Proceed to code review?" / "Request test fixes" / "Abort"
• Auto mode: Skip this gate

Step 5: Code Review

All modes - MANDATORY subagent:

• MUST spawn code-reviewer subagent: Task(subagent_type="code-reviewer", prompt="Review changes. Return score, critical issues, warnings.", description="Code review")
• DO NOT review code yourself - delegate to subagent

Interactive/Parallel/Code/No-test:

• Interactive cycle (max 3): see review-cycle.md
• Requires user approval

Auto:

• Auto-approve if score≥9.5 AND 0 critical
• Auto-fix critical (max 3 cycles)
• Escalate to user after 3 failed cycles

Fast:

• Simplified review, no fix loop
• User approves or aborts

Output: ✓ Step 5: Review [score]/10 - [Approved|Auto-approved] - code-reviewer subagent invoked

Step 6: Finalize

All modes - MANDATORY subagents (NON-NEGOTIABLE):

1. MUST spawn these subagents in parallel:
   • Task(subagent_type="project-manager", prompt="Run full sync-back for [plan-path]: reconcile all completed Claude Tasks with all phase files, backfill stale completed checkboxes across every phase, then update plan.md frontmatter/table progress. Do NOT only mark current phase.", description="Update plan")
   • Task(subagent_type="docs-manager", prompt="Update docs for changes.", description="Update docs")
2. Project-manager sync-back MUST include:

Status Sync (Finalize)

Use CLI commands for deterministic status updates:

# Mark completed phases
ck plan check <phase-id>

# Mark in-progress phases
ck plan check <phase-id> --start

# Revert if needed
ck plan uncheck <phase-id>

Fallback: If ck is not available, edit plan.md directly — only change the Status column cell, preserve table structure.

• Sweep all phase-XX-*.md files in the plan directory.
• Mark every completed item [ ] → [x] based on completed tasks (including earlier phases finished before current phase).
• Update plan.md status/progress (pending/in-progress/completed) from actual checkbox state.
• Return unresolved mappings if any completed task cannot be matched to a phase file.

3. Use TaskUpdate to mark Claude Tasks complete after sync-back confirmation.
4. Onboarding check (API keys, env vars)
5. MUST spawn git subagent: Task(subagent_type="git-manager", prompt="Stage and commit changes", description="Commit")

CRITICAL: Step 6 is INCOMPLETE without spawning all 3 subagents. DO NOT skip subagent delegation.

Auto mode: Continue to next phase automatically, start from Step 3. Others: Ask user before next phase

Output: ✓ Step 6: Finalized - 3 subagents invoked - Full-plan sync-back completed - Committed

Mode-Specific Flow Summary

Legend: [R] = Review Gate (human approval required)

interactive: 0 → 1 → [R] → 2 → [R] → 3 → [R] → 4 → [R] → 5(user) → 6
auto:        0 → 1 → 2 → 3 → 4 → 5(auto) → 6 → next phase (NO stops)
fast:        0 → skip → 2(fast) → [R] → 3 → [R] → 4 → [R] → 5(simple) → 6
parallel:    0 → 1? → [R] → 2(parallel) → [R] → 3(multi-agent) → [R] → 4 → [R] → 5(user) → 6
no-test:     0 → 1 → [R] → 2 → [R] → 3 → [R] → skip → 5(user) → 6
code:        0 → skip → skip → 3 → [R] → 4 → [R] → 5(user) → 6

Key difference: auto mode is the ONLY mode that skips all review gates.

Critical Rules

• Never skip steps without mode justification
• MANDATORY SUBAGENT DELEGATION: Steps 4, 5, 6 MUST spawn subagents via Task tool. DO NOT implement directly.
  • Step 4: tester (and debugger if failures)
  • Step 5: code-reviewer
  • Step 6: project-manager, docs-manager, git-manager
• Use TaskCreate to create Claude Tasks for each unchecked item with priority order and dependencies (or TodoWrite if Task tools unavailable).
• Use TaskUpdate to mark Claude Tasks in_progress when picking up a task (skip if Task tools unavailable).
• Use TaskUpdate to mark Claude Tasks complete immediately after finalizing the task (skip if Task tools unavailable).
• All step outputs follow format: ✓ Step [N]: [status] - [metrics]
• VALIDATION: If Task tool calls = 0 at end of workflow, the workflow is INCOMPLETE.