claude-code-workflow 6.3.26 → 6.3.28

package/.claude/skills/skill-tuning/phases/actions/action-generate-report.md

@@ -0,0 +1,228 @@
+# Action: Generate Consolidated Report
+
+Generate a comprehensive tuning report merging all diagnosis results with prioritized recommendations.
+
+## Purpose
+
+- Merge all diagnosis results into unified report
+- Prioritize issues by severity and impact
+- Generate actionable recommendations
+- Create human-readable markdown report
+
+## Preconditions
+
+- [ ] state.status === 'running'
+- [ ] All diagnoses in focus_areas are completed
+- [ ] state.issues.length > 0 OR generate summary report
+
+## Execution
+
+```javascript
+async function execute(state, workDir) {
+  console.log('Generating consolidated tuning report...');
+
+  const targetSkill = state.target_skill;
+  const issues = state.issues;
+
+  // 1. Group issues by type
+  const issuesByType = {
+    context_explosion: issues.filter(i => i.type === 'context_explosion'),
+    memory_loss: issues.filter(i => i.type === 'memory_loss'),
+    dataflow_break: issues.filter(i => i.type === 'dataflow_break'),
+    agent_failure: issues.filter(i => i.type === 'agent_failure')
+  };
+
+  // 2. Group issues by severity
+  const issuesBySeverity = {
+    critical: issues.filter(i => i.severity === 'critical'),
+    high: issues.filter(i => i.severity === 'high'),
+    medium: issues.filter(i => i.severity === 'medium'),
+    low: issues.filter(i => i.severity === 'low')
+  };
+
+  // 3. Calculate overall health score
+  const weights = { critical: 25, high: 15, medium: 5, low: 1 };
+  const deductions = Object.entries(issuesBySeverity)
+    .reduce((sum, [sev, arr]) => sum + arr.length * weights[sev], 0);
+  const healthScore = Math.max(0, 100 - deductions);
+
+  // 4. Generate report content
+  const report = `# Skill Tuning Report
+
+**Target Skill**: ${targetSkill.name}
+**Path**: ${targetSkill.path}
+**Execution Mode**: ${targetSkill.execution_mode}
+**Generated**: ${new Date().toISOString()}
+
+---
+
+## Executive Summary
+
+| Metric | Value |
+|--------|-------|
+| Health Score | ${healthScore}/100 |
+| Total Issues | ${issues.length} |
+| Critical | ${issuesBySeverity.critical.length} |
+| High | ${issuesBySeverity.high.length} |
+| Medium | ${issuesBySeverity.medium.length} |
+| Low | ${issuesBySeverity.low.length} |
+
+### User Reported Issue
+> ${state.user_issue_description}
+
+### Overall Assessment
+${healthScore >= 80 ? '✅ Skill is in good health with minor issues.' :
+  healthScore >= 60 ? '⚠️ Skill has significant issues requiring attention.' :
+  healthScore >= 40 ? '🔶 Skill has serious issues affecting reliability.' :
+  '❌ Skill has critical issues requiring immediate fixes.'}
+
+---
+
+## Diagnosis Results
+
+### Context Explosion Analysis
+${state.diagnosis.context ?
+  `- **Status**: ${state.diagnosis.context.status}
+- **Severity**: ${state.diagnosis.context.severity}
+- **Issues Found**: ${state.diagnosis.context.issues_found}
+- **Key Findings**: ${state.diagnosis.context.details.recommendations.join('; ') || 'None'}` :
+  '_Not analyzed_'}
+
+### Long-tail Memory Analysis
+${state.diagnosis.memory ?
+  `- **Status**: ${state.diagnosis.memory.status}
+- **Severity**: ${state.diagnosis.memory.severity}
+- **Issues Found**: ${state.diagnosis.memory.issues_found}
+- **Key Findings**: ${state.diagnosis.memory.details.recommendations.join('; ') || 'None'}` :
+  '_Not analyzed_'}
+
+### Data Flow Analysis
+${state.diagnosis.dataflow ?
+  `- **Status**: ${state.diagnosis.dataflow.status}
+- **Severity**: ${state.diagnosis.dataflow.severity}
+- **Issues Found**: ${state.diagnosis.dataflow.issues_found}
+- **Key Findings**: ${state.diagnosis.dataflow.details.recommendations.join('; ') || 'None'}` :
+  '_Not analyzed_'}
+
+### Agent Coordination Analysis
+${state.diagnosis.agent ?
+  `- **Status**: ${state.diagnosis.agent.status}
+- **Severity**: ${state.diagnosis.agent.severity}
+- **Issues Found**: ${state.diagnosis.agent.issues_found}
+- **Key Findings**: ${state.diagnosis.agent.details.recommendations.join('; ') || 'None'}` :
+  '_Not analyzed_'}
+
+---
+
+## Critical & High Priority Issues
+
+${issuesBySeverity.critical.length + issuesBySeverity.high.length === 0 ?
+  '_No critical or high priority issues found._' :
+  [...issuesBySeverity.critical, ...issuesBySeverity.high].map((issue, i) => `
+### ${i + 1}. [${issue.severity.toUpperCase()}] ${issue.description}
+
+- **ID**: ${issue.id}
+- **Type**: ${issue.type}
+- **Location**: ${typeof issue.location === 'object' ? issue.location.file : issue.location}
+- **Root Cause**: ${issue.root_cause}
+- **Impact**: ${issue.impact}
+- **Suggested Fix**: ${issue.suggested_fix}
+
+**Evidence**:
+${issue.evidence.map(e => `- \`${e}\``).join('\n')}
+`).join('\n')}
+
+---
+
+## Medium & Low Priority Issues
+
+${issuesBySeverity.medium.length + issuesBySeverity.low.length === 0 ?
+  '_No medium or low priority issues found._' :
+  [...issuesBySeverity.medium, ...issuesBySeverity.low].map((issue, i) => `
+### ${i + 1}. [${issue.severity.toUpperCase()}] ${issue.description}
+
+- **ID**: ${issue.id}
+- **Type**: ${issue.type}
+- **Suggested Fix**: ${issue.suggested_fix}
+`).join('\n')}
+
+---
+
+## Recommended Fix Order
+
+Based on severity and dependencies, apply fixes in this order:
+
+${[...issuesBySeverity.critical, ...issuesBySeverity.high, ...issuesBySeverity.medium]
+  .slice(0, 10)
+  .map((issue, i) => `${i + 1}. **${issue.id}**: ${issue.suggested_fix}`)
+  .join('\n')}
+
+---
+
+## Quality Gates
+
+| Gate | Threshold | Current | Status |
+|------|-----------|---------|--------|
+| Critical Issues | 0 | ${issuesBySeverity.critical.length} | ${issuesBySeverity.critical.length === 0 ? '✅ PASS' : '❌ FAIL'} |
+| High Issues | ≤ 2 | ${issuesBySeverity.high.length} | ${issuesBySeverity.high.length <= 2 ? '✅ PASS' : '❌ FAIL'} |
+| Health Score | ≥ 60 | ${healthScore} | ${healthScore >= 60 ? '✅ PASS' : '❌ FAIL'} |
+
+**Overall Quality Gate**: ${
+  issuesBySeverity.critical.length === 0 &&
+  issuesBySeverity.high.length <= 2 &&
+  healthScore >= 60 ? '✅ PASS' : '❌ FAIL'}
+
+---
+
+*Report generated by skill-tuning*
+`;
+
+  // 5. Write report
+  Write(`${workDir}/tuning-report.md`, report);
+
+  // 6. Calculate quality gate
+  const qualityGate = issuesBySeverity.critical.length === 0 &&
+                      issuesBySeverity.high.length <= 2 &&
+                      healthScore >= 60 ? 'pass' :
+                      healthScore >= 40 ? 'review' : 'fail';
+
+  return {
+    stateUpdates: {
+      quality_score: healthScore,
+      quality_gate: qualityGate,
+      issues_by_severity: {
+        critical: issuesBySeverity.critical.length,
+        high: issuesBySeverity.high.length,
+        medium: issuesBySeverity.medium.length,
+        low: issuesBySeverity.low.length
+      }
+    },
+    outputFiles: [`${workDir}/tuning-report.md`],
+    summary: `Report generated: ${issues.length} issues, health score ${healthScore}/100, gate: ${qualityGate}`
+  };
+}
+```
+
+## State Updates
+
+```javascript
+return {
+  stateUpdates: {
+    quality_score: <0-100>,
+    quality_gate: '<pass|review|fail>',
+    issues_by_severity: { critical: N, high: N, medium: N, low: N }
+  }
+};
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| Write error | Retry to alternative path |
+| Empty issues | Generate summary with no issues |
+
+## Next Actions
+
+- If issues.length > 0: action-propose-fixes
+- If issues.length === 0: action-complete

package/.claude/skills/skill-tuning/phases/actions/action-init.md

@@ -0,0 +1,149 @@
+# Action: Initialize Tuning Session
+
+Initialize the skill-tuning session by collecting target skill information, creating work directories, and setting up initial state.
+
+## Purpose
+
+- Identify target skill to tune
+- Collect user's problem description
+- Create work directory structure
+- Backup original skill files
+- Initialize state for orchestrator
+
+## Preconditions
+
+- [ ] state.status === 'pending'
+
+## Execution
+
+```javascript
+async function execute(state, workDir) {
+  // 1. Ask user for target skill
+  const skillInput = await AskUserQuestion({
+    questions: [{
+      question: "Which skill do you want to tune?",
+      header: "Target Skill",
+      multiSelect: false,
+      options: [
+        { label: "Specify path", description: "Enter skill directory path" }
+      ]
+    }]
+  });
+
+  const skillPath = skillInput["Target Skill"];
+
+  // 2. Validate skill exists and read structure
+  const skillMdPath = `${skillPath}/SKILL.md`;
+  if (!Glob(`${skillPath}/SKILL.md`).length) {
+    throw new Error(`Invalid skill path: ${skillPath} - SKILL.md not found`);
+  }
+
+  // 3. Read skill metadata
+  const skillMd = Read(skillMdPath);
+  const frontMatterMatch = skillMd.match(/^---\n([\s\S]*?)\n---/);
+  const skillName = frontMatterMatch
+    ? frontMatterMatch[1].match(/name:\s*(.+)/)?.[1]?.trim()
+    : skillPath.split('/').pop();
+
+  // 4. Detect execution mode
+  const hasOrchestrator = Glob(`${skillPath}/phases/orchestrator.md`).length > 0;
+  const executionMode = hasOrchestrator ? 'autonomous' : 'sequential';
+
+  // 5. Scan skill structure
+  const phases = Glob(`${skillPath}/phases/**/*.md`).map(f => f.replace(skillPath + '/', ''));
+  const specs = Glob(`${skillPath}/specs/**/*.md`).map(f => f.replace(skillPath + '/', ''));
+
+  // 6. Ask for problem description
+  const issueInput = await AskUserQuestion({
+    questions: [{
+      question: "Describe the issue or what you want to optimize:",
+      header: "Issue",
+      multiSelect: false,
+      options: [
+        { label: "Context grows too large", description: "Token explosion over multiple turns" },
+        { label: "Instructions forgotten", description: "Early constraints lost in long execution" },
+        { label: "Data inconsistency", description: "State format changes between phases" },
+        { label: "Agent failures", description: "Sub-agent calls fail or return unexpected results" }
+      ]
+    }]
+  });
+
+  // 7. Ask for focus areas
+  const focusInput = await AskUserQuestion({
+    questions: [{
+      question: "Which areas should be diagnosed? (Select all that apply)",
+      header: "Focus",
+      multiSelect: true,
+      options: [
+        { label: "context", description: "Context explosion analysis" },
+        { label: "memory", description: "Long-tail forgetting analysis" },
+        { label: "dataflow", description: "Data flow analysis" },
+        { label: "agent", description: "Agent coordination analysis" }
+      ]
+    }]
+  });
+
+  const focusAreas = focusInput["Focus"] || ['context', 'memory', 'dataflow', 'agent'];
+
+  // 8. Create backup
+  const backupDir = `${workDir}/backups/${skillName}-backup`;
+  Bash(`mkdir -p "${backupDir}"`);
+  Bash(`cp -r "${skillPath}"/* "${backupDir}/"`);
+
+  // 9. Return state updates
+  return {
+    stateUpdates: {
+      status: 'running',
+      started_at: new Date().toISOString(),
+      target_skill: {
+        name: skillName,
+        path: skillPath,
+        execution_mode: executionMode,
+        phases: phases,
+        specs: specs
+      },
+      user_issue_description: issueInput["Issue"],
+      focus_areas: Array.isArray(focusAreas) ? focusAreas : [focusAreas],
+      work_dir: workDir,
+      backup_dir: backupDir
+    },
+    outputFiles: [],
+    summary: `Initialized tuning for "${skillName}" (${executionMode} mode), focus: ${focusAreas.join(', ')}`
+  };
+}
+```
+
+## State Updates
+
+```javascript
+return {
+  stateUpdates: {
+    status: 'running',
+    started_at: '<timestamp>',
+    target_skill: {
+      name: '<skill-name>',
+      path: '<skill-path>',
+      execution_mode: '<sequential|autonomous>',
+      phases: ['...'],
+      specs: ['...']
+    },
+    user_issue_description: '<user description>',
+    focus_areas: ['context', 'memory', ...],
+    work_dir: '<work-dir>',
+    backup_dir: '<backup-dir>'
+  }
+};
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| Skill path not found | Ask user to re-enter valid path |
+| SKILL.md missing | Suggest path correction |
+| Backup creation failed | Retry with alternative location |
+
+## Next Actions
+
+- Success: Continue to first diagnosis action based on focus_areas
+- Failure: action-abort

package/.claude/skills/skill-tuning/phases/actions/action-propose-fixes.md

@@ -0,0 +1,317 @@
+# Action: Propose Fixes
+
+Generate fix proposals for identified issues with implementation strategies.
+
+## Purpose
+
+- Create fix strategies for each issue
+- Generate implementation plans
+- Estimate risk levels
+- Allow user to select fixes to apply
+
+## Preconditions
+
+- [ ] state.status === 'running'
+- [ ] state.issues.length > 0
+- [ ] action-generate-report completed
+
+## Fix Strategy Catalog
+
+### Context Explosion Fixes
+
+| Strategy | Description | Risk |
+|----------|-------------|------|
+| `context_summarization` | Add summarizer agent between phases | low |
+| `sliding_window` | Keep only last N turns in context | low |
+| `structured_state` | Replace text context with JSON state | medium |
+| `path_reference` | Pass file paths instead of content | low |
+
+### Memory Loss Fixes
+
+| Strategy | Description | Risk |
+|----------|-------------|------|
+| `constraint_injection` | Add constraints to each phase prompt | low |
+| `checkpoint_restore` | Save state at milestones | low |
+| `goal_embedding` | Track goal similarity throughout | medium |
+| `state_constraints_field` | Add constraints field to state schema | low |
+
+### Data Flow Fixes
+
+| Strategy | Description | Risk |
+|----------|-------------|------|
+| `state_centralization` | Single state.json for all data | medium |
+| `schema_enforcement` | Add Zod validation | low |
+| `field_normalization` | Normalize field names | low |
+| `transactional_updates` | Atomic state updates | medium |
+
+### Agent Coordination Fixes
+
+| Strategy | Description | Risk |
+|----------|-------------|------|
+| `error_wrapping` | Add try-catch to all Task calls | low |
+| `result_validation` | Validate agent returns | low |
+| `orchestrator_refactor` | Centralize agent coordination | high |
+| `flatten_nesting` | Remove nested agent calls | medium |
+
+## Execution
+
+```javascript
+async function execute(state, workDir) {
+  console.log('Generating fix proposals...');
+
+  const issues = state.issues;
+  const fixes = [];
+
+  // Group issues by type for batch fixes
+  const issuesByType = {
+    context_explosion: issues.filter(i => i.type === 'context_explosion'),
+    memory_loss: issues.filter(i => i.type === 'memory_loss'),
+    dataflow_break: issues.filter(i => i.type === 'dataflow_break'),
+    agent_failure: issues.filter(i => i.type === 'agent_failure')
+  };
+
+  // Generate fixes for context explosion
+  if (issuesByType.context_explosion.length > 0) {
+    const ctxIssues = issuesByType.context_explosion;
+
+    if (ctxIssues.some(i => i.description.includes('history accumulation'))) {
+      fixes.push({
+        id: `FIX-${fixes.length + 1}`,
+        issue_ids: ctxIssues.filter(i => i.description.includes('history')).map(i => i.id),
+        strategy: 'sliding_window',
+        description: 'Implement sliding window for conversation history',
+        rationale: 'Prevents unbounded context growth by keeping only recent turns',
+        changes: [{
+          file: 'phases/orchestrator.md',
+          action: 'modify',
+          diff: `+ const MAX_HISTORY = 5;
++ state.history = state.history.slice(-MAX_HISTORY);`
+        }],
+        risk: 'low',
+        estimated_impact: 'Reduces token usage by ~50%',
+        verification_steps: ['Run skill with 10+ iterations', 'Verify context size stable']
+      });
+    }
+
+    if (ctxIssues.some(i => i.description.includes('full content'))) {
+      fixes.push({
+        id: `FIX-${fixes.length + 1}`,
+        issue_ids: ctxIssues.filter(i => i.description.includes('content')).map(i => i.id),
+        strategy: 'path_reference',
+        description: 'Pass file paths instead of full content',
+        rationale: 'Agents can read files when needed, reducing prompt size',
+        changes: [{
+          file: 'phases/*.md',
+          action: 'modify',
+          diff: `- prompt: \${content}
++ prompt: Read file at: \${filePath}`
+        }],
+        risk: 'low',
+        estimated_impact: 'Significant token reduction',
+        verification_steps: ['Verify agents can still access needed content']
+      });
+    }
+  }
+
+  // Generate fixes for memory loss
+  if (issuesByType.memory_loss.length > 0) {
+    const memIssues = issuesByType.memory_loss;
+
+    if (memIssues.some(i => i.description.includes('constraint'))) {
+      fixes.push({
+        id: `FIX-${fixes.length + 1}`,
+        issue_ids: memIssues.filter(i => i.description.includes('constraint')).map(i => i.id),
+        strategy: 'constraint_injection',
+        description: 'Add constraint injection to all phases',
+        rationale: 'Ensures original requirements are visible in every phase',
+        changes: [{
+          file: 'phases/*.md',
+          action: 'modify',
+          diff: `+ [CONSTRAINTS]
++ Original requirements from state.original_requirements:
++ \${JSON.stringify(state.original_requirements)}`
+        }],
+        risk: 'low',
+        estimated_impact: 'Improves constraint adherence',
+        verification_steps: ['Run skill with specific constraints', 'Verify output matches']
+      });
+    }
+
+    if (memIssues.some(i => i.description.includes('State schema'))) {
+      fixes.push({
+        id: `FIX-${fixes.length + 1}`,
+        issue_ids: memIssues.filter(i => i.description.includes('schema')).map(i => i.id),
+        strategy: 'state_constraints_field',
+        description: 'Add original_requirements field to state schema',
+        rationale: 'Preserves original intent throughout execution',
+        changes: [{
+          file: 'phases/state-schema.md',
+          action: 'modify',
+          diff: `+ original_requirements: string[];  // User's original constraints
++ goal_summary: string;              // One-line goal statement`
+        }],
+        risk: 'low',
+        estimated_impact: 'Enables constraint tracking',
+        verification_steps: ['Verify state includes requirements after init']
+      });
+    }
+  }
+
+  // Generate fixes for data flow
+  if (issuesByType.dataflow_break.length > 0) {
+    const dfIssues = issuesByType.dataflow_break;
+
+    if (dfIssues.some(i => i.description.includes('multiple locations'))) {
+      fixes.push({
+        id: `FIX-${fixes.length + 1}`,
+        issue_ids: dfIssues.filter(i => i.description.includes('location')).map(i => i.id),
+        strategy: 'state_centralization',
+        description: 'Centralize all state to single state.json',
+        rationale: 'Single source of truth prevents inconsistencies',
+        changes: [{
+          file: 'phases/*.md',
+          action: 'modify',
+          diff: `- Write(\`\${workDir}/config.json\`, ...)
++ updateState({ config: ... })  // Use state manager`
+        }],
+        risk: 'medium',
+        estimated_impact: 'Eliminates state fragmentation',
+        verification_steps: ['Verify all reads come from state.json', 'Test state persistence']
+      });
+    }
+
+    if (dfIssues.some(i => i.description.includes('validation'))) {
+      fixes.push({
+        id: `FIX-${fixes.length + 1}`,
+        issue_ids: dfIssues.filter(i => i.description.includes('validation')).map(i => i.id),
+        strategy: 'schema_enforcement',
+        description: 'Add Zod schema validation',
+        rationale: 'Runtime validation catches schema violations',
+        changes: [{
+          file: 'phases/state-schema.md',
+          action: 'modify',
+          diff: `+ import { z } from 'zod';
++ const StateSchema = z.object({...});
++ function validateState(s) { return StateSchema.parse(s); }`
+        }],
+        risk: 'low',
+        estimated_impact: 'Catches invalid state early',
+        verification_steps: ['Test with invalid state input', 'Verify error thrown']
+      });
+    }
+  }
+
+  // Generate fixes for agent coordination
+  if (issuesByType.agent_failure.length > 0) {
+    const agentIssues = issuesByType.agent_failure;
+
+    if (agentIssues.some(i => i.description.includes('error handling'))) {
+      fixes.push({
+        id: `FIX-${fixes.length + 1}`,
+        issue_ids: agentIssues.filter(i => i.description.includes('error')).map(i => i.id),
+        strategy: 'error_wrapping',
+        description: 'Wrap all Task calls in try-catch',
+        rationale: 'Prevents cascading failures from agent errors',
+        changes: [{
+          file: 'phases/*.md',
+          action: 'modify',
+          diff: `+ try {
+    const result = await Task({...});
++   if (!result) throw new Error('Empty result');
++ } catch (e) {
++   updateState({ errors: [...errors, e.message], error_count: error_count + 1 });
++ }`
+        }],
+        risk: 'low',
+        estimated_impact: 'Improves error resilience',
+        verification_steps: ['Simulate agent failure', 'Verify graceful handling']
+      });
+    }
+
+    if (agentIssues.some(i => i.description.includes('nested'))) {
+      fixes.push({
+        id: `FIX-${fixes.length + 1}`,
+        issue_ids: agentIssues.filter(i => i.description.includes('nested')).map(i => i.id),
+        strategy: 'flatten_nesting',
+        description: 'Flatten nested agent calls',
+        rationale: 'Reduces complexity and context explosion',
+        changes: [{
+          file: 'phases/orchestrator.md',
+          action: 'modify',
+          diff: `// Instead of agent calling agent:
+// Agent A returns {needs_agent_b: true}
+// Orchestrator sees this and calls Agent B next`
+        }],
+        risk: 'medium',
+        estimated_impact: 'Reduces nesting depth',
+        verification_steps: ['Verify no nested Task calls', 'Test agent chaining via orchestrator']
+      });
+    }
+  }
+
+  // Write fix proposals
+  Write(`${workDir}/fixes/fix-proposals.json`, JSON.stringify(fixes, null, 2));
+
+  // Ask user to select fixes to apply
+  const fixOptions = fixes.slice(0, 4).map(f => ({
+    label: f.id,
+    description: `[${f.risk.toUpperCase()} risk] ${f.description}`
+  }));
+
+  if (fixOptions.length > 0) {
+    const selection = await AskUserQuestion({
+      questions: [{
+        question: 'Which fixes would you like to apply?',
+        header: 'Fixes',
+        multiSelect: true,
+        options: fixOptions
+      }]
+    });
+
+    const selectedFixIds = Array.isArray(selection['Fixes'])
+      ? selection['Fixes']
+      : [selection['Fixes']];
+
+    return {
+      stateUpdates: {
+        proposed_fixes: fixes,
+        pending_fixes: selectedFixIds.filter(id => id && fixes.some(f => f.id === id))
+      },
+      outputFiles: [`${workDir}/fixes/fix-proposals.json`],
+      summary: `Generated ${fixes.length} fix proposals, ${selectedFixIds.length} selected for application`
+    };
+  }
+
+  return {
+    stateUpdates: {
+      proposed_fixes: fixes,
+      pending_fixes: []
+    },
+    outputFiles: [`${workDir}/fixes/fix-proposals.json`],
+    summary: `Generated ${fixes.length} fix proposals (none selected)`
+  };
+}
+```
+
+## State Updates
+
+```javascript
+return {
+  stateUpdates: {
+    proposed_fixes: [...fixes],
+    pending_fixes: [...selectedFixIds]
+  }
+};
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| No issues to fix | Skip to action-complete |
+| User cancels selection | Set pending_fixes to empty |
+
+## Next Actions
+
+- If pending_fixes.length > 0: action-apply-fix
+- If pending_fixes.length === 0: action-complete