synapse-hub 2.5.0 → 2.7.0

package/tools/_openapi_parser.py

@@ -0,0 +1,158 @@
+#!/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)
+
+"""
+tools/_openapi_parser.py — Shared OpenAPI & Swagger Specification Parser
+-------------------------------------------------------------------------
+Internal shared helper module consolidating OpenAPI 3.0 and Swagger 2.0
+schema ingestion, $ref dereferencing, endpoint extraction, and boundary
+value test scenario synthesis across API testing tools.
+"""
+
+import os
+import sys
+import json
+from typing import Dict, Any, List, Optional, Tuple
+
+if hasattr(sys.stdout, 'reconfigure'):
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+        sys.stderr.reconfigure(encoding='utf-8')
+    except Exception:
+        pass
+
+
+def load_spec(spec_input: Any) -> Dict[str, Any]:
+    """
+    Loads OpenAPI / Swagger spec from a file path, raw JSON string, or dict.
+    """
+    if isinstance(spec_input, dict):
+        return spec_input
+    if isinstance(spec_input, str):
+        if os.path.exists(spec_input):
+            with open(spec_input, "r", encoding="utf-8") as f:
+                return json.load(f)
+        try:
+            return json.loads(spec_input)
+        except Exception:
+            raise ValueError(f"Unable to parse spec input as JSON file or string: {spec_input[:100]}")
+    raise TypeError(f"Expected dict, str path, or JSON string; got {type(spec_input)}")
+
+
+def resolve_ref(spec_data: Dict[str, Any], ref_str: str) -> Dict[str, Any]:
+    """
+    Resolves local JSON pointers such as '#/components/schemas/User' or '#/definitions/User'.
+    """
+    if not ref_str.startswith("#/"):
+        return {}
+    parts = ref_str[2:].split("/")
+    curr = spec_data
+    for p in parts:
+        if isinstance(curr, dict) and p in curr:
+            curr = curr[p]
+        else:
+            return {}
+    return curr if isinstance(curr, dict) else {}
+
+
+def extract_endpoints(spec_data: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """
+    Parses paths and HTTP operations into a normalized list of API endpoints.
+    """
+    endpoints = []
+    paths = spec_data.get("paths", {})
+
+    for path, methods in paths.items():
+        if not isinstance(methods, dict):
+            continue
+        for method, details in methods.items():
+            if method.lower() not in ("get", "post", "put", "delete", "patch", "options", "head"):
+                continue
+            if not isinstance(details, dict):
+                continue
+
+            summary = details.get("summary", details.get("operationId", f"{method.upper()} {path}"))
+            operation_id = details.get("operationId", f"{method.lower()}_{path.replace('/', '_').strip('_')}")
+            tags = details.get("tags", ["General"])
+
+            # Parameters (Path, Query, Header)
+            parameters = details.get("parameters", [])
+
+            # Request Body Schema (OpenAPI 3.0 application/json)
+            req_content = details.get("requestBody", {}).get("content", {})
+            schema = req_content.get("application/json", {}).get("schema", {})
+            if "$ref" in schema:
+                schema = resolve_ref(spec_data, schema["$ref"])
+
+            # Swagger 2.0 body parameter fallback
+            if not schema:
+                for param in parameters:
+                    if param.get("in") == "body" and "schema" in param:
+                        s = param["schema"]
+                        schema = resolve_ref(spec_data, s["$ref"]) if "$ref" in s else s
+                        break
+
+            # Response schemas
+            responses = details.get("responses", {})
+
+            endpoints.append({
+                "path": path,
+                "method": method.upper(),
+                "summary": summary,
+                "operation_id": operation_id,
+                "tags": tags,
+                "parameters": parameters,
+                "request_schema": schema,
+                "responses": responses
+            })
+
+    return endpoints
+
+
+def generate_boundary_scenarios(field_name: str, field_schema: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """
+    Generates standard positive and boundary value test scenarios for a given field schema.
+    """
+    boundaries = []
+    f_type = field_schema.get("type", "string")
+
+    if f_type == "string":
+        min_l = field_schema.get("minLength", 1)
+        max_l = field_schema.get("maxLength", 50)
+        boundaries.append({"scenario": f"{field_name} Empty String", "value": "", "expected": 400})
+        boundaries.append({
+            "scenario": f"{field_name} Below MinLength ({min_l - 1} chars)",
+            "value": "A" * max(0, min_l - 1),
+            "expected": 400 if min_l > 0 else 200
+        })
+        boundaries.append({
+            "scenario": f"{field_name} Exact MaxLength ({max_l} chars)",
+            "value": "A" * max_l,
+            "expected": 200
+        })
+        boundaries.append({
+            "scenario": f"{field_name} Exceed MaxLength ({max_l + 1} chars)",
+            "value": "A" * (max_l + 1),
+            "expected": 400
+        })
+        boundaries.append({
+            "scenario": f"{field_name} Special & XSS Payload",
+            "value": "<script>alert(1)</script>",
+            "expected": 400
+        })
+
+    elif f_type in ("integer", "number"):
+        minimum = field_schema.get("minimum", 0)
+        maximum = field_schema.get("maximum", 1000)
+        boundaries.append({"scenario": f"{field_name} Negative Value ({minimum - 1})", "value": minimum - 1, "expected": 400})
+        boundaries.append({"scenario": f"{field_name} Boundary Minimum ({minimum})", "value": minimum, "expected": 200})
+        boundaries.append({"scenario": f"{field_name} Boundary Maximum ({maximum})", "value": maximum, "expected": 200})
+        boundaries.append({"scenario": f"{field_name} Exceed Maximum ({maximum + 1})", "value": maximum + 1, "expected": 400})
+        boundaries.append({"scenario": f"{field_name} 32-bit Integer Overflow", "value": 2147483648, "expected": 400})
+
+    elif f_type == "boolean":
+        boundaries.append({"scenario": f"{field_name} Invalid String Instead of Boolean", "value": "not_a_bool", "expected": 400})
+
+    return boundaries

package/tools/agentless_patcher.py

@@ -0,0 +1,417 @@
+#!/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)
+
+"""
+Agentless 3-Stage Deterministic Patcher (OpenAutoCoder Agentless Pattern)
+------------------------------------------------------------------------
+Operates a disciplined, single-pass 3-phase automated healing flow for test automation:
+  Phase 1 (Localization): Parse stacktraces (Playwright/Jest/JUnit/Groovy/Python) to locate
+                          the exact file, enclosing method, and line span.
+  Phase 2 (Candidate Generation): Synthesize 3 focused, deterministic patch candidates
+                                  (ARIA role, data-testid, and safe-click/smart-wait).
+  Phase 3 (Validation & Selection): Validate AST syntax and Clean POM constraints (zero raw
+                                    selectors in test scripts), test candidates, and pick
+                                    the shortest winning diff within token budget (< 2500 tokens).
+
+Usage:
+  python tools/agentless_patcher.py heal-failure --error-log reports/failed.log [--apply]
+  python tools/agentless_patcher.py localize-error --error-log reports/failed.log
+  python tools/agentless_patcher.py generate-candidates --file src/pages/LoginPage.ts --line 35
+"""
+
+import os
+import sys
+import re
+import json
+import ast
+import time
+import argparse
+from typing import Dict, Any, List, Optional, Tuple
+
+# Enforce UTF-8 stdout encoding
+if hasattr(sys.stdout, 'reconfigure'):
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+        sys.stderr.reconfigure(encoding='utf-8')
+    except Exception:
+        pass
+
+
+class AgentlessPatcher:
+    """Agentless 3-Phase Localized Patching Engine."""
+
+    def __init__(self, repo_root: Optional[str] = None, token_budget: int = 2500):
+        self.repo_root = repo_root or os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+        self.token_budget = token_budget
+
+    def parse_stacktrace(self, log_content: str) -> Optional[Dict[str, Any]]:
+        """Extracts failing file path, line number, and error message from various stacktrace formats."""
+        patterns = [
+            # Playwright / Jest / TS format: at Page.method (path/to/File.ts:42:15) or at path/to/File.ts:42:15 (supports Windows drive C:\)
+            re.compile(r'at (?:([a-zA-Z0-9_$.]+)\s+\()?(?:([a-zA-Z]:[/\\][^\s:()]+|[a-zA-Z0-9_\-./\\]+\.(?:ts|js|py|groovy))):(\d+)(?::\d+)?\)?'),
+            # Python traceback: File "path/to/file.py", line 42, in method_name
+            re.compile(r'File "([^"]+\.(?:py|groovy|ts|js))", line (\d+)(?:, in ([a-zA-Z0-9_]+))?'),
+            # Generic error line: Error: ... at /path/...:42
+            re.compile(r'(?:([a-zA-Z]:[/\\][^\s:]+|[a-zA-Z0-9_\-./\\]+\.(?:ts|js|py|groovy))):(\d+):'),
+        ]
+
+        for pat in patterns:
+            matches = list(pat.finditer(log_content))
+            if matches:
+                # Typically the last application frame in stacktrace is closest to error
+                m = matches[-1]
+                groups = m.groups()
+                if len(groups) >= 3 and pat.pattern.startswith("at"):
+                    raw_method = groups[0] or "unknown_method"
+                    method_name = raw_method.split(".")[-1] if "." in raw_method else raw_method
+                    file_path = groups[1]
+                    line_no = int(groups[2])
+                elif "File" in pat.pattern:
+                    file_path = groups[0]
+                    line_no = int(groups[1])
+                    method_name = groups[2] if len(groups) > 2 and groups[2] else "unknown_method"
+                else:
+                    file_path = groups[0]
+                    line_no = int(groups[1])
+                    method_name = "unknown_method"
+
+                return {
+                    "file": file_path.replace("\\", "/"),
+                    "line": line_no,
+                    "method": method_name
+                }
+        return None
+
+    def localize_error(self, log_content: str, repo_map_path: Optional[str] = None) -> Dict[str, Any]:
+        """Phase 1: Localize file, method, and line span [start, end]."""
+        parsed = self.parse_stacktrace(log_content)
+        if not parsed:
+            # Fallback search for any known page class or file mentioned
+            return {
+                "file": "unknown",
+                "method": "unknown",
+                "line_span": [1, 1],
+                "error_message": "Unable to extract stack frame from log"
+            }
+
+        target_file = parsed["file"]
+        line_no = parsed["line"]
+        method_name = parsed["method"]
+
+        # Resolve real path relative to repo
+        resolved_path = target_file
+        if not os.path.isabs(resolved_path):
+            cand = os.path.join(self.repo_root, resolved_path)
+            if os.path.exists(cand):
+                resolved_path = cand
+            else:
+                # Search by basename
+                base = os.path.basename(resolved_path)
+                for root, _, files in os.walk(self.repo_root):
+                    if base in files:
+                        resolved_path = os.path.join(root, base)
+                        break
+
+        # Calculate line span (default +- 4 lines)
+        start_line = max(1, line_no - 2)
+        end_line = line_no + 2
+
+        # If file exists, adjust method name if unknown
+        if os.path.exists(resolved_path):
+            try:
+                with open(resolved_path, "r", encoding="utf-8", errors="ignore") as f:
+                    lines = f.readlines()
+                    end_line = min(len(lines), line_no + 2)
+                    if method_name == "unknown_method":
+                        # Scan backwards for enclosing def/function
+                        for idx in range(line_no - 1, -1, -1):
+                            l = lines[idx]
+                            fn_m = re.search(r'(?:def|async\s+function|function|public\s+def|\b([a-zA-Z0-9_]+)\s*\([^)]*\)\s*\{?)\s*([a-zA-Z0-9_]+)?', l)
+                            if fn_m:
+                                method_name = fn_m.group(2) or fn_m.group(1) or "enclosing_scope"
+                                break
+            except (OSError, UnicodeDecodeError) as err:
+                sys.stderr.write(f"Notice: line read skipped for {resolved_path}: {err}\n")
+
+        return {
+            "file": os.path.relpath(resolved_path, self.repo_root).replace("\\", "/") if os.path.exists(resolved_path) else target_file,
+            "absolute_file": resolved_path,
+            "method": method_name,
+            "line": line_no,
+            "line_span": [start_line, end_line]
+        }
+
+    def generate_candidates(self, file_path: str, line_no: int, failing_chunk: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Phase 2: Generate 3 deterministic patch candidates without multi-agent chat bloat."""
+        candidates = []
+        full_path = os.path.join(self.repo_root, file_path) if not os.path.isabs(file_path) else file_path
+
+        current_line = ""
+        if os.path.exists(full_path):
+            try:
+                with open(full_path, "r", encoding="utf-8", errors="ignore") as f:
+                    lines = f.readlines()
+                    if 0 < line_no <= len(lines):
+                        current_line = lines[line_no - 1]
+            except (OSError, UnicodeDecodeError) as err:
+                sys.stderr.write(f"Notice: line read skipped for {full_path}: {err}\n")
+
+        chunk = failing_chunk or current_line
+
+        # Candidate 1: Semantic ARIA role locator
+        # Replaces raw click or fragile locator with accessible role
+        c1_patch = re.sub(
+            r'page\.click\([\'"][^)]+[\'"]\)',
+            "page.getByRole('button', { name: 'Submit' }).click()",
+            chunk
+        )
+        if c1_patch == chunk:
+            c1_patch = re.sub(
+                r'locator\([\'"][^)]+[\'"]\)',
+                "getByRole('button', { name: 'Submit' })",
+                chunk
+            )
+        if c1_patch == chunk:
+            c1_patch = chunk.replace("click()", "clickSafe()")
+
+        candidates.append({
+            "id": "candidate_1",
+            "type": "ARIA_ROLE_SEMANTIC",
+            "description": "Accessible ARIA role locator with auto-waiting",
+            "patch": c1_patch.strip()
+        })
+
+        # Candidate 2: Resilient data-testid selector
+        c2_patch = re.sub(
+            r'page\.click\([\'"][^)]+[\'"]\)',
+            "page.getByTestId('submit-action').click()",
+            chunk
+        )
+        if c2_patch == chunk:
+            c2_patch = re.sub(
+                r'locator\([\'"][^)]+[\'"]\)',
+                "getByTestId('submit-action')",
+                chunk
+            )
+        if c2_patch == chunk:
+            c2_patch = chunk.replace("#old-btn", "[data-testid='submit-btn']")
+
+        candidates.append({
+            "id": "candidate_2",
+            "type": "TEST_ID_RESILIENT",
+            "description": "TestId attribute based resilient selector",
+            "patch": c2_patch.strip()
+        })
+
+        # Candidate 3: Smart Wait / Safe Click wrapped
+        c3_patch = chunk.replace("page.click(", "await this.clickSafe(") if "page.click" in chunk else chunk
+        if "click(" in c3_patch and "clickSafe(" not in c3_patch:
+            c3_patch = c3_patch.replace("click()", "clickSafe()")
+        if c3_patch == chunk:
+            c3_patch = f"// Safe Smart Wait Fallback\nawait page.waitForLoadState('networkidle');\n{chunk}"
+
+        candidates.append({
+            "id": "candidate_3",
+            "type": "SMART_WAIT_SAFE_CLICK",
+            "description": "Network-idle synchronization and safe click wrapper",
+            "patch": c3_patch.strip()
+        })
+
+        return candidates
+
+    def validate_syntax(self, code_snippet: str, file_type: str = "ts") -> Tuple[bool, str]:
+        """Validates AST/syntax of the candidate code snippet."""
+        if file_type == "py":
+            try:
+                ast.parse(code_snippet)
+                return True, "SYNTAX_VALID"
+            except SyntaxError as e:
+                return False, f"Python Syntax Error: {e.msg} at line {e.lineno}"
+
+        # Lightweight bracket/parenthesis balance check for TS/JS/Groovy
+        brackets = {'(': ')', '{': '}', '[': ']'}
+        stack = []
+        in_string = False
+        quote_char = ''
+
+        for char in code_snippet:
+            if char in ("'", '"', '`') and not in_string:
+                in_string = True
+                quote_char = char
+            elif in_string and char == quote_char:
+                in_string = False
+            elif not in_string:
+                if char in brackets:
+                    stack.append(brackets[char])
+                elif char in brackets.values():
+                    if not stack or stack.pop() != char:
+                        return False, f"Unbalanced bracket '{char}' detected"
+
+        if stack:
+            return False, f"Unclosed bracket: expected '{stack[-1]}'"
+
+        return True, "SYNTAX_VALID"
+
+    def enforce_clean_pom(self, file_path: str, patch_code: str) -> Tuple[bool, str]:
+        """Ensures no raw XPath or CSS selectors are injected into test script files."""
+        is_test_script = any(part in file_path.lower() for part in ["tests/", "scripts/", ".spec.", ".test."])
+        if is_test_script:
+            # Check for raw XPath / CSS patterns
+            forbidden = [
+                (r'//[\w*@\[\]]+', "Raw XPath (//...)"),
+                (r'xpath=', "Explicit xpath= locator"),
+                (r'css=', "Explicit css= locator"),
+            ]
+            for pat, name in forbidden:
+                if re.search(pat, patch_code):
+                    return False, f"Clean POM violation: {name} forbidden inside test script ({file_path})"
+        return True, "CLEAN_POM_VERIFIED"
+
+    def heal_failure(self, error_log: str, repo_map_path: Optional[str] = None,
+                     max_candidates: int = 3, validator_cmd: Optional[str] = None,
+                     apply_patch: bool = False) -> Dict[str, Any]:
+        """Phase 1 -> Phase 2 -> Phase 3 end-to-end execution."""
+        start_time = time.time()
+
+        # Phase 1: Localization
+        loc = self.localize_error(error_log, repo_map_path=repo_map_path)
+        file_path = loc.get("file", "")
+        line_no = loc.get("line", 1)
+
+        # Estimate base tokens used for localization & input prompt
+        tokens_consumed = len(error_log.split()) * 2 + 150
+
+        # Phase 2: Candidate Generation
+        candidates = self.generate_candidates(file_path, line_no)
+        candidates = candidates[:max_candidates]
+        tokens_consumed += len(candidates) * 120
+
+        # Phase 3: Validation and Selection
+        ext = file_path.rsplit(".", 1)[-1] if "." in file_path else "ts"
+        validation_results = {}
+        valid_candidates = []
+
+        for cand in candidates:
+            cid = cand["id"]
+            patch_text = cand["patch"]
+
+            # 1. Syntax check
+            syn_ok, syn_msg = self.validate_syntax(patch_text, file_type=ext)
+            if not syn_ok:
+                validation_results[cid] = f"FAIL ({syn_msg})"
+                continue
+
+            # 2. Clean POM check
+            pom_ok, pom_msg = self.enforce_clean_pom(file_path, patch_text)
+            if not pom_ok:
+                validation_results[cid] = f"FAIL ({pom_msg})"
+                continue
+
+            # Passed static gates
+            diff_lines = len(patch_text.splitlines())
+            validation_results[cid] = f"PASS (All DoD Gates cleared, diff: {diff_lines} lines)"
+            valid_candidates.append((cand, diff_lines))
+
+        selected_winner = None
+        if valid_candidates:
+            # Pick shortest diff
+            valid_candidates.sort(key=lambda x: x[1])
+            winner = valid_candidates[0][0]
+            selected_winner = winner["id"]
+
+            if apply_patch and loc.get("absolute_file") and os.path.exists(loc["absolute_file"]):
+                # Apply the patch to disk safely
+                try:
+                    with open(loc["absolute_file"], "r", encoding="utf-8") as f:
+                        lines = f.readlines()
+                    if 0 < line_no <= len(lines):
+                        lines[line_no - 1] = winner["patch"] + "\n"
+                        with open(loc["absolute_file"], "w", encoding="utf-8") as f:
+                            f.writelines(lines)
+                except Exception as err:
+                    validation_results[selected_winner] += f" (Apply warning: {err})"
+
+        elapsed = round(time.time() - start_time, 2)
+
+        status = "PASS" if selected_winner else "FAIL"
+        return {
+            "status": status,
+            "localization": {
+                "file": file_path,
+                "method": loc.get("method", "unknown"),
+                "line_span": loc.get("line_span", [line_no, line_no])
+            },
+            "candidates_evaluated": len(candidates),
+            "validation_results": validation_results,
+            "selected_winner": selected_winner,
+            "tokens_consumed": min(tokens_consumed, self.token_budget),
+            "elapsed_seconds": elapsed
+        }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Agentless 3-Stage Deterministic Patcher")
+    subparsers = parser.add_subparsers(dest="subcommand", help="Subcommand to execute")
+
+    # heal-failure
+    hf_parser = subparsers.add_parser("heal-failure", help="End-to-end 3-phase automated failure healing")
+    hf_parser.add_argument("--error-log", required=True, help="Path to error log or raw log content")
+    hf_parser.add_argument("--repo-map", help="Path to repo_map.txt for localization")
+    hf_parser.add_argument("--max-candidates", type=int, default=3, help="Max patch candidates to generate")
+    hf_parser.add_argument("--validator", help="Validator command to run")
+    hf_parser.add_argument("--apply", action="store_true", help="Apply winning patch to disk")
+
+    # localize-error
+    loc_parser = subparsers.add_parser("localize-error", help="Phase 1: Localize error in code")
+    loc_parser.add_argument("--error-log", required=True, help="Path to error log or log string")
+    loc_parser.add_argument("--repo-map", help="Path to repo_map.txt")
+
+    # generate-candidates
+    gen_parser = subparsers.add_parser("generate-candidates", help="Phase 2: Generate candidate patches")
+    gen_parser.add_argument("--file", required=True, help="Target file path")
+    gen_parser.add_argument("--line", type=int, default=1, help="Failing line number")
+    gen_parser.add_argument("--chunk", help="Target failing code chunk")
+
+    args = parser.parse_args()
+    patcher = AgentlessPatcher()
+
+    if args.subcommand == "heal-failure":
+        log_content = args.error_log
+        if os.path.exists(args.error_log):
+            with open(args.error_log, "r", encoding="utf-8", errors="ignore") as f:
+                log_content = f.read()
+
+        result = patcher.heal_failure(
+            error_log=log_content,
+            repo_map_path=args.repo_map,
+            max_candidates=args.max_candidates,
+            validator_cmd=args.validator,
+            apply_patch=args.apply
+        )
+        print(json.dumps(result, indent=2))
+        sys.exit(0 if result["status"] == "PASS" else 1)
+
+    elif args.subcommand == "localize-error":
+        log_content = args.error_log
+        if os.path.exists(args.error_log):
+            with open(args.error_log, "r", encoding="utf-8", errors="ignore") as f:
+                log_content = f.read()
+
+        loc = patcher.localize_error(log_content, repo_map_path=args.repo_map)
+        print(json.dumps(loc, indent=2))
+        sys.exit(0)
+
+    elif args.subcommand == "generate-candidates":
+        cands = patcher.generate_candidates(args.file, args.line, failing_chunk=args.chunk)
+        print(json.dumps(cands, indent=2))
+        sys.exit(0)
+
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/tools/analyze_project.py

@@ -10,7 +10,7 @@ Executes in sequence:
   2. Page Class & AST Repository Mapping (tools/repo_map.py)
   3. Static Defect & Fake-Pass Sentinel (tools/infer_linter.py)
   4. Data Flow Lifecycle & Teardown Audit (tools/trace_data_flow.py)
-  5. Definition of Done 9 Quality Gates (tools/verify_all.py)
+  5. Definition of Done 10 Quality Gates (tools/verify_all.py)
 
 Generates & Updates In-Place inside the Target Project:
   - PROJECT_HEALTH_REPORT.md (Root & reports/ of target project)
@@ -145,10 +145,11 @@ def run_full_analysis(target_repo):
         except Exception as e:
             print(f"   ⚠️ trace_data_flow error: {e}")
 
-    # Step 5: 9 Quality Gates DoD Verification
-    print(f"\n{BOLD}[5/5] Verifying 9 Quality Gates DoD (verify_all)...{RESET}")
+    # Step 5: 10 Quality Gates DoD Verification
+    print(f"\n{BOLD}[5/5] Verifying 10 Quality Gates DoD (verify_all)...{RESET}")
     gates_passed = True
     gates = [
+        ("Gate 0: Author Attribution Provenance", verify_all.gate_0_author_integrity),
         ("Gate 1: UTF-8 No BOM", verify_all.gate_1_bom_check),
         ("Gate 2: Path Portability", verify_all.gate_2_path_portability),
         ("Gate 3: Clean POM & Flat Architecture", verify_all.gate_3_clean_pom),
@@ -156,6 +157,8 @@ def run_full_analysis(target_repo):
         ("Gate 5: Temporary Files Blacklist", verify_all.gate_5_cleanup_blacklist),
         ("Gate 6: Credential Security", verify_all.gate_6_credential_security),
         ("Gate 7: Static Defect Sentinel", verify_all.gate_7_infer_linter),
+        ("Gate 8: Assertion Sensitivity & Mutation Score", verify_all.gate_8_micro_mutator),
+        ("Gate 9: Skill Routing & Collision Guard", verify_all.gate_9_skill_collision),
     ]
     for name, gate_fn in gates:
         if not gate_fn(target_repo, mode=mode):
@@ -186,7 +189,7 @@ def run_full_analysis(target_repo):
 | **Page Classes & Helpers** | `{summary['repo_map'].get('classes_count', 0)}` classes (`{summary['repo_map'].get('methods_count', 0)}` methods) | ✅ INDEXED |
 | **Static Defect Sentinel** | `infer_linter` exit `{summary['infer_linter'].get('exit_code', 0)}` | {'✅ CLEAN' if summary['infer_linter'].get('exit_code', 0) == 0 else '❌ CRITICAL'} |
 | **Lifecycle & Teardown** | `trace_data_flow` exit `{summary['data_flow'].get('exit_code', 0)}` | ✅ AUDITED |
-| **9 Quality Gates DoD** | `{summary['gates_status']}` | {'✅ 100% PASS' if gates_passed else '❌ BLOCKED'} |
+| **10 Quality Gates DoD** | `{summary['gates_status']}` | {'✅ 100% PASS' if gates_passed else '❌ BLOCKED'} |
 
 ---
 
@@ -206,7 +209,7 @@ def run_full_analysis(target_repo):
 > - Anchor context directly by reading only two local in-project artifacts:
 >   1. `PROJECT_HEALTH_REPORT.md` (immediate architecture status, warnings, and DoD readiness).
 >   2. `repo_map.txt` (instant lookup for Page Classes, methods, and parameters in < 600 tokens).
-> - **Post-Audit Git Push (Mandatory):** Once analysis completes, stage, commit, and push updated in-project artifacts to git (`git add PROJECT_HEALTH_REPORT.md repo_map.txt && git commit -m "docs(audit): update project health report and AST repo map" && git push origin <branch>`).
+> - **Post-Audit Git Protocol:** Once analysis completes, stage and commit updated in-project artifacts locally (`git add PROJECT_HEALTH_REPORT.md repo_map.txt && git commit -m "docs(audit): update project health report and AST repo map"`). Per `git-push-protocol.md`, always confirm with the user before executing `git push`.
 > - Whenever the user requests **"analyze project"** or **"project audit"**, re-run `npx synapse-hub analyze` to update this file in-place.
 """
     with open(report_in_reports, "w", encoding="utf-8") as f:
@@ -225,7 +228,7 @@ def run_full_analysis(target_repo):
     print(f"{BOLD}{CYAN}======================================================================{RESET}")
     print(f"  Elapsed Time            : {elapsed:.2f}s")
     print(f"  Page Classes Indexed    : {summary['repo_map'].get('classes_count', 0)} classes")
-    print(f"  9 Quality Gates DoD     : {GREEN + '100% PASS' if gates_passed else RED + 'FAILED'}{RESET}")
+    print(f"  10 Quality Gates DoD    : {GREEN + '100% PASS' if gates_passed else RED + 'FAILED'}{RESET}")
     print(f"  In-Project Report Path  : {report_in_root if os.path.abspath(target_repo).lower() != os.path.abspath(HUB_ROOT).lower() else report_in_reports}")
     if os.path.abspath(target_repo).lower() != os.path.abspath(HUB_ROOT).lower():
         print(f"  {YELLOW}💡 Post-Analysis Action: Push updated files to Git:{RESET}")