claude-evolve 1.8.5 → 1.8.8

package/bin/claude-evolve-run

@@ -295,8 +295,23 @@ get_csv_stats() {
 echo "[DISPATCHER] Starting unified evolution engine"
 echo "[DISPATCHER] Configuration: max_workers=$MAX_WORKERS, timeout=${timeout_seconds:-none}"
 
-# Clean up any stuck 'running' statuses at startup
+# Clean up any stuck 'running' statuses and duplicates at startup
 if [[ -f "$FULL_CSV_PATH" ]]; then
+  echo "[DISPATCHER] Checking for duplicate candidates..."
+  "$PYTHON_CMD" -c "
+import sys
+sys.path.insert(0, '$SCRIPT_DIR/..')
+from lib.evolution_csv import EvolutionCSV
+
+try:
+    with EvolutionCSV('$FULL_CSV_PATH') as csv:
+        dup_count = csv.remove_duplicate_candidates()
+        if dup_count == 0:
+            print('[DISPATCHER] No duplicate candidates found', file=sys.stderr)
+except Exception as e:
+    print(f'[ERROR] Failed to remove duplicates: {e}', file=sys.stderr)
+" 2>&1 || true
+
   echo "[DISPATCHER] Resetting any stuck 'running' candidates to 'pending'..."
   if "$SCRIPT_DIR/claude-evolve-edit" running pending >/dev/null 2>&1; then
     echo "[DISPATCHER] Successfully reset stuck candidates"
@@ -583,44 +598,17 @@ while true; do
     if [[ -f "$FULL_CSV_PATH" && ${#worker_pids[@]} -eq 0 ]]; then
       echo "[DISPATCHER] Checking for stuck candidates (no active workers)..."
       "$PYTHON_CMD" -c "
-import csv
 import sys
-from pathlib import Path
-
-csv_file = '$FULL_CSV_PATH'
-rows = []
-
-with open(csv_file, 'r') as f:
-    rows = list(csv.reader(f))
+sys.path.insert(0, '$SCRIPT_DIR/..')
+from lib.evolution_csv import EvolutionCSV
 
-reset_count = 0
-has_header = rows and rows[0] and rows[0][0].lower() == 'id'
-start_idx = 1 if has_header else 0
-
-for i in range(start_idx, len(rows)):
-    if len(rows[i]) > 4:
-        status = rows[i][4].strip() if rows[i][4] else ''
-        candidate_id = rows[i][0] if rows[i] else ''
-
-        # Reset 'running' when no workers are active
-        if status == 'running':
-            print(f'[INFO] Resetting stuck running candidate: {candidate_id}', file=sys.stderr)
-            rows[i][4] = 'pending'
-            reset_count += 1
-        # Reset unknown statuses like 'ready'
-        elif status not in ['', 'pending', 'complete', 'failed', 'failed-ai-retry',
-                           'failed-retry1', 'failed-retry2', 'failed-retry3', 'skipped',
-                           'failed-parent-missing']:
-            print(f'[WARN] Resetting unknown status \"{status}\" to pending: {candidate_id}', file=sys.stderr)
-            rows[i][4] = 'pending'
-            reset_count += 1
-
-if reset_count > 0:
-    with open(csv_file + '.tmp', 'w', newline='') as f:
-        csv.writer(f).writerows(rows)
-    Path(csv_file + '.tmp').rename(csv_file)
-    print(f'[INFO] Reset {reset_count} stuck/unknown candidates to pending', file=sys.stderr)
-" || true
+try:
+    with EvolutionCSV('$FULL_CSV_PATH') as csv:
+        reset_count = csv.reset_stuck_candidates()
+except Exception as e:
+    print(f'[ERROR] Failed to reset stuck candidates: {e}', file=sys.stderr)
+    sys.exit(1)
+"
     fi
   fi
 
@@ -642,22 +630,17 @@ if reset_count > 0:
     # Before blocking, do final check for stuck work (immediate, not periodic)
     echo "[DISPATCHER] Performing final verification for stuck candidates..."
     stuck_work_count=$("$PYTHON_CMD" -c "
-import csv
-csv_file = '$FULL_CSV_PATH'
-stuck = 0
-with open(csv_file, 'r') as f:
-    reader = csv.reader(f)
-    next(reader, None)  # Skip header
-    for row in reader:
-        if len(row) > 4:
-            status = row[4].strip() if row[4] else ''
-            # Count running, unknown, and retry statuses
-            if status in ['running'] or \
-               (status and status not in ['', 'pending', 'complete', 'failed', 'skipped',
-                                          'failed-ai-retry', 'failed-retry1', 'failed-retry2', 'failed-retry3',
-                                          'failed-parent-missing']):
-                stuck += 1
-print(stuck)
+import sys
+sys.path.insert(0, '$SCRIPT_DIR/..')
+from lib.evolution_csv import EvolutionCSV
+
+try:
+    with EvolutionCSV('$FULL_CSV_PATH') as csv:
+        stuck = csv.count_stuck_candidates()
+        print(stuck)
+except Exception as e:
+    print(f'[ERROR] Failed to count stuck candidates: {e}', file=sys.stderr)
+    print('0')  # Default to 0 on error
 " 2>/dev/null || echo "0")
 
     if [[ $stuck_work_count -gt 0 ]]; then

package/bin/claude-evolve-worker

@@ -297,13 +297,22 @@ with EvolutionCSV('$FULL_CSV_PATH') as csv:
     if [[ "$current_status" == "complete" ]]; then
       echo "[WORKER-$$] Already evaluated - skipping"
       # Reset status back to complete since get_next_pending_candidate() set it to running
-      "$PYTHON_CMD" -c "
+      if ! "$PYTHON_CMD" -c "
 import sys
 sys.path.insert(0, '$SCRIPT_DIR/..')
 from lib.evolution_csv import EvolutionCSV
 with EvolutionCSV('$FULL_CSV_PATH') as csv:
-    csv.update_candidate_status('$candidate_id', 'complete')
-" 2>/dev/null || true
+    success = csv.update_candidate_status('$candidate_id', 'complete')
+    if not success:
+        print(f'ERROR: Failed to update status for $candidate_id', file=sys.stderr)
+        sys.exit(1)
+"; then
+        echo "[WORKER-$$] ERROR: Failed to reset status to complete for $candidate_id" >&2
+        # Don't clear CURRENT_CANDIDATE_ID so cleanup handler can try again
+        return 1
+      fi
+
+      echo "[WORKER-$$] Status confirmed as complete"
       # Clear CURRENT_CANDIDATE_ID before returning to prevent cleanup from interfering
       CURRENT_CANDIDATE_ID=""
       return 0
@@ -591,11 +600,17 @@ with EvolutionCSV('$FULL_CSV_PATH') as csv:
     if rows:
         start_idx = 1 if rows and rows[0] and rows[0][0].lower() == 'id' else 0
         status_count = {}
+        running_candidates = []
         for row in rows[start_idx:]:
             if len(row) > 4:
                 status = row[4].strip() or 'pending'
                 status_count[status] = status_count.get(status, 0) + 1
+                if status == 'running':
+                    candidate_id = row[0].strip().strip('\"') if len(row) > 0 else '?'
+                    running_candidates.append(candidate_id)
         print(f'Status counts: {status_count}', file=sys.stderr)
+        if running_candidates:
+            print(f'Running candidates: {running_candidates}', file=sys.stderr)
 " 2>&1 || true
 
   # Try to claim a pending candidate

package/lib/evolution_csv.py

@@ -205,27 +205,33 @@ class EvolutionCSV:
         rows = self._read_csv()
         if not rows:
             return False
-            
+
         updated = False
-        
+        update_count = 0
+
         # Skip header row if it exists
         start_idx = 1 if rows and rows[0] and rows[0][0].lower() == 'id' else 0
-        
+
+        # Update ALL matching rows (in case of duplicates)
         for i in range(start_idx, len(rows)):
             row = rows[i]
-            
+
             if self.is_valid_candidate_row(row) and row[0].strip().strip('"') == candidate_id.strip().strip('"'):
                 # Ensure row has at least 5 columns
                 while len(row) < 5:
                     row.append('')
-                    
+
                 row[4] = new_status
                 updated = True
-                break
-                
+                update_count += 1
+                # Don't break - continue to update ALL instances (handles duplicates)
+
+        if update_count > 1:
+            print(f'[WARN] Updated {update_count} duplicate entries for candidate {candidate_id} to status {new_status}', file=sys.stderr)
+
         if updated:
             self._write_csv(rows)
-            
+
         return updated
         
     def update_candidate_performance(self, candidate_id: str, performance: str) -> bool:
@@ -233,27 +239,33 @@ class EvolutionCSV:
         rows = self._read_csv()
         if not rows:
             return False
-            
+
         updated = False
-        
+        update_count = 0
+
         # Skip header row if it exists
         start_idx = 1 if rows and rows[0] and rows[0][0].lower() == 'id' else 0
-        
+
+        # Update ALL matching rows (in case of duplicates)
         for i in range(start_idx, len(rows)):
             row = rows[i]
-            
+
             if self.is_valid_candidate_row(row) and row[0].strip().strip('"') == candidate_id.strip().strip('"'):
                 # Ensure row has at least 4 columns
                 while len(row) < 4:
                     row.append('')
-                    
+
                 row[3] = performance  # Performance is column 4 (index 3)
                 updated = True
-                break
-                
+                update_count += 1
+                # Don't break - continue to update ALL instances (handles duplicates)
+
+        if update_count > 1:
+            print(f'[WARN] Updated {update_count} duplicate entries for candidate {candidate_id} performance', file=sys.stderr)
+
         if updated:
             self._write_csv(rows)
-            
+
         return updated
         
     def update_candidate_field(self, candidate_id: str, field_name: str, value: str) -> bool:
@@ -304,8 +316,10 @@ class EvolutionCSV:
         
         # Update the candidate's field
         updated = False
+        update_count = 0
         start_idx = 1 if has_header else 0
-        
+
+        # Update ALL matching rows (in case of duplicates)
         for i in range(start_idx, len(rows)):
             row = rows[i]
             # Strip quotes from both stored ID and search ID for comparison
@@ -315,14 +329,18 @@ class EvolutionCSV:
                 # Ensure row has enough columns
                 while len(row) <= field_index:
                     row.append('')
-                    
+
                 row[field_index] = value
                 updated = True
-                break
-                
+                update_count += 1
+                # Don't break - continue to update ALL instances (handles duplicates)
+
+        if update_count > 1:
+            print(f'[WARN] Updated {update_count} duplicate entries for candidate {candidate_id} field {field_name}', file=sys.stderr)
+
         if updated:
             self._write_csv(rows)
-            
+
         return updated
         
     def get_candidate_info(self, candidate_id: str) -> Optional[Dict[str, str]]:
@@ -416,6 +434,126 @@ class EvolutionCSV:
 
         return fixed_count
 
+    def reset_stuck_candidates(self) -> int:
+        """
+        Reset 'running' candidates and unknown statuses to 'pending'.
+        Should only be called when no workers are active.
+        Returns the number of candidates reset.
+        """
+        rows = self._read_csv()
+        if not rows:
+            return 0
+
+        reset_count = 0
+        has_header = rows and rows[0] and rows[0][0].lower() == 'id'
+        start_idx = 1 if has_header else 0
+
+        valid_statuses = {'', 'pending', 'complete', 'failed', 'failed-ai-retry',
+                         'failed-retry1', 'failed-retry2', 'failed-retry3', 'skipped',
+                         'failed-parent-missing', 'running'}
+
+        # Track seen IDs to detect duplicates
+        seen_ids = {}
+
+        for i in range(start_idx, len(rows)):
+            if len(rows[i]) > 4:
+                status = rows[i][4].strip() if rows[i][4] else ''
+                candidate_id = rows[i][0].strip().strip('"') if rows[i] else ''
+
+                # Check for duplicate IDs
+                if candidate_id in seen_ids:
+                    print(f'[WARN] Duplicate candidate ID found: {candidate_id} at rows {seen_ids[candidate_id]} and {i}', file=sys.stderr)
+                    print(f'[WARN] Row {seen_ids[candidate_id]}: status={rows[seen_ids[candidate_id]][4] if len(rows[seen_ids[candidate_id]]) > 4 else "?"}', file=sys.stderr)
+                    print(f'[WARN] Row {i}: status={status}', file=sys.stderr)
+                else:
+                    seen_ids[candidate_id] = i
+
+                # Reset 'running' when no workers are active
+                if status == 'running':
+                    print(f'[INFO] Resetting stuck running candidate: {candidate_id} (row {i})', file=sys.stderr)
+                    rows[i][4] = 'pending'
+                    reset_count += 1
+                # Reset unknown statuses
+                elif status not in valid_statuses:
+                    print(f'[WARN] Resetting unknown status "{status}" to pending: {candidate_id}', file=sys.stderr)
+                    rows[i][4] = 'pending'
+                    reset_count += 1
+
+        if reset_count > 0:
+            self._write_csv(rows)
+            print(f'[INFO] Reset {reset_count} stuck/unknown candidates to pending', file=sys.stderr)
+
+        return reset_count
+
+    def count_stuck_candidates(self) -> int:
+        """
+        Count candidates that are stuck (running or have unknown status).
+        Returns the number of stuck candidates.
+        """
+        rows = self._read_csv()
+        if not rows:
+            return 0
+
+        stuck = 0
+        has_header = rows and rows[0] and rows[0][0].lower() == 'id'
+        start_idx = 1 if has_header else 0
+
+        valid_statuses = {'', 'pending', 'complete', 'failed', 'failed-ai-retry',
+                         'failed-retry1', 'failed-retry2', 'failed-retry3', 'skipped',
+                         'failed-parent-missing'}
+
+        for i in range(start_idx, len(rows)):
+            if len(rows[i]) > 4:
+                status = rows[i][4].strip() if rows[i][4] else ''
+                # Count running and unknown statuses
+                if status == 'running' or (status and status not in valid_statuses):
+                    stuck += 1
+
+        return stuck
+
+    def remove_duplicate_candidates(self) -> int:
+        """
+        Remove duplicate candidate entries, keeping only the first occurrence.
+        Returns the number of duplicates removed.
+        """
+        rows = self._read_csv()
+        if not rows:
+            return 0
+
+        has_header = rows and rows[0] and rows[0][0].lower() == 'id'
+        start_idx = 1 if has_header else 0
+
+        # Track seen IDs and their row indices
+        seen_ids = {}
+        rows_to_remove = []
+
+        for i in range(start_idx, len(rows)):
+            if len(rows[i]) > 0:
+                candidate_id = rows[i][0].strip().strip('"')
+
+                if candidate_id in seen_ids:
+                    # Duplicate found
+                    first_row = seen_ids[candidate_id]
+                    status_first = rows[first_row][4] if len(rows[first_row]) > 4 else ''
+                    status_dup = rows[i][4] if len(rows[i]) > 4 else ''
+
+                    print(f'[WARN] Removing duplicate candidate {candidate_id}:', file=sys.stderr)
+                    print(f'[WARN]   Keeping row {first_row}: status={status_first}', file=sys.stderr)
+                    print(f'[WARN]   Removing row {i}: status={status_dup}', file=sys.stderr)
+                    rows_to_remove.append(i)
+                else:
+                    seen_ids[candidate_id] = i
+
+        if rows_to_remove:
+            # Remove rows in reverse order to maintain indices
+            for idx in sorted(rows_to_remove, reverse=True):
+                del rows[idx]
+
+            self._write_csv(rows)
+            print(f'[INFO] Removed {len(rows_to_remove)} duplicate candidate(s)', file=sys.stderr)
+
+        return len(rows_to_remove)
+
     def has_pending_work(self) -> bool:
         """Check if there are any pending candidates. Used by dispatcher."""
         return self.count_pending_candidates() > 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-evolve",
-  "version": "1.8.5",
+  "version": "1.8.8",
   "bin": {
     "claude-evolve": "./bin/claude-evolve",
     "claude-evolve-main": "./bin/claude-evolve-main",