synapse-hub 2.7.0 → 3.0.1

package/tools/cache_resolver.py

@@ -313,7 +313,7 @@ def init_db(seed=True, target_db=None):
         try:
             cursor.execute("ALTER TABLE healing_cache ADD COLUMN code_patch TEXT DEFAULT ''")
         except sqlite3.OperationalError:
-            column_exists = True
+            _ = True
 
         # 2. Negative Memory Table (Blacklist of Failed Fix Attempts)
         cursor.execute("""
@@ -362,30 +362,29 @@ def init_db(seed=True, target_db=None):
         # Migrate existing solutions from local DB if initializing global DB for the first time
         if current_db == GLOBAL_DB and os.path.exists(LOCAL_DB):
             try:
-                local_conn = get_db(LOCAL_DB)
-                rows = local_conn.execute("SELECT * FROM healing_cache").fetchall()
-                for r in rows:
-                    cursor.execute("""
-                        INSERT OR IGNORE INTO healing_cache 
-                        (error_signature, module_name, symptom, root_cause, groovy_patch, hit_count)
-                        VALUES (?, ?, ?, ?, ?, ?)
-                    """, (r["error_signature"], r["module_name"], r["symptom"], r["root_cause"], r["groovy_patch"], r["hit_count"]))
-                conn.commit()
-                local_conn.close()
+                with get_db(LOCAL_DB) as local_conn:
+                    rows = local_conn.execute("SELECT * FROM healing_cache").fetchall()
+                    for r in rows:
+                        cursor.execute("""
+                            INSERT OR IGNORE INTO healing_cache
+                            (error_signature, module_name, symptom, root_cause, groovy_patch, hit_count)
+                            VALUES (?, ?, ?, ?, ?, ?)
+                        """, (r["error_signature"], r["module_name"], r["symptom"], r["root_cause"], r["groovy_patch"], r["hit_count"]))
+                    conn.commit()
             except (sqlite3.Error, OSError) as e:
                 sys.stderr.write(f"Notice: Local cache migration skipped: {e}\n")
 
         if seed:
             for s in SEED_SOLUTIONS:
                 cursor.execute("""
-                    INSERT OR IGNORE INTO healing_cache 
+                    INSERT OR IGNORE INTO healing_cache
                     (error_signature, module_name, symptom, root_cause, groovy_patch)
                     VALUES (?, ?, ?, ?, ?)
                 """, (s["error_signature"], s["module_name"], s["symptom"], s["root_cause"], s["groovy_patch"]))
 
             for f in SEED_FAILED_FIXES:
                 cursor.execute("""
-                    SELECT COUNT(*) as cnt FROM failed_fixes 
+                    SELECT COUNT(*) as cnt FROM failed_fixes
                     WHERE error_signature = ? AND attempted_patch = ?
                 """, (f["error_signature"], f["attempted_patch"]))
                 if cursor.fetchone()["cnt"] == 0:
@@ -394,17 +393,17 @@ def init_db(seed=True, target_db=None):
                         VALUES (?, ?, ?, ?)
                     """, (f["error_signature"], f["attempted_patch"], f["failure_reason"], f["agent_role"]))
 
-            for l in SEED_LESSONS_LEARNED:
+            for les in SEED_LESSONS_LEARNED:
                 cursor.execute("""
-                    SELECT COUNT(*) as cnt FROM lessons_learned 
+                    SELECT COUNT(*) as cnt FROM lessons_learned
                     WHERE error_signature = ? AND page_context = ?
-                """, (l["error_signature"], l["page_context"]))
+                """, (les["error_signature"], les["page_context"]))
                 if cursor.fetchone()["cnt"] == 0:
                     cursor.execute("""
-                        INSERT INTO lessons_learned 
+                        INSERT INTO lessons_learned
                         (page_context, error_signature, root_cause, failed_attempt, successful_fix, lesson_summary)
                         VALUES (?, ?, ?, ?, ?, ?)
-                    """, (l["page_context"], l["error_signature"], l["root_cause"], l["failed_attempt"], l["successful_fix"], l["lesson_summary"]))
+                    """, (les["page_context"], les["error_signature"], les["root_cause"], les["failed_attempt"], les["successful_fix"], les["lesson_summary"]))
             conn.commit()
 
 
@@ -552,7 +551,7 @@ def get_failed_fixes(error_signature):
     with get_db() as conn:
         cursor = conn.cursor()
         cursor.execute("""
-            SELECT * FROM failed_fixes 
+            SELECT * FROM failed_fixes
             WHERE error_signature = ? OR error_signature LIKE ?
             ORDER BY created_at DESC
         """, (error_signature, f"%{error_signature}%"))
@@ -587,7 +586,7 @@ def query_solution(error_signature, module_name="GLOBAL", threshold=0.35):
         cursor = conn.cursor()
         # 1. Exact match with module
         cursor.execute("""
-            SELECT * FROM healing_cache 
+            SELECT * FROM healing_cache
             WHERE error_signature = ? AND module_name = ?
         """, (error_signature, module_name))
         row = cursor.fetchone()
@@ -596,7 +595,7 @@ def query_solution(error_signature, module_name="GLOBAL", threshold=0.35):
         # 2. Fallback to GLOBAL match
         if not row:
             cursor.execute("""
-                SELECT * FROM healing_cache 
+                SELECT * FROM healing_cache
                 WHERE error_signature = ? AND module_name = 'GLOBAL'
             """, (error_signature,))
             row = cursor.fetchone()
@@ -605,7 +604,7 @@ def query_solution(error_signature, module_name="GLOBAL", threshold=0.35):
         # 3. Fuzzy search on symptom/error
         if not row:
             cursor.execute("""
-                SELECT * FROM healing_cache 
+                SELECT * FROM healing_cache
                 WHERE error_signature LIKE ? OR symptom LIKE ?
             """, (f"%{error_signature}%", f"%{error_signature}%"))
             row = cursor.fetchone()
@@ -639,8 +638,8 @@ def query_solution(error_signature, module_name="GLOBAL", threshold=0.35):
 
         if row:
             cursor.execute("""
-                UPDATE healing_cache 
-                SET hit_count = hit_count + 1 
+                UPDATE healing_cache
+                SET hit_count = hit_count + 1
                 WHERE id = ?
             """, (row["id"],))
             conn.commit()
@@ -700,57 +699,53 @@ def sync_db():
     init_db(seed=True, target_db=GLOBAL_DB)
     DB_FILE = resolve_db_path(use_local=True)
     init_db(seed=False, target_db=LOCAL_DB)
-    
-    g_conn = get_db(GLOBAL_DB)
-    l_conn = get_db(LOCAL_DB)
-    
-    # 1. Sync positive cache
-    g_rows = g_conn.execute("SELECT * FROM healing_cache").fetchall()
-    for r in g_rows:
-        l_conn.execute("""
-            INSERT INTO healing_cache (error_signature, module_name, symptom, root_cause, groovy_patch, hit_count)
-            VALUES (?, ?, ?, ?, ?, ?)
-            ON CONFLICT(error_signature, module_name) DO UPDATE SET
-                symptom = excluded.symptom,
-                root_cause = excluded.root_cause,
-                groovy_patch = excluded.groovy_patch
-        """, (r["error_signature"], r["module_name"], r["symptom"], r["root_cause"], r["groovy_patch"], r["hit_count"]))
-    l_conn.commit()
-
-    l_rows = l_conn.execute("SELECT * FROM healing_cache").fetchall()
-    for r in l_rows:
-        g_conn.execute("""
-            INSERT INTO healing_cache (error_signature, module_name, symptom, root_cause, groovy_patch, hit_count)
-            VALUES (?, ?, ?, ?, ?, ?)
-            ON CONFLICT(error_signature, module_name) DO UPDATE SET
-                symptom = excluded.symptom,
-                root_cause = excluded.root_cause,
-                groovy_patch = excluded.groovy_patch
-        """, (r["error_signature"], r["module_name"], r["symptom"], r["root_cause"], r["groovy_patch"], r["hit_count"]))
-    g_conn.commit()
-
-    # 2. Sync negative failed fixes
-    g_failed = g_conn.execute("SELECT * FROM failed_fixes").fetchall()
-    for f in g_failed:
-        l_conn.execute("""
-            INSERT OR IGNORE INTO failed_fixes (error_signature, attempted_patch, failure_reason, agent_role)
-            VALUES (?, ?, ?, ?)
-        """, (f["error_signature"], f["attempted_patch"], f["failure_reason"], f["agent_role"]))
-    l_conn.commit()
-
-    # 3. Sync lessons learned
-    g_lessons = g_conn.execute("SELECT * FROM lessons_learned").fetchall()
-    for r in g_lessons:
-        l_conn.execute("""
-            INSERT OR IGNORE INTO lessons_learned 
-            (page_context, error_signature, root_cause, failed_attempt, successful_fix, lesson_summary, hit_count)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-        """, (r["page_context"], r["error_signature"], r["root_cause"], r["failed_attempt"], r["successful_fix"], r["lesson_summary"], r["hit_count"]))
-    l_conn.commit()
 
-    l_conn.close()
-    g_conn.close()
-    return len(g_rows)
+    with get_db(GLOBAL_DB) as g_conn, get_db(LOCAL_DB) as l_conn:
+        # 1. Sync positive cache
+        g_rows = g_conn.execute("SELECT * FROM healing_cache").fetchall()
+        for r in g_rows:
+            l_conn.execute("""
+                INSERT INTO healing_cache (error_signature, module_name, symptom, root_cause, groovy_patch, hit_count)
+                VALUES (?, ?, ?, ?, ?, ?)
+                ON CONFLICT(error_signature, module_name) DO UPDATE SET
+                    symptom = excluded.symptom,
+                    root_cause = excluded.root_cause,
+                    groovy_patch = excluded.groovy_patch
+            """, (r["error_signature"], r["module_name"], r["symptom"], r["root_cause"], r["groovy_patch"], r["hit_count"]))
+        l_conn.commit()
+
+        l_rows = l_conn.execute("SELECT * FROM healing_cache").fetchall()
+        for r in l_rows:
+            g_conn.execute("""
+                INSERT INTO healing_cache (error_signature, module_name, symptom, root_cause, groovy_patch, hit_count)
+                VALUES (?, ?, ?, ?, ?, ?)
+                ON CONFLICT(error_signature, module_name) DO UPDATE SET
+                    symptom = excluded.symptom,
+                    root_cause = excluded.root_cause,
+                    groovy_patch = excluded.groovy_patch
+            """, (r["error_signature"], r["module_name"], r["symptom"], r["root_cause"], r["groovy_patch"], r["hit_count"]))
+        g_conn.commit()
+
+        # 2. Sync negative failed fixes
+        g_failed = g_conn.execute("SELECT * FROM failed_fixes").fetchall()
+        for f in g_failed:
+            l_conn.execute("""
+                INSERT OR IGNORE INTO failed_fixes (error_signature, attempted_patch, failure_reason, agent_role)
+                VALUES (?, ?, ?, ?)
+            """, (f["error_signature"], f["attempted_patch"], f["failure_reason"], f["agent_role"]))
+        l_conn.commit()
+
+        # 3. Sync lessons learned
+        g_lessons = g_conn.execute("SELECT * FROM lessons_learned").fetchall()
+        for r in g_lessons:
+            l_conn.execute("""
+                INSERT OR IGNORE INTO lessons_learned
+                (page_context, error_signature, root_cause, failed_attempt, successful_fix, lesson_summary, hit_count)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            """, (r["page_context"], r["error_signature"], r["root_cause"], r["failed_attempt"], r["successful_fix"], r["lesson_summary"], r["hit_count"]))
+        l_conn.commit()
+
+        return len(g_rows)
 
 
 @retry_on_locked()
@@ -769,7 +764,7 @@ def record_lesson(page_context, error_signature, root_cause, failed_attempt, suc
     with get_db() as conn:
         cursor = conn.cursor()
         cursor.execute("""
-            INSERT INTO lessons_learned 
+            INSERT INTO lessons_learned
             (page_context, error_signature, root_cause, failed_attempt, successful_fix, lesson_summary)
             VALUES (?, ?, ?, ?, ?, ?)
         """, (page_context, error_signature, root_cause, failed_attempt, successful_fix, lesson_summary))
@@ -847,7 +842,7 @@ def get_flaky_telemetry(days=30, min_runs=2, threshold=0.15, target_db=None):
     with get_db(current_db) as conn:
         cursor = conn.cursor()
         cursor.execute("""
-            SELECT 
+            SELECT
                 test_id,
                 COUNT(*) as total_runs,
                 SUM(CASE WHEN status = 'PASS' THEN 1 ELSE 0 END) as pass_count,
@@ -1051,7 +1046,7 @@ def main():
         if sol:
             print("==================================================")
             if sol.get("groovy_patch"):
-                print(f"✅ [CACHE HIT - 0 TOKENS] Found pre-tested solution!")
+                print("✅ [CACHE HIT - 0 TOKENS] Found pre-tested solution!")
                 print(f"Database Scope  : {'LOCAL' if args.local else 'GLOBAL CENTRAL (~/.agent_memory)'}")
                 print(f"Match Strategy  : {sol.get('match_type', 'EXACT')}")
                 print(f"Error Signature : {sol['error_signature']}")
@@ -1104,12 +1099,12 @@ def main():
         if not lessons:
             print("  (Zero relevant lessons in cache yet. Proceeding with clean reasoning.)")
         else:
-            for idx, l in enumerate(lessons, 1):
-                print(f"📌 [Lesson {idx}] Context: {l['page_context']} | Trigger: {l['error_signature']}")
-                print(f"   💡 Rule: {l['lesson_summary']}")
-                if l.get("failed_attempt") or l.get("successful_fix"):
-                    print(f"   ⚠️ Anti-Pattern: {l.get('failed_attempt') or 'N/A'}")
-                    print(f"   ✅ Proven Fix  : {l.get('successful_fix') or 'N/A'}")
+            for idx, les in enumerate(lessons, 1):
+                print(f"📌 [Lesson {idx}] Context: {les['page_context']} | Trigger: {les['error_signature']}")
+                print(f"   💡 Rule: {les['lesson_summary']}")
+                if les.get("failed_attempt") or les.get("successful_fix"):
+                    print(f"   ⚠️ Anti-Pattern: {les.get('failed_attempt') or 'N/A'}")
+                    print(f"   ✅ Proven Fix  : {les.get('successful_fix') or 'N/A'}")
         print("==================================================")
 
     elif args.command == "record-telemetry":

package/tools/check_env.py

@@ -12,7 +12,6 @@ Autonomously detects Target Project or QA Hub (CLI, CWD, ENV).
 
 import os
 import sys
-import shutil
 import shlex
 import platform
 import subprocess
@@ -101,12 +100,14 @@ class DiagnosticRunner:
             return False, str(e)
 
     def check_os(self):
+        """Verifies operating system platform, kernel version, and architecture."""
         os_name = platform.system()
         os_ver = platform.release()
         arch = platform.machine()
         self.log_check("Operating System", "PASS", f"{os_name} {os_ver} ({arch})")
 
     def check_chrome(self):
+        """Checks for Google Chrome, Chromium, Brave, or Playwright browser runtimes."""
         # 1. Search via 'where' (Windows) or 'which' (Unix)
         cmd = "where chrome" if platform.system() == "Windows" else "which google-chrome google-chrome-stable chromium chromium-browser"
         found, out = self.run_command(cmd)
@@ -149,6 +150,7 @@ class DiagnosticRunner:
                        "Download and install Google Chrome from https://www.google.com/chrome/")
 
     def check_java(self):
+        """Verifies presence of Java JRE/JDK runtime via CLI or JAVA_HOME."""
         found, out = self.run_command("java -version")
         if found or "version" in out:
             ver = out.splitlines()[0] if out else "Installed"
@@ -162,6 +164,7 @@ class DiagnosticRunner:
                                "Katalon includes embedded JRE, but for Gradle/Jenkins CLI, install OpenJDK 17.")
 
     def check_katalon(self):
+        """Verifies Katalon Studio / Katalon Runtime Engine installation if applicable."""
         # Context-aware: check if current target is actually a Katalon project
         is_katalon_project = (
             any(self.target_dir.glob("*.prj"))
@@ -196,6 +199,7 @@ class DiagnosticRunner:
             self.log_check("Katalon Studio IDE", "PASS", "Not installed (Optional - not required for Playwright/Cypress/Pytest)")
 
     def check_node_allure(self):
+        """Verifies presence of Node.js runtime for test runners and Allure reports."""
         found_node, node_ver = self.run_command("node -v")
         if found_node:
             self.log_check("Node.js Runtime", "PASS", f"Node.js {node_ver}")
@@ -204,6 +208,7 @@ class DiagnosticRunner:
                            "Install Node.js from https://nodejs.org/ to execute './tools/generate_allure_report.sh serve'")
 
     def check_python_runner(self):
+        """Verifies active Python environment and optional virtual environment presence."""
         py_ver = sys.version.split()[0]
         venv_path = self.target_dir / ".venv"
 
@@ -213,6 +218,7 @@ class DiagnosticRunner:
             self.log_check("Python Virtual Environment", "PASS", f"Python {py_ver} (Optional: create .venv if using auxiliary runners)")
 
     def check_project_structure(self):
+        """Audits folder layout and configuration integrity for Hub or Spoke projects."""
         # 1. QA Hub Repository Check
         is_hub = (self.target_dir / "skills_manifest.json").exists() or (self.target_dir / ".agents" / "skills").is_dir()
         if is_hub:
@@ -301,6 +307,7 @@ class DiagnosticRunner:
                        "Run 'agent-qa setup .' to initialize Clean POM / Playwright configuration for this project.")
 
     def check_network(self):
+        """Audits AUT network reachability via BASE_URL configured in environment."""
         env_file = self.target_dir / ".env"
         if env_file.exists():
             try:
@@ -345,6 +352,7 @@ class DiagnosticRunner:
                            "Check internet connection or enable VPN if corporate network required.")
 
     def run_all(self):
+        """Runs the complete diagnostic suite and returns 0 if all prerequisites pass."""
         print(f"\n{BOLD}{'='*70}{RESET}")
         print(f"{BOLD}{CYAN} ENTERPRISE AUTOMATION - ENVIRONMENT & ONBOARDING DIAGNOSTIC{RESET}")
         print(f"{BOLD}{'='*70}{RESET}")

package/tools/check_version_sync.py

@@ -102,7 +102,7 @@ def extract_versions(repo_root: str) -> Dict[str, str]:
             if m:
                 versions["tools/mcp_excel_server.py"] = m.group(1)
 
-    # 10. docs/ARCHITECTURE.md
+    # 10. docs/ARCHITECTURE.md & docs/ARCHITECTURE.en.md
     arch_path = os.path.join(repo_root, "docs", "ARCHITECTURE.md")
     if os.path.exists(arch_path):
         with open(arch_path, "r", encoding="utf-8") as f:
@@ -110,6 +110,50 @@ def extract_versions(repo_root: str) -> Dict[str, str]:
             m = re.search(r'>\s*\*\*Version:\*\*\s*`([^`]+)`', content)
             if m:
                 versions["docs/ARCHITECTURE.md"] = m.group(1)
+    arch_en_path = os.path.join(repo_root, "docs", "ARCHITECTURE.en.md")
+    if os.path.exists(arch_en_path):
+        with open(arch_en_path, "r", encoding="utf-8") as f:
+            content = f.read()
+            m = re.search(r'>\s*\*\*Version:\*\*\s*`([^`]+)`', content)
+            if m:
+                versions["docs/ARCHITECTURE.en.md"] = m.group(1)
+
+    # 11. README.md
+    readme_path = os.path.join(repo_root, "README.md")
+    if os.path.exists(readme_path):
+        with open(readme_path, "r", encoding="utf-8") as f:
+            content = f.read()
+            m_badge = re.search(r'Phiên bản(?: Hub)?:\*\*\s*`v([0-9]+\.[0-9]+\.[0-9]+)', content)
+            m_rev = re.search(r'rev:\s*v([0-9]+\.[0-9]+\.[0-9]+)', content)
+            if m_badge:
+                versions["README.md"] = m_badge.group(1)
+            elif m_rev:
+                versions["README.md"] = m_rev.group(1)
+            if m_badge and m_rev:
+                versions["README.md (rev)"] = m_rev.group(1)
+
+    # 12. README.en.md
+    readme_en_path = os.path.join(repo_root, "README.en.md")
+    if os.path.exists(readme_en_path):
+        with open(readme_en_path, "r", encoding="utf-8") as f:
+            content = f.read()
+            m_badge = re.search(r'(?:Hub )?Version:\*\*\s*`v([0-9]+\.[0-9]+\.[0-9]+)', content)
+            m_rev = re.search(r'rev:\s*v([0-9]+\.[0-9]+\.[0-9]+)', content)
+            if m_badge:
+                versions["README.en.md"] = m_badge.group(1)
+            elif m_rev:
+                versions["README.en.md"] = m_rev.group(1)
+            if m_badge and m_rev:
+                versions["README.en.md (rev)"] = m_rev.group(1)
+
+    # 13. SECURITY.md
+    sec_path = os.path.join(repo_root, "SECURITY.md")
+    if os.path.exists(sec_path):
+        with open(sec_path, "r", encoding="utf-8") as f:
+            content = f.read()
+            m = re.search(r'\|\s*`([0-9]+\.[0-9]+\.x)`\s*\|\s*✅', content)
+            if m:
+                versions["SECURITY.md"] = m.group(1)
 
     return versions
 
@@ -127,7 +171,15 @@ def check_sync(repo_root: str, expected_version: Optional[str] = None) -> Tuple[
     if not target_ver:
         target_ver = next(iter(versions.values()))
 
-    mismatches = {path: ver for path, ver in versions.items() if ver != target_ver}
+    target_prefix = ".".join(target_ver.split(".")[:2]) + ".x"
+    mismatches = {}
+    for path, ver in versions.items():
+        if path == "SECURITY.md":
+            if ver != target_prefix:
+                mismatches[path] = ver
+        elif ver != target_ver:
+            mismatches[path] = ver
+
     if mismatches:
         return False, versions, target_ver
     return True, versions, target_ver
@@ -151,10 +203,12 @@ def main() -> int:
     print(f"Target Version: v{canonical}")
     print("----------------------------------------------------------------------")
 
+    target_prefix = ".".join(canonical.split(".")[:2]) + ".x"
     all_matched = True
     for file_path, ver in sorted(versions.items()):
-        status = "[MATCH]" if ver == canonical else "[MISMATCH]"
-        if ver != canonical:
+        is_match = (ver == target_prefix) if file_path == "SECURITY.md" else (ver == canonical)
+        status = "[MATCH]" if is_match else "[MISMATCH]"
+        if not is_match:
             all_matched = False
         print(f"  {status:<11} {file_path:<26} -> {ver}")
 

package/tools/ci_healing_hook.py

@@ -10,10 +10,8 @@ When a test fails due to a broken locator:
 """
 
 import os
-import sys
-import json
 import argparse
-from typing import Dict, Any, Optional
+from typing import Dict, Any
 from datetime import datetime
 
 
@@ -35,11 +33,11 @@ class CIHealingHook:
         """
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         branch_name = f"auto-heal/{test_id.lower()}_{timestamp}"
-        
+
         pr_description = f"""## 🤖 Autonomous CI/CD Self-Healing Report
 
-> **Target File:** `{file_path}`  
-> **Confidence Score:** `{confidence * 100:.1f}%`  
+> **Target File:** `{file_path}`
+> **Confidence Score:** `{confidence * 100:.1f}%`
 > **Timestamp:** `{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}`
 
 ### 📝 Summary of Changes

package/tools/cli.py

@@ -41,7 +41,7 @@ RESET = "\033[0m"
 def cmd_version(args):
     """Displays the current hub version, skill catalog count, and license information."""
     manifest_path = os.path.join(REPO_ROOT, "skills_manifest.json")
-    version = "2.7.0"
+    version = "3.0.1"
     if os.path.exists(manifest_path):
         try:
             import json
@@ -145,7 +145,7 @@ def cmd_clean(args):
                     os.remove(os.path.join(root, f))
                     removed_count += 1
                 except OSError as err:
-                    failed_files = getattr(args, "verbose", False) and print(f"Notice: Could not remove {f}: {err}")
+                    getattr(args, "verbose", False) and print(f"Notice: Could not remove {f}: {err}")
     print(f"✅ Cleanup finished: {removed_count} build artifacts and caches removed.")
 
 
@@ -255,7 +255,6 @@ def cmd_transpile(args):
 def cmd_omni_scan(args):
     from omni_transpiler import scan_repository
     inv = scan_repository(args.path)
-    import json
     if getattr(args, "json", False):
         print(json.dumps(inv, indent=2))
     else:
@@ -542,21 +541,20 @@ def cmd_release(args):
 
 def _hub_version():
     manifest_path = os.path.join(REPO_ROOT, "skills_manifest.json")
-    version = "2.7.0"
+    version = "3.0.1"
     if os.path.exists(manifest_path):
         try:
             import json
             with open(manifest_path, "r", encoding="utf-8") as f:
                 version = json.load(f).get("version", version)
         except (OSError, json.JSONDecodeError):
-            version = "2.7.0"
+            version = "3.0.1"
     return version
 
 
 class SynapseArgumentParser(argparse.ArgumentParser):
     """Enhanced ArgumentParser providing fuzzy Did-You-Mean suggestions on command typos."""
     def error(self, message):
-        import difflib
         m = re.search(r"invalid choice: '([^']+)'", message)
         if m:
             bad_choice = m.group(1)
@@ -1008,7 +1006,7 @@ def main():
             import update_sentinel
             update_sentinel.check_for_updates(force=False, notify=True)
         except (ImportError, OSError, TimeoutError):
-            update_status = None
+            _ = False
 
     # Dispatch subcommand
     args.func(args)

package/tools/config_decoupler.py

@@ -15,8 +15,7 @@ import re
 import sys
 import json
 import argparse
-from pathlib import Path
-from typing import Dict, List, Any, Tuple
+from typing import Dict, List, Any, Tuple, Optional
 
 # Enforce UTF-8 stdout encoding for Windows console compatibility
 if hasattr(sys.stdout, 'reconfigure'):
@@ -129,7 +128,7 @@ class ConfigDecoupler:
                     "replacement": f"process.env.{key}"
                 })
 
-    def export_configs(self, output_dir: str = None) -> Tuple[str, str]:
+    def export_configs(self, output_dir: Optional[str] = None) -> Tuple[str, str]:
         """Generates env.default.json and .env.example configuration files."""
         out_base = output_dir or os.path.join(self.target_dir, "config", "profiles")
         os.makedirs(out_base, exist_ok=True)