claude-code-workflow 7.2.11 → 7.2.12

package/.claude/commands/idaw/run-coordinate.md

@@ -1,648 +0,0 @@
----
-name: run-coordinate
-description: IDAW coordinator - execute task skill chains via external CLI with hook callbacks and git checkpoints
-argument-hint: "[-y|--yes] [--task <id>[,<id>,...]] [--dry-run] [--tool <tool>]"
-allowed-tools: Agent(*), AskUserQuestion(*), Read(*), Write(*), Bash(*), Glob(*), Grep(*)
----
-
-# IDAW Run Coordinate Command (/idaw:run-coordinate)
-
-Coordinator variant of `/idaw:run`: external CLI execution with background tasks and hook callbacks.
-
-**Execution Model**: `ccw cli -p "..." --tool <tool> --mode write` in background → hook callback → next step.
-
-**vs `/idaw:run`**: Direct `Skill()` calls (blocking, main process) vs `ccw cli` (background, external process).
-
-## When to Use
-
-| Scenario | Use |
-|----------|-----|
-| Standard IDAW execution (main process) | `/idaw:run` |
-| External CLI execution (background, hook-driven) | `/idaw:run-coordinate` |
-| Need `claude` or `gemini` as execution tool | `/idaw:run-coordinate --tool claude` |
-| Long-running tasks, avoid context window pressure | `/idaw:run-coordinate` |
-
-## Skill Chain Mapping
-
-```javascript
-const SKILL_CHAIN_MAP = {
-  'bugfix':          ['workflow-lite-plan', 'workflow-test-fix'],
-  'bugfix-hotfix':   ['workflow-lite-plan'],
-  'feature':         ['workflow-lite-plan', 'workflow-test-fix'],
-  'feature-complex': ['workflow-plan', 'workflow-execute', 'workflow-test-fix'],
-  'refactor':        ['workflow:refactor-cycle'],
-  'tdd':             ['workflow-tdd-plan', 'workflow-execute'],
-  'test':            ['workflow-test-fix'],
-  'test-fix':        ['workflow-test-fix'],
-  'review':          ['review-cycle'],
-  'docs':            ['workflow-lite-plan']
-};
-```
-
-## Task Type Inference
-
-```javascript
-function inferTaskType(title, description) {
-  const text = `${title} ${description}`.toLowerCase();
-  if (/urgent|production|critical/.test(text) && /fix|bug/.test(text)) return 'bugfix-hotfix';
-  if (/refactor|重构|tech.*debt/.test(text)) return 'refactor';
-  if (/tdd|test-driven|test first/.test(text)) return 'tdd';
-  if (/test fail|fix test|failing test/.test(text)) return 'test-fix';
-  if (/generate test|写测试|add test/.test(text)) return 'test';
-  if (/review|code review/.test(text)) return 'review';
-  if (/docs|documentation|readme/.test(text)) return 'docs';
-  if (/fix|bug|error|crash|fail/.test(text)) return 'bugfix';
-  if (/complex|multi-module|architecture/.test(text)) return 'feature-complex';
-  return 'feature';
-}
-```
-
-## 6-Phase Execution (Coordinator Model)
-
-### Phase 1: Load Tasks
-
-```javascript
-const args = $ARGUMENTS;
-const autoYes = /(-y|--yes)/.test(args);
-const dryRun = /--dry-run/.test(args);
-const taskFilter = args.match(/--task\s+([\w,-]+)/)?.[1]?.split(',') || null;
-const cliTool = args.match(/--tool\s+(\w+)/)?.[1] || 'claude';
-
-// Load task files
-const taskFiles = Glob('.workflow/.idaw/tasks/IDAW-*.json') || [];
-
-if (taskFiles.length === 0) {
-  console.log('No IDAW tasks found. Use /idaw:add to create tasks.');
-  return;
-}
-
-// Parse and filter
-let tasks = taskFiles.map(f => JSON.parse(Read(f)));
-
-if (taskFilter) {
-  tasks = tasks.filter(t => taskFilter.includes(t.id));
-} else {
-  tasks = tasks.filter(t => t.status === 'pending');
-}
-
-if (tasks.length === 0) {
-  console.log('No pending tasks to execute. Use /idaw:add to add tasks or --task to specify IDs.');
-  return;
-}
-
-// Sort: priority ASC (1=critical first), then ID ASC
-tasks.sort((a, b) => {
-  if (a.priority !== b.priority) return a.priority - b.priority;
-  return a.id.localeCompare(b.id);
-});
-```
-
-### Phase 2: Session Setup
-
-```javascript
-// Generate session ID: IDA-{slug}-YYYYMMDD
-const slug = tasks[0].title
-  .toLowerCase()
-  .replace(/[^a-z0-9]+/g, '-')
-  .substring(0, 20)
-  .replace(/-$/, '');
-const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, '');
-let sessionId = `IDA-${slug}-${dateStr}`;
-
-// Check collision
-const existingSession = Glob(`.workflow/.idaw/sessions/${sessionId}/session.json`);
-if (existingSession?.length > 0) {
-  sessionId = `${sessionId}-2`;
-}
-
-const sessionDir = `.workflow/.idaw/sessions/${sessionId}`;
-Bash(`mkdir -p "${sessionDir}"`);
-
-const session = {
-  session_id: sessionId,
-  mode: 'coordinate',  // ★ Marks this as coordinator-mode session
-  cli_tool: cliTool,
-  status: 'running',
-  created_at: new Date().toISOString(),
-  updated_at: new Date().toISOString(),
-  tasks: tasks.map(t => t.id),
-  current_task: null,
-  current_skill_index: 0,
-  completed: [],
-  failed: [],
-  skipped: [],
-  prompts_used: []
-};
-
-Write(`${sessionDir}/session.json`, JSON.stringify(session, null, 2));
-
-// Initialize progress.md
-const progressHeader = `# IDAW Progress — ${sessionId} (coordinate mode)\nStarted: ${session.created_at}\nCLI Tool: ${cliTool}\n\n`;
-Write(`${sessionDir}/progress.md`, progressHeader);
-```
-
-### Phase 3: Startup Protocol
-
-```javascript
-// Check for existing running sessions
-const runningSessions = Glob('.workflow/.idaw/sessions/IDA-*/session.json')
-  ?.map(f => { try { return JSON.parse(Read(f)); } catch { return null; } })
-  .filter(s => s && s.status === 'running' && s.session_id !== sessionId) || [];
-
-if (runningSessions.length > 0 && !autoYes) {
-  const answer = AskUserQuestion({
-    questions: [{
-      question: `Found running session: ${runningSessions[0].session_id}. How to proceed?`,
-      header: 'Conflict',
-      multiSelect: false,
-      options: [
-        { label: 'Resume existing', description: 'Use /idaw:resume instead' },
-        { label: 'Start fresh', description: 'Continue with new session' },
-        { label: 'Abort', description: 'Cancel this run' }
-      ]
-    }]
-  });
-  if (answer.answers?.Conflict === 'Resume existing') {
-    console.log(`Use: /idaw:resume ${runningSessions[0].session_id}`);
-    return;
-  }
-  if (answer.answers?.Conflict === 'Abort') return;
-}
-
-// Check git status
-const gitStatus = Bash('git status --porcelain 2>/dev/null');
-if (gitStatus?.trim() && !autoYes) {
-  const answer = AskUserQuestion({
-    questions: [{
-      question: 'Working tree has uncommitted changes. How to proceed?',
-      header: 'Git',
-      multiSelect: false,
-      options: [
-        { label: 'Continue', description: 'Proceed with dirty tree' },
-        { label: 'Stash', description: 'git stash before running' },
-        { label: 'Abort', description: 'Stop and handle manually' }
-      ]
-    }]
-  });
-  if (answer.answers?.Git === 'Stash') Bash('git stash push -m "idaw-pre-run"');
-  if (answer.answers?.Git === 'Abort') return;
-}
-
-// Dry run
-if (dryRun) {
-  console.log(`# Dry Run — ${sessionId} (coordinate mode, tool: ${cliTool})\n`);
-  for (const task of tasks) {
-    const taskType = task.task_type || inferTaskType(task.title, task.description);
-    const chain = task.skill_chain || SKILL_CHAIN_MAP[taskType] || SKILL_CHAIN_MAP['feature'];
-    console.log(`## ${task.id}: ${task.title}`);
-    console.log(`  Type: ${taskType} | Priority: ${task.priority}`);
-    console.log(`  Chain: ${chain.join(' → ')}`);
-    console.log(`  CLI: ccw cli --tool ${cliTool} --mode write\n`);
-  }
-  console.log(`Total: ${tasks.length} tasks`);
-  return;
-}
-```
-
-### Phase 4: Launch First Task (then wait for hook)
-
-```javascript
-// Start with the first task, first skill
-const firstTask = tasks[0];
-const resolvedType = firstTask.task_type || inferTaskType(firstTask.title, firstTask.description);
-const chain = firstTask.skill_chain || SKILL_CHAIN_MAP[resolvedType] || SKILL_CHAIN_MAP['feature'];
-
-// Update task → in_progress
-firstTask.status = 'in_progress';
-firstTask.task_type = resolvedType;
-firstTask.execution.started_at = new Date().toISOString();
-Write(`.workflow/.idaw/tasks/${firstTask.id}.json`, JSON.stringify(firstAgent, null, 2));
-
-// Update session
-session.current_task = firstTask.id;
-session.current_skill_index = 0;
-session.updated_at = new Date().toISOString();
-Write(`${sessionDir}/session.json`, JSON.stringify(session, null, 2));
-
-// ━━━ Pre-Task CLI Context Analysis (for complex/bugfix tasks) ━━━
-if (['bugfix', 'bugfix-hotfix', 'feature-complex'].includes(resolvedType)) {
-  console.log(`Pre-analysis: gathering context for ${resolvedType} task...`);
-  const affectedFiles = (firstTask.context?.affected_files || []).join(', ');
-  const preAnalysisPrompt = `PURPOSE: Pre-analyze codebase context for IDAW task.
-TASK: • Understand current state of: ${affectedFiles || 'files related to: ' + firstTask.title} • Identify dependencies and risk areas
-MODE: analysis
-CONTEXT: @**/*
-EXPECTED: Brief context summary in 3-5 bullet points
-CONSTRAINTS: Keep concise`;
-  Bash(`ccw cli -p '${preAnalysisPrompt.replace(/'/g, "'\\''")}' --tool gemini --mode analysis 2>&1 || echo "Pre-analysis skipped"`);
-}
-
-// Assemble prompt for first skill
-const skillName = chain[0];
-const prompt = assembleCliPrompt(skillName, firstAgent, null, autoYes);
-
-session.prompts_used.push({
-  task_id: firstTask.id,
-  skill_index: 0,
-  skill: skillName,
-  prompt: prompt,
-  timestamp: new Date().toISOString()
-});
-session.updated_at = new Date().toISOString();
-Write(`${sessionDir}/session.json`, JSON.stringify(session, null, 2));
-
-// Launch via ccw cli in background
-console.log(`[1/${tasks.length}] ${firstTask.id}: ${firstTask.title}`);
-console.log(`  Chain: ${chain.join(' → ')}`);
-console.log(`  Launching: ${skillName} via ccw cli --tool ${cliTool}`);
-
-Bash(
-  `ccw cli -p "${escapeForShell(prompt)}" --tool ${cliTool} --mode write`,
-  { run_in_background: true }
-);
-
-// ★ STOP HERE — wait for hook callback
-// Hook callback will trigger handleStepCompletion() below
-```
-
-### Phase 5: Hook Callback Handler (per-step completion)
-
-```javascript
-// Called by hook when background CLI completes
-async function handleStepCompletion(sessionId, cliOutput) {
-  const sessionDir = `.workflow/.idaw/sessions/${sessionId}`;
-  const session = JSON.parse(Read(`${sessionDir}/session.json`));
-
-  const taskId = session.current_task;
-  const task = JSON.parse(Read(`.workflow/.idaw/tasks/${taskId}.json`));
-
-  const resolvedType = task.task_type || inferTaskType(task.title, task.description);
-  const chain = task.skill_chain || SKILL_CHAIN_MAP[resolvedType] || SKILL_CHAIN_MAP['feature'];
-  const skillIdx = session.current_skill_index;
-  const skillName = chain[skillIdx];
-
-  // Parse CLI output for session ID
-  const parsedOutput = parseCliOutput(cliOutput);
-
-  // Record skill result
-  task.execution.skill_results.push({
-    skill: skillName,
-    status: parsedOutput.success ? 'completed' : 'failed',
-    session_id: parsedOutput.sessionId,
-    timestamp: new Date().toISOString()
-  });
-
-  // ━━━ Handle failure with CLI diagnosis ━━━
-  if (!parsedOutput.success) {
-    console.log(`  ${skillName} failed. Running CLI diagnosis...`);
-    const diagnosisPrompt = `PURPOSE: Diagnose why skill "${skillName}" failed during IDAW task.
-TASK: • Analyze error output • Check affected files: ${(task.context?.affected_files || []).join(', ') || 'unknown'}
-MODE: analysis
-CONTEXT: @**/* | Memory: IDAW task ${task.id}: ${task.title}
-EXPECTED: Root cause + fix recommendation
-CONSTRAINTS: Actionable diagnosis`;
-    Bash(`ccw cli -p '${diagnosisPrompt.replace(/'/g, "'\\''")}' --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause 2>&1 || true`);
-
-    task.execution.skill_results.push({
-      skill: `cli-diagnosis:${skillName}`,
-      status: 'completed',
-      timestamp: new Date().toISOString()
-    });
-
-    // Retry once
-    console.log(`  Retrying: ${skillName}`);
-    const retryPrompt = assembleCliPrompt(skillName, task, parsedOutput, true);
-    session.prompts_used.push({
-      task_id: taskId,
-      skill_index: skillIdx,
-      skill: `${skillName}-retry`,
-      prompt: retryPrompt,
-      timestamp: new Date().toISOString()
-    });
-    Write(`${sessionDir}/session.json`, JSON.stringify(session, null, 2));
-    Write(`.workflow/.idaw/tasks/${taskId}.json`, JSON.stringify(task, null, 2));
-
-    Bash(
-      `ccw cli -p "${escapeForShell(retryPrompt)}" --tool ${session.cli_tool} --mode write`,
-      { run_in_background: true }
-    );
-    return; // Wait for retry hook
-  }
-
-  // ━━━ Skill succeeded — advance ━━━
-  const nextSkillIdx = skillIdx + 1;
-
-  if (nextSkillIdx < chain.length) {
-    // More skills in this task's chain → launch next skill
-    session.current_skill_index = nextSkillIdx;
-    session.updated_at = new Date().toISOString();
-
-    const nextSkill = chain[nextSkillIdx];
-    const nextPrompt = assembleCliPrompt(nextSkill, task, parsedOutput, true);
-
-    session.prompts_used.push({
-      task_id: taskId,
-      skill_index: nextSkillIdx,
-      skill: nextSkill,
-      prompt: nextPrompt,
-      timestamp: new Date().toISOString()
-    });
-    Write(`${sessionDir}/session.json`, JSON.stringify(session, null, 2));
-    Write(`.workflow/.idaw/tasks/${taskId}.json`, JSON.stringify(task, null, 2));
-
-    console.log(`  Next skill: ${nextSkill}`);
-    Bash(
-      `ccw cli -p "${escapeForShell(nextPrompt)}" --tool ${session.cli_tool} --mode write`,
-      { run_in_background: true }
-    );
-    return; // Wait for next hook
-  }
-
-  // ━━━ Task chain complete — git checkpoint ━━━
-  const commitMsg = `feat(idaw): ${task.title} [${task.id}]`;
-  const diffCheck = Bash('git diff --stat HEAD 2>/dev/null || echo ""');
-  const untrackedCheck = Bash('git ls-files --others --exclude-standard 2>/dev/null || echo ""');
-
-  if (diffCheck?.trim() || untrackedCheck?.trim()) {
-    Bash('git add -A');
-    Bash(`git commit -m "$(cat <<'EOF'\n${commitMsg}\nEOF\n)"`);
-    const commitHash = Bash('git rev-parse --short HEAD 2>/dev/null')?.trim();
-    task.execution.git_commit = commitHash;
-  } else {
-    task.execution.git_commit = 'no-commit';
-  }
-
-  task.status = 'completed';
-  task.execution.completed_at = new Date().toISOString();
-  task.updated_at = new Date().toISOString();
-  Write(`.workflow/.idaw/tasks/${taskId}.json`, JSON.stringify(task, null, 2));
-
-  session.completed.push(taskId);
-
-  // Append progress
-  const progressEntry = `## ${task.id} — ${task.title}\n` +
-    `- Status: completed\n` +
-    `- Type: ${task.task_type}\n` +
-    `- Chain: ${chain.join(' → ')}\n` +
-    `- Commit: ${task.execution.git_commit || '-'}\n` +
-    `- Mode: coordinate (${session.cli_tool})\n\n`;
-  const currentProgress = Read(`${sessionDir}/progress.md`);
-  Write(`${sessionDir}/progress.md`, currentProgress + progressEntry);
-
-  // ━━━ Advance to next task ━━━
-  const allTaskIds = session.tasks;
-  const completedSet = new Set([...session.completed, ...session.failed, ...session.skipped]);
-  const nextTaskId = allTaskIds.find(id => !completedSet.has(id));
-
-  if (nextTaskId) {
-    // Load next task
-    const nextTask = JSON.parse(Read(`.workflow/.idaw/tasks/${nextTaskId}.json`));
-    const nextType = nextTask.task_type || inferTaskType(nextTask.title, nextTask.description);
-    const nextChain = nextTask.skill_chain || SKILL_CHAIN_MAP[nextType] || SKILL_CHAIN_MAP['feature'];
-
-    nextTask.status = 'in_progress';
-    nextTask.task_type = nextType;
-    nextTask.execution.started_at = new Date().toISOString();
-    Write(`.workflow/.idaw/tasks/${nextTaskId}.json`, JSON.stringify(nextAgent, null, 2));
-
-    session.current_task = nextTaskId;
-    session.current_skill_index = 0;
-    session.updated_at = new Date().toISOString();
-    Write(`${sessionDir}/session.json`, JSON.stringify(session, null, 2));
-
-    // Pre-analysis for complex tasks
-    if (['bugfix', 'bugfix-hotfix', 'feature-complex'].includes(nextType)) {
-      const affectedFiles = (nextTask.context?.affected_files || []).join(', ');
-      Bash(`ccw cli -p 'PURPOSE: Pre-analyze context for ${nextTask.title}. TASK: Check ${affectedFiles || "related files"}. MODE: analysis. EXPECTED: 3-5 bullet points.' --tool gemini --mode analysis 2>&1 || true`);
-    }
-
-    const nextSkillName = nextChain[0];
-    const nextPrompt = assembleCliPrompt(nextSkillName, nextAgent, null, true);
-
-    session.prompts_used.push({
-      task_id: nextTaskId,
-      skill_index: 0,
-      skill: nextSkillName,
-      prompt: nextPrompt,
-      timestamp: new Date().toISOString()
-    });
-    Write(`${sessionDir}/session.json`, JSON.stringify(session, null, 2));
-
-    const taskNum = session.completed.length + 1;
-    const totalTasks = session.tasks.length;
-    console.log(`\n[${taskNum}/${totalTasks}] ${nextTaskId}: ${nextTask.title}`);
-    console.log(`  Chain: ${nextChain.join(' → ')}`);
-
-    Bash(
-      `ccw cli -p "${escapeForShell(nextPrompt)}" --tool ${session.cli_tool} --mode write`,
-      { run_in_background: true }
-    );
-    return; // Wait for hook
-  }
-
-  // ━━━ All tasks complete — Phase 6: Report ━━━
-  session.status = session.failed.length > 0 && session.completed.length === 0 ? 'failed' : 'completed';
-  session.current_task = null;
-  session.updated_at = new Date().toISOString();
-  Write(`${sessionDir}/session.json`, JSON.stringify(session, null, 2));
-
-  const summary = `\n---\n## Summary (coordinate mode)\n` +
-    `- CLI Tool: ${session.cli_tool}\n` +
-    `- Completed: ${session.completed.length}\n` +
-    `- Failed: ${session.failed.length}\n` +
-    `- Skipped: ${session.skipped.length}\n` +
-    `- Total: ${session.tasks.length}\n`;
-  const finalProgress = Read(`${sessionDir}/progress.md`);
-  Write(`${sessionDir}/progress.md`, finalProgress + summary);
-
-  console.log('\n=== IDAW Coordinate Complete ===');
-  console.log(`Session: ${sessionId}`);
-  console.log(`Completed: ${session.completed.length}/${session.tasks.length}`);
-  if (session.failed.length > 0) console.log(`Failed: ${session.failed.join(', ')}`);
-}
-```
-
-## Helper Functions
-
-### assembleCliPrompt
-
-```javascript
-function assembleCliPrompt(skillName, task, previousResult, autoYes) {
-  let prompt = '';
-  const yFlag = autoYes ? ' -y' : '';
-
-  // Map skill to command invocation
-  if (skillName === 'workflow-lite-plan') {
-    const goal = sanitize(`${task.title}\n${task.description}`);
-    prompt = `/workflow-lite-plan${yFlag} "${goal}"`;
-    if (task.task_type === 'bugfix') prompt = `/workflow-lite-plan${yFlag} --bugfix "${goal}"`;
-    if (task.task_type === 'bugfix-hotfix') prompt = `/workflow-lite-plan${yFlag} --hotfix "${goal}"`;
-
-  } else if (skillName === 'workflow-plan') {
-    prompt = `/workflow-plan${yFlag} "${sanitize(task.title)}"`;
-
-  } else if (skillName === 'workflow-execute') {
-    if (previousResult?.sessionId) {
-      prompt = `/workflow-execute${yFlag} --resume-session="${previousResult.sessionId}"`;
-    } else {
-      prompt = `/workflow-execute${yFlag}`;
-    }
-
-  } else if (skillName === 'workflow-test-fix') {
-    if (previousResult?.sessionId) {
-      prompt = `/workflow-test-fix${yFlag} "${previousResult.sessionId}"`;
-    } else {
-      prompt = `/workflow-test-fix${yFlag} "${sanitize(task.title)}"`;
-    }
-
-  } else if (skillName === 'workflow-tdd-plan') {
-    prompt = `/workflow-tdd-plan${yFlag} "${sanitize(task.title)}"`;
-
-  } else if (skillName === 'workflow:refactor-cycle') {
-    prompt = `/workflow:refactor-cycle${yFlag} "${sanitize(task.title)}"`;
-
-  } else if (skillName === 'review-cycle') {
-    if (previousResult?.sessionId) {
-      prompt = `/review-cycle${yFlag} --session="${previousResult.sessionId}"`;
-    } else {
-      prompt = `/review-cycle${yFlag}`;
-    }
-
-  } else {
-    // Generic fallback
-    prompt = `/${skillName}${yFlag} "${sanitize(task.title)}"`;
-  }
-
-  // Append task context
-  prompt += `\n\nTask: ${task.title}\nDescription: ${task.description}`;
-  if (task.context?.affected_files?.length > 0) {
-    prompt += `\nAffected files: ${task.context.affected_files.join(', ')}`;
-  }
-  if (task.context?.acceptance_criteria?.length > 0) {
-    prompt += `\nAcceptance criteria: ${task.context.acceptance_criteria.join('; ')}`;
-  }
-
-  return prompt;
-}
-```
-
-### sanitize & escapeForShell
-
-```javascript
-function sanitize(text) {
-  return text
-    .replace(/\\/g, '\\\\')
-    .replace(/"/g, '\\"')
-    .replace(/\$/g, '\\$')
-    .replace(/`/g, '\\`');
-}
-
-function escapeForShell(prompt) {
-  return prompt.replace(/'/g, "'\\''");
-}
-```
-
-### parseCliOutput
-
-```javascript
-function parseCliOutput(output) {
-  // Extract session ID from CLI output (e.g., WFS-xxx, session-xxx)
-  const sessionMatch = output.match(/(?:session|WFS|Session ID)[:\s]*([\w-]+)/i);
-  const success = !/(?:error|failed|fatal)/i.test(output) || /completed|success/i.test(output);
-
-  return {
-    success,
-    sessionId: sessionMatch?.[1] || null,
-    raw: output?.substring(0, 500)
-  };
-}
-```
-
-## CLI-Assisted Analysis
-
-Same as `/idaw:run` — integrated at two points:
-
-### Pre-Task Context Analysis
-For `bugfix`, `bugfix-hotfix`, `feature-complex` tasks: auto-invoke `ccw cli --tool gemini --mode analysis` before launching skill chain.
-
-### Error Recovery with CLI Diagnosis
-When a skill's CLI execution fails: invoke diagnosis → retry once → if still fails, mark failed and advance.
-
-```
-Skill CLI fails → CLI diagnosis (gemini) → Retry CLI → Still fails → mark failed → next task
-```
-
-## State Flow
-
-```
-Phase 4: Launch first skill
-    ↓
-  ccw cli --tool claude --mode write (background)
-    ↓
-  ★ STOP — wait for hook callback
-    ↓
-Phase 5: handleStepCompletion()
-    ├─ Skill succeeded + more in chain → launch next skill → STOP
-    ├─ Skill succeeded + chain complete → git checkpoint → next task → STOP
-    ├─ Skill failed → CLI diagnosis → retry → STOP
-    └─ All tasks done → Phase 6: Report
-```
-
-## Session State (session.json)
-
-```json
-{
-  "session_id": "IDA-fix-login-20260301",
-  "mode": "coordinate",
-  "cli_tool": "claude",
-  "status": "running|waiting|completed|failed",
-  "created_at": "ISO",
-  "updated_at": "ISO",
-  "tasks": ["IDAW-001", "IDAW-002"],
-  "current_task": "IDAW-001",
-  "current_skill_index": 0,
-  "completed": [],
-  "failed": [],
-  "skipped": [],
-  "prompts_used": [
-    {
-      "task_id": "IDAW-001",
-      "skill_index": 0,
-      "skill": "workflow-lite-plan",
-      "prompt": "/workflow-lite-plan -y \"Fix login timeout\"",
-      "timestamp": "ISO"
-    }
-  ]
-}
-```
-
-## Differences from /idaw:run
-
-| Aspect | /idaw:run | /idaw:run-coordinate |
-|--------|-----------|---------------------|
-| Execution | `Skill()` blocking in main process | `ccw cli` background + hook callback |
-| Context window | Shared (each skill uses main context) | Isolated (each CLI gets fresh context) |
-| Concurrency | Sequential blocking | Sequential non-blocking (hook-driven) |
-| State tracking | session.json + task.json | session.json + task.json + prompts_used |
-| Tool selection | N/A (Skill native) | `--tool claude\|gemini\|qwen` |
-| Resume | Via `/idaw:resume` (same) | Via `/idaw:resume` (same, detects mode) |
-| Best for | Short chains, interactive | Long chains, autonomous, context-heavy |
-
-## Examples
-
-```bash
-# Execute all pending tasks via claude CLI
-/idaw:run-coordinate -y
-
-# Use specific CLI tool
-/idaw:run-coordinate -y --tool gemini
-
-# Execute specific tasks
-/idaw:run-coordinate --task IDAW-001,IDAW-003 --tool claude
-
-# Dry run (show plan without executing)
-/idaw:run-coordinate --dry-run
-
-# Interactive mode
-/idaw:run-coordinate
-```