synapse-hub 3.0.0 → 3.0.1

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,24 +110,41 @@ 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 = re.search(r'rev:\s*v([0-9]+\.[0-9]+\.[0-9]+)', content)
-            if m:
-                versions["README.md"] = m.group(1)
+            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 = re.search(r'rev:\s*v([0-9]+\.[0-9]+\.[0-9]+)', content)
-            if m:
-                versions["README.en.md"] = m.group(1)
+            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")

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 = "3.0.0"
+    version = "3.0.1"
     if os.path.exists(manifest_path):
         try:
             import json
@@ -541,14 +541,14 @@ def cmd_release(args):
 
 def _hub_version():
     manifest_path = os.path.join(REPO_ROOT, "skills_manifest.json")
-    version = "3.0.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 = "3.0.0"
+            version = "3.0.1"
     return version
 
 

package/tools/contract_validator.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: Copyright (c) 2026 Thế Vị (@TeeVee998). All rights reserved.
+# SPDX-License-Identifier: MIT
+# Project: Synapse-Hub (https://github.com/TeeVee998/Synapse-Hub)
+
+"""
+Swarm Data Contract Validator (Single Front-Door Integrity Guard)
+-----------------------------------------------------------------
+Validates the JSON Data Contract emitted by `live-explorer` before
+`pom-crafter` consumes it for Clean POM code synthesis.
+Ensures zero locator guessing, validates semantic ARIA roles, and enforces
+latency measurement (< 200ms) for durable selectors.
+"""
+
+import os
+import sys
+import json
+import argparse
+from typing import Dict, Any, List, Tuple
+
+# Enforce UTF-8 stdout encoding for Windows console compatibility
+if hasattr(sys.stdout, 'reconfigure'):
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+        sys.stderr.reconfigure(encoding='utf-8')
+    except Exception:
+        pass
+
+CONTRACT_SCHEMA = {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "title": "SelectorContract",
+    "type": "object",
+    "required": ["url", "screen_name", "elements"],
+    "properties": {
+        "url": {"type": "string"},
+        "screen_name": {"type": "string"},
+        "viewport": {
+            "type": "object",
+            "properties": {
+                "width": {"type": "integer"},
+                "height": {"type": "integer"}
+            }
+        },
+        "elements": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "object",
+                "required": ["name", "role"],
+                "properties": {
+                    "name": {"type": "string"},
+                    "role": {"type": "string"},
+                    "selector": {"type": "string"},
+                    "target": {"type": "string"},
+                    "latency_ms": {"type": "number"},
+                    "action_type": {"type": "string"}
+                }
+            }
+        }
+    }
+}
+
+
+def validate_contract_dict(data: Dict[str, Any]) -> Tuple[bool, List[str]]:
+    """Validates contract structure without external dependencies."""
+    errors = []
+    if not isinstance(data, dict):
+        return False, ["Root contract must be a JSON object."]
+
+    # Required top-level fields
+    for field in ("url", "screen_name", "elements"):
+        if field not in data:
+            errors.append(f"Missing required top-level field: '{field}'")
+
+    if "elements" in data:
+        elements = data["elements"]
+        if not isinstance(elements, list) or len(elements) == 0:
+            errors.append("'elements' must be a non-empty list of interactive components.")
+        else:
+            for idx, el in enumerate(elements):
+                if not isinstance(el, dict):
+                    errors.append(f"Element at index {idx} must be a dictionary object.")
+                    continue
+                if "name" not in el or not el["name"]:
+                    errors.append(f"Element at index {idx} missing 'name' identifier.")
+                if "role" not in el or not el["role"]:
+                    errors.append(f"Element at index {idx} missing ARIA 'role' classification.")
+                if "selector" not in el and "target" not in el:
+                    errors.append(f"Element '{el.get('name', f'index_{idx}')}' must provide 'selector' or 'target'.")
+
+                latency = el.get("latency_ms")
+                if latency is not None and isinstance(latency, (int, float)):
+                    if latency > 200:
+                        errors.append(
+                            f"Element '{el.get('name')}' latency ({latency}ms) exceeds the 200ms latency budget."
+                        )
+
+    return len(errors) == 0, errors
+
+
+def validate_contract_file(file_path: str) -> Tuple[bool, List[str]]:
+    """Loads and validates a contract file from disk."""
+    if not os.path.exists(file_path):
+        return False, [f"Contract file does not exist: {file_path}"]
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return validate_contract_dict(data)
+    except json.JSONDecodeError as err:
+        return False, [f"Malformed JSON syntax: {err}"]
+    except OSError as err:
+        return False, [f"File read error: {err}"]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Swarm Data Contract Validator")
+    parser.add_argument("contract_path", nargs="?", default=None, help="Path to JSON Data Contract file")
+    parser.add_argument("--schema", action="store_true", help="Print standard JSON schema and exit")
+    args = parser.parse_args()
+
+    if args.schema:
+        print(json.dumps(CONTRACT_SCHEMA, indent=2))
+        return 0
+
+    if not args.contract_path:
+        parser.print_help()
+        return 1
+
+    valid, errors = validate_contract_file(args.contract_path)
+    if valid:
+        print(f"✅ [VALID CONTRACT] '{args.contract_path}' is ready for Clean POM synthesis.")
+        return 0
+    else:
+        print(f"❌ [INVALID CONTRACT] '{args.contract_path}' contains {len(errors)} violation(s):")
+        for err in errors:
+            print(f"   • {err}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/tools/dashboard_generator.py

@@ -655,7 +655,7 @@ def build_swarm_timeline_html(default_lang: str = "vi") -> str:
         ("Tool Exec", "badge-tool", "pom-crafter", "synthesize_page_class (Clean POM)", "210ms", "1,850 tok", "✓ ZERO XPATHS", "badge-pass", "gen_ai.system: google | model: gemini-flash | target: PageClass"),
         ("Test Run", "badge-ver", "test-runner", "dispatch_headless_cli & distill_log", "3,200ms", "120 tok", "✓ PASS (0 Fails)", "badge-pass", "tool.name: distill_log.py | noise_reduction: 95.2%"),
         ("Memory Cache", "badge-cat", "failure-analyst", "cache_resolver.py fingerprint & lookup", "8ms", "0 tok", "⚡ 0-TOKEN RESOLVE", "badge-pass", "tool.name: cache_resolver.py | fingerprint: fp_7f2e76cf | hits: 0"),
-        ("Gatekeeper", "badge-gate", "quality-gatekeeper", "verify_all.py (9 Gates + MicroMutator)", "1,450ms", "0 tok", "🛡️ 9/9 GATES PASS", "badge-pass", "tool.name: verify_all.py | mutation_score: 91.4% (DoD >= 80%)"),
+        ("Gatekeeper", "badge-gate", "quality-gatekeeper", "verify_all.py (10 Gates + MicroMutator)", "1,450ms", "0 tok", "🛡️ 10/10 GATES PASS", "badge-pass", "tool.name: verify_all.py | mutation_score: 91.4% (DoD >= 80%)"),
     ]
 
     step_rows = []
@@ -1320,7 +1320,7 @@ def _build_target_translations(
         "th_step_status": "Trạng Thái",
         "th_step_details": "Chi Tiết Kỹ Thuật (OTel & AST)",
 
-        "footer_text": "Báo cáo được khởi tạo tự động bởi Synapse-Hub v3.0.0 • Bản quyền © Thế Vị (@TeeVee998) • Chuẩn Clean POM & Kiểm Thử Tự Chủ",
+        "footer_text": "Báo cáo được khởi tạo tự động bởi Synapse-Hub v3.0.1 • Bản quyền © Thế Vị (@TeeVee998) • Chuẩn Clean POM & Kiểm Thử Tự Chủ",
     }
 
     translations_en = {
@@ -1398,7 +1398,7 @@ def _build_target_translations(
         "th_step_status": "Status",
         "th_step_details": "Technical Details (OTel & AST)",
 
-        "footer_text": "Generated automatically by Synapse-Hub v3.0.0 • Copyright © Thế Vị (@TeeVee998) • Clean POM & Autonomous Testing",
+        "footer_text": "Generated automatically by Synapse-Hub v3.0.1 • Copyright © Thế Vị (@TeeVee998) • Clean POM & Autonomous Testing",
     }
 
     _inject_gate_translations(translations_vi, translations_en, gates)
@@ -1804,13 +1804,13 @@ def _build_hub_translations(
     """Builds bilingual dictionaries for Hub Dashboard."""
     translations_vi = {
         "header_title": "Bảng Điều Hành Chất Lượng Doanh Nghiệp",
-        "header_subtitle": "Synapse-Hub v3.0.0 • Hệ Sinh Thái Kiểm Thử AI Agent Tự Chủ",
+        "header_subtitle": "Synapse-Hub v3.0.1 • Hệ Sinh Thái Kiểm Thử AI Agent Tự Chủ",
         "nav_welcome": "Giới Thiệu",
         "meta_mode": "🏷️ Chế độ: <strong>HỆ SINH THÁI QA HUB</strong>",
         "meta_gen": f"🕒 Khởi tạo: <strong>{now_str}</strong>",
-        "meta_status": "🛡️ Gatekeeper: <strong>9/9 ĐẠT CHUẨN</strong>",
+        "meta_status": "🛡️ Gatekeeper: <strong>10/10 ĐẠT CHUẨN</strong>",
 
-        "kpi_dod_lbl": "9 Cổng Kiểm Soát DoD",
+        "kpi_dod_lbl": "10 Cổng Kiểm Soát DoD",
         "kpi_dod_sub": "✓ 100% Cổng Đạt Chuẩn",
         "kpi_skills_lbl": "Kỹ Năng AI Chuyên Biệt",
         "kpi_skills_sub": "Phân Bổ Trong 4 Danh Mục Doanh Nghiệp",
@@ -1874,18 +1874,18 @@ def _build_hub_translations(
         "th_sk_ver": "Phiên Bản",
         "th_sk_cap": "Khả Năng Nghiệp Vụ Cốt Lõi",
 
-        "footer_text": "Bảng Điều Hành Chất Lượng Doanh Nghiệp &bull; Synapse-Hub v3.0.0 &bull; Bản quyền &copy; Thế Vị (@TeeVee998) &bull; Hệ Thống Kiểm Thử AI Agent Tự Chủ",
+        "footer_text": "Bảng Điều Hành Chất Lượng Doanh Nghiệp &bull; Synapse-Hub v3.0.1 &bull; Bản quyền &copy; Thế Vị (@TeeVee998) &bull; Hệ Thống Kiểm Thử AI Agent Tự Chủ",
     }
 
     translations_en = {
         "header_title": "Enterprise QA Executive Dashboard",
-        "header_subtitle": "Synapse-Hub v3.0.0 &bull; Autonomous AI Agent Testing Ecosystem",
+        "header_subtitle": "Synapse-Hub v3.0.1 &bull; Autonomous AI Agent Testing Ecosystem",
         "nav_welcome": "Welcome",
         "meta_mode": "🏷️ Mode: <strong>QA HUB ECOSYSTEM</strong>",
         "meta_gen": f"🕒 Generated: <strong>{now_str}</strong>",
-        "meta_status": "🛡️ Gatekeeper: <strong>9/9 COMPLIANT</strong>",
+        "meta_status": "🛡️ Gatekeeper: <strong>10/10 COMPLIANT</strong>",
 
-        "kpi_dod_lbl": "9 Quality Gates",
+        "kpi_dod_lbl": "10 Quality Gates",
         "kpi_dod_sub": "✓ 100% Verification Compliant",
         "kpi_skills_lbl": "Specialized AI Skills",
         "kpi_skills_sub": "Spanned across 4 Enterprise Categories",
@@ -1949,7 +1949,7 @@ def _build_hub_translations(
         "th_sk_ver": "Version",
         "th_sk_cap": "Core Capabilities",
 
-        "footer_text": "Enterprise QA Executive Dashboard &bull; Synapse-Hub v3.0.0 &bull; Copyright &copy; Thế Vị (@TeeVee998) &bull; Autonomous AI Agent Testing Ecosystem",
+        "footer_text": "Enterprise QA Executive Dashboard &bull; Synapse-Hub v3.0.1 &bull; Copyright &copy; Thế Vị (@TeeVee998) &bull; Autonomous AI Agent Testing Ecosystem",
     }
 
     _inject_gate_translations(translations_vi, translations_en, gates)

package/tools/db_sandbox.py

@@ -191,23 +191,36 @@ class DBSandbox:
         cursor = conn.cursor()
         executed_count = 0
 
+        safe_sp = re.sub(r'[^a-zA-Z0-9_]', '', savepoint_name) or "sp_test_run"
         try:
-            cursor.execute(f"SAVEPOINT {savepoint_name};")
+            cursor.execute(f"SAVEPOINT {safe_sp};")
             for sql in sql_commands:
                 cursor.execute(sql)
                 executed_count += 1
 
-            # Simulate verification read inside the savepoint
-            cursor.execute("SELECT COUNT(*) FROM users")
-            count_inside_tx = cursor.fetchone()[0]
+            # Determine sample table for verification read (prefer 'users', fallback to first user table)
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';")
+            tables = [row[0] for row in cursor.fetchall()]
+            target_table = "users" if "users" in tables else (tables[0] if tables else None)
+
+            count_inside_tx = 0
+            if target_table:
+                safe_tbl = target_table.replace('"', '""')
+                cursor.execute(f'SELECT COUNT(*) FROM "{safe_tbl}"')
+                count_inside_tx = cursor.fetchone()[0]
+            else:
+                count_inside_tx = executed_count
 
             # Enforce automatic zero-pollution rollback
-            cursor.execute(f"ROLLBACK TO SAVEPOINT {savepoint_name};")
-            cursor.execute(f"RELEASE SAVEPOINT {savepoint_name};")
+            cursor.execute(f"ROLLBACK TO SAVEPOINT {safe_sp};")
+            cursor.execute(f"RELEASE SAVEPOINT {safe_sp};")
 
             # Verify that outside the savepoint, table is pristine
-            cursor.execute("SELECT COUNT(*) FROM users")
-            count_after_rollback = cursor.fetchone()[0]
+            count_after_rollback = 0
+            if target_table:
+                safe_tbl = target_table.replace('"', '""')
+                cursor.execute(f'SELECT COUNT(*) FROM "{safe_tbl}"')
+                count_after_rollback = cursor.fetchone()[0]
 
             return {
                 "status": "SUCCESS",
@@ -219,7 +232,7 @@ class DBSandbox:
             }
         except Exception as e:
             try:
-                cursor.execute(f"ROLLBACK TO SAVEPOINT {savepoint_name};")
+                cursor.execute(f"ROLLBACK TO SAVEPOINT {safe_sp};")
             except sqlite3.Error as rollback_err:
                 sys.stderr.write(f"Notice: Savepoint rollback notice: {rollback_err}\n")
             return {

package/tools/generate_allure_report.py

@@ -41,7 +41,7 @@ def generate_allure_report(results_dir=None, report_dir=None, clean=True, open_b
 
     print(f"[+] Generating Allure HTML report from '{results_path}' to '{report_path}'...")
     try:
-        subprocess.run(cmd, check=True)
+        subprocess.run(cmd, check=True, timeout=120.0)
         print(f"[+] Report generated successfully at: {report_path}")
     except subprocess.CalledProcessError as e:
         print(f"[ERROR] Allure report generation failed with exit code {e.returncode}")

package/tools/infer_linter.py

@@ -16,6 +16,7 @@ import sys
 import re
 import json
 import glob
+import ast
 import html as html_lib
 import argparse
 from datetime import datetime
@@ -76,15 +77,19 @@ def parse_with_tree_sitter(file_path, content):
         return None
 
 # Generic Detection regexes (including Cypress .should and .and assertions)
+# Note: Standalone expect(...) without chained matcher is caught as DANGLING_ASSERTION_NO_MATCHER.
 ASSERTION_PATTERN = re.compile(
-    r'\b(verify[A-Za-z0-9_]*|assert[A-Za-z0-9_]*|waitForToast|checkStatus|assertEquals|assertTrue|assertFalse|assertThat|expect|ensure[A-Z][A-Za-z0-9_]*Exists)\b|\.should\s*\(|\.and\s*\('
+    r'\b(verify[A-Za-z0-9_]*|assert[A-Za-z0-9_]*|waitForToast|checkStatus|assertEquals|assertTrue|assertFalse|assertThat|expect|ensure[A-Z][A-Za-z0-9_]*Exists)\b'
+    r'|\.should\s*\('
+    r'|\.and\s*\(',
+    re.MULTILINE
 )
 
 # Rule L1 & L5: Empty catch / swallowed exceptions across JS/TS/Groovy/Java and Python
-# Also catches try/catch that only console.log or promise .catch(() => {})
+# Also catches try/catch that only console.log/logger.error or promise .catch(() => {})
 EMPTY_CATCH_PATTERN = re.compile(
-    r'(?:catch\s*(?:\([^\)]*\))?\s*\{\s*(?:console\.(?:log|warn|error)\([^)]*\);?\s*)?\}'
-    r'|\.catch\s*\(\s*(?:\([^)]*\)|[a-zA-Z0-9_]+)?\s*=>\s*\{\s*(?:console\.(?:log|warn|error)\([^)]*\);?\s*)?\}\s*\)'
+    r'(?:catch\s*(?:\([^\)]*\))?\s*\{\s*(?:(?:console|logger|log)\.(?:log|warn|error|info)\([^)]*\);?\s*)?\}'
+    r'|\.catch\s*\(\s*(?:\([^)]*\)|[a-zA-Z0-9_]+)?\s*=>\s*\{\s*(?:(?:console|logger|log)\.(?:log|warn|error|info)\([^)]*\);?\s*)?\}\s*\)'
     r'|\bexcept(?:\s+[^:]*)?:\s*(?:pass|\.\.\.)(?:\s*$|\s*#))',
     re.MULTILINE
 )
@@ -96,16 +101,48 @@ BENIGN_TRY_CALL_PATTERN = re.compile(
     r'^[\w\.]*\.(?:reconfigure|chmod|flush)\s*\('
 )
 
-# Rule L3: Tautological assertions (e.g. expect(true).toBe(true), assert r == r, expect(true).toBeTruthy())
+# Rule L3: Tautological assertions (e.g. expect(true).toBe(true), assert r == r, assert f() == f(), assert len(x) >= 0)
 TAUTOLOGY_PATTERN = re.compile(
-    r'(?:expect\s*\(\s*(?:true|1)\s*\)\s*\.\s*(?:toBe|toEqual|toBeTruthy)\s*\(\s*(?:true|1)?\s*\)'
+    r'(?:expect(?:\.soft|\.poll)?\s*\(\s*(?:true|1|null|undefined)\s*\)\s*\.\s*(?:toBe|toEqual|toBeTruthy|toBeNull|toBeUndefined)\s*\(\s*(?:true|1|null|undefined)?\s*\)'
+    r'|expect(?:\.soft|\.poll)?\s*\(\s*([a-zA-Z0-9_]+)\s*\)\s*\.\s*(?:toBe|toEqual)\s*\(\s*\1\s*\)'
     r'|\bassert\s+(?:True|true|1\s*==\s*1)\b'
-    r'|\bassert\s+([a-zA-Z0-9_]+)\s*==\s*\1\b'
-    r'|assertEquals\s*\(\s*(?:true|1)\s*,\s*(?:true|1)\s*\)'
+    r'|\bassert\s+([a-zA-Z0-9_\.]+(?:\([^)]*\))?)\s*==\s*\1\b'
+    r'|\bassert\s+(?:len\s*\([^)]*\)|[a-zA-Z0-9_\.]+\.(?:length|size\(\)))\s*(?:>=\s*0|>\s*-(?:1|0))\b'
+    r'|assertEquals\s*\(\s*(?:true|1|null)\s*,\s*(?:true|1|null)\s*\)'
     r'|assertTrue\s*\(\s*(?:true|1)\s*\))',
     re.IGNORECASE
 )
 
+
+def find_dangling_expects(clean_code, raw_lines):
+    """
+    Detects dangling expect(...) calls lacking chained matchers (e.g. expect(page) without .toBeVisible()).
+    Correctly handles nested parentheses like expect(page.locator('#id')).
+    """
+    dangling = []
+    pattern = re.compile(r'(?:await\s+)?\bexpect(?:\.soft|\.poll)?\s*\(')
+    for m in pattern.finditer(clean_code):
+        start_idx = m.end()
+        depth = 1
+        pos = start_idx
+        while pos < len(clean_code) and depth > 0:
+            ch = clean_code[pos]
+            if ch == '(':
+                depth += 1
+            elif ch == ')':
+                depth -= 1
+            elif ch in (';', '\n') and depth > 0:
+                # Malformed unclosed expect
+                break
+            pos += 1
+        if depth == 0:
+            rest = clean_code[pos:].lstrip()
+            if not rest.startswith('.'):
+                line_no = clean_code[:m.start()].count("\n") + 1
+                raw_line = raw_lines[line_no - 1].strip() if line_no <= len(raw_lines) else ""
+                dangling.append((line_no, raw_line))
+    return dangling
+
 # Rule L4: Unawaited Playwright assertions in JS/TS
 # Expanded with all standard Playwright async matchers and optional .not modifier
 PLAYWRIGHT_ASYNC_MATCHERS = (
@@ -300,7 +337,7 @@ def format_junit(report_data):
     return "\n".join(lines)
 
 
-def classify_file_role(file_path: str) -> str:
+def classify_file_role(file_path: str, content: str = "") -> str:
     """
     Classifies a source file into:
       - 'CONFIG': Configuration files (playwright.config, cypress.config, conftest, wdio.conf, jest.config)
@@ -324,6 +361,8 @@ def classify_file_role(file_path: str) -> str:
         return "PAGE_OBJECT"
     if re.search(r'(^|_)basepage\b', base) or re.search(r'[a-z0-9_]page\.(ts|js|py|groovy|java)$', base):
         return "PAGE_OBJECT"
+    if content and (re.search(r'\bclass\s+[A-Za-z0-9_]*Page\b', content) or re.search(r'\bextends\s+BasePage\b', content)):
+        return "PAGE_OBJECT"
 
     # 3. Helpers & Fixtures / Tools & Utilities / Benchmarks
     if any(p in ("fixtures", "helpers", "utils", "support", "tools", "bin", "benchmarks", "benchmark") for p in parts):
@@ -348,13 +387,16 @@ def classify_file_role(file_path: str) -> str:
 
 def analyze_script(file_path, baseline_set=None, disabled_rules=None):
     """Performs static rule scanning on a single test script or automation asset."""
-    role = classify_file_role(file_path)
-
     try:
         rel_path = os.path.relpath(file_path, REPO_ROOT)
     except ValueError:
         rel_path = os.path.abspath(file_path)
 
+    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+        content = f.read()
+
+    role = classify_file_role(file_path, content=content)
+
     # Config files have zero test assertions by definition
     if role == "CONFIG":
         return {
@@ -364,9 +406,6 @@ def analyze_script(file_path, baseline_set=None, disabled_rules=None):
             "is_clean": True
         }
 
-    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
-        content = f.read()
-
     defects = []
 
     # Lexically strip comments and string literals for accurate analysis
@@ -402,12 +441,14 @@ def analyze_script(file_path, baseline_set=None, disabled_rules=None):
             elif arg.isdigit():
                 delay_val = int(arg)
                 if delay_val > 0:
-                    d_type = "EXCESSIVE_HARD_DELAY" if delay_val >= 3000 else "HARD_DELAY_ANTI_PATTERN"
+                    is_excessive = delay_val >= 3000
+                    d_type = "EXCESSIVE_HARD_DELAY" if is_excessive else "HARD_DELAY_ANTI_PATTERN"
+                    sev = "CRITICAL" if (is_excessive and role == "TEST_SCRIPT") else "WARNING"
                     defects.append({
                         "type": d_type,
-                        "severity": "WARNING",
+                        "severity": sev,
                         "line": idx,
-                        "message": f"Static sleep of {delay_val}ms found ('{raw_line}'). Replace with dynamic Smart Wait (waitForElement/networkidle)."
+                        "message": f"Static sleep of {delay_val}ms found ('{raw_line}'). {'Prohibited in test scripts by AGENTS.md Rule 1.4. ' if is_excessive else ''}Replace with dynamic Smart Wait (waitForElement/networkidle)."
                     })
                     continue
             elif re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', arg) and not line.strip().startswith("cy.wait"):
@@ -428,12 +469,14 @@ def analyze_script(file_path, baseline_set=None, disabled_rules=None):
                 if delay_val > 0:
                     delay_ms = int(delay_val * 1000)
                     delay_str = f"{delay_val:g}"
-                    d_type = "EXCESSIVE_HARD_DELAY" if delay_ms >= 3000 else "HARD_DELAY_ANTI_PATTERN"
+                    is_excessive = delay_ms >= 3000
+                    d_type = "EXCESSIVE_HARD_DELAY" if is_excessive else "HARD_DELAY_ANTI_PATTERN"
+                    sev = "CRITICAL" if (is_excessive and role == "TEST_SCRIPT") else "WARNING"
                     defects.append({
                         "type": d_type,
-                        "severity": "WARNING",
+                        "severity": sev,
                         "line": idx,
-                        "message": f"Static sleep of {delay_str}s ({delay_ms}ms) found ('{raw_line}'). Replace with dynamic Smart Wait (waitForElement/networkidle)."
+                        "message": f"Static sleep of {delay_str}s ({delay_ms}ms) found ('{raw_line}'). {'Prohibited in test scripts by AGENTS.md Rule 1.4. ' if is_excessive else ''}Replace with dynamic Smart Wait (waitForElement/networkidle)."
                     })
             except ValueError:
                 if re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', arg):
@@ -470,6 +513,68 @@ def analyze_script(file_path, baseline_set=None, disabled_rules=None):
                     "message": f"Tautological assertion detected ('{raw_line}'). Test assertion always evaluates to True without testing system state."
                 })
 
+        # Rule 4.1: Dangling expect(...) calls without chained matcher
+        for d_line, d_raw in find_dangling_expects(clean_code, raw_lines):
+            defects.append({
+                "type": "DANGLING_ASSERTION_NO_MATCHER",
+                "severity": "CRITICAL",
+                "line": d_line,
+                "message": f"Dangling expect() call without matcher detected ('{d_raw}'). expect() returns an expectation object and does not perform any assertion without a matcher (e.g. .toBeVisible(), .toHaveText())."
+            })
+
+        # Rule 4.2: Python AST Compiler-Grade Verification for .py Test Scripts
+        if file_path.endswith(".py"):
+            try:
+                tree = ast.parse(content, filename=file_path)
+                for node in ast.walk(tree):
+                    if isinstance(node, ast.Assert):
+                        if isinstance(node.test, ast.Compare) and len(node.test.ops) == 1:
+                            op = node.test.ops[0]
+                            right = node.test.comparators[0]
+                            if isinstance(op, ast.Eq):
+                                if ast.dump(node.test.left) == ast.dump(right):
+                                    line_no = getattr(node, "lineno", 1)
+                                    raw_line = raw_lines[line_no - 1].strip() if line_no <= len(raw_lines) else ""
+                                    defects.append({
+                                        "type": "TAUTOLOGICAL_ASSERTION",
+                                        "severity": "CRITICAL",
+                                        "line": line_no,
+                                        "message": f"Tautological assertion detected via AST ('{raw_line}'). Both sides of comparison evaluate to identical AST expressions."
+                                    })
+                            elif isinstance(op, (ast.GtE, ast.Gt)):
+                                if isinstance(node.test.left, ast.Call) and getattr(node.test.left.func, 'id', None) == 'len':
+                                    if isinstance(right, ast.Constant):
+                                        if (isinstance(op, ast.GtE) and right.value == 0) or (isinstance(op, ast.Gt) and right.value < 0):
+                                            line_no = getattr(node, "lineno", 1)
+                                            raw_line = raw_lines[line_no - 1].strip() if line_no <= len(raw_lines) else ""
+                                            defects.append({
+                                                "type": "TAUTOLOGICAL_ASSERTION",
+                                                "severity": "CRITICAL",
+                                                "line": line_no,
+                                                "message": f"Tautological assertion detected via AST ('{raw_line}'). len() is non-negative by definition."
+                                            })
+                        elif isinstance(node.test, ast.Constant) and node.test.value is True:
+                            line_no = getattr(node, "lineno", 1)
+                            raw_line = raw_lines[line_no - 1].strip() if line_no <= len(raw_lines) else ""
+                            defects.append({
+                                "type": "TAUTOLOGICAL_ASSERTION",
+                                "severity": "CRITICAL",
+                                "line": line_no,
+                                "message": f"Tautological assertion detected via AST ('{raw_line}'). Constant True assertion."
+                            })
+                    elif isinstance(node, ast.Expr) and isinstance(node.value, ast.Call):
+                        if getattr(node.value.func, 'id', None) == 'expect':
+                            line_no = getattr(node, "lineno", 1)
+                            raw_line = raw_lines[line_no - 1].strip() if line_no <= len(raw_lines) else ""
+                            defects.append({
+                                "type": "DANGLING_ASSERTION_NO_MATCHER",
+                                "severity": "CRITICAL",
+                                "line": line_no,
+                                "message": f"Dangling expect() call without matcher detected via AST ('{raw_line}')."
+                            })
+            except SyntaxError:
+                _ = False  # synapse-ignore
+
         # Rule 5 (L4): Unawaited Playwright Assertions in JS/TS
         if file_path.endswith((".ts", ".tsx", ".js", ".jsx")):
             for match in UNAWAITED_EXPECT_PATTERN.finditer(clean_code):
@@ -544,6 +649,15 @@ def analyze_script(file_path, baseline_set=None, disabled_rules=None):
                     "message": "Test case file contains executable logic but has no verification or assertion statements."
                 })
 
+    seen_keys = set()
+    deduped = []
+    for d in defects:
+        k = (d.get("type"), d.get("line"))
+        if k not in seen_keys:
+            seen_keys.add(k)
+            deduped.append(d)
+    defects = deduped
+
     active_defects = []
     disabled = {r.upper() for r in (disabled_rules or [])}
     norm_rel = rel_path.replace("\\", "/")
@@ -777,7 +891,7 @@ def run_infer_linter(target_dir=None, output_path=None, strict: bool = False,
             sys.stderr.write(f"Notice: Target report write failed: {err}\n")
 
     if strict:
-        fake_pass_count = sum(1 for r in results for d in r["defects"] if d["type"] in ("FAKE_PASS_NO_ASSERTION", "NO_ASSERTION_IN_TEST"))
+        fake_pass_count = sum(1 for r in results for d in r["defects"] if d["type"] in ("FAKE_PASS_NO_ASSERTION", "NO_ASSERTION_IN_TEST", "DANGLING_ASSERTION_NO_MATCHER"))
         return 0 if (critical_count == 0 and fake_pass_count == 0) else 1
     return 0 if critical_count == 0 else 1
 

package/tools/mcp_excel_server.py

@@ -23,7 +23,7 @@ if hasattr(sys.stdout, 'reconfigure'):
     except Exception:
         pass
 
-SERVER_VERSION = "3.0.0"
+SERVER_VERSION = "3.0.1"
 
 NS_MAIN = "{http://schemas.openxmlformats.org/spreadsheetml/2006/main}"
 NS_REL = "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}"