claude-flow-novice 2.18.29 → 2.18.32

package/.claude/commands/cfn-fix-errors.md

@@ -4,423 +4,338 @@ argument-hint: "<language> [--max-parallel=5] [--max-cycles=10]"
 allowed-tools: ["Task", "TaskOutput", "TodoWrite", "Read", "Bash"]
 ---
 
-# CFN Fix Errors - Coordination Mode
+# CFN Fix Errors - Agent Coordination Mode
 
-**Version:** 1.0.0  |  **Date:** 2025-12-21  |  **Status:** Production Ready
+**Version:** 1.2.0  |  **Date:** 2025-12-21  |  **Status:** Production Ready
 
 ## Quick Overview
 
-Coordination mode for fixing compilation errors using agent-driven post-edit validation with Cerebras acceleration.
+Main chat coordinates up to 5 background agents to fix compilation errors in parallel. Each agent works on one file using Cerebras acceleration and post-edit validation.
 
 ### Key Features
-- **Agent Coordination:** Main chat spawns agents with `background=true`
-- **Parallel Processing:** Max 5 agents working simultaneously
-- **Single-File Focus:** Each agent fixes 1 file only
-- **Post-Edit Validation:** Mandatory validation after each fix
-- **Cerebras Gates:** 12 structural validations prevent semantic changes
-- **Smart Retry:** 2 attempts per file before deferring to Phase 2
-- **Continuous Spawning:** New agent launches immediately when slot opens
+- **Max 5 parallel agents** with continuous spawning
+- **Single-file focus** - each agent fixes one file only
+- **2-attempt retry** logic per file before deferring to Phase 2
+- **Post-edit validation** confirms fixes are correct
+- **Cerebras gates** prevent semantic changes (12 structural validations)
+- **Automatic Phase 2** transition at <40 errors
 
 ### When to Use
 - 20+ compilation errors
-- Need fast bulk reduction
-- Errors are mostly mechanical (type mismatches, imports, syntax)
+- Errors are mostly mechanical (imports, types, syntax)
 - Want visibility into agent progress
+- Need fast bulk error reduction
 
 ---
 
-## Execution Instructions (AUTO-EXECUTE)
+## Execution Instructions (Follow These Steps)
 
-### Step 1: Parse Arguments
+### Step 1: Parse Arguments and Initialize
+
+**YOU SHOULD:** Parse the command arguments and set up session tracking.
 
 ```bash
-# Parse command
-LANGUAGE="$ARGUMENTS"
-LANGUAGE=$(echo "$LANGUAGE" | sed 's/--max-parallel[[:space:]]*[0-9]*//' | sed 's/--max-cycles[[:space:]]*[0-9]*//' | xargs)
+# Extract language from arguments (first word before any flags)
+LANGUAGE="typescript"  # or "rust" from user's command
 
+# Parse optional flags (use defaults if not provided)
 MAX_PARALLEL=5
 MAX_CYCLES=10
 
-for arg in $ARGUMENTS; do
-  case $arg in
-    --max-parallel=*) MAX_PARALLEL="${arg#*=}" ;;
-    --max-cycles=*) MAX_CYCLES="${arg#*=}" ;;
-  esac
-done
-
-# Validate language
-if [[ ! "$LANGUAGE" =~ ^(rust|typescript|ts)$ ]]; then
-  echo "ERROR: Language must be: rust, typescript, ts"
-  exit 1
-fi
-
-# Normalize typescript
-if [[ "$LANGUAGE" == "ts" ]]; then
-  LANGUAGE="typescript"
-fi
-
-SESSION_ID="cfn-fix-$(date +%s%N | tail -c 7)-${RANDOM}"
+# Generate unique session ID
+SESSION_ID="cfn-fix-$(date +%s | tail -c 6)-${RANDOM}"
 echo "Session ID: $SESSION_ID | Language: $LANGUAGE | Max Parallel: $MAX_PARALLEL"
 ```
 
-### Step 2: Initialize State
+**VALIDATE:** Language must be "rust", "typescript", or "ts"
 
-```typescript
-// State tracking
-const fileState = new Map<string, {
-  attempts: number;
-  status: 'queued' | 'in_progress' | 'success' | 'defer_to_phase2';
-  agentId: string | null;
-  lastError: string | null;
-}>();
-
-const activeAgents = new Map<string, {
-  file: string;
-  agentId: string;
-  taskId: string;
-}>();
-
-const phase2Queue: string[] = [];
-let currentCycle = 0;
+---
+
+### Step 2: Get Error Files
+
+**YOU SHOULD:** Run the appropriate type checker and get files with errors.
+
+**For Rust:**
+```bash
+cd [PROJECT_ROOT]
+# Cargo errors: file paths are on lines starting with "-->"
+SQLX_OFFLINE=true cargo check 2>&1 | grep "^\s*-->" | awk '{print $2}' | awk -F':' '{print $1}' | sort | uniq -c | sort -rn
 ```
 
-### Step 3: Get Error Files (Sorted by Error Count)
+**For TypeScript (tsc):**
+```bash
+cd [PROJECT_ROOT]
+# TypeScript compiler errors: file paths before first parenthesis
+npm run typecheck 2>&1 | grep "error TS" | awk -F'(' '{print $1}' | sort | uniq -c | sort -rn
+```
 
+**For TypeScript (ESLint):**
 ```bash
-# Rust
-if [[ "$LANGUAGE" == "rust" ]]; then
-  ERROR_FILES=$(SQLX_OFFLINE=true cargo check 2>&1 | \
-    grep "^error\[" | \
-    awk -F':' '{print $1}' | \
-    sort | uniq -c | sort -rn | \
-    awk '{print $2}')
+cd [PROJECT_ROOT]
+# ESLint: file paths are on separate lines, extract .ts/.tsx files
+npm run lint 2>&1 > /tmp/eslint-output.txt
+grep -B1 "error" /tmp/eslint-output.txt | grep -v "error\|--" | grep "\.tsx\?$" | sort | uniq -c | sort -rn
+```
 
-  TOTAL_ERRORS=$(SQLX_OFFLINE=true cargo check 2>&1 | grep -c "^error\[")
-fi
+**Alternative (Universal TypeScript/ESLint parser):**
+```bash
+# Save full output first
+npm run lint 2>&1 > /tmp/lint-output.txt || npm run typecheck 2>&1 > /tmp/lint-output.txt
+
+# Parse with Python for robust extraction
+python3 << 'PARSE_SCRIPT'
+import re
+from collections import defaultdict
+
+error_counts = defaultdict(int)
+current_file = None
+
+with open('/tmp/lint-output.txt', 'r') as f:
+    for line in f:
+        # ESLint format: file path on its own line
+        if line.strip().endswith('.ts') or line.strip().endswith('.tsx'):
+            current_file = line.strip()
+        # ESLint error line
+        elif re.search(r'^\s+\d+:\d+\s+(error|warning)', line) and current_file:
+            error_counts[current_file] += 1
+        # TSC format: file.ts(line,col): error TS
+        elif match := re.match(r'^(.+\.tsx?)\(\d+,\d+\):\s+error', line):
+            error_counts[match.group(1)] += 1
+
+# Print sorted by error count
+for file, count in sorted(error_counts.items(), key=lambda x: -x[1])[:30]:
+    print(f"{count:6d} {file}")
+PARSE_SCRIPT
+```
 
-# TypeScript
-if [[ "$LANGUAGE" == "typescript" ]]; then
-  ERROR_FILES=$(npm run type-check 2>&1 | \
-    grep "error TS" | \
-    awk -F'(' '{print $1}' | \
-    sort | uniq -c | sort -rn | \
-    awk '{print $2}')
-
-  TOTAL_ERRORS=$(npm run type-check 2>&1 | grep -c "error TS")
-fi
-
-echo "Found $TOTAL_ERRORS errors across $(echo "$ERROR_FILES" | wc -l) files"
-
-# Initialize file state
-for file in $ERROR_FILES; do
-  fileState.set(file, {
-    attempts: 0,
-    status: 'queued',
-    agentId: null,
-    lastError: null
-  });
-done
+**OUTPUT FORMAT:**
 ```
+  45 src/api/handler.ts
+  32 src/db/models.ts
+  18 src/utils/helpers.ts
+```
+
+**YOU SHOULD:** Store this list and track state for each file:
+- `attempts`: 0-2 (retry counter)
+- `status`: "queued" | "in_progress" | "success" | "defer"
+- `agentId`: null | "agent-session-file"
+
+---
 
-### Step 4: Agent Spawn Loop (Continuous)
+### Step 3: Spawn Agents (Continuous Loop)
+
+**YOU SHOULD:** Spawn agents continuously, maintaining exactly 5 active agents at any time.
+
+**Agent Spawn Pattern:**
 
 ```typescript
-// Main coordination loop
-while (fileQueue.length > 0 || activeAgents.size > 0) {
+// While there are files to process OR active agents running:
+while (fileQueue.length > 0 || activeAgents.length > 0) {
 
-  // Spawn agents up to max parallel
-  while (activeAgents.size < MAX_PARALLEL && fileQueue.length > 0) {
+  // Spawn up to 5 agents
+  while (activeAgents.length < MAX_PARALLEL && fileQueue.length > 0) {
     const file = fileQueue.shift();
-    const state = fileState.get(file);
+    const agentId = `${LANGUAGE}-fixer-${SESSION_ID}-${sanitize(file)}`;
+
+    // Use Task tool with background=true
+    const taskId = Task("rust-developer" OR "typescript-specialist",
+      `[SEE AGENT PROMPT BELOW]`,
+      {run_in_background: true}
+    );
+
+    // Track this agent
+    activeAgents.push({file, agentId, taskId, attempts: 1});
+  }
+
+  // Monitor agents (non-blocking check)
+  for each activeAgent {
+    const result = TaskOutput(agent.taskId, {block: false, timeout: 0});
+
+    if (result.status === 'completed') {
+      // Parse result: SUCCESS | RETRY | DEFER
+      if (result.output.includes('SUCCESS')) {
+        // File fixed! Remove from queue
+      } else if (agent.attempts < 2) {
+        // Retry: add back to queue, increment attempts
+        fileQueue.push(file);
+        fileState[file].attempts++;
+      } else {
+        // 2 attempts failed: defer to Phase 2
+        phase2Queue.push(file);
+      }
 
-    // Skip if already succeeded or deferred
-    if (state.status === 'success' || state.status === 'defer_to_phase2') {
-      continue;
+      // Remove from active agents (frees slot for next file)
+      activeAgents.remove(agent);
     }
+  }
 
-    // Spawn agent for this file
-    const agentId = `${LANGUAGE}-fixer-${SESSION_ID}-${file.replace(/\W/g, '_')}`;
-    state.attempts++;
-    state.status = 'in_progress';
-    state.agentId = agentId;
+  // Small delay to prevent tight loop
+  sleep(1 second);
+}
+```
 
-    const agentType = LANGUAGE === 'rust' ? 'rust-developer' : 'typescript-specialist';
+**AGENT PROMPT TEMPLATE:**
 
-    const taskId = Task(agentType, `
+Use this exact prompt structure for spawned agents:
+
+```
 AGENT_ID="${agentId}"
 FILE_PATH="${file}"
 SESSION_ID="${SESSION_ID}"
-ATTEMPT=${state.attempts}/2
+ATTEMPT=${attempts}/2
 
-TASK: Fix compilation errors in a single file using Cerebras acceleration and post-edit validation.
+TASK: Fix compilation errors in a single file using Cerebras acceleration.
 
 WORKFLOW:
 1. Read file: ${file}
 
-2. Call single-file Cerebras fixer:
-   ${LANGUAGE === 'rust'
-     ? 'npx tsx ./.claude/skills/cfn-compilation-error-fixer/lib/fixer/cerebras-gated-fixer-v2.ts --file="${FILE_PATH}" --agent-id="${AGENT_ID}"'
-     : 'npx tsx ./.claude/skills/cfn-compilation-error-fixer/lib/fixer/typescript-gated-fixer-v2.ts --file="${FILE_PATH}" --agent-id="${AGENT_ID}"'}
+2. Call Cerebras single-file fixer:
+   [FOR RUST]
+   npx tsx /path/to/cerebras-gated-fixer-v2.ts --file="${file}" --agent-id="${agentId}"
+
+   [FOR TYPESCRIPT]
+   npx tsx /path/to/typescript-gated-fixer-v2.ts --file="${file}" --agent-id="${agentId}"
 
 3. Validate with post-edit pipeline:
-   ./.claude/hooks/cfn-invoke-post-edit.sh "${FILE_PATH}" --agent-id "${AGENT_ID}"
+   ./.claude/hooks/cfn-invoke-post-edit.sh "${file}" --agent-id "${agentId}"
 
 4. Return status:
    - If post-edit validation PASSES (exit 0): Return "SUCCESS"
-   - If post-edit validation FAILS (exit 1): Return "RETRY" (if attempt 1) or "DEFER" (if attempt 2)
+   - If post-edit validation FAILS (exit 1): Return "RETRY" (attempt 1) or "DEFER" (attempt 2)
 
-CEREBRAS GATES (12 Structural Validations):
+CEREBRAS GATES:
 - Phase 1a: Cerebras generates fix
-- Phase 1b: Gates validate (LineCount, FnSignature, ImportDup, BraceBalance, SemanticDiff, OrphanedCode, ImportPath, PatternDup, ImplLocation, TypeCast, MatchArm, Regression)
-- Up to 3 retries with feedback per gate rejection
+- Phase 1b: 12 gates validate (LineCount, FnSignature, ImportDup, BraceBalance, SemanticDiff, OrphanedCode, ImportPath, PatternDup, ImplLocation, TypeCast, MatchArm, Regression)
+- Up to 3 retries per gate rejection
 
 CRITICAL RESTRICTIONS:
-- DO NOT run eslint, cargo clippy, cargo fmt, rustfmt, or any linter on the ENTIRE codebase
-- DO NOT run cargo check on the entire project
-- DO NOT run npm run type-check on the entire project
+- DO NOT run eslint, cargo clippy, cargo check, or npm run typecheck on ENTIRE codebase
 - Work ONLY on file: ${file}
-- Use Cerebras tool for speed, not manual fixes
+- Use Cerebras for speed
 - Post-edit validation runs on this file only
 
-POST-EDIT VALIDATION (MANDATORY):
-After Cerebras applies fixes, run:
-./.claude/hooks/cfn-invoke-post-edit.sh "${FILE_PATH}" --agent-id "${AGENT_ID}"
-
 SUCCESS CRITERIA:
 Post-edit pipeline returns exit code 0
 
-RETURN FORMAT:
-{
-  "status": "SUCCESS" | "RETRY" | "DEFER",
-  "file": "${file}",
-  "attempts": ${state.attempts},
-  "errors_fixed": <number>,
-  "validation_passed": <boolean>
-}
-`, {run_in_background: true});
-
-    // Track active agent
-    activeAgents.set(taskId, {
-      file,
-      agentId,
-      taskId
-    });
-
-    echo(`Spawned agent ${agentId} for ${file} (attempt ${state.attempts}/2)`);
-  }
-
-  // Monitor active agents (continuous)
-  if (activeAgents.size > 0) {
-    // Check for completed agents (non-blocking)
-    for (const [taskId, agent] of activeAgents.entries()) {
-      const result = TaskOutput(taskId, {block: false, timeout: 0});
-
-      if (result.status === 'completed') {
-        const state = fileState.get(agent.file);
-
-        // Parse result
-        if (result.output.includes('SUCCESS')) {
-          state.status = 'success';
-          echo(`✓ ${agent.file} - Fixed successfully`);
-        } else if (result.output.includes('DEFER') || state.attempts >= 2) {
-          state.status = 'defer_to_phase2';
-          phase2Queue.push(agent.file);
-          echo(`→ ${agent.file} - Deferred to Phase 2 (${state.attempts} attempts)`);
-        } else {
-          // Retry
-          state.status = 'queued';
-          fileQueue.push(agent.file);
-          echo(`↻ ${agent.file} - Retrying (attempt ${state.attempts + 1}/2)`);
-        }
-
-        // Remove from active agents
-        activeAgents.delete(taskId);
-      }
-    }
-
-    // Small delay to prevent tight loop
-    await sleep(1000);
-  }
-}
+RETURN: Print "SUCCESS" or "DEFER" clearly in your final output.
 ```
 
-### Step 5: Cycle Check (After All Agents Complete)
-
-```bash
-# Wait for all agents to complete
-echo "Waiting for all agents to complete cycle $currentCycle..."
-
-while activeAgents.size > 0; do
-  # Block until any agent completes
-  for (const [taskId, agent] of activeAgents.entries()) {
-    const result = TaskOutput(taskId, {block: true, timeout: 30000});
-
-    if (result.status === 'completed') {
-      // Process result (same as Step 4)
-      activeAgents.delete(taskId);
-      break;
-    }
-  }
-done
-
-# Rerun error check
-echo "Cycle $currentCycle complete. Rechecking errors..."
+---
 
-if [[ "$LANGUAGE" == "rust" ]]; then
-  NEW_ERROR_COUNT=$(SQLX_OFFLINE=true cargo check 2>&1 | grep -c "^error\[")
-else
-  NEW_ERROR_COUNT=$(npm run type-check 2>&1 | grep -c "error TS")
-fi
+### Step 4: Cycle Completion and Phase Transition
 
-echo "Errors: $TOTAL_ERRORS → $NEW_ERROR_COUNT"
+**YOU SHOULD:** After all agents complete (activeAgents.length === 0), check if Phase 2 is needed.
 
-# Update total for next cycle
-PREV_ERROR_COUNT=$TOTAL_ERRORS
-TOTAL_ERRORS=$NEW_ERROR_COUNT
-currentCycle=$((currentCycle + 1))
-```
-
-### Step 6: Phase Transition Logic
+**Recheck Error Count:**
 
 ```bash
-# Check if should proceed to Phase 2
-PROCEED_TO_PHASE2=false
-
-# Condition 1: Error count below threshold
-if [ $TOTAL_ERRORS -lt 40 ]; then
-  echo "Error count below 40 - proceeding to Phase 2"
-  PROCEED_TO_PHASE2=true
-fi
-
-# Condition 2: No progress made
-if [ $TOTAL_ERRORS -eq $PREV_ERROR_COUNT ] && [ $currentCycle -gt 1 ]; then
-  echo "No progress made - proceeding to Phase 2"
-  PROCEED_TO_PHASE2=true
-fi
-
-# Condition 3: Max cycles reached
-if [ $currentCycle -ge $MAX_CYCLES ]; then
-  echo "Max cycles reached - proceeding to Phase 2"
-  PROCEED_TO_PHASE2=true
-fi
-
-# Condition 4: All files processed
-if [ ${#fileQueue[@]} -eq 0 ] && [ ${#phase2Queue[@]} -eq 0 ]; then
-  echo "All files processed successfully!"
-  PROCEED_TO_PHASE2=false
-fi
-
-if [ "$PROCEED_TO_PHASE2" = true ]; then
-  # Proceed to Phase 2
-  echo "=== PHASE 2: Dedicated Agent Cleanup ==="
-else
-  # Continue next cycle
-  echo "=== Continuing Phase 1: Cycle $currentCycle ==="
-  # Go back to Step 3 (get new error files)
-fi
-```
-
-### Step 7: Phase 2 (Dedicated Agent Cleanup)
+# Rust
+SQLX_OFFLINE=true cargo check 2>&1 | grep -c "^error\["
 
-```bash
-if [ "$PROCEED_TO_PHASE2" = true ]; then
+# TypeScript
+npm run typecheck 2>&1 | grep -c "error TS"
+```
 
-  echo "Spawning dedicated ${LANGUAGE}-developer agent for remaining errors..."
+**Phase 2 Triggers:**
+- Error count < 40
+- No progress made (same error count as before)
+- Max cycles reached
+- All files processed (queue empty, no deferrals)
 
-  # Get files with remaining errors
-  PHASE2_FILES=$(echo "$ERROR_FILES" | head -20)
+**IF Phase 2 needed:**
 
-  # Spawn dedicated agent (NOT background - visible progress)
-  Task(${agentType}, `
+```typescript
+// Spawn dedicated cleanup agent (NOT background - visible)
+Task("rust-developer" OR "typescript-specialist", `
 AGENT_ID="${LANGUAGE}-phase2-${SESSION_ID}"
 
 TASK: Fix remaining compilation errors after Phase 1 bulk processing.
 
 CONTEXT:
-- Phase 1 (agent coordination) processed files with Cerebras acceleration
-- Remaining errors require high-quality, context-aware fixes
-- ${TOTAL_ERRORS} errors remaining
+- Phase 1 processed files with Cerebras acceleration
+- ${ERROR_COUNT} errors remaining
+- Errors require context-aware fixes
 
-WORKING DIRECTORY:
-${LANGUAGE === 'rust' ? 'RUST_PROJECT_PATH' : 'TYPESCRIPT_PROJECT_PATH'}
+WORKING DIRECTORY: [PROJECT_ROOT]
 
-STEP 1: Get current error locations
-${LANGUAGE === 'rust'
-  ? 'SQLX_OFFLINE=true cargo check 2>&1 | grep -E "^error\\[E" | sort | uniq -c | sort -rn'
-  : 'npm run type-check 2>&1 | grep -E "error TS" | sort | uniq -c | sort -rn'}
+STEP 1: Get error locations
+[RUST] SQLX_OFFLINE=true cargo check 2>&1 | grep -E "^error\\[E" | sort | uniq -c
+[TYPESCRIPT] npm run typecheck 2>&1 | grep -E "error TS" | sort | uniq -c
 
-STEP 2: Fix each error file in dependency order
+STEP 2: Fix each file
 1. Read FULL file for context
-2. Identify root cause (not just symptom)
-3. Apply minimal fix preserving semantics
+2. Identify root cause (not symptom)
+3. Apply minimal fix
 4. Run post-edit validation:
-   ./.claude/hooks/cfn-invoke-post-edit.sh "\$FILE" --agent-id "${AGENT_ID}"
+   ./.claude/hooks/cfn-invoke-post-edit.sh "$FILE" --agent-id "${AGENT_ID}"
 5. Verify with compiler after EACH file
 
 RULES:
 - Read FULL file before editing
-- Preserve ALL existing imports, don't duplicate
-- Use proper ${LANGUAGE} idioms
-- Fix root causes first (cascading errors will resolve)
+- Preserve ALL existing imports
+- Fix root causes first
 - Verify after EACH file
 - Run post-edit pipeline after EACH edit
 
 RESTRICTIONS:
-- DO NOT run eslint/cargo clippy on entire codebase
+- DO NOT run linters on entire codebase
 - Work on one file at a time
-- Validate each fix before moving to next
-
-COMMON ERROR TYPES:
-${LANGUAGE === 'rust'
-  ? '- E0308 (type mismatch): Add explicit casts or fix generics\n- E0412/E0433/E0425 (missing type/import): Add use statements\n- E0599 (wrong method): Fix method chain\n- E0277 (trait not implemented): Add trait implementations\n- E0382 (borrow checker): Fix ownership issues'
-  : '- TS2307 (module not found): Fix import paths\n- TS2322 (type mismatch): Add type annotations\n- TS2339 (property not exists): Add interface definitions\n- TS7006 (implicit any): Add explicit types\n- TS2688 (cannot find type): Install @types packages'}
 
 Report final error count when done.
 `)
-
-fi
 ```
 
 ---
 
-## State Management
+## Important Notes
+
+### State Tracking
 
-### File State Structure
+**YOU SHOULD** maintain these data structures in memory:
 
 ```typescript
-interface FileState {
-  attempts: number;           // 0-2
-  status: 'queued' | 'in_progress' | 'success' | 'defer_to_phase2';
-  agentId: string | null;     // Current/last agent ID
-  lastError: string | null;   // Last error message
+// File state
+fileState = {
+  "src/api.ts": {attempts: 1, status: "in_progress", agentId: "ts-fixer-123-api"},
+  "src/db.ts": {attempts: 2, status: "defer", agentId: null}
 }
 
-const fileState = new Map<string, FileState>();
+// Active agents
+activeAgents = [
+  {file: "src/api.ts", agentId: "ts-fixer-123-api", taskId: "abc123", attempts: 1}
+]
+
+// Phase 2 queue
+phase2Queue = ["src/db.ts", "src/models.ts"]
 ```
 
-### Active Agent Tracking
+### Error Handling
 
-```typescript
-interface ActiveAgent {
-  file: string;          // File being processed
-  agentId: string;       // Agent identifier
-  taskId: string;        // TaskOutput ID for monitoring
-}
+- If agent fails to spawn: Log error, skip file, continue
+- If TaskOutput times out: Treat as DEFER, add to Phase 2
+- If post-edit hook missing: Warn user, continue without validation
 
-const activeAgents = new Map<string, ActiveAgent>();
-```
+### Progress Reporting
+
+**YOU SHOULD** periodically report progress to user:
+- "Spawned agent 3/5 for src/api.ts (attempt 1/2)"
+- "Agent completed: src/utils.ts - SUCCESS"
+- "Agent completed: src/db.ts - DEFER (2 attempts failed)"
+- "Cycle 1 complete: 45 → 23 errors (-22)"
 
 ---
 
 ## Related Documentation
 
-- **Compilation Error Fixer Skill**: `.claude/skills/cfn-compilation-error-fixer/SKILL.md`
+- **Cerebras Rust Fixer**: `.claude/skills/cfn-compilation-error-fixer/lib/fixer/cerebras-gated-fixer-v2.ts`
+- **Cerebras TypeScript Fixer**: `.claude/skills/cfn-compilation-error-fixer/lib/fixer/typescript-gated-fixer-v2.ts`
 - **Post-Edit Pipeline**: `.claude/hooks/cfn-invoke-post-edit.sh`
-- **Cerebras Gated Fixer (Rust)**: `.claude/skills/cfn-compilation-error-fixer/lib/fixer/cerebras-gated-fixer-v2.ts`
-- **Cerebras Gated Fixer (TypeScript)**: `.claude/skills/cfn-compilation-error-fixer/lib/fixer/typescript-gated-fixer-v2.ts`
 - **Task Mode Reference**: `.claude/commands/cfn-loop-task.md`
 
 ---
 
-**Version History:**
+## Version History
+
+- v1.2.0 (2025-12-21) - Fixed error file extraction patterns for Rust and TypeScript/ESLint
+- v1.1.0 (2025-12-21) - Clarified instructions, removed pseudocode confusion
 - v1.0.0 (2025-12-21) - Initial coordination mode implementation

package/.claude/skills/cfn-compilation-error-fixer/lib/fixer/cerebras-gated-fixer-v2.ts

@@ -12,11 +12,15 @@
  * - Targeted crate compile testing
  */
 
+import * as dotenv from 'dotenv';
 import createCerebrasClient from './cerebras-wrapper.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
 
+// Load environment variables from .env file
+dotenv.config();
+
 // ============== CONFIGURATION ==============
 
 // Parse --file and --agent-id parameters

package/.claude/skills/cfn-compilation-error-fixer/lib/fixer/typescript-gated-fixer-v2.ts

@@ -9,10 +9,14 @@
  * - Phase 2: Dedicated agent cleanup (high quality)
  */
 
+import * as dotenv from 'dotenv';
 import Cerebras from '@cerebras/cerebras_cloud_sdk';
 import * as fs from 'fs';
 import * as path from 'path';
 import { execFileSync, spawnSync } from 'child_process';
+
+// Load environment variables from .env file
+dotenv.config();
 import {
   gateLineCountDelta,
   gateMethodSignature,
@@ -167,9 +171,9 @@ function validateApiKey(apiKey: string | undefined): boolean {
     return false;
   }
 
-  // Check for basic format (starts with sk- and reasonable length)
-  if (!apiKey.startsWith('sk-') || apiKey.length < 20) {
-    console.error('❌ Security: Invalid API key format');
+  // Check for basic format (starts with sk- or csk- and reasonable length)
+  if ((!apiKey.startsWith('sk-') && !apiKey.startsWith('csk-')) || apiKey.length < 20) {
+    console.error('❌ Security: Invalid API key format (expected sk-* or csk-*)');
     return false;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow-novice",
-  "version": "2.18.29",
+  "version": "2.18.32",
   "description": "Claude Flow Novice - Advanced orchestration platform for multi-agent AI workflows with CFN Loop architecture\n\nIncludes Local RuVector Accelerator and all CFN skills for complete functionality.",
   "main": "index.js",
   "type": "module",