code-oracle 0.1.0__py3-none-any.whl

code_oracle/linearizer.py

@@ -0,0 +1,166 @@
+"""
+Stage 5: Graph Linearizer.
+Serializes the sliced subgraph and patch metadata into a compact Domain-Specific Language (< 400 tokens)
+for Laya ModernBERT decision head ingestion.
+"""
+
+import re
+from typing import List, Optional
+
+from code_oracle.models import GateResult, PatchResult, SlicedGraph
+
+
+def estimate_tokens(text: str) -> int:
+    """
+    Conservative token estimator matching BPE / WordPiece tokenizers.
+    Counts word/identifier chunks and individual punctuation symbols.
+    """
+    if not text:
+        return 0
+    tokens = re.findall(r"[A-Za-z0-9_]+|[^\w\s]", text)
+    return len(tokens)
+
+
+def linearize_subgraph(
+    patch_result: PatchResult,
+    slice_graph: SlicedGraph,
+    gate_result: GateResult,
+    max_tokens: int = 400,
+) -> str:
+    """
+    Convert patch metadata, sliced subgraph, and gate verdict into a compact DSL.
+    Guarantees output size <= max_tokens (default 400 tokens).
+    """
+    # 1. Diff target header
+    if patch_result.affected_symbols:
+        seed_names = [s.qualname for s in patch_result.affected_symbols]
+        seed_str = ", ".join(seed_names)
+        target_header = f"[DIFF_TARGET] {patch_result.file_path}::{seed_str} (MODIFIED)"
+    elif patch_result.deleted_symbols:
+        del_names = [s.qualname for s in patch_result.deleted_symbols]
+        seed_str = ", ".join(del_names)
+        target_header = f"[DIFF_TARGET] {patch_result.file_path}::{seed_str} (DELETED)"
+    elif patch_result.added_symbols:
+        add_names = [s.qualname for s in patch_result.added_symbols]
+        seed_str = ", ".join(add_names)
+        target_header = f"[DIFF_TARGET] {patch_result.file_path}::{seed_str} (ADDED)"
+    else:
+        target_header = f"[DIFF_TARGET] {patch_result.file_path}::<module> (MODIFIED)"
+
+    def format_line_numbers(line_set: set) -> str:
+        if not line_set:
+            return "[]"
+        sorted_lines = sorted(list(line_set))
+        if len(sorted_lines) <= 6:
+            return str(sorted_lines)
+        return f"[{sorted_lines[0]}..{sorted_lines[-1]}] ({len(sorted_lines)} lines)"
+
+    lines_str = f"OldLines: {format_line_numbers(patch_result.modified_old_lines)} | NewLines: {format_line_numbers(patch_result.modified_new_lines)}"
+    meta_header = f"[METADATA] File: {patch_result.file_path} | {lines_str} | Nodes: {len(slice_graph.nodes)} | Edges: {len(slice_graph.edges)}"
+
+    # 2. Gate Section
+    status_str = f"STATUS: {gate_result.status} (conf: {round(gate_result.confidence, 2)})"
+    cycles_str = f"CYCLES: {len(gate_result.cycles)}"
+    if gate_result.violations:
+        violations_str = "VIOLATIONS:\n  - " + "\n  - ".join(gate_result.violations[:3])
+        if len(gate_result.violations) > 3:
+            violations_str += f"\n  - ... ({len(gate_result.violations) - 3} more)"
+    else:
+        violations_str = "VIOLATIONS: NONE"
+
+    gate_section = f"[GATE]\n{status_str}\n{cycles_str}\n{violations_str}"
+
+    # 3. Nodes and Edges preparation
+    node_id_map = {}
+    ordered_nodes = []
+
+    # Put seeds first
+    for n_id, node in slice_graph.nodes.items():
+        if node.is_seed:
+            node_id_map[n_id] = f"N{len(node_id_map)}"
+            ordered_nodes.append((n_id, node))
+
+    # Then non-seed nodes
+    for n_id, node in slice_graph.nodes.items():
+        if not node.is_seed:
+            node_id_map[n_id] = f"N{len(node_id_map)}"
+            ordered_nodes.append((n_id, node))
+
+    def build_dsl(active_node_pairs: List[tuple]) -> str:
+        active_ids = {n_id for n_id, _ in active_node_pairs}
+
+        node_lines = []
+        for n_id, node in active_node_pairs:
+            short_id = node_id_map[n_id]
+            flags = []
+            if node.is_seed:
+                flags.append("SEED")
+            if node.is_modified:
+                flags.append("MODIFIED")
+            if node.truncated:
+                flags.append("TRUNCATED")
+            flag_str = f" ({', '.join(flags)})" if flags else ""
+            node_lines.append(f"{short_id}: {node.file_path}::{node.name} [{node.signature}]{flag_str}")
+
+        edge_lines = []
+        for edge in slice_graph.edges:
+            if edge.source in active_ids and edge.target in active_ids:
+                src_short = node_id_map.get(edge.source, edge.source.split("::")[-1])
+                tgt_short = node_id_map.get(edge.target, edge.target.split("::")[-1])
+                edge_lines.append(f"{src_short} -> {tgt_short} ({edge.relation})")
+
+        nodes_section = "[NODES]\n" + ("\n".join(node_lines) if node_lines else "(none)")
+        edges_section = "[EDGES]\n" + ("\n".join(edge_lines) if edge_lines else "(none)")
+
+        return f"{target_header}\n{meta_header}\n{nodes_section}\n{edges_section}\n{gate_section}"
+
+    # Try full graph first
+    dsl = build_dsl(ordered_nodes)
+    current_tokens = estimate_tokens(dsl)
+
+    # If exceeding max_tokens, prune non-seed nodes from tail until under budget
+    if current_tokens > max_tokens:
+        seed_nodes = [(n_id, n) for n_id, n in ordered_nodes if n.is_seed]
+        non_seed_nodes = [(n_id, n) for n_id, n in ordered_nodes if not n.is_seed]
+
+        pruned = False
+        while non_seed_nodes:
+            non_seed_nodes.pop()
+            candidate_dsl = build_dsl(seed_nodes + non_seed_nodes)
+            candidate_dsl += f"\n[TRUNCATED: {len(ordered_nodes) - len(seed_nodes) - len(non_seed_nodes)} peripheral nodes pruned for token budget]"
+            if estimate_tokens(candidate_dsl) <= max_tokens:
+                dsl = candidate_dsl
+                pruned = True
+                break
+
+        if not pruned:
+            candidate_dsl = build_dsl(seed_nodes)
+            candidate_dsl += f"\n[TRUNCATED: all non-seed nodes pruned]"
+            if estimate_tokens(candidate_dsl) <= max_tokens:
+                dsl = candidate_dsl
+            else:
+                # Even seed nodes exceed max_tokens; prune excess seeds
+                while len(seed_nodes) > 1:
+                    seed_nodes.pop()
+                    cand = build_dsl(seed_nodes) + f"\n[TRUNCATED: excess seeds pruned]"
+                    if estimate_tokens(cand) <= max_tokens:
+                        dsl = cand
+                        break
+                else:
+                    dsl = candidate_dsl
+
+    # Hard guarantee: strictly under or equal to max_tokens budget
+    if estimate_tokens(dsl) > max_tokens:
+        dsl_lines = dsl.splitlines()
+        min_lines = min(2, len(dsl_lines))
+        while len(dsl_lines) > min_lines and estimate_tokens("\n".join(dsl_lines)) > max_tokens:
+            dsl_lines.pop()
+        dsl = "\n".join(dsl_lines)
+
+        if estimate_tokens(dsl) > max_tokens:
+            tokens_list = dsl.split()
+            while tokens_list and estimate_tokens(" ".join(tokens_list)) > max_tokens:
+                tokens_list.pop()
+            dsl = " ".join(tokens_list)
+
+    return dsl

code_oracle/locator.py

@@ -0,0 +1,301 @@
+"""
+Stage 1: Diff Boundary Locator.
+Maps patch diff line changes to AST symbol spans (functions, methods, classes).
+"""
+
+import ast
+import difflib
+import re
+from pathlib import Path
+from typing import List, Optional, Set, Tuple
+
+from code_oracle.languages import extract_imports, extract_symbols, validate_syntax
+from code_oracle.models import CallReference, DiffHunk, ImportReference, Parameter, PatchResult, Symbol
+
+
+def parse_unified_diff(diff_text: str) -> List[DiffHunk]:
+    """Parse unified diff text into structured DiffHunk objects."""
+    hunk_pattern = re.compile(r"^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@")
+    hunks: List[DiffHunk] = []
+    current_hunk: Optional[DiffHunk] = None
+
+    for line in diff_text.splitlines():
+        match = hunk_pattern.match(line)
+        if match:
+            old_start = int(match.group(1))
+            old_count = int(match.group(2)) if match.group(2) else 1
+            new_start = int(match.group(3)) if match.group(3) else 1
+            new_count = int(match.group(4)) if match.group(4) else 1
+            current_hunk = DiffHunk(
+                old_start=old_start,
+                old_count=old_count,
+                new_start=new_start,
+                new_count=new_count,
+                lines=[],
+            )
+            hunks.append(current_hunk)
+        elif current_hunk is not None:
+            if line.startswith(("--- ", "+++ ", "diff --git", "index ")):
+                current_hunk = None
+            elif line.startswith(("+", "-", " ", "\\")):
+                current_hunk.lines.append(line)
+            elif line == "":
+                current_hunk.lines.append(" ")
+
+    return hunks
+
+
+def apply_patch(
+    original_text: str,
+    patch_text: str,
+    is_replacement: bool = False,
+) -> Tuple[str, Set[int], Set[int]]:
+    """
+    Applies unified diff or replacement text in memory.
+    Returns:
+        (patched_text, modified_old_lines, modified_new_lines)
+    """
+    hunks = [] if is_replacement else parse_unified_diff(patch_text)
+
+    # If no diff hunks found or explicitly replacement, treat patch_text as full replacement content
+    if is_replacement or not hunks:
+        orig_lines = original_text.splitlines(keepends=True)
+        patched_lines = patch_text.splitlines(keepends=True)
+
+        if not original_text.strip():
+            # Brand new file
+            new_lines = set(range(1, len(patched_lines) + 1))
+            return patch_text, set(), new_lines
+
+        # Calculate line differences via difflib
+        matcher = difflib.SequenceMatcher(None, orig_lines, patched_lines)
+        old_modified = set()
+        new_modified = set()
+        for tag, alo, ahi, blo, bhi in matcher.get_opcodes():
+            if tag != "equal":
+                for l in range(alo + 1, ahi + 1):
+                    old_modified.add(l)
+                for l in range(blo + 1, bhi + 1):
+                    new_modified.add(l)
+        return patch_text, old_modified, new_modified
+
+    # Apply unified diff hunks line by line
+    orig_lines = original_text.splitlines(keepends=True)
+    out_lines: List[str] = []
+    orig_idx = 0  # 0-indexed cursor into orig_lines
+    old_modified = set()
+    new_modified = set()
+    current_new_line = 1
+
+    for hunk in hunks:
+        target_orig_idx = max(0, hunk.old_start - 1) if hunk.old_start > 0 else 0
+        while orig_idx < target_orig_idx and orig_idx < len(orig_lines):
+            out_lines.append(orig_lines[orig_idx])
+            orig_idx += 1
+            current_new_line += 1
+
+        cur_old_line = hunk.old_start
+        for line in hunk.lines:
+            if line.startswith("+"):
+                content = line[1:]
+                if not content.endswith("\n"):
+                    content += "\n"
+                out_lines.append(content)
+                new_modified.add(current_new_line)
+                current_new_line += 1
+            elif line.startswith("-"):
+                old_modified.add(cur_old_line)
+                cur_old_line += 1
+                orig_idx += 1
+            elif line.startswith(" "):
+                content = line[1:]
+                if not content.endswith("\n"):
+                    content += "\n"
+                out_lines.append(content)
+                cur_old_line += 1
+                orig_idx += 1
+                current_new_line += 1
+            # Ignore ''
+
+    while orig_idx < len(orig_lines):
+        out_lines.append(orig_lines[orig_idx])
+        orig_idx += 1
+        current_new_line += 1
+
+    return "".join(out_lines), old_modified, new_modified
+
+
+def _extract_calls_from_node(node: ast.AST, caller_id: Optional[str] = None) -> List[CallReference]:
+    """Extract all function/method calls inside an AST node."""
+    calls: List[CallReference] = []
+    for child in ast.walk(node):
+        if isinstance(child, ast.Call):
+            try:
+                callee_name = ast.unparse(child.func)
+            except Exception:
+                callee_name = "<unknown>"
+            kwargs = [kw.arg for kw in child.keywords if kw.arg is not None]
+            has_vararg = any(isinstance(a, ast.Starred) for a in child.args)
+            has_kwarg = any(kw.arg is None for kw in child.keywords)
+            calls.append(
+                CallReference(
+                    callee=callee_name,
+                    args_count=len(child.args),
+                    kwargs=kwargs,
+                    lineno=getattr(child, "lineno", 0),
+                    caller=caller_id,
+                    has_vararg=has_vararg,
+                    has_kwarg=has_kwarg,
+                )
+            )
+    return calls
+
+
+def extract_imports_from_ast(source: str, file_path: str = "") -> List[ImportReference]:
+    """Extract all import statements from source for any supported language."""
+    return extract_imports(source, file_path=file_path)
+
+
+def extract_symbols_from_ast(source: str, file_path: str = "") -> List[Symbol]:
+    """Parse source into AST and extract symbol entities with detailed metadata."""
+    if not source.strip():
+        return []
+    return extract_symbols(source, file_path=file_path)
+
+
+
+def locate_affected_symbols(
+    file_path: str,
+    patch_content: str,
+    workspace_root: Optional[Path] = None,
+    original_content: Optional[str] = None,
+    is_replacement: bool = False,
+) -> PatchResult:
+    """
+    Stage 1 Diff Boundary Locator:
+    Maps patch changes to precise AST symbol spans.
+    """
+    full_path = Path(file_path)
+    if workspace_root:
+        if not full_path.is_absolute():
+            full_path = (workspace_root / file_path).resolve()
+        else:
+            full_path = full_path.resolve()
+        try:
+            clean_path = str(full_path.relative_to(workspace_root.resolve())).replace("\\", "/")
+        except ValueError:
+            clean_path = str(file_path).replace("\\", "/")
+    else:
+        clean_path = str(file_path).replace("\\", "/")
+
+    # Read original file if not supplied
+    if original_content is None:
+        if full_path.exists() and full_path.is_file():
+            try:
+                original_content = full_path.read_text(encoding="utf-8")
+            except Exception:
+                original_content = ""
+        else:
+            original_content = ""
+
+    # Apply patch
+    patched_content, old_lines, new_lines = apply_patch(
+        original_content, patch_content, is_replacement=is_replacement
+    )
+
+    # Check syntax of patched content
+    syntax_error = validate_syntax(patched_content, file_path=clean_path)
+    if syntax_error:
+        return PatchResult(
+            file_path=clean_path,
+            original_content=original_content,
+            patched_content=patched_content,
+            modified_old_lines=old_lines,
+            modified_new_lines=new_lines,
+            syntax_error=syntax_error,
+        )
+
+    orig_symbols = extract_symbols_from_ast(original_content, file_path=clean_path)
+    patched_symbols = extract_symbols_from_ast(patched_content, file_path=clean_path)
+    patched_imports = extract_imports_from_ast(patched_content, file_path=clean_path)
+
+    orig_map = {s.qualname: s for s in orig_symbols}
+    patched_map = {s.qualname: s for s in patched_symbols}
+
+    # Identify deleted and added symbols
+    deleted_symbols = [s for q, s in orig_map.items() if q not in patched_map]
+    added_symbols = [s for q, s in patched_map.items() if q not in orig_map]
+
+    # Identify affected symbols (modified or newly added)
+    affected: List[Symbol] = []
+    seen_qualnames = set()
+
+    for sym in patched_symbols:
+        if sym.kind == "module":
+            continue
+        # Check if any new line overlaps with symbol span
+        sym_lines = set(range(sym.lineno, sym.end_lineno + 1))
+        if sym_lines.intersection(new_lines):
+            affected.append(sym)
+            seen_qualnames.add(sym.qualname)
+
+    # Also check if old symbols were modified/removed and not yet caught
+    for sym in orig_symbols:
+        if sym.kind == "module":
+            continue
+        sym_lines = set(range(sym.lineno, sym.end_lineno + 1))
+        if sym_lines.intersection(old_lines):
+            if sym.qualname in patched_map and sym.qualname not in seen_qualnames:
+                affected.append(patched_map[sym.qualname])
+                seen_qualnames.add(sym.qualname)
+
+    # Check if lines outside any function/class symbol were modified
+    non_module_patched = [s for s in patched_symbols if s.kind != "module"]
+    non_module_orig = [s for s in orig_symbols if s.kind != "module"]
+    has_module_level_change = (
+        any(not any(s.lineno <= l <= s.end_lineno for s in non_module_patched) for l in new_lines)
+        or any(not any(s.lineno <= l <= s.end_lineno for s in non_module_orig) for l in old_lines)
+    )
+
+    if has_module_level_change or (not affected and (old_lines or new_lines)):
+        module_sym = next((s for s in patched_symbols if s.qualname == "<module>"), None)
+        if not module_sym:
+            line_count = len(patched_content.splitlines()) or 1
+            module_calls: List[CallReference] = []
+            if clean_path.endswith(".py") or not clean_path:
+                try:
+                    tree = ast.parse(patched_content)
+                    module_calls = [
+                        c for c in _extract_calls_from_node(tree, caller_id=f"{clean_path}::<module>")
+                        if not any(s.lineno <= c.lineno <= s.end_lineno for s in non_module_patched)
+                    ]
+                except Exception:
+                    pass
+
+            module_sym = Symbol(
+                name="<module>",
+                qualname="<module>",
+                file_path=clean_path,
+                kind="module",
+                lineno=1,
+                end_lineno=line_count,
+                signature=f"# module {clean_path}",
+                calls=module_calls,
+            )
+            patched_symbols.append(module_sym)
+
+        if module_sym not in affected:
+            affected.append(module_sym)
+
+    return PatchResult(
+        file_path=clean_path,
+        original_content=original_content,
+        patched_content=patched_content,
+        modified_old_lines=old_lines,
+        modified_new_lines=new_lines,
+        affected_symbols=affected,
+        deleted_symbols=deleted_symbols,
+        added_symbols=added_symbols,
+        all_patched_symbols=patched_symbols,
+        imports=patched_imports,
+    )

code_oracle/models.py

@@ -0,0 +1,237 @@
+"""
+Core data structures for the TopoSlice neuro-symbolic verification engine.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Set, Any
+
+
+@dataclass
+class CallReference:
+    """Represents a function or method call site."""
+    callee: str
+    args_count: int
+    kwargs: List[str] = field(default_factory=list)
+    lineno: int = 0
+    caller: Optional[str] = None
+    has_vararg: bool = False
+    has_kwarg: bool = False
+
+
+@dataclass
+class ImportReference:
+    """Represents an imported module or symbol reference."""
+    module: Optional[str]
+    name: str
+    asname: Optional[str] = None
+    lineno: int = 0
+    file_path: str = ""
+    level: int = 0
+
+
+@dataclass
+class Parameter:
+    """Represents a function parameter in an AST."""
+    name: str
+    annotation: Optional[str] = None
+    default: Optional[str] = None
+    has_default: bool = False
+    is_vararg: bool = False
+    is_kwarg: bool = False
+    is_kwonly: bool = False
+    is_posonly: bool = False
+
+
+@dataclass
+class Symbol:
+    """Represents a code symbol (function, method, class, module)."""
+    name: str
+    qualname: str
+    file_path: str
+    kind: str  # 'function', 'async_function', 'class', 'method', 'module'
+    lineno: int
+    end_lineno: int
+    signature: str = ""
+    params: List[Parameter] = field(default_factory=list)
+    min_args: int = 0
+    max_args: Optional[int] = None  # None indicates *args allowed
+    accepted_kwargs: Optional[Set[str]] = None  # None indicates **kwargs allowed
+    required_kwargs: Set[str] = field(default_factory=set)
+    return_type: Optional[str] = None
+    calls: List[CallReference] = field(default_factory=list)
+    is_method: bool = False
+    is_static: bool = False
+    bases: List[str] = field(default_factory=list)
+    docstring: Optional[str] = None
+    is_exported: bool = False
+    visibility: str = "internal"
+
+    @property
+    def id(self) -> str:
+        return f"{self.file_path}::{self.qualname}"
+
+
+@dataclass
+class DiffHunk:
+    """Represents a unified diff hunk."""
+    old_start: int
+    old_count: int
+    new_start: int
+    new_count: int
+    lines: List[str] = field(default_factory=list)
+
+
+@dataclass
+class PatchResult:
+    """Represents the output of the Diff Boundary Locator."""
+    file_path: str
+    original_content: str
+    patched_content: str
+    modified_old_lines: Set[int] = field(default_factory=set)
+    modified_new_lines: Set[int] = field(default_factory=set)
+    affected_symbols: List[Symbol] = field(default_factory=list)
+    deleted_symbols: List[Symbol] = field(default_factory=list)
+    added_symbols: List[Symbol] = field(default_factory=list)
+    all_patched_symbols: List[Symbol] = field(default_factory=list)
+    imports: List[ImportReference] = field(default_factory=list)
+    syntax_error: Optional[str] = None
+
+
+@dataclass
+class SliceNode:
+    """Node in the k-hop sliced subgraph."""
+    id: str
+    name: str
+    file_path: str
+    kind: str
+    signature: str
+    is_seed: bool = False
+    is_modified: bool = False
+    truncated: bool = False
+    symbol: Optional[Symbol] = None
+
+
+@dataclass
+class SliceEdge:
+    """Directed edge in the k-hop sliced subgraph."""
+    source: str
+    target: str
+    relation: str  # 'CALLS', 'IMPORTS', 'INHERITS'
+
+
+@dataclass
+class SlicedGraph:
+    """Compact directed subgraph representing the affected neighborhood."""
+    nodes: Dict[str, SliceNode] = field(default_factory=dict)
+    edges: List[SliceEdge] = field(default_factory=list)
+    seed_ids: Set[str] = field(default_factory=set)
+    truncated: bool = False
+
+
+@dataclass
+class GateResult:
+    """Outcome of the Deterministic Symbolic Gate."""
+    status: str  # 'APPROVED', 'REJECTED'
+    confidence: float
+    cycles: List[List[str]] = field(default_factory=list)
+    violations: List[str] = field(default_factory=list)
+    details: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class VerificationReport:
+    """Complete verification response for agent consumption."""
+    status: str
+    confidence: float
+    cycles_detected: List[List[str]]
+    invariant_violations: List[str]
+    linearized_subgraph: str
+    affected_symbols: List[str]
+    latency_ms: float
+    risk_score: float = 0.05
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "status": self.status,
+            "confidence": round(self.confidence, 4),
+            "risk_score": round(self.risk_score, 4),
+            "cycles_detected": self.cycles_detected,
+            "invariant_violations": self.invariant_violations,
+            "linearized_subgraph": self.linearized_subgraph,
+            "affected_symbols": self.affected_symbols,
+            "latency_ms": round(self.latency_ms, 2),
+        }
+
+
+@dataclass
+class RiskTaxonomyScores:
+    """Multi-label risk taxonomy probabilities."""
+    breaking_public_api: float = 0.0
+    security_surface: float = 0.0
+    concurrency_hazard: float = 0.0
+    performance_regression: float = 0.0
+    silent_logic_drift: float = 0.0
+
+    def active_categories(self, threshold: float = 0.5) -> List[str]:
+        """Return list of active risk categories exceeding threshold."""
+        categories = []
+        if self.breaking_public_api >= threshold:
+            categories.append("BreakingPublicAPI")
+        if self.security_surface >= threshold:
+            categories.append("SecuritySurface")
+        if self.concurrency_hazard >= threshold:
+            categories.append("ConcurrencyHazard")
+        if self.performance_regression >= threshold:
+            categories.append("PerformanceRegression")
+        if self.silent_logic_drift >= threshold:
+            categories.append("SilentLogicDrift")
+        return categories
+
+    def to_dict(self) -> Dict[str, float]:
+        return {
+            "breaking_public_api": round(self.breaking_public_api, 4),
+            "security_surface": round(self.security_surface, 4),
+            "concurrency_hazard": round(self.concurrency_hazard, 4),
+            "performance_regression": round(self.performance_regression, 4),
+            "silent_logic_drift": round(self.silent_logic_drift, 4),
+        }
+
+
+@dataclass
+class EnhancedVerificationReport:
+    """
+    Backward-compatible verification report featuring Multi-Task Risk Taxonomy
+    and Epistemic Uncertainty Estimation.
+    """
+    status: str  # "APPROVED" | "REJECTED"
+    confidence: float  # Calibrated epistemic confidence [0.0 - 1.0]
+    risk_score: float  # Continuous calibrated risk [0.0 - 1.0]
+    epistemic_uncertainty: float  # Predicted variance sigma^2
+    risk_taxonomy: RiskTaxonomyScores
+    active_risk_categories: List[str]
+    cycles_detected: List[List[str]]
+    invariant_violations: List[str]
+    linearized_subgraph: str
+    affected_symbols: List[str]
+    latency_ms: float
+    is_neural_calibrated: bool = False
+    engine_mode: str = "heuristic"
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert report to JSON-serializable dictionary with backward compatibility."""
+        return {
+            "status": self.status,
+            "confidence": round(self.confidence, 4),
+            "risk_score": round(self.risk_score, 4),
+            "epistemic_uncertainty": round(self.epistemic_uncertainty, 4),
+            "risk_taxonomy": self.risk_taxonomy.to_dict(),
+            "active_risk_categories": self.active_risk_categories,
+            "cycles_detected": self.cycles_detected,
+            "invariant_violations": self.invariant_violations,
+            "linearized_subgraph": self.linearized_subgraph,
+            "affected_symbols": self.affected_symbols,
+            "latency_ms": round(self.latency_ms, 2),
+            "is_neural_calibrated": self.is_neural_calibrated,
+            "engine_mode": self.engine_mode,
+        }
+