nti-scanner 0.1.0__py3-none-any.whl

nti_scanner/__init__.py

@@ -0,0 +1,2 @@
+"""nti-scanner: Professional NTI-1 compliance and AI agent security scanner."""
+__version__ = "0.1.0"

nti_scanner/analysis/__init__.py

@@ -0,0 +1 @@
+"""Advanced NTI-specific analysis."""

nti_scanner/analysis/behavior_graph.py

@@ -0,0 +1,31 @@
+"""Build an agent behavior graph from AST."""
+import ast
+import json
+from pathlib import Path
+from typing import Dict, List
+
+
+def build_behavior_graph(trees: Dict) -> dict:
+    nodes = []
+    edges = []
+    for f, tree in trees.items():
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                name = _name(node.func)
+                if name in {"Agent", "AgentExecutor", "Crew"}:
+                    nodes.append({"id": f"{f}:{node.lineno}", "type": "agent", "name": name, "file": str(f)})
+                elif name in {"execute_transfer", "delete_account", "read_account", "transfer"}:
+                    nodes.append({"id": f"{f}:{node.lineno}", "type": "action", "name": name, "file": str(f)})
+                elif name in {"os.system", "subprocess.run", "eval", "exec", "open"}:
+                    nodes.append({"id": f"{f}:{node.lineno}", "type": "sink", "name": name, "file": str(f)})
+    return {"nodes": nodes, "edges": edges}
+
+
+def _name(node):
+    if isinstance(node, ast.Name): return node.id
+    if isinstance(node, ast.Attribute): return node.attr
+    return ""
+
+
+def render_graph_json(graph: dict) -> str:
+    return json.dumps(graph, indent=2)

nti_scanner/ast_analysis/__init__.py

@@ -0,0 +1 @@
+"""AST-based analysis utilities."""

nti_scanner/ast_analysis/callgraph.py

@@ -0,0 +1,15 @@
+"""Build a call graph from Python AST."""
+import ast
+from typing import Dict, Set
+
+
+def build_call_graph(tree: ast.AST) -> Dict[str, Set[str]]:
+    graph: Dict[str, Set[str]] = {}
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            calls = set()
+            for sub in ast.walk(node):
+                if isinstance(sub, ast.Call) and isinstance(sub.func, ast.Name):
+                    calls.add(sub.func.id)
+            graph[node.name] = calls
+    return graph

nti_scanner/ast_analysis/parser.py

@@ -0,0 +1,20 @@
+"""Safe AST parser."""
+import ast
+from pathlib import Path
+from typing import Optional
+
+
+def parse_python_file(path: Path) -> Optional[ast.AST]:
+    try:
+        source = path.read_text(encoding="utf-8", errors="ignore")
+        return ast.parse(source, filename=str(path))
+    except (SyntaxError, ValueError):
+        return None
+
+
+def get_source_segment(path: Path, node: ast.AST) -> str:
+    try:
+        source = path.read_text(encoding="utf-8", errors="ignore")
+        return ast.get_source_segment(source, node) or ""
+    except Exception:
+        return ""

nti_scanner/ast_analysis/taint.py

@@ -0,0 +1,42 @@
+"""Lightweight taint tracking."""
+import ast
+from typing import Set
+
+
+USER_INPUT_SOURCES = {"input", "request.form", "request.json", "request.args", "sys.stdin.read", "sys.argv"}
+UNSAFE_SINKS = {"eval", "exec", "os.system", "subprocess.run", "subprocess.Popen", "subprocess.call", "pickle.loads", "yaml.load", "os.popen"}
+
+
+def find_tainted_calls(tree: ast.AST) -> list:
+    findings = []
+    tainted_names: Set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Assign):
+            if _is_user_input(node.value):
+                for target in node.targets:
+                    if isinstance(target, ast.Name):
+                        tainted_names.add(target.id)
+        if isinstance(node, ast.Call):
+            func_name = _get_call_name(node)
+            if func_name in UNSAFE_SINKS:
+                for arg in node.args:
+                    if isinstance(arg, ast.Name) and arg.id in tainted_names:
+                        findings.append({"line": node.lineno, "col": node.col_offset, "sink": func_name, "source": arg.id})
+    return findings
+
+
+def _is_user_input(node: ast.AST) -> bool:
+    if isinstance(node, ast.Call):
+        return _get_call_name(node) in USER_INPUT_SOURCES
+    return False
+
+
+def _get_call_name(node: ast.Call) -> str:
+    parts = []
+    cur = node.func
+    while isinstance(cur, ast.Attribute):
+        parts.append(cur.attr)
+        cur = cur.value
+    if isinstance(cur, ast.Name):
+        parts.append(cur.id)
+    return ".".join(reversed(parts))

nti_scanner/cli.py

@@ -0,0 +1,85 @@
+"""Command-line interface."""
+import sys
+from pathlib import Path
+import click
+from rich.console import Console
+from nti_scanner.scanner import scan_directory
+from nti_scanner.report.terminal import render_terminal
+from nti_scanner.report.json_report import render_json
+from nti_scanner.report.sarif import render_sarif
+from nti_scanner.report.html import render_html
+console = Console()
+
+
+@click.group()
+@click.version_option()
+def main():
+    """nti-scanner: NTI-1 compliance and AI agent security scanner."""
+    pass
+
+
+@main.command()
+@click.argument("path", type=click.Path(exists=True, file_okay=False))
+@click.option("--format", "fmt", type=click.Choice(["terminal", "json", "sarif", "html"]), default="terminal")
+@click.option("--output", "-o", type=click.Path(), default=None)
+@click.option("--min-score", default=0)
+@click.option("--severity", type=click.Choice(["critical", "high", "medium", "low", "info"]), default="info")
+@click.option("--exclude", multiple=True)
+def scan(path, fmt, output, min_score, severity, exclude):
+    """Scan a directory for NTI-1 compliance and AI agent security issues."""
+    if fmt == "terminal":
+        console.print(f"[bold cyan]nti-scanner v{__import__('nti_scanner').__version__}[/bold cyan]")
+        console.print(f"Scanning [bold]{path}[/bold]...\n")
+    result = scan_directory(Path(path).resolve(), min_severity=severity, excludes=list(exclude))
+    if fmt == "terminal":
+        render_terminal(result, console)
+    elif fmt == "json":
+        content = render_json(result)
+        if output: Path(output).write_text(content)
+        else: console.print_json(content)
+    elif fmt == "sarif":
+        content = render_sarif(result)
+        if output: Path(output).write_text(content)
+        else: print(content)
+    elif fmt == "html":
+        content = render_html(result)
+        if output: Path(output).write_text(content)
+        else: print(content)
+    if min_score and result.nti1_score < min_score:
+        sys.exit(1)
+
+
+@main.command()
+def rules():
+    """List all available rules."""
+    from rich.table import Table
+    from nti_scanner.rules.registry import RULES
+    table = Table(title="Available Rules")
+    table.add_column("ID", style="cyan")
+    table.add_column("Category")
+    table.add_column("Severity")
+    table.add_column("Description")
+    for r in RULES:
+        table.add_row(r.meta.id, r.meta.category, r.meta.severity, r.meta.description[:60])
+    console.print(table)
+
+
+@main.command()
+@click.argument("path", type=click.Path(exists=True, file_okay=False))
+@click.option("--output", "-o", type=click.Path(), required=True)
+def graph(path, output):
+    """Build and export the agent behavior graph."""
+    from pathlib import Path
+    from nti_scanner.ast_analysis.parser import parse_python_file
+    from nti_scanner.analysis.behavior_graph import build_behavior_graph, render_graph_json
+    trees = {}
+    for f in Path(path).rglob("*.py"):
+        t = parse_python_file(f)
+        if t: trees[f] = t
+    graph_data = build_behavior_graph(trees)
+    Path(output).write_text(render_graph_json(graph_data))
+    console.print(f"[green]Graph written to {output}[/green]")
+
+
+if __name__ == "__main__":
+    main()

nti_scanner/cwe/__init__.py

@@ -0,0 +1 @@
+"""CWE metadata."""

nti_scanner/cwe/mapping.py

@@ -0,0 +1,10 @@
+"""CWE metadata lookup."""
+CWE_NAMES = {"CWE-22": "Path Traversal", "CWE-78": "OS Command Injection", "CWE-89": "SQL Injection",
+             "CWE-269": "Privilege Management", "CWE-287": "Authentication", "CWE-353": "Missing Integrity",
+             "CWE-502": "Unsafe Deserialization", "CWE-778": "Insufficient Logging", "CWE-798": "Hardcoded Credentials",
+             "CWE-862": "Missing Authorization", "CWE-918": "SSRF", "CWE-1336": "Template Injection",
+             "CWE-1426": "AI Output Validation"}
+
+
+def cwe_url(cwe: str) -> str:
+    return f"https://cwe.mitre.org/data/definitions/{cwe.replace('CWE-', '')}.html"

nti_scanner/framework/__init__.py

@@ -0,0 +1 @@
+"""Framework detection."""

nti_scanner/framework/detector.py

@@ -0,0 +1,39 @@
+"""Detect which AI frameworks a codebase uses."""
+import ast
+from typing import Dict, List
+
+
+FRAMEWORK_SIGNATURES = {
+    "langchain": {"langchain", "langchain_core", "langchain_openai", "ChatOpenAI", "AgentExecutor"},
+    "crewai": {"crewai", "Crew", "Agent", "Task"},
+    "autogen": {"autogen", "ConversableAgent", "AssistantAgent"},
+    "openai": {"openai", "OpenAI", "ChatCompletion"},
+    "anthropic": {"anthropic", "Anthropic"},
+}
+
+
+def detect_frameworks(trees: Dict) -> List[str]:
+    detected = set()
+    for tree in trees.values():
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for n in node.names: _match(n.name, detected)
+            elif isinstance(node, ast.ImportFrom):
+                if node.module: _match(node.module, detected)
+            elif isinstance(node, ast.Call):
+                name = _name(node.func)
+                if name: _match(name, detected)
+    return sorted(detected)
+
+
+def _match(name: str, detected: set):
+    for fw, sigs in FRAMEWORK_SIGNATURES.items():
+        for sig in sigs:
+            if sig.lower() in name.lower():
+                detected.add(fw); return
+
+
+def _name(node):
+    if isinstance(node, ast.Name): return node.id
+    if isinstance(node, ast.Attribute): return node.attr
+    return ""

nti_scanner/report/__init__.py

@@ -0,0 +1 @@
+"""Report renderers."""

nti_scanner/report/html.py

@@ -0,0 +1,10 @@
+"""HTML report."""
+from html import escape
+
+
+def render_html(result) -> str:
+    findings_html = ""
+    for f in result.findings:
+        findings_html += f'<div class="finding {f.severity}"><div><strong>{f.severity.upper()}</strong> - {f.rule_id}</div><div>{escape(f.message)}</div><div>{escape(f.file)}:{f.line}</div></div>'
+    pillars_html = "".join(f'<div><span>{p}</span><span>{s}/100</span></div>' for p, s in result.pillar_scores.items())
+    return f'<!DOCTYPE html><html><head><meta charset="utf-8"><title>nti-scanner</title></head><body><h1>NTI-1 Report</h1><div>{result.nti1_score}/100</div><p>{result.files_scanned} files - {len(result.findings)} findings</p><h2>Pillars</h2>{pillars_html}<h2>Findings</h2>{findings_html}</body></html>'

nti_scanner/report/json_report.py

@@ -0,0 +1,6 @@
+"""JSON report."""
+import json
+
+
+def render_json(result) -> str:
+    return json.dumps(result.to_dict(), indent=2)

nti_scanner/report/sarif.py

@@ -0,0 +1,29 @@
+"""SARIF 2.1.0 reporter for GitHub Security integration."""
+import json
+from nti_scanner.rules.registry import RULES
+
+
+SEVERITY_TO_LEVEL = {"critical": "error", "high": "error", "medium": "warning", "low": "note", "info": "note"}
+
+
+def render_sarif(result) -> str:
+    rules_meta = []
+    for r in RULES:
+        rules_meta.append({"id": r.meta.id, "name": r.meta.id,
+                           "shortDescription": {"text": r.meta.description},
+                           "helpUri": f"https://cwe.mitre.org/data/definitions/{r.meta.cwe.replace('CWE-','')}.html" if r.meta.cwe else "",
+                           "properties": {"category": r.meta.category, "confidence": r.meta.confidence}})
+    sarif_results = []
+    for f in result.findings:
+        sarif_results.append({"ruleId": f.rule_id, "level": SEVERITY_TO_LEVEL.get(f.severity, "warning"),
+                              "message": {"text": f.message},
+                              "locations": [{"physicalLocation": {"artifactLocation": {"uri": f.file},
+                                                                    "region": {"startLine": max(1, f.line), "startColumn": max(1, f.column)}}}],
+                              "properties": {"cwe": f.cwe, "confidence": f.confidence}})
+    sarif = {"$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+             "version": "2.1.0",
+             "runs": [{"tool": {"driver": {"name": "nti-scanner",
+                                            "informationUri": "https://github.com/abisheakp197/nti-scanner",
+                                            "version": "0.1.0", "rules": rules_meta}},
+                       "results": sarif_results}]}
+    return json.dumps(sarif, indent=2)

nti_scanner/report/terminal.py

@@ -0,0 +1,41 @@
+"""Rich terminal renderer."""
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+
+SEVERITY_COLORS = {"critical": "bold red", "high": "red", "medium": "yellow", "low": "dim", "info": "blue"}
+
+
+def render_terminal(result, console: Console):
+    score = result.nti1_score
+    if score >= 90: color, grade = "green", "A"
+    elif score >= 75: color, grade = "cyan", "B"
+    elif score >= 50: color, grade = "yellow", "C"
+    elif score >= 25: color, grade = "orange3", "D"
+    else: color, grade = "red", "F"
+    console.print(Panel.fit(f"[bold {color}]NTI-1 Score: {score}/100 (Grade {grade})[/bold {color}]\n"
+                            f"Files scanned: {result.files_scanned}  |  Lines: {result.lines_scanned}  |  Findings: {len(result.findings)}\n"
+                            f"Frameworks detected: {', '.join(result.frameworks) or 'none'}", title="nti-scanner"))
+    if result.pillar_scores:
+        table = Table(title="Pillar Breakdown")
+        table.add_column("Pillar", style="cyan")
+        table.add_column("Score", justify="right")
+        for p, s in result.pillar_scores.items():
+            color = "green" if s >= 80 else "yellow" if s >= 50 else "red"
+            table.add_row(p, f"[{color}]{s}/100[/]")
+        console.print(table)
+    if result.findings:
+        t = Table(title=f"Findings ({len(result.findings)})")
+        t.add_column("Severity")
+        t.add_column("Rule")
+        t.add_column("CWE")
+        t.add_column("Message")
+        t.add_column("File:Line")
+        for f in result.findings[:30]:
+            t.add_row(f"[{SEVERITY_COLORS.get(f.severity, 'white')}]{f.severity.upper()}[/]",
+                      f.rule_id, f.cwe or "-", f.message[:70], f"{f.file.split('/')[-1]}:{f.line}")
+        console.print(t)
+    console.print()
+    console.print("[bold]Fix your score:[/bold] pip install ube-foundation")
+    console.print("[dim]Spec: https://abisheakp197.github.io/nti-spec/[/dim]")

nti_scanner/rules/__init__.py

@@ -0,0 +1 @@
+"""Rule package."""

nti_scanner/rules/base.py

@@ -0,0 +1,42 @@
+"""Base class for rules."""
+import ast
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+
+@dataclass
+class Finding:
+    rule_id: str
+    category: str
+    severity: str
+    confidence: str
+    message: str
+    file: str
+    line: int
+    column: int
+    cwe: Optional[str] = None
+    remediation: str = ""
+    code_snippet: str = ""
+
+
+@dataclass
+class RuleMeta:
+    id: str
+    category: str
+    severity: str
+    confidence: str
+    description: str
+    cwe: str = ""
+    remediation: str = ""
+
+
+class BaseRule:
+    meta: RuleMeta
+    def check(self, path: Path, tree: ast.AST, frameworks: List[str]) -> List[Finding]:
+        raise NotImplementedError
+    def make_finding(self, path: Path, node: ast.AST, message: str, snippet: str = "") -> Finding:
+        return Finding(rule_id=self.meta.id, category=self.meta.category, severity=self.meta.severity,
+                       confidence=self.meta.confidence, message=message, file=str(path),
+                       line=getattr(node, "lineno", 0), column=getattr(node, "col_offset", 0),
+                       cwe=self.meta.cwe, remediation=self.meta.remediation, code_snippet=snippet)

nti_scanner/rules/nti/__init__.py

@@ -0,0 +1 @@
+"""NTI-1 compliance rules."""

nti_scanner/rules/nti/audit.py

@@ -0,0 +1,31 @@
+"""NTI-1 Pillar 4: Audit."""
+import ast
+from pathlib import Path
+from typing import List
+from nti_scanner.rules.base import BaseRule, RuleMeta
+from nti_scanner.scanner import Finding
+
+
+class AuditRule(BaseRule):
+    meta = RuleMeta(id="NTI-AUDIT-001", category="Audit", severity="high", confidence="high",
+                    description="No Merkle-chained audit trail detected", cwe="CWE-778",
+                    remediation="Install ube-foundation for Merkle-chained audit.")
+    AUDIT_KEYWORDS = {"audit", "merkle", "audit_event", "verify_history", "log_event", "ube_foundation"}
+    def check(self, path: Path, tree: ast.AST, frameworks: List[str]) -> List[Finding]:
+        has_agent = False
+        first_node = None
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call) and "Agent" in _name(node.func):
+                has_agent = True
+                first_node = node
+                break
+        if not has_agent: return []
+        content = path.read_text(errors="ignore").lower()
+        if any(kw in content for kw in self.AUDIT_KEYWORDS): return []
+        return [self.make_finding(path, first_node, "Agent without audit trail. NTI-1 requires Merkle-chained logs.")]
+
+
+def _name(node):
+    if isinstance(node, ast.Name): return node.id
+    if isinstance(node, ast.Attribute): return node.attr
+    return ""

nti_scanner/rules/nti/capability_diff.py

@@ -0,0 +1,38 @@
+"""NTI-unique: Detect unauthorized tool capabilities."""
+import ast
+from pathlib import Path
+from typing import List
+from nti_scanner.rules.base import BaseRule, RuleMeta
+from nti_scanner.scanner import Finding
+
+
+class CapabilityDiffRule(BaseRule):
+    meta = RuleMeta(id="NTI-CAPDIFF-001", category="Governance", severity="critical", confidence="high",
+                    description="Tool declared but never granted as a capability", cwe="CWE-862",
+                    remediation="Every tool must have grant_capability().")
+    def check(self, path: Path, tree: ast.AST, frameworks: List[str]) -> List[Finding]:
+        declared_tools = set()
+        granted_caps = set()
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                for dec in node.decorator_list:
+                    name = _name(dec.func if isinstance(dec, ast.Call) else dec)
+                    if name in {"tool", "function_tool"}: declared_tools.add(node.name)
+            if isinstance(node, ast.Call):
+                if _name(node.func) == "grant_capability" and node.args:
+                    if isinstance(node.args[0], ast.Constant) and isinstance(node.args[0].value, str):
+                        granted_caps.add(node.args[0].value)
+        if not declared_tools: return []
+        unguarded = declared_tools - granted_caps
+        if not unguarded: return []
+        content = path.read_text(errors="ignore")
+        if "grant_capability" not in content:
+            node = next((n for n in ast.walk(tree) if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))), tree)
+            return [self.make_finding(path, node, f"Tools declared but no grant_capability(). All {len(declared_tools)} tools unauthorized.")]
+        return []
+
+
+def _name(node):
+    if isinstance(node, ast.Name): return node.id
+    if isinstance(node, ast.Attribute): return node.attr
+    return ""

nti_scanner/rules/nti/consensus.py

@@ -0,0 +1,29 @@
+"""NTI-1 Pillar 3: BFT Consensus."""
+import ast
+from pathlib import Path
+from typing import List
+from nti_scanner.rules.base import BaseRule, RuleMeta
+from nti_scanner.scanner import Finding
+
+
+class ConsensusRule(BaseRule):
+    meta = RuleMeta(id="NTI-CONS-001", category="Consensus", severity="medium", confidence="low",
+                    description="Multi-agent system without BFT consensus", cwe="CWE-703",
+                    remediation="Use NTI BFT consensus for multi-agent systems.")
+    def check(self, path: Path, tree: ast.AST, frameworks: List[str]) -> List[Finding]:
+        agent_count = 0
+        first_node = None
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call) and _name(node.func) == "Agent":
+                agent_count += 1
+                if first_node is None: first_node = node
+        if agent_count < 2: return []
+        content = path.read_text(errors="ignore").lower()
+        if any(kw in content for kw in {"consensus", "voter", "bft", "threshold"}): return []
+        return [self.make_finding(path, first_node, f"Multi-agent system ({agent_count} agents) without BFT consensus.")]
+
+
+def _name(node):
+    if isinstance(node, ast.Name): return node.id
+    if isinstance(node, ast.Attribute): return node.attr
+    return ""

nti_scanner/rules/nti/governance.py

@@ -0,0 +1,32 @@
+"""NTI-1 Pillar 2: Governance."""
+import ast
+from pathlib import Path
+from typing import List
+from nti_scanner.rules.base import BaseRule, RuleMeta
+from nti_scanner.scanner import Finding
+
+
+class GovernanceRule(BaseRule):
+    meta = RuleMeta(id="NTI-GOV-001", category="Governance", severity="critical", confidence="high",
+                    description="Tool functions without zero-trust capability bounds", cwe="CWE-862",
+                    remediation="Grant explicit capabilities per tool.")
+    TOOL_DECORATORS = {"tool", "function_tool"}
+    GOVERNANCE_KEYWORDS = {"grant_capability", "check_capability", "trustengine", "trust_engine", "nti", "policy"}
+    def check(self, path: Path, tree: ast.AST, frameworks: List[str]) -> List[Finding]:
+        tool_functions = []
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                for dec in node.decorator_list:
+                    if isinstance(dec, ast.Call) and _name(dec.func) in self.TOOL_DECORATORS: tool_functions.append(node)
+                    elif isinstance(dec, ast.Name) and dec.id in self.TOOL_DECORATORS: tool_functions.append(node)
+        if not tool_functions: return []
+        content = path.read_text(errors="ignore").lower()
+        if not any(kw in content for kw in self.GOVERNANCE_KEYWORDS):
+            return [self.make_finding(path, tool_functions[0], f"Found {len(tool_functions)} tool function(s) without governance.")]
+        return []
+
+
+def _name(node):
+    if isinstance(node, ast.Name): return node.id
+    if isinstance(node, ast.Attribute): return node.attr
+    return ""

nti_scanner/rules/nti/identity.py

@@ -0,0 +1,33 @@
+"""NTI-1 Pillar 1: Identity."""
+import ast
+from pathlib import Path
+from typing import List
+from nti_scanner.rules.base import BaseRule, RuleMeta
+from nti_scanner.scanner import Finding
+
+
+class IdentityRule(BaseRule):
+    meta = RuleMeta(id="NTI-IDENT-001", category="Identity", severity="high", confidence="medium",
+                    description="Agent code lacks cryptographic identity (PQC signatures)", cwe="CWE-287",
+                    remediation="Install ube-foundation and wrap your agent with NTICallbackHandler.")
+    IDENTITY_KEYWORDS = {"dilithium", "kyber", "pqc", "sign", "verify", "signature", "ube_foundation", "nti"}
+    def check(self, path: Path, tree: ast.AST, frameworks: List[str]) -> List[Finding]:
+        findings = []
+        agent_nodes = []
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                fname = _name(node.func)
+                if fname in {"Agent", "ChatOpenAI", "LLMChain"} or "agent" in fname.lower():
+                    agent_nodes.append(node)
+        if not agent_nodes: return []
+        content = path.read_text(errors="ignore").lower()
+        if not any(kw in content for kw in self.IDENTITY_KEYWORDS):
+            for node in agent_nodes[:3]:
+                findings.append(self.make_finding(path, node, "Agent declared without cryptographic identity. NTI-1 requires Dilithium5 signatures."))
+        return findings
+
+
+def _name(node):
+    if isinstance(node, ast.Name): return node.id
+    if isinstance(node, ast.Attribute): return node.attr
+    return ""

nti_scanner/rules/nti/persistence.py

@@ -0,0 +1,25 @@
+"""NTI-1 Pillar 5: Persistence."""
+import ast
+from pathlib import Path
+from typing import List
+from nti_scanner.rules.base import BaseRule, RuleMeta
+from nti_scanner.scanner import Finding
+
+
+class PersistenceRule(BaseRule):
+    meta = RuleMeta(id="NTI-PERS-001", category="Persistence", severity="low", confidence="low",
+                    description="No state persistence with integrity verification", cwe="CWE-353",
+                    remediation="Persist agent state with cryptographic integrity.")
+    PERSISTENCE_KEYWORDS = {"persist", "save_state", "load_state", "verify_history", "integrity"}
+    def check(self, path: Path, tree: ast.AST, frameworks: List[str]) -> List[Finding]:
+        has_agent = any(isinstance(n, ast.Call) and "Agent" in _name(n.func) for n in ast.walk(tree))
+        if not has_agent: return []
+        content = path.read_text(errors="ignore").lower()
+        if any(kw in content for kw in self.PERSISTENCE_KEYWORDS): return []
+        return []
+
+
+def _name(node):
+    if isinstance(node, ast.Name): return node.id
+    if isinstance(node, ast.Attribute): return node.attr
+    return ""

nti_scanner/rules/nti/trust_boundary.py

@@ -0,0 +1,36 @@
+"""NTI-unique: Trace trust boundary crossings."""
+import ast
+from pathlib import Path
+from typing import List
+from nti_scanner.rules.base import BaseRule, RuleMeta
+from nti_scanner.scanner import Finding
+
+
+class TrustBoundaryRule(BaseRule):
+    meta = RuleMeta(id="NTI-TRUST-001", category="Security", severity="high", confidence="high",
+                    description="Trust boundary crossing without NTI verification", cwe="CWE-1426",
+                    remediation="Wrap the boundary crossing with an NTI callback.")
+    PRIVILEGED_SINKS = {"eval", "exec", "compile", "__import__", "open"}
+    def check(self, path: Path, tree: ast.AST, frameworks: List[str]) -> List[Finding]:
+        findings = []
+        llm_outputs = set()
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Assign):
+                if isinstance(node.value, ast.Call):
+                    fname = _name(node.value.func)
+                    if fname in {"invoke", "run", "predict", "generate", "chat", "completion"}:
+                        for t in node.targets:
+                            if isinstance(t, ast.Name): llm_outputs.add(t.id)
+            if isinstance(node, ast.Call):
+                fname = _name(node.func)
+                if fname in self.PRIVILEGED_SINKS:
+                    for arg in node.args:
+                        if isinstance(arg, ast.Name) and arg.id in llm_outputs:
+                            findings.append(self.make_finding(path, node, f"Trust boundary crossing: LLM output '{arg.id}' flows to {fname}()."))
+        return findings[:3]
+
+
+def _name(node):
+    if isinstance(node, ast.Name): return node.id
+    if isinstance(node, ast.Attribute): return node.attr
+    return ""