torusguard 1.3.5 → 1.4.0

package/.torusguard/scripts/sarif_exporter.py

@@ -9,6 +9,7 @@ import sys
 import json
 import hashlib
 import argparse
+from pathlib import Path
 from typing import List, Dict, Any
 
 def generate_sarif(findings: List[Dict[str, Any]], run_id: str = "default", category: str = "torusguard/static") -> Dict[str, Any]:
@@ -76,7 +77,7 @@ def generate_sarif(findings: List[Dict[str, Any]], run_id: str = "default", cate
                 "tool": {
                     "driver": {
                         "name": "TorusGuard",
-                        "semanticVersion": "1.3.5",
+                        "semanticVersion": "1.3.6",
                         "informationUri": "https://github.com/githubmofo/TorusGuard",
                         "rules": list(rules_map.values())
                     }
@@ -95,22 +96,61 @@ def main():
     parser = argparse.ArgumentParser(description="TorusGuard SARIF v2.1.0 Exporter")
     parser.add_argument("--input", "-i", help="Path to findings JSON file")
     parser.add_argument("--output", "-o", help="Output path for sarif.json")
-    parser.add_argument("--run-id", default="run-default", help="Unique execution Run ID")
+    parser.add_argument("--root", "-r", help="Project root override")
+    parser.add_argument("--run-id", default=None, help="Unique execution Run ID")
+    parser.add_argument("--stdout", action="store_true", help="Print SARIF JSON to stdout")
     args = parser.parse_args()
 
+    root = Path(args.root).resolve() if args.root else Path.cwd().resolve()
     findings = []
+    run_id = args.run_id or "run-default"
+
     if args.input:
-        with open(args.input, "r", encoding="utf-8") as f:
-            findings = json.load(f)
+        in_path = Path(args.input)
+        if not in_path.is_absolute():
+            in_path = (root / in_path).resolve()
+        if in_path.is_file():
+            with open(in_path, "r", encoding="utf-8") as f:
+                findings = json.load(f)
+    else:
+        # Auto-discover latest audit run findings
+        runs_dir = root / ".torusguard" / "runs"
+        if runs_dir.is_dir():
+            run_folders = sorted(
+                [d for d in runs_dir.iterdir() if d.is_dir() and (d / "findings.json").is_file()],
+                key=lambda p: p.stat().st_mtime,
+                reverse=True
+            )
+            if run_folders:
+                latest_run = run_folders[0]
+                run_id = args.run_id or latest_run.name
+                findings_file = latest_run / "findings.json"
+                try:
+                    with open(findings_file, "r", encoding="utf-8") as f:
+                        findings = json.load(f)
+                except Exception:
+                    findings = []
 
-    sarif = generate_sarif(findings, run_id=args.run_id)
+    sarif = generate_sarif(findings, run_id=run_id)
 
     if args.output:
-        with open(args.output, "w", encoding="utf-8") as f:
+        out_path = Path(args.output)
+        if not out_path.is_absolute():
+            out_path = (root / out_path).resolve()
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(out_path, "w", encoding="utf-8") as f:
             json.dump(sarif, f, indent=2)
-        print(f"SARIF log written to: {args.output}")
-    else:
+        print(f"[SUCCESS] SARIF log written to: {out_path}")
+    elif args.stdout:
         print(json.dumps(sarif, indent=2))
+    else:
+        # Default to writing in .torusguard/runs/results-latest.sarif
+        default_sarif = root / ".torusguard" / "runs" / "results-latest.sarif"
+        default_sarif.parent.mkdir(parents=True, exist_ok=True)
+        with open(default_sarif, "w", encoding="utf-8") as f:
+            json.dump(sarif, f, indent=2)
+        print(f"[SUCCESS] SARIF log written to: {default_sarif}")
+
 
 if __name__ == "__main__":
     main()

package/.torusguard/scripts/stack_detect.py

@@ -221,6 +221,24 @@ def detect_stack(project_root: Path) -> dict[str, Any]:
                         "indicator": "Flask application instantiation"
                     })
                     profile["recommended_references"].append("flask-security.md")
+                elif "tornado" in content or "tornado.web" in content:
+                    add_to_list(profile, "languages_found", "Python")
+                    profile["ecosystem_family"] = "python"
+                    add_to_list(profile, "frameworks_found", "Tornado")
+                    profile["confidence"] = "Confirmed"
+                    profile["detection_evidence"].append({
+                        "file": str(py_file.relative_to(project_root)),
+                        "indicator": "Tornado application"
+                    })
+                elif "starlette" in content:
+                    add_to_list(profile, "languages_found", "Python")
+                    profile["ecosystem_family"] = "python"
+                    add_to_list(profile, "frameworks_found", "Starlette")
+                    profile["confidence"] = "Confirmed"
+                    profile["detection_evidence"].append({
+                        "file": str(py_file.relative_to(project_root)),
+                        "indicator": "Starlette application"
+                    })
 
                 if "sqlalchemy" in content:
                     add_to_list(profile, "data_layers_found", "SQLAlchemy")
@@ -286,11 +304,27 @@ def detect_stack(project_root: Path) -> dict[str, Any]:
                 profile["confidence"] = "Confirmed"
                 profile["detection_evidence"].append({"file": "package.json", "indicator": "express dependency"})
                 profile["recommended_references"].append("express-security.md")
+            elif "fastify" in deps:
+                add_to_list(profile, "frameworks_found", "Fastify")
+                profile["confidence"] = "Confirmed"
+                profile["detection_evidence"].append({"file": "package.json", "indicator": "fastify dependency"})
+            elif "koa" in deps:
+                add_to_list(profile, "frameworks_found", "Koa")
+                profile["confidence"] = "Confirmed"
+                profile["detection_evidence"].append({"file": "package.json", "indicator": "koa dependency"})
+            elif "@remix-run/react" in deps or "@remix-run/node" in deps:
+                add_to_list(profile, "frameworks_found", "Remix")
+                profile["confidence"] = "Confirmed"
+                profile["detection_evidence"].append({"file": "package.json", "indicator": "Remix dependency"})
             elif "react" in deps:
                 add_to_list(profile, "frameworks_found", "React / Vite")
                 profile["confidence"] = "Confirmed"
                 profile["detection_evidence"].append({"file": "package.json", "indicator": "react dependency"})
                 profile["recommended_references"].append("react-vite-security.md")
+            elif "vite" in deps:
+                add_to_list(profile, "frameworks_found", "Vite")
+                profile["confidence"] = "Confirmed"
+                profile["detection_evidence"].append({"file": "package.json", "indicator": "vite dependency"})
 
             # ORM / Data layer detection
             if "@prisma/client" in deps or "prisma" in deps:
@@ -433,6 +467,8 @@ def detect_stack(project_root: Path) -> dict[str, Any]:
 
         if "Microsoft.NET.Sdk.Web" in csproj_content or "Microsoft.AspNetCore" in csproj_content or "Swashbuckle" in csproj_content:
             add_to_list(profile, "frameworks_found", "ASP.NET Core")
+        if list(project_root.glob("**/*.razor")) or "Microsoft.AspNetCore.Components" in csproj_content or "blazor" in csproj_content.lower():
+            add_to_list(profile, "frameworks_found", "Blazor")
         if "Microsoft.EntityFrameworkCore" in csproj_content:
             add_to_list(profile, "data_layers_found", "Entity Framework Core")
         elif "Dapper" in csproj_content:
@@ -442,11 +478,17 @@ def detect_stack(project_root: Path) -> dict[str, Any]:
     # G. PHP Ecosystem
     # -------------------------------------------------------------------------
     composer_json = project_root / "composer.json"
-    if composer_json.is_file():
+    is_wordpress = (project_root / "wp-config.php").is_file() or (project_root / "wp-load.php").is_file() or (project_root / "wp-content").is_dir()
+    if composer_json.is_file() or is_wordpress:
         add_to_list(profile, "languages_found", "PHP")
         profile["ecosystem_family"] = "php"
         profile["confidence"] = "Confirmed"
-        profile["detection_evidence"].append({"file": "composer.json", "indicator": "PHP Composer manifest"})
+        if is_wordpress:
+            add_to_list(profile, "frameworks_found", "WordPress")
+            add_to_list(profile, "data_layers_found", "MySQL / wpdb")
+            profile["detection_evidence"].append({"file": "wp-config.php" if (project_root / "wp-config.php").is_file() else "wp-content", "indicator": "WordPress installation"})
+        if composer_json.is_file():
+            profile["detection_evidence"].append({"file": "composer.json", "indicator": "PHP Composer manifest"})
         profile["recommended_rules"].extend(["TG-SEC-*", "TG-INPUT-001", "TG-INPUT-002", "TG-PLATFORM-*"])
         profile["recommended_references"].append("polyglot-security-matrix.md")
 

package/.torusguard/scripts/status_runner.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+"""
+TorusGuard Diagnostic Status Engine (v1.4.0)
+Displays workspace security posture, detected stack, active rules, historical runs,
+golden recipes, and runtime scope validity in mathematically aligned 75-column cards.
+Adheres to Python Pro & Python Patterns standards.
+"""
+
+from __future__ import annotations
+
+import sys
+import json
+import argparse
+from pathlib import Path
+from dataclasses import dataclass, asdict
+from typing import Any
+
+# Import term_ui for 75-column card formatting
+try:
+    from term_ui import (
+        BOLD, DIM, RESET, CYAN, GREEN, YELLOW, WHITE, GRAY, RED,
+        card_header, card_border_top, card_border_bottom, card_divider, format_box_line
+    )
+except ImportError:
+    scripts_dir = Path(__file__).resolve().parent
+    if str(scripts_dir) not in sys.path:
+        sys.path.insert(0, str(scripts_dir))
+    from term_ui import (
+        BOLD, DIM, RESET, CYAN, GREEN, YELLOW, WHITE, GRAY, RED,
+        card_header, card_border_top, card_border_bottom, card_divider, format_box_line
+    )
+
+
+@dataclass
+class WorkspaceStatus:
+    version: str
+    target_path: str
+    is_initialized: bool
+    stack_detected: str
+    active_rules_count: int
+    total_runs_count: int
+    latest_run_id: str | None
+    latest_run_time: str | None
+    latest_findings: int
+    golden_recipes_count: int
+    scope_status: str
+    health_score: int
+    posture_status: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+def collect_status(target_dir: Path) -> WorkspaceStatus:
+    """Inspect workspace configuration and filesystem records to construct status snapshot."""
+    target_dir = target_dir.resolve()
+    tg_dir = target_dir / ".torusguard"
+    is_init = tg_dir.is_dir()
+
+    # 1. Read config
+    version = "1.4.0"
+    stack_name = "Undetected"
+    cfg_file = tg_dir / "config" / "torusguard.json"
+    if cfg_file.is_file():
+        try:
+            with open(cfg_file, "r", encoding="utf-8") as f:
+                cfg = json.load(f)
+            version = cfg.get("version", version)
+            stack_name = cfg.get("stack", stack_name)
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    if stack_name in ("Undetected", "Unknown", "None", ""):
+        try:
+            from stack_detect import detect_stack
+            p = detect_stack(target_dir)
+            parts = []
+            if p.get("language") and p["language"] != "Unknown":
+                parts.append(p["language"])
+            if p.get("framework") and p["framework"] != "None":
+                parts.append(p["framework"])
+            if parts:
+                stack_name = " / ".join(parts)
+        except Exception:
+            pass
+
+    # 2. Count active rules
+    active_rules_count = 0
+    active_rules_dir = tg_dir / "rules" / "active"
+    if active_rules_dir.is_dir():
+        active_rules_count = sum(1 for f in active_rules_dir.glob("*.md"))
+    if active_rules_count == 0:
+        rules_root = tg_dir / "rules"
+        if rules_root.is_dir():
+            active_rules_count = sum(1 for f in rules_root.rglob("TG-*.md"))
+    if active_rules_count == 0:
+        active_rules_count = 74  # Canonical rule catalog default
+
+    # 3. Read run history
+    total_runs = 0
+    latest_run_id: str | None = None
+    latest_run_time: str | None = None
+    latest_findings = 0
+    runs_dir = tg_dir / "runs"
+    if runs_dir.is_dir():
+        run_folders = [d for d in runs_dir.iterdir() if d.is_dir() and d.name.startswith("run-")]
+        run_folders.sort(key=lambda d: d.name, reverse=True)
+        total_runs = len(run_folders)
+        if run_folders:
+            latest = run_folders[0]
+            latest_run_id = latest.name
+            manifest_file = latest / "manifest.json"
+            if manifest_file.is_file():
+                try:
+                    with open(manifest_file, "r", encoding="utf-8") as f:
+                        m = json.load(f)
+                    latest_run_time = m.get("created_at", latest.name)
+                    latest_findings = m.get("findings_count", 0)
+                except (json.JSONDecodeError, OSError):
+                    pass
+
+    # 4. Golden recipes in persistent memory
+    golden_recipes_count = 0
+    patterns_file = tg_dir / "memory" / "patterns.json"
+    if patterns_file.is_file():
+        try:
+            with open(patterns_file, "r", encoding="utf-8") as f:
+                p_data = json.load(f)
+            if isinstance(p_data, list):
+                golden_recipes_count = sum(
+                    1 for p in p_data
+                    if isinstance(p, dict) and (
+                        p.get("pattern_type") == "golden_fix_recipe" or "recipe_data" in p or "recipe_id" in p
+                    )
+                )
+            elif isinstance(p_data, dict):
+                golden_recipes_count = len(p_data.get("golden_recipes", []))
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    # 5. Scope authorization
+    scope_status = "Unconfigured"
+    scope_file = tg_dir / "config" / "scope.json"
+    if scope_file.is_file():
+        try:
+            with open(scope_file, "r", encoding="utf-8") as f:
+                s_data = json.load(f)
+            expires_at = s_data.get("expires_at")
+            if expires_at:
+                scope_status = "Authorized (TTL Active)"
+            else:
+                scope_status = "Authorized (Static)"
+        except (json.JSONDecodeError, OSError):
+            scope_status = "Error reading scope"
+
+    # 6. Posture health from security_report.md
+    health_score = 100
+    posture = "CLEAN & SECURE"
+    report_file = target_dir / "security_report.md"
+    if report_file.is_file():
+        try:
+            content = report_file.read_text(encoding="utf-8")
+            import re
+            m = re.search(r"Posture Score:\s*`(\d+)/100`", content)
+            if m:
+                health_score = int(m.group(1))
+            m_stat = re.search(r"Posture Status:\s*`([^`]+)`", content)
+            if m_stat:
+                posture = m_stat.group(1)
+        except OSError:
+            pass
+
+    if health_score < 70:
+        posture = "ACTION NEEDED"
+    elif health_score < 90:
+        posture = "ELEVATED RISK"
+    elif health_score == 100:
+        posture = "CLEAN & SECURE"
+
+    return WorkspaceStatus(
+        version=version,
+        target_path=str(target_dir),
+        is_initialized=is_init,
+        stack_detected=stack_name,
+        active_rules_count=active_rules_count,
+        total_runs_count=total_runs,
+        latest_run_id=latest_run_id,
+        latest_run_time=latest_run_time,
+        latest_findings=latest_findings,
+        golden_recipes_count=golden_recipes_count,
+        scope_status=scope_status,
+        health_score=health_score,
+        posture_status=posture,
+    )
+
+
+def print_status_card(status: WorkspaceStatus) -> None:
+    """Render standardized 75-column diagnostic status cards."""
+    print()
+    print(card_header(
+        "🛡️  T O R U S G U A R D   S T A T U S",
+        "Workspace Diagnostic Overview & Posture Snapshot",
+        f"v{status.version}"
+    ))
+    print()
+
+    # Card 1: Workspace & Stack
+    print(card_border_top("Workspace Environment", CYAN))
+    init_str = f"{GREEN}Initialized (.torusguard/ active){RESET}" if status.is_initialized else f"{RED}Uninitialized (Run: npx torusguard init){RESET}"
+    print(format_box_line(f"Workspace:    {WHITE}{status.target_path}{RESET}", 67))
+    print(format_box_line(f"Status:       {init_str}", 67))
+    print(format_box_line(f"Stack:        {BOLD}{WHITE}{status.stack_detected}{RESET}", 67))
+    print(format_box_line(f"Active Rules: {GREEN}{status.active_rules_count}{RESET} canonical rules enabled across 18 families", 67))
+    print(card_border_bottom(CYAN))
+    print()
+
+    # Card 2: Run History & Memory
+    print(card_border_top("Run History & Memory Engine", YELLOW))
+    print(format_box_line(f"Total Runs:     {WHITE}{status.total_runs_count}{RESET} historical audit runs", 67, border_color=YELLOW))
+    if status.latest_run_id:
+        print(format_box_line(f"Latest Run:     {CYAN}{status.latest_run_id}{RESET}", 67, border_color=YELLOW))
+        print(format_box_line(f"Run Timestamp:  {DIM}{status.latest_run_time or 'N/A'}{RESET}", 67, border_color=YELLOW))
+        print(format_box_line(f"Run Findings:   {WHITE}{status.latest_findings}{RESET} vulnerabilities discovered", 67, border_color=YELLOW))
+    else:
+        print(format_box_line(f"Latest Run:     {DIM}No runs recorded yet (Run: npx torusguard audit){RESET}", 67, border_color=YELLOW))
+    print(format_box_line(f"Golden Recipes: {GREEN}{status.golden_recipes_count}{RESET} verified fix patterns distilled in memory", 67, border_color=YELLOW))
+    print(format_box_line(f"Runtime Scope:  {WHITE}{status.scope_status}{RESET}", 67, border_color=YELLOW))
+    print(card_border_bottom(YELLOW))
+    print()
+
+    # Card 3: Security Posture
+    posture_color = GREEN if status.health_score >= 90 else (YELLOW if status.health_score >= 70 else RED)
+    print(card_border_top("Security Health Posture", posture_color, double=True))
+    print(format_box_line(f"Health Score:   {posture_color}{BOLD}{status.health_score}/100{RESET}", 67, border="║", border_color=posture_color))
+    print(format_box_line(f"Posture State:  {posture_color}{BOLD}{status.posture_status}{RESET}", 67, border="║", border_color=posture_color))
+    print(format_box_line(f"Living Ledger:  {CYAN}security_report.md (Synchronized){RESET}", 67, border="║", border_color=posture_color))
+    print(card_border_bottom(posture_color, double=True))
+    print()
+
+    # Quick Next Actions
+    print(card_border_top("Available Lifecycle Actions", GRAY))
+    print(format_box_line(f"Audit Codebase:   {GREEN}npx torusguard audit{RESET}", 67, border_color=GRAY))
+    print(format_box_line(f"Harden Patches:   {GREEN}npx torusguard harden{RESET}", 67, border_color=GRAY))
+    print(format_box_line(f"View Recipes:     {GREEN}npx torusguard recipes{RESET}", 67, border_color=GRAY))
+    print(format_box_line(f"HTML Dashboard:   {GREEN}npx torusguard report --html{RESET}", 67, border_color=GRAY))
+    print(card_border_bottom(GRAY))
+    print()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="TorusGuard Workspace Diagnostic Status Engine")
+    parser.add_argument("path", nargs="?", default=".", help="Target project root directory")
+    parser.add_argument("--target", "-t", help="Target project root directory (alias for path)")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON snapshot")
+    args = parser.parse_args()
+
+    target = Path(args.target or args.path).resolve()
+    status = collect_status(target)
+
+    if args.json:
+        print(json.dumps(status.to_dict(), indent=2))
+    else:
+        print_status_card(status)
+
+
+if __name__ == "__main__":
+    main()

package/.torusguard/scripts/term_ui.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-TorusGuard Unified Terminal UI Engine (v1.3.5)
+TorusGuard Unified Terminal UI Engine (v1.3.6)
 Provides mathematically exact 75-column card formatting, ANSI-stripping,
 Unicode/emoji visual width calculation, and visual truncation with ellipsis.
 Pure Python 3.10+ standard library (zero external dependencies).

package/.torusguard/skills/torusguard/SKILL.md

@@ -1,72 +1,75 @@
----
-name: torusguard
-description: Universal autonomous security engine: 71 canonical rules across 11 families, polyglot stack detection across 16+ languages, Ponytail remediation bounds (<=35 add, <=25 del), standardized 75-column terminal UI, SARIF v2.1.0 exports, and persistent security memory context.
-version: 1.3.4
----
-
-# TorusGuard Master Security Engine & Command Router
-
-**Core Invariant:** If the browser or client receives it, users can inspect it. Never expose database credentials, master keys, or private API secrets in client bundles. Always isolate multi-tenant database queries.
-
----
-
-## Command Catalog: Terminal CLI & AI Chat Parity
-
-TorusGuard operates with 100% feature parity across both the terminal CLI and AI chat slash commands:
-
-| Capability | Terminal CLI Command | AI Chat Slash Command | Specialist Skill | Purpose |
-| :--- | :--- | :--- | :--- | :--- |
-| **Init** | `npx torusguard init` | `/torusguard init` | `skills/torusguard-init` | Stack discovery, rule activation, workspace scaffolding |
-| **Status** | `npx torusguard status` | `/torusguard status` | `skills/torusguard-status` | Posture score, active rules, run history, scope check |
-| **Audit** | `npx torusguard audit` | `/torusguard audit` | `skills/torusguard-audit` | Static AST scan, invariant fingerprinting, confidence scoring |
-| **Verify** | `npx torusguard verify` | `/torusguard verify` | `skills/torusguard-verify` | Evidence sufficiency audit & line match calibration |
-| **Harden** | `npx torusguard harden` | `/torusguard harden` | `skills/torusguard-harden` | Ponytail patch formulation ($\le 35$ add, $\le 25$ del) |
-| **Apply** | `npx torusguard apply [--yes]` | `/torusguard apply` | `skills/torusguard-apply` | Human Gate review, `.bak` snapshots, patch application |
-| **Rollback** | `npx torusguard rollback` | `/torusguard rollback` | `skills/torusguard-apply` | Instant 1-step rollback from pre-apply snapshots |
-| **Recheck** | `npx torusguard recheck` | `/torusguard recheck` | `skills/torusguard-recheck` | Targeted differential AST scan, fix closure verification |
-| **Recipes** | `npx torusguard recipes` | `/torusguard recipes` | `skills/torusguard-harden` | Explore verified Golden Fix Recipes from persistent memory |
-| **Report** | `npx torusguard report --html` | `/torusguard report` | `skills/torusguard-report` | Executive posture reporting, SARIF v2.1.0 & visual HTML |
-| **Authorize** | `npx torusguard authorize` | `/torusguard authorize` | `skills/torusguard-authorize`| Legal scope definition & safety boundaries |
-| **Validate** | `npx torusguard web-validate` | `/torusguard web-validate` | `skills/torusguard-web-validate`| Authorized non-destructive HTTP probing |
-| **Exploit** | `npx torusguard exploit-check` | `/torusguard exploit-check`| `skills/torusguard-exploit-check`| Bounded single-step exploitability confirmation |
-| **Full** | `npx torusguard full` | `/torusguard full` | `skills/torusguard-full` | End-to-end 7-stage closed-loop execution |
-| **Sync** | `npx torusguard rules sync` | `/torusguard rules sync` | `skills/torusguard-init` | Synchronize rules across AI editors (Cursor, Claude, Antigravity) |
-
----
-
-## Non-Negotiable Invariants
-
-1. **Browser-Code Truth:** If the client receives it, it is public. Zero hardcoded secrets (`SUPABASE_SERVICE_ROLE_KEY`, private tokens, live API keys) in frontend code.
-2. **Multi-Tenant Isolation:** All database lookups must be scoped by organization or user ownership (`tenant_id`, `organization_id`, `where: { tenantId }`).
-3. **Ponytail Churn Bounds:** Patches must be minimal and surgical ($\le 35$ additions, $\le 25$ deletions). Never perform full-file rewrites.
-4. **Standardized 75-Column Terminal:** All CLI terminal output is strictly normalized to 75 visual columns with Unicode emoji width calculation, ANSI escape handling, and visual truncation with ellipsis (`...`).
-5. **Zero Security Bypasses:** Never insert `# nosec`, `verify=False`, `InsecureSkipVerify: true`, `[AllowAnonymous]`, or `csrf().disable()`.
-6. **Snapshots Before Edits:** Every code modification must capture a byte-for-byte pre-apply backup in `.torusguard/snapshots/<run_id>/` before touching disk code.
-
----
-
-## Workspace Layout Structure
-```
-.torusguard/
-├── config/
-│   ├── torusguard.json          # Detected stack, settings, and rule counts
-│   └── scope.json               # Authorized runtime validation targets & TTL
-├── memory/
-│   ├── context.json             # Aggregated security memory context
-│   ├── patterns.json            # Distilled Golden Fix Recipes
-│   └── events.json              # Historical audit, apply, and recheck events
-├── rules/
-│   └── active/                  # Active TG-* rule definitions
-├── runs/
-│   └── run-YYYYMMDD-HHMMSS-audit/
-│       ├── findings.json        # Machine-readable AST findings
-│       ├── findings.md          # Actionable markdown finding cards
-│       ├── remediation.md       # Formulated candidate patch catalog
-│       ├── diff_summary.md      # Summary of applied diffs
-│       ├── recheck.md           # Differential recheck status transitions
-│       ├── report.html          # Single-file visual dark-mode HTML report
-│       ├── results.sarif        # OASIS SARIF v2.1.0 log
-│       └── bundles/             # Formulated Ponytail remediation bundles
-└── snapshots/
-    └── run-YYYYMMDD-HHMMSS-audit/ # Pre-apply .bak files for instant rollback
-```
+---
+name: torusguard
+description: Universal autonomous security engine: 74 canonical rules across 18 families, polyglot stack detection across 16+ languages, Ponytail remediation bounds (<=35 add, <=25 del), standardized 75-column terminal UI, SARIF v2.1.0 exports, and persistent security memory context.
+version: 1.3.6
+---
+
+# TorusGuard Master Security Engine & Command Router
+
+**Core Invariant:** If the browser or client receives it, users can inspect it. Never expose database credentials, master keys, or private API secrets in client bundles. Always isolate multi-tenant database queries.
+
+---
+
+## Command Catalog: Terminal CLI & AI Chat Parity
+
+TorusGuard operates with 100% feature parity across both the terminal CLI and AI chat slash commands:
+
+| Capability | Terminal CLI Command | AI Chat Slash Command | Specialist Skill | Purpose |
+| :--- | :--- | :--- | :--- | :--- |
+| **Init** | `npx torusguard init` | `/torusguard init` | `skills/torusguard-init` | Stack discovery, rule activation, workspace scaffolding |
+| **Status** | `npx torusguard status` | `/torusguard status` | `skills/torusguard-status` | Posture score, active rules, run history, scope check |
+| **Audit** | `npx torusguard audit` | `/torusguard audit` | `skills/torusguard-audit` | Static AST scan, invariant fingerprinting, confidence scoring |
+| **Verify** | `npx torusguard verify` | `/torusguard verify` | `skills/torusguard-verify` | Evidence sufficiency audit & line match calibration |
+| **Harden** | `npx torusguard harden` | `/torusguard harden` | `skills/torusguard-harden` | Ponytail patch formulation ($\le 35$ add, $\le 25$ del) |
+| **Apply** | `npx torusguard apply [--yes]` | `/torusguard apply` | `skills/torusguard-apply` | Human Gate review, `.bak` snapshots, patch application |
+| **Rollback** | `npx torusguard rollback` | `/torusguard rollback` | `skills/torusguard-apply` | Instant 1-step rollback from pre-apply snapshots |
+| **Recheck** | `npx torusguard recheck` | `/torusguard recheck` | `skills/torusguard-recheck` | Targeted differential AST scan, fix closure verification |
+| **Recipes** | `npx torusguard recipes` | `/torusguard recipes` | `skills/torusguard-harden` | Explore verified Golden Fix Recipes from persistent memory |
+| **Report** | `npx torusguard report --html` | `/torusguard report` | `skills/torusguard-report` | Executive posture reporting, SARIF v2.1.0 & visual HTML |
+| **Authorize** | `npx torusguard authorize` | `/torusguard authorize` | `skills/torusguard-authorize`| Legal scope definition & safety boundaries |
+| **Validate** | `npx torusguard web-validate` | `/torusguard web-validate` | `skills/torusguard-web-validate`| Authorized non-destructive HTTP probing |
+| **Exploit** | `npx torusguard exploit-check` | `/torusguard exploit-check`| `skills/torusguard-exploit-check`| Bounded single-step exploitability confirmation |
+| **Full** | `npx torusguard full` | `/torusguard full` | `skills/torusguard-full` | End-to-end 7-stage closed-loop execution |
+| **Sync** | `npx torusguard rules sync` | `/torusguard rules sync` | `skills/torusguard-init` | Synchronize rules across AI editors (Cursor, Claude, Antigravity) |
+
+---
+
+## Non-Negotiable Invariants
+
+1. **Browser-Code Truth:** If the client receives it, it is public. Zero hardcoded secrets (`SUPABASE_SERVICE_ROLE_KEY`, private tokens, live API keys) in frontend code.
+2. **Multi-Tenant Isolation:** All database lookups must be scoped by organization or user ownership (`tenant_id`, `organization_id`, `where: { tenantId }`).
+3. **Ponytail Churn Bounds:** Patches must be minimal and surgical ($\le 35$ additions, $\le 25$ deletions). Never perform full-file rewrites.
+4. **Standardized 75-Column Terminal:** All CLI terminal output is strictly normalized to 75 visual columns with Unicode emoji width calculation, ANSI escape handling, and visual truncation with ellipsis (`...`).
+5. **Zero Security Bypasses:** Never insert `# nosec`, `verify=False`, `InsecureSkipVerify: true`, `[AllowAnonymous]`, or `csrf().disable()`.
+6. **Snapshots Before Edits:** Every code modification must capture a byte-for-byte pre-apply backup in `.torusguard/snapshots/<run_id>/` before touching disk code.
+
+---
+
+## Workspace Layout Structure
+```
+.torusguard/
+├── config/
+│   ├── torusguard.json          # Detected stack, settings, and rule counts
+│   └── scope.json               # Authorized runtime validation targets & TTL
+├── memory/
+│   ├── context.json             # Aggregated security memory context
+│   ├── patterns.json            # Distilled Golden Fix Recipes
+│   └── events.json              # Historical audit, apply, and recheck events
+├── rules/
+│   └── active/                  # Active TG-* rule definitions
+├── runs/
+│   └── run-YYYYMMDD-HHMMSS-audit/
+│       ├── findings.json        # Machine-readable AST findings
+│       ├── findings.md          # Actionable markdown finding cards
+│       ├── remediation.md       # Formulated candidate patch catalog
+│       ├── diff_summary.md      # Summary of applied diffs
+│       ├── recheck.md           # Differential recheck status transitions
+│       ├── report.html          # Single-file visual dark-mode HTML report
+│       ├── results.sarif        # OASIS SARIF v2.1.0 log
+│       └── bundles/             # Formulated Ponytail remediation bundles
+└── snapshots/
+    └── run-YYYYMMDD-HHMMSS-audit/ # Pre-apply .bak files for instant rollback
+```
+
+## Living Report Ground Truth
+- Read `security_report.md` in the workspace root before taking any action. Update the relevant finding card after completing remediation.