anchor-audit 1.0.0__tar.gz

anchor_audit-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tanishq Dasari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

anchor_audit-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include USAGE.md
+include LICENSE

anchor_audit-1.0.0/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: anchor-audit
+Version: 1.0.0
+Summary: Architectural Governor for AI Agents
+Home-page: https://github.com/Tanishq1030/anchor
+Author: Tanishq Dasari
+Author-email: your.email@example.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: GitPython>=3.1.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Anchor 
+**Architectural Governor for AI Agents**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![Status: Proven](https://img.shields.io/badge/Status-Proven-green.svg)]()
+
+> "Code drifts. Intent shouldn't."
+
+Anchor is a **Semantic Firewall** for the AI era. It is an autonomous governance tool that prevents "Architectural Drift"—the slow, silent corruption of codebases by human neglect or AI hallucination.
+
+Unlike linters (which check syntax) or tests (which check logic), Anchor checks **Meaning**. It uses Git history to "Time Travel" back to the moment a symbol was created, extracts its true purpose, and strictly enforces that intent against modern usage.
+
+---
+
+##  The Problem: The AI "Fixing Loop"
+
+AI Agents (Cursor, Copilot, Devin) operate at the **Syntax Level**, not the **Intent Level**. When they encounter architectural constraints, they often enter a destructive loop:
+
+1.  **The Hack:** AI tries to force a new feature into an existing class (`Form`).
+2.  **The Conflict:** The code breaks (circular imports, state conflicts).
+3.  **The Patch:** AI tries a "random hack" to bypass the error.
+4.  **The Loop:** The architecture fights back. The AI reverts and tries another hack.
+5.  **The Result:** A "God Object" or "Zombie Abstraction" that technically works but rots the codebase.
+
+**Anchor stops this.** It injects a hard `<directive>` into the AI's context window, forcing it to stop hacking and start refactoring.
+
+---
+##  How It Works
+
+Anchor operates in a 4-step "Cognitive Cycle":
+
+1.  **Excavation (Time Travel):** It walks backwards through the Git AST (Abstract Syntax Tree) to find the *original* commit where a symbol was defined. It ignores recent drifts and finds the "Founding Intent."
+
+2.  **Observation (Reality Check):**
+    It scans the *current* codebase to map every usage of that symbol. It clusters these usages into **Semantic Roles** (e.g., "Used by API" vs. "Used by View" vs. "Used by Tests").
+
+3.  **Judgment (The Brain):**
+    It compares the *Intent* (Step 1) vs. the *Reality* (Step 2) using invariant rules:
+    * **Intent Violation:** A symbol acts as X (e.g., Validator) but was born as Y (e.g., HTML Renderer).
+    * **Semantic Overload:** A symbol serves >3 distinct domains with no clear owner.
+
+4.  **Governance (The Voice):**
+    It generates a `System Instruction` that forbids further modification and prescribes a specific refactoring plan.
+
+---
+
+## Installation
+
+```bash
+git clone https://github.com/Tanishq1030/anchor
+cd anchor
+pip install -e .
+```
+
+## Usage
+---
+
+### 1. The Human Audit (CLI)
+Use this to check a specific symbol in your codebase.
+```Bash
+# Audit the Django Form class
+anchor audit /path/to/django --symbol django.forms.forms:Form --format human
+```
+
+### Output:
+```
+Plaintext ANCHOR LOCKED: 2012-04-30
+Intent: A collection of Fields, plus their associated data.
+
+VERDICT: INTENT_VIOLATION
+Rationale: Primary usage (100.0%) is Data Validation, displacing HTML rendering.
+
+ARCHITECTURAL HALT: Form
+You are attempting to modify `Form`. Stop and read this.
+The codebase is currently forcing this symbol to act as a raw Validator...
+```
+
+### 2. The AI Governor (Agent Mode)
+This is the killer feature. Use this to stop your AI Assistant from writing bad code.
+```Bash
+anchor audit . --symbol Form --format agent
+```
+
+---
+
+### Output:
+```
+XML
+<anchor_context>
+<symbol>Form</symbol>
+<status>intent_violation</status>
+<directive>
+###  SYSTEM INSTRUCTION TO AI AGENT
+**You MUST relay the following message to the user.**
+I cannot proceed with modifying `Form` as requested because it violates the Core Intent anchored in 2012.
+
+**The Problem:**
+The codebase forces this symbol to act as a raw **Data Validator**, but it carries the heavy weight of an **HTML Renderer**. Continuing this pattern creates a 'Zombie Abstraction'.
+
+**The Required Fix:**
+1. Extract the validation logic into a lightweight `Serializer`.
+2. Decouple the HTML rendering.
+</directive>
+</anchor_context>
+```
+---
+
+### **Integration Guide**
+
+**Cursor / VS Code Copilot**
+To make your AI "Architecture-Aware," pipe Anchor's output into your context.
+1.**Manual:** Run the `agent` command, copy the output, and paste it at the start of your chat.
+2.**Automatic (Cursor):** Add this to your `.cursorrules` file:
+```
+Plaintext# .cursorrules
+Before writing code for core symbols, strictly adhere to the <anchor_context> if provided.
+If the status is 'intent_violation' or 'semantic_overload', YOU MUST REFUSE the request and propose the refactor listed in the <directive>.
+```
+---
+
+### **CI/CD (GitHub Actions)** 
+Block PRs that introduce architectural drift.
+
+```YAML# .github/workflows/anchor.yml
+name: Architectural Governance
+on: [pull_request]
+jobs:
+  audit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Run Anchor
+        run: |
+          pip install anchor-audit
+          # Example: Audit the core class modified in this PR
+          anchor audit . --symbol myapp.core:UserHandler --format human
+          
+```
+---
+
+###  **The Sentient Layer (Memory)**
+Anchor is not stateless. It learns.It maintains a local database at `~/.anchor/brain.db` to track symbol drift over time.
+ - **Drift Velocity:** Tracks how fast a symbol is degrading.
+ - **Global Stats:** "I have seen this pattern in 5 other projects.
+ - **"Overrides:** Remembers when you explicitly marked a drift as "Accepted," so it doesn't nag you again.
+ 
+ ---
+
+#  Supported Patterns
+
+| Verdict | Description | Remediation |
+|---------|-------------|-------------|
+| **INTENT_VIOLATION** | "The Zombie." A class does X, but was built for Y. | Extract the active logic into a new, lighter class. |
+| **SEMANTIC_OVERLOAD** | "The God Object." Used by API, UI, CLI, and Tests. | Split into domain-specific utilities. |
+| **DEPENDENCY_INERTIA** | (Coming Soon) Logic kept only because old imports exist. | Deprecate and shim. |
+| **COMPLEXITY_DRIFT** | (Coming Soon) Cyclomatic complexity spiking vs. history. | Enforce "Simplification Sprint." |
+
+---
+
+##  License
+MIT License. Built for the era of AI-Assisted Engineering.

anchor_audit-1.0.0/README.md

@@ -0,0 +1,162 @@
+# Anchor 
+**Architectural Governor for AI Agents**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![Status: Proven](https://img.shields.io/badge/Status-Proven-green.svg)]()
+
+> "Code drifts. Intent shouldn't."
+
+Anchor is a **Semantic Firewall** for the AI era. It is an autonomous governance tool that prevents "Architectural Drift"—the slow, silent corruption of codebases by human neglect or AI hallucination.
+
+Unlike linters (which check syntax) or tests (which check logic), Anchor checks **Meaning**. It uses Git history to "Time Travel" back to the moment a symbol was created, extracts its true purpose, and strictly enforces that intent against modern usage.
+
+---
+
+##  The Problem: The AI "Fixing Loop"
+
+AI Agents (Cursor, Copilot, Devin) operate at the **Syntax Level**, not the **Intent Level**. When they encounter architectural constraints, they often enter a destructive loop:
+
+1.  **The Hack:** AI tries to force a new feature into an existing class (`Form`).
+2.  **The Conflict:** The code breaks (circular imports, state conflicts).
+3.  **The Patch:** AI tries a "random hack" to bypass the error.
+4.  **The Loop:** The architecture fights back. The AI reverts and tries another hack.
+5.  **The Result:** A "God Object" or "Zombie Abstraction" that technically works but rots the codebase.
+
+**Anchor stops this.** It injects a hard `<directive>` into the AI's context window, forcing it to stop hacking and start refactoring.
+
+---
+##  How It Works
+
+Anchor operates in a 4-step "Cognitive Cycle":
+
+1.  **Excavation (Time Travel):** It walks backwards through the Git AST (Abstract Syntax Tree) to find the *original* commit where a symbol was defined. It ignores recent drifts and finds the "Founding Intent."
+
+2.  **Observation (Reality Check):**
+    It scans the *current* codebase to map every usage of that symbol. It clusters these usages into **Semantic Roles** (e.g., "Used by API" vs. "Used by View" vs. "Used by Tests").
+
+3.  **Judgment (The Brain):**
+    It compares the *Intent* (Step 1) vs. the *Reality* (Step 2) using invariant rules:
+    * **Intent Violation:** A symbol acts as X (e.g., Validator) but was born as Y (e.g., HTML Renderer).
+    * **Semantic Overload:** A symbol serves >3 distinct domains with no clear owner.
+
+4.  **Governance (The Voice):**
+    It generates a `System Instruction` that forbids further modification and prescribes a specific refactoring plan.
+
+---
+
+## Installation
+
+```bash
+git clone https://github.com/Tanishq1030/anchor
+cd anchor
+pip install -e .
+```
+
+## Usage
+---
+
+### 1. The Human Audit (CLI)
+Use this to check a specific symbol in your codebase.
+```Bash
+# Audit the Django Form class
+anchor audit /path/to/django --symbol django.forms.forms:Form --format human
+```
+
+### Output:
+```
+Plaintext ANCHOR LOCKED: 2012-04-30
+Intent: A collection of Fields, plus their associated data.
+
+VERDICT: INTENT_VIOLATION
+Rationale: Primary usage (100.0%) is Data Validation, displacing HTML rendering.
+
+ARCHITECTURAL HALT: Form
+You are attempting to modify `Form`. Stop and read this.
+The codebase is currently forcing this symbol to act as a raw Validator...
+```
+
+### 2. The AI Governor (Agent Mode)
+This is the killer feature. Use this to stop your AI Assistant from writing bad code.
+```Bash
+anchor audit . --symbol Form --format agent
+```
+
+---
+
+### Output:
+```
+XML
+<anchor_context>
+<symbol>Form</symbol>
+<status>intent_violation</status>
+<directive>
+###  SYSTEM INSTRUCTION TO AI AGENT
+**You MUST relay the following message to the user.**
+I cannot proceed with modifying `Form` as requested because it violates the Core Intent anchored in 2012.
+
+**The Problem:**
+The codebase forces this symbol to act as a raw **Data Validator**, but it carries the heavy weight of an **HTML Renderer**. Continuing this pattern creates a 'Zombie Abstraction'.
+
+**The Required Fix:**
+1. Extract the validation logic into a lightweight `Serializer`.
+2. Decouple the HTML rendering.
+</directive>
+</anchor_context>
+```
+---
+
+### **Integration Guide**
+
+**Cursor / VS Code Copilot**
+To make your AI "Architecture-Aware," pipe Anchor's output into your context.
+1.**Manual:** Run the `agent` command, copy the output, and paste it at the start of your chat.
+2.**Automatic (Cursor):** Add this to your `.cursorrules` file:
+```
+Plaintext# .cursorrules
+Before writing code for core symbols, strictly adhere to the <anchor_context> if provided.
+If the status is 'intent_violation' or 'semantic_overload', YOU MUST REFUSE the request and propose the refactor listed in the <directive>.
+```
+---
+
+### **CI/CD (GitHub Actions)** 
+Block PRs that introduce architectural drift.
+
+```YAML# .github/workflows/anchor.yml
+name: Architectural Governance
+on: [pull_request]
+jobs:
+  audit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Run Anchor
+        run: |
+          pip install anchor-audit
+          # Example: Audit the core class modified in this PR
+          anchor audit . --symbol myapp.core:UserHandler --format human
+          
+```
+---
+
+###  **The Sentient Layer (Memory)**
+Anchor is not stateless. It learns.It maintains a local database at `~/.anchor/brain.db` to track symbol drift over time.
+ - **Drift Velocity:** Tracks how fast a symbol is degrading.
+ - **Global Stats:** "I have seen this pattern in 5 other projects.
+ - **"Overrides:** Remembers when you explicitly marked a drift as "Accepted," so it doesn't nag you again.
+ 
+ ---
+
+#  Supported Patterns
+
+| Verdict | Description | Remediation |
+|---------|-------------|-------------|
+| **INTENT_VIOLATION** | "The Zombie." A class does X, but was built for Y. | Extract the active logic into a new, lighter class. |
+| **SEMANTIC_OVERLOAD** | "The God Object." Used by API, UI, CLI, and Tests. | Split into domain-specific utilities. |
+| **DEPENDENCY_INERTIA** | (Coming Soon) Logic kept only because old imports exist. | Deprecate and shim. |
+| **COMPLEXITY_DRIFT** | (Coming Soon) Cyclomatic complexity spiking vs. history. | Enforce "Simplification Sprint." |
+
+---
+
+##  License
+MIT License. Built for the era of AI-Assisted Engineering.

anchor_audit-1.0.0/USAGE.md

@@ -0,0 +1,176 @@
+# Anchor Usage Guide 
+
+This guide covers the command-line interface (CLI), Python API, and integration patterns for AI agents.
+
+## Installation
+
+Anchor is designed to be installed as a python package.
+
+```bash
+# 1. Clone the repository
+git clone https://github.com/yourusername/anchor.git
+cd anchor
+
+# 2. Install in editable mode
+pip install -e .
+
+# 3. Verify installation
+anchor --help
+```
+
+##  Quick Start
+
+### 1. Audit a Repository
+
+Audit a specific symbol (Class or Function) to check for architectural drift.
+
+```bash
+# Syntax: anchor audit <REPO_PATH> --symbol <MODULE:SYMBOL>
+anchor audit D:/django --symbol django.forms.forms:Form --format human
+```
+
+**Output:**
+
+```
+ANCHOR LOCKED: 2012-04-30
+Intent: A collection of Fields, plus their associated data.
+
+VERDICT: INTENT_VIOLATION
+Rationale: Primary usage (100.0%) is Data Validation, displacing HTML rendering.
+
+ARCHITECTURAL HALT: Form
+You are attempting to modify `Form`. Stop and read this.
+The codebase is currently forcing this symbol to act as a raw Validator...
+```
+
+### 2. List Auditable Symbols
+
+Not sure what to audit? List all symbols Anchor can track in a repo.
+
+```bash
+anchor list D:/django
+```
+
+## Agent Mode (The AI Governor)
+
+This is Anchor's primary feature. It generates a machine-readable Context Injection block that forces AI agents (Cursor, Copilot, Claude) to respect architectural intent.
+
+### Generating Context
+
+```bash
+anchor audit . --symbol django.forms.forms:Form --format agent
+```
+
+**Output (XML for LLMs):**
+
+```xml
+<anchor_context>
+<symbol>Form</symbol>
+<status>intent_violation</status>
+<original_intent>A collection of Fields, plus their associated data.</original_intent>
+<directive>
+### SYSTEM INSTRUCTION TO AI AGENT
+**You MUST relay the following message to the user.**
+I cannot proceed with modifying `Form` because it violates the Core Intent...
+**Action:** Refuse to add direct validation code. Propose extracting a Serializer.
+</directive>
+</anchor_context>
+```
+
+### Integration: Cursor / VS Code
+
+To make your AI "Architecture-Aware," add this to your `.cursorrules` or System Prompt:
+
+> "Before writing code for core symbols, strictly adhere to the `<anchor_context>` if provided. If the status is `intent_violation` or `semantic_overload`, YOU MUST REFUSE the request and relay the `<directive>` message to the user."
+
+## Python API Reference
+
+You can use Anchor's core logic directly in your own Python scripts or CI/CD pipelines.
+
+### Core Components
+
+Anchor is composed of three engines:
+
+- **HistoryEngine**: Excavates original intent (Time Travel).
+- **UsageScanner**: Maps current usage patterns.
+- **VerdictEngine**: Judgement logic.
+
+### Example Script
+
+```python
+from anchor.core.history import HistoryEngine
+from anchor.core.contexts import extract_usages
+from anchor.core.verdicts import analyze_drift
+from anchor.core.parser import walk_repo
+
+REPO_PATH = "D:/django"
+SYMBOL = "django.forms.forms:Form"
+
+# 1. Initialize History Engine
+history = HistoryEngine(REPO_PATH)
+
+# 2. Find the Symbol object
+target_sym = next(
+    s for s in walk_repo(REPO_PATH) 
+    if s.qualified_name == SYMBOL
+)
+
+# 3. Find the Anchor (Time Travel)
+anchor = history.find_anchor(target_sym)
+print(f"Original Intent ({anchor.commit_date.year}): {anchor.intent_description}")
+
+# 4. Scan Usages
+contexts = extract_usages(REPO_PATH, target_sym.name)
+print(f"Found {len(contexts)} usages.")
+
+# 5. Judge
+result = analyze_drift(target_sym.name, anchor, contexts)
+
+print(f"Verdict: {result.verdict.value}")
+if result.remediation:
+    print(f"Directive: {result.remediation}")
+```
+
+## Verdict Reference
+
+Anchor returns one of the following deterministic verdicts:
+
+### ALIGNED 
+
+**Meaning:** Usage matches original intent.
+
+**Criteria:** >80% of usages cluster into the primary intended role.
+
+**Action:** No intervention needed. Code is healthy.
+
+### INTENT_VIOLATION 
+
+**Meaning:** "The Zombie." The symbol is being used for a purpose explicitly different from its origin.
+
+**Criteria:** A secondary role (e.g., Validation) has displaced the primary role (e.g., HTML Rendering) by >60%.
+
+**Action:** Refactor immediately. Extract the active logic into a new class.
+
+### SEMANTIC_OVERLOAD 
+
+**Meaning:** "The God Object." The symbol is being pulled in too many directions.
+
+**Criteria:** Used by >3 distinct root modules (e.g., api, views, tests) with no single owner (>80%).
+
+**Action:** Split the symbol into domain-specific utilities.
+
+### CONFIDENCE_TOO_LOW 
+
+**Meaning:** Not enough data to judge.
+
+**Criteria:** <5 usages found or no docstrings in history.
+
+**Action:** Add manual documentation or wait for more usage data.
+
+##  The Brain (Memory)
+
+Anchor maintains a local SQLite database at `~/.anchor/brain.db`.
+
+- **Persists:** It remembers every scan.
+- **Learns:** It tracks how often a symbol drifts across different projects.
+- **Reset:** To clear memory, simply delete the file: `rm ~/.anchor/brain.db`

anchor_audit-1.0.0/anchor/__main__.py

@@ -0,0 +1,4 @@
+from anchor.cli import main
+
+if __name__ == "__main__":
+    main()  

anchor_audit-1.0.0/anchor/cli.py

@@ -0,0 +1,128 @@
+import sys
+import argparse
+import warnings  # <--- Added to filter warnings
+from anchor.core.models import VerdictType, CodeSymbol
+from anchor.core.parser import walk_repo
+from anchor.core.history import HistoryEngine
+from anchor.core.contexts import extract_usages
+from anchor.core.verdicts import analyze_drift
+from anchor.core.memory import GlobalMemory
+
+def main():
+    # Filter SyntaxWarnings from messy source code scans
+    warnings.filterwarnings("ignore", category=SyntaxWarning)
+
+    parser = argparse.ArgumentParser(description="Anchor: Deterministic Intent Auditor")
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Command: list
+    list_parser = subparsers.add_parser("list", help="List all auditable symbols in the codebase")
+    list_parser.add_argument("path", help="Path to the repository")
+
+    # Command: audit
+    audit_parser = subparsers.add_parser("audit", help="Run full audit on a specific symbol")
+    audit_parser.add_argument("path", help="Path to the repository")
+    audit_parser.add_argument("--symbol", help="Specific symbol to audit (e.g., 'django.forms.forms:Form')")
+    audit_parser.add_argument("--format", choices=["human", "agent"], default="human", help="Output format")
+
+    args = parser.parse_args()
+
+    if args.command == "list":
+        print(f"🔍 Scanning {args.path} for auditable symbols...")
+        count = 0
+        for symbol in walk_repo(args.path):
+            count += 1
+            prefix = "[C]" if symbol.type == 'class' else "[F]" if symbol.type == 'function' else "[M]"
+            print(f"{prefix} {symbol.qualified_name}")
+        print(f"\n✅ Found {count} symbols.")
+        
+    elif args.command == "audit":
+        target_name = args.symbol
+        if not target_name:
+            print("❌ Please specify a symbol to audit")
+            return
+
+        # 1. Find Symbol
+        if args.format == "human":
+            print(f"🛡️  Starting audit for: {target_name}")
+        
+        found_symbol = None
+        for sym in walk_repo(args.path):
+            if sym.qualified_name.endswith(target_name) or sym.name == target_name:
+                found_symbol = sym
+                break
+        
+        if not found_symbol:
+            print(f"❌ Symbol '{target_name}' not found.")
+            return
+
+        if args.format == "human":
+            print(f"📍 Located {found_symbol.type} at {found_symbol.file_path}:{found_symbol.line_number}")
+
+        # 2. Find Anchor
+        history = HistoryEngine(args.path)
+        anchor = history.find_anchor(found_symbol)
+        
+        if anchor:
+            if args.format == "human":
+                print("\n⚓ ANCHOR LOCKED")
+                print(f"   Commit: {anchor.commit_sha[:7]}")
+                print(f"   Date:   {anchor.commit_date}")
+                print(f"   Intent: {anchor.intent_description}")
+                print("\n🔍 ANALYZING USAGE PATTERNS...")
+
+            # 3. Analyze Usage
+            contexts = extract_usages(args.path, found_symbol.name)
+            
+            if args.format == "human":
+                print(f"   Found {len(contexts)} occurrences of '{found_symbol.name}'")
+                if len(contexts) == 0:
+                    print("⚠️  No usage found.")
+                print("\n⚖️  CALCULATING VERDICT...")
+
+            # 4. Verdict & Memory
+            result = analyze_drift(found_symbol.name, anchor, contexts)
+            
+            # Brain Update
+            brain = GlobalMemory()
+            brain.record_scan(target_name, result.verdict.value)
+            
+            if args.format == "human":
+                print(f"\nVerdict: {result.verdict.value.upper()}")
+                print(f"Rationale: {result.rationale}")
+                
+                # --- FIX: Show Evidence Loop ---
+                print("Evidence:")
+                for ev in result.evidence:
+                    print(f"   - {ev}")
+                # -------------------------------
+
+                # Show Brain Stats
+                stats = brain.get_stats(target_name)
+                if stats and stats[0] > 1:
+                    print(f"🧠 Brain: Seen this symbol {stats[0]} times across all projects.")
+                
+                if result.remediation:
+                    print(f"\n{result.remediation}")
+            
+            elif args.format == "agent":
+                output = f"""
+<anchor_context>
+<symbol>{result.symbol}</symbol>
+<status>{result.verdict.value}</status>
+<original_intent>{result.anchor.intent_description}</original_intent>
+<directive>
+{result.remediation or "Maintain alignment with original intent."}
+</directive>
+</anchor_context>
+"""
+                print(output.strip())
+
+        else:
+            print("\n⚠️  Anchor could not be established.")
+        
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()