feat: add comprehensive database maintenance and diagnostic tools

Add suite of database maintenance, diagnostic, and emergency repair tools
to improve system reliability and support development workflows.

Database maintenance tools:
- apply_schema_fix.py - Apply schema corrections and validations
- check_db_access.py - Verify database connectivity and permissions
- check_schema.py - Validate database schema integrity
- create_fresh_db.py - Initialize clean database for development
- emergency_schema_fix.py - Emergency schema repair procedures
- fix_db_simple.py - Simplified database repair workflows
- fix_schema.sql - SQL scripts for schema corrections
- fix_unicode_error.py - Handle encoding and Unicode issues

Emergency and diagnostic tools:
- emergency_fix.py - Critical system repair procedures
- quick_fix.py - Rapid issue resolution scripts
- run_fix.py - Automated fix execution framework
- verify_fix.py - Validation and testing after repairs
- debug_maintenance_issue.py - Maintenance coordinator debugging

Cleanup and task management:
- cleanup_duplicate_tasks.py - Remove duplicate task entries
- cleanup_old_tasks.py - Archive and clean stale tasks
- simple_cleanup_script.py - Basic maintenance routines
- test_maintenance_fix.py - Validate maintenance operations

Benefits:
- ✅ Improved system reliability and recovery capabilities
- ✅ Better diagnostic tools for troubleshooting issues
- ✅ Automated maintenance and cleanup procedures
- ✅ Emergency repair capabilities for production issues
- ✅ Enhanced development workflow support

🔧 Enhanced system maintenance and diagnostic capabilities

Author: EchoingVesper

apply_schema_fix.py

@@ -0,0 +1,61 @@
+import sqlite3
+import os
+
+# Change to project directory
+import sys
+from pathlib import Path
+os.chdir(Path(__file__).parent)
+
+print("🔧 Applying emergency database schema fix...")
+
+# Connect to database
+conn = sqlite3.connect("task_orchestrator.db")
+cursor = conn.cursor()
+
+# Check current schema
+cursor.execute("PRAGMA table_info(subtasks)")
+columns = cursor.fetchall()
+existing_cols = [col[1] for col in columns]
+print(f"Current columns: {existing_cols}")
+
+# Add missing columns
+fixes = [
+    "ALTER TABLE subtasks ADD COLUMN verification_status TEXT DEFAULT 'pending';",
+    "ALTER TABLE subtasks ADD COLUMN prerequisite_satisfaction_required BOOLEAN DEFAULT 0;",
+    "ALTER TABLE subtasks ADD COLUMN auto_maintenance_enabled BOOLEAN DEFAULT 1;",
+    "ALTER TABLE subtasks ADD COLUMN quality_gate_level TEXT DEFAULT 'standard';"
+]
+
+applied_fixes = []
+for fix in fixes:
+    try:
+        cursor.execute(fix)
+        applied_fixes.append(fix)
+        print(f"✅ Applied: {fix}")
+    except Exception as e:
+        if "duplicate column name" in str(e):
+            print(f"⚠️ Column already exists: {fix}")
+        else:
+            print(f"❌ Failed: {fix} - {e}")
+
+conn.commit()
+conn.close()
+
+print(f"\n✅ Applied {len(applied_fixes)} schema fixes!")
+print("\n🧪 Testing orchestrator functionality...")
+
+try:
+    from mcp_task_orchestrator.db.persistence import DatabasePersistenceManager
+    persistence = DatabasePersistenceManager()
+    tasks = persistence.get_all_active_tasks()
+    print(f"✅ Successfully imported and got {len(tasks)} active tasks")
+    persistence.dispose()
+    print("✅ Database connection disposed properly")
+    print("\n🎉 Emergency schema repair SUCCESSFUL!")
+    print("\n📋 Next steps:")
+    print("1. Restart Claude Desktop to clear any cached tool states")
+    print("2. Test the orchestration tools to verify they work") 
+    print("3. If working, proceed with Phase 2: orchestrated migration system")
+except Exception as e:
+    print(f"❌ Orchestrator still not working: {e}")
+    print("Additional investigation may be needed")

check_db_access.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""Check database access and try to fix issues."""
+
+import os
+import shutil
+import sqlite3
+from pathlib import Path
+
+os.chdir(Path(__file__).parent)
+
+print("🔍 Checking database access...")
+
+# Try to copy the database file first
+try:
+    shutil.copy2("task_orchestrator.db", "task_orchestrator_backup.db")
+    print("✅ Created backup: task_orchestrator_backup.db")
+except Exception as e:
+    print(f"❌ Failed to create backup: {e}")
+
+# Try to create a new temporary database
+try:
+    test_conn = sqlite3.connect("test_db.db")
+    test_conn.execute("CREATE TABLE test (id INTEGER)")
+    test_conn.close()
+    os.remove("test_db.db")
+    print("✅ Can create new databases")
+except Exception as e:
+    print(f"❌ Cannot create new databases: {e}")
+
+# Try to open the database in read-only mode
+try:
+    conn = sqlite3.connect("file:task_orchestrator.db?mode=ro", uri=True)
+    cursor = conn.cursor()
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
+    tables = cursor.fetchall()
+    print(f"✅ Can read database - Tables: {[t[0] for t in tables]}")
+    conn.close()
+except Exception as e:
+    print(f"❌ Cannot read database: {e}")
+
+print("\n💡 Attempting to recreate database with schema...")
+
+# If we can't access the original, create a fresh one
+try:
+    # Move the old one out of the way
+    if os.path.exists("task_orchestrator.db"):
+        os.rename("task_orchestrator.db", "task_orchestrator_old.db")
+        print("📦 Moved old database to task_orchestrator_old.db")
+    
+    # Create new database with proper schema
+    from mcp_task_orchestrator.db.models import Base
+    from sqlalchemy import create_engine
+    
+    engine = create_engine('sqlite:///task_orchestrator.db')
+    Base.metadata.create_all(engine)
+    engine.dispose()
+    
+    print("✅ Created new database with proper schema!")
+    
+except Exception as e:
+    print(f"❌ Failed to recreate database: {e}")

check_schema.py

@@ -0,0 +1,14 @@
+import sqlite3
+
+conn = sqlite3.connect('task_orchestrator.db')
+cursor = conn.cursor()
+
+# Get table schema
+cursor.execute("PRAGMA table_info(subtasks)")
+columns = cursor.fetchall()
+
+print("Subtasks table schema:")
+for col in columns:
+    print(f"  {col[1]}: {col[2]}")
+
+conn.close()

cleanup_duplicate_tasks.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""Clean up duplicate Generic Task Model tasks, keeping only the enhanced plan."""
+
+import sqlite3
+import os
+from datetime import datetime
+
+def cleanup_duplicate_tasks():
+    """Remove duplicate task plans, keeping only the enhanced version."""
+    
+    db_path = os.path.join(".task_orchestrator", "orchestrator_state.db")
+    
+    if not os.path.exists(db_path):
+        print("❌ Database not found")
+        return False
+        
+    try:
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        
+        # First, let's see what parent tasks we have
+        cursor.execute("""
+            SELECT DISTINCT parent_task_id, created_at 
+            FROM tasks 
+            WHERE parent_task_id IS NOT NULL 
+            ORDER BY created_at DESC
+        """)
+        parent_tasks = cursor.fetchall()
+        
+        print(f"Found {len(parent_tasks)} parent task groups")
+        
+        # Find all tasks related to Generic Task Model (older versions)
+        cursor.execute("""
+            SELECT task_id, title, created_at, parent_task_id
+            FROM tasks
+            WHERE (title LIKE '%Plugin Architecture%' 
+                   OR title LIKE '%Task Type Registry%'
+                   OR title LIKE '%Extensible%Attributes%'
+                   OR title LIKE '%Generic Task Model%')
+            AND created_at < '2025-06-03 06:36:00'
+            ORDER BY created_at
+        """)
+        
+        old_tasks = cursor.fetchall()
+        print(f"\nFound {len(old_tasks)} old Generic Task Model tasks to remove")
+        
+        if old_tasks:
+            # Get parent task IDs from old tasks
+            old_parent_ids = set()
+            for task in old_tasks:
+                if task[3]:  # parent_task_id
+                    old_parent_ids.add(task[3])
+            
+            # Delete old subtasks
+            old_task_ids = [task[0] for task in old_tasks]
+            placeholders = ','.join('?' * len(old_task_ids))
+            cursor.execute(f"DELETE FROM tasks WHERE task_id IN ({placeholders})", old_task_ids)
+            
+            # Delete old parent tasks
+            if old_parent_ids:
+                placeholders = ','.join('?' * len(old_parent_ids))
+                cursor.execute(f"DELETE FROM tasks WHERE task_id IN ({placeholders})", list(old_parent_ids))
+                print(f"Deleted {len(old_parent_ids)} old parent tasks")
+            
+            print(f"Deleted {len(old_task_ids)} old subtasks")
+            
+        # Verify what's left
+        cursor.execute("""
+            SELECT COUNT(*) FROM tasks WHERE status = 'pending'
+        """)
+        remaining = cursor.fetchone()[0]
+        print(f"\n✅ Cleanup complete. {remaining} tasks remaining (should be 24)")
+        
+        conn.commit()
+        conn.close()
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error during cleanup: {e}")
+        return False
+
+if __name__ == "__main__":
+    cleanup_duplicate_tasks()

cleanup_old_tasks.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+Direct cleanup script to archive old tasks from the database.
+"""
+
+import sqlite3
+import datetime
+from pathlib import Path
+import json
+
+def cleanup_old_tasks(db_path, age_days=2):
+    """Archive tasks older than specified days."""
+    
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+    
+    # Calculate cutoff date
+    cutoff_date = datetime.datetime.now() - datetime.timedelta(days=age_days)
+    
+    print(f"Archiving tasks older than {age_days} days (before {cutoff_date.strftime('%Y-%m-%d')})")
+    print("=" * 80)
+    
+    # Find old active/pending tasks
+    cursor.execute("""
+        SELECT task_id, title, status, specialist_type, created_at 
+        FROM subtasks 
+        WHERE status IN ('active', 'pending') 
+        AND created_at < ?
+        ORDER BY created_at
+    """, (cutoff_date.isoformat(),))
+    
+    old_tasks = cursor.fetchall()
+    
+    if not old_tasks:
+        print("No old tasks found to archive.")
+        return
+    
+    print(f"\nFound {len(old_tasks)} tasks to archive:")
+    
+    # Create archive record
+    archive_data = {
+        'archived_at': datetime.datetime.now().isoformat(),
+        'reason': f'Tasks older than {age_days} days',
+        'tasks': []
+    }
+    
+    for task in old_tasks:
+        task_id, title, status, specialist_type, created_at = task
+        print(f"\n  - {task_id}")
+        print(f"    Title: {title}")
+        print(f"    Status: {status}")
+        print(f"    Created: {created_at}")
+        
+        archive_data['tasks'].append({
+            'task_id': task_id,
+            'title': title,
+            'status': status,
+            'specialist_type': specialist_type,
+            'created_at': created_at
+        })
+    
+    # Save archive
+    archive_dir = Path("archives/task_cleanup")
+    archive_dir.mkdir(parents=True, exist_ok=True)
+    
+    archive_file = archive_dir / f"archived_tasks_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+    with open(archive_file, 'w') as f:
+        json.dump(archive_data, f, indent=2)
+    
+    print(f"\n\nArchive saved to: {archive_file}")
+    
+    # Ask for confirmation
+    response = input("\nProceed with archiving these tasks? (yes/no): ")
+    
+    if response.lower() == 'yes':
+        # Update tasks to completed with archive note
+        for task in old_tasks:
+            cursor.execute("""
+                UPDATE subtasks 
+                SET status = 'completed',
+                    results = 'Archived due to age (auto-cleanup)',
+                    completed_at = ?
+                WHERE task_id = ?
+            """, (datetime.datetime.now().isoformat(), task[0]))
+        
+        conn.commit()
+        print(f"\n✓ Successfully archived {len(old_tasks)} tasks")
+    else:
+        print("\nArchiving cancelled.")
+    
+    conn.close()
+
+if __name__ == "__main__":
+    db_path = Path("task_orchestrator.db")
+    
+    if not db_path.exists():
+        print("Database not found!")
+        exit(1)
+    
+    cleanup_old_tasks(db_path)

create_fresh_db.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""Create a fresh database with the correct schema."""
+
+import os
+import sys
+from pathlib import Path
+
+# Add the project root to Python path
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+os.chdir(project_root)
+
+print("🔧 Creating fresh database with correct schema...")
+
+try:
+    # Import the models to get the schema
+    from mcp_task_orchestrator.db.models import Base
+    from sqlalchemy import create_engine
+    
+    # Create a new database file with a different name
+    db_path = "task_orchestrator_new.db"
+    
+    # Remove if exists
+    if os.path.exists(db_path):
+        os.remove(db_path)
+    
+    # Create new database with schema
+    engine = create_engine(f'sqlite:///{db_path}')
+    Base.metadata.create_all(engine)
+    engine.dispose()
+    
+    print(f"✅ Created new database: {db_path}")
+    
+    # Verify the schema
+    import sqlite3
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+    
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
+    tables = [row[0] for row in cursor.fetchall()]
+    print(f"📋 Tables created: {tables}")
+    
+    # Check subtasks schema
+    cursor.execute("PRAGMA table_info(subtasks)")
+    columns = cursor.fetchall()
+    print(f"\n📊 Subtasks table columns:")
+    for col in columns:
+        print(f"  - {col[1]}: {col[2]}")
+    
+    conn.close()
+    
+    print(f"\n✅ Database created successfully!")
+    print(f"\n📋 Next steps:")
+    print(f"1. Stop any running orchestrator processes")
+    print(f"2. In Windows, rename task_orchestrator.db to task_orchestrator_old.db")
+    print(f"3. Rename task_orchestrator_new.db to task_orchestrator.db")
+    print(f"4. Restart the orchestrator")
+    
+except Exception as e:
+    print(f"❌ Failed to create database: {e}")
+    import traceback
+    traceback.print_exc()