torusguard 0.9.2

package/.torusguard/scripts/stack_detect.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""
+TorusGuard Stack Detector Utility
+Inspects project directory to detect programming language, frameworks, ORM/data layer,
+and dependency manifests. Outputs canonical stack block and structured JSON.
+"""
+
+import sys
+import json
+import argparse
+from pathlib import Path
+from typing import Dict, Any, List
+
+def detect_stack(project_root: Path) -> Dict[str, Any]:
+    profile = {
+        "language": "Unknown",
+        "framework": "None",
+        "data_layer": "None",
+        "dependency_files": [],
+        "detection_evidence": [],
+        "confidence": "Needs Review",
+        "recommended_rules": [
+            "TG-SEC-*",
+            "TG-INPUT-*",
+            "TG-AUTH-*"
+        ],
+        "recommended_references": []
+    }
+
+    # 1. Inspect dependency manifests
+    dep_candidates = ["pyproject.toml", "requirements.txt", "Pipfile", "package.json", "package-lock.json", "pnpm-lock.yaml"]
+    for dc in dep_candidates:
+        if (project_root / dc).is_file():
+            profile["dependency_files"].append(dc)
+
+    # 2. Check Python ecosystem
+    manage_py = project_root / "manage.py"
+    settings_py = list(project_root.glob("**/settings.py"))
+    
+    if manage_py.is_file() or settings_py:
+        profile["language"] = "Python"
+        profile["framework"] = "Django"
+        profile["data_layer"] = "Django ORM"
+        profile["confidence"] = "Confirmed"
+        profile["detection_evidence"].append({
+            "file": "manage.py" if manage_py.is_file() else str(settings_py[0].relative_to(project_root)),
+            "indicator": "Django management or settings configuration"
+        })
+        profile["recommended_rules"].extend(["TG-DB-004", "TG-RATE-001", "TG-PLATFORM-*"])
+        profile["recommended_references"].extend(["django-security.md", "python-security-overview.md"])
+        
+        # Check for DRF
+        for py_file in project_root.glob("**/*.py"):
+            try:
+                content = py_file.read_text(encoding="utf-8", errors="ignore")
+                if "rest_framework" in content:
+                    profile["framework"] = "Django / DRF"
+                    profile["recommended_references"].append("drf-security.md")
+                    break
+            except Exception:
+                continue
+
+    # Check for FastAPI / Flask if not Django
+    if profile["framework"] == "None":
+        for py_file in list(project_root.glob("*.py")) + list(project_root.glob("app/**/*.py")) + list(project_root.glob("src/**/*.py")):
+            try:
+                content = py_file.read_text(encoding="utf-8", errors="ignore")
+                if "FastAPI(" in content or "from fastapi" in content:
+                    profile["language"] = "Python"
+                    profile["framework"] = "FastAPI"
+                    profile["confidence"] = "Confirmed"
+                    profile["detection_evidence"].append({
+                        "file": str(py_file.relative_to(project_root)),
+                        "indicator": "FastAPI application instantiation"
+                    })
+                    profile["recommended_references"].append("fastapi-security.md")
+                elif "Flask(__name__)" in content or "from flask" in content:
+                    profile["language"] = "Python"
+                    profile["framework"] = "Flask"
+                    profile["confidence"] = "Confirmed"
+                    profile["detection_evidence"].append({
+                        "file": str(py_file.relative_to(project_root)),
+                        "indicator": "Flask application instantiation"
+                    })
+                    profile["recommended_references"].append("flask-security.md")
+
+                if "sqlalchemy" in content:
+                    profile["data_layer"] = "SQLAlchemy"
+                    profile["recommended_references"].append("sqlalchemy-security.md")
+            except Exception:
+                continue
+
+    # 3. Check JavaScript / TypeScript ecosystem
+    pkg_json_path = project_root / "package.json"
+    if pkg_json_path.is_file():
+        profile["language"] = "TypeScript" if list(project_root.glob("**/*.ts*")) else "JavaScript"
+        try:
+            with open(pkg_json_path, "r", encoding="utf-8") as f:
+                pkg = json.load(f)
+            deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
+            
+            if "next" in deps:
+                profile["framework"] = "Next.js"
+                profile["confidence"] = "Confirmed"
+                profile["detection_evidence"].append({"file": "package.json", "indicator": "next dependency"})
+                profile["recommended_references"].append("nextjs-security.md")
+                profile["recommended_rules"].extend(["TG-CLIENT-*", "TG-PLATFORM-001"])
+            elif "express" in deps:
+                profile["framework"] = "Express"
+                profile["confidence"] = "Confirmed"
+                profile["detection_evidence"].append({"file": "package.json", "indicator": "express dependency"})
+                profile["recommended_references"].append("express-security.md")
+            elif "react" in deps:
+                profile["framework"] = "React / Vite"
+                profile["confidence"] = "Confirmed"
+                profile["detection_evidence"].append({"file": "package.json", "indicator": "react dependency"})
+                profile["recommended_references"].append("react-vite-security.md")
+
+            if "@supabase/supabase-js" in deps:
+                profile["data_layer"] = "Supabase"
+                profile["recommended_references"].append("supabase-security.md")
+            elif "firebase" in deps or "firebase-admin" in deps:
+                profile["data_layer"] = "Firebase"
+                profile["recommended_references"].append("firebase-security.md")
+        except Exception:
+            pass
+
+    return profile
+
+
+def main():
+    parser = argparse.ArgumentParser(description="TorusGuard Stack Detector")
+    parser.add_argument("path", nargs="?", default=".", help="Target project root directory")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON")
+    args = parser.parse_args()
+
+    project_root = Path(args.path).resolve()
+    profile = detect_stack(project_root)
+
+    if args.json:
+        print(json.dumps(profile, indent=2))
+    else:
+        evidence = profile["detection_evidence"][0]["file"] if profile["detection_evidence"] else "heuristic"
+        print(f"## Detected Stack")
+        print(f"- Language: {profile['language']}")
+        print(f"- Framework: {profile['framework']}")
+        print(f"- Data layer: {profile['data_layer']}")
+        print(f"- Dependency files: {', '.join(profile['dependency_files']) if profile['dependency_files'] else 'None'}")
+        print(f"- Detection confidence: {profile['confidence']} ({evidence})")
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,37 @@
+---
+name: torusguard
+description: Security guardrails, governed remediation, and authorized runtime validation for AI-built web applications across Python and TypeScript.
+version: 0.9.2
+---
+
+# TorusGuard Master Router
+
+**Principle:** If the browser receives it, users can inspect it. Keep secrets, direct database access, and authorization on trusted server-side code.
+
+---
+
+## ⚡ Workspace Bootstrap Check
+1. **If `.torusguard/` exists:** Load matching specialist skill on demand per command.
+2. **If `.torusguard/` is missing:** Run `python skills/torusguard/bootstrap.py --target .` or `/torusguard init`.
+
+---
+
+## Specialist Skill Routing (Lazy Loading)
+Load **only** the designated sub-skill when a slash command is executed to maintain strict 1,000–1,500 token budget:
+
+| Command | Specialist Skill | Agent |
+| :--- | :--- | :--- |
+| `/torusguard init` | `skills/torusguard-init/SKILL.md` | `profiler` |
+| `/torusguard authorize` | `skills/torusguard-authorize/SKILL.md` | `reviewer` |
+| `/torusguard audit` | `skills/torusguard-audit/SKILL.md` | `auditor` |
+| `/torusguard verify` | `skills/torusguard-verify/SKILL.md` | `validator` |
+| `/torusguard web-validate` | `skills/torusguard-web-validate/SKILL.md` | `validator` |
+| `/torusguard exploit-check` | `skills/torusguard-exploit-check/SKILL.md` | `validator` |
+| `/torusguard harden` | `skills/torusguard-harden/SKILL.md` | `remediator` |
+| `/torusguard apply` | `skills/torusguard-apply/SKILL.md` | `remediator` |
+| `/torusguard recheck` | `skills/torusguard-recheck/SKILL.md` | `reviewer` |
+| `/torusguard report` | `skills/torusguard-report/SKILL.md` | `reviewer` |
+| `/torusguard status` | `skills/torusguard-status/SKILL.md` | `reviewer` |
+| `/torusguard full` | `skills/torusguard-full/SKILL.md` | *All* |
+
+*Note: Never load all skills simultaneously. Lazy-load strictly on demand.*

package/.torusguard/skills/torusguard/bootstrap.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+TorusGuard Autonomous Workspace Bootstrapper
+Scaffolds the complete .torusguard/ directory into any user project when
+/torusguard init is executed or when npx skills add installs the skill kit.
+"""
+
+import os
+import sys
+import shutil
+import json
+import argparse
+import subprocess
+from pathlib import Path
+
+
+def find_project_root(start_dir=None):
+    """Detect project root directory by searching for standard repo root markers."""
+    current = Path(start_dir or os.getcwd()).resolve()
+    markers = [".git", "package.json", "pyproject.toml", "manage.py", "Pipfile", "requirements.txt"]
+    
+    # First check current directory
+    for m in markers:
+        if (current / m).exists():
+            return current
+            
+    # Search upwards
+    for parent in current.parents:
+        for m in markers:
+            if (parent / m).exists():
+                return parent
+                
+    return current
+
+
+def scaffold_workspace(target_root=None, force=False):
+    """Scaffold the .torusguard workspace into the target project root."""
+    target_root = Path(target_root or find_project_root()).resolve()
+    torusguard_target = target_root / ".torusguard"
+    script_dir = Path(__file__).resolve().parent
+    payload_dir = script_dir / "payload"
+
+    print("================================================================================")
+    print("TORUSGUARD WORKSPACE BOOTSTRAPPER")
+    print("================================================================================")
+    print(f"Target Directory: {target_root}")
+    print(f"Destination:      {torusguard_target}")
+
+    if torusguard_target.exists() and not force:
+        print(f"\n[INFO] Workspace already exists at {torusguard_target}")
+        config_file = torusguard_target / "config" / "torusguard.json"
+        if config_file.exists():
+            try:
+                with open(config_file, "r", encoding="utf-8") as f:
+                    cfg = json.load(f)
+                print(f"Current Version:   {cfg.get('version', 'unknown')}")
+                print(f"Severity Minimum:  {cfg.get('severity_threshold', 'medium')}")
+            except Exception:
+                pass
+        print("\nUse --force to re-scaffold or refresh templates.")
+        return True
+
+    # 1. Unpack Payload Template
+    if payload_dir.is_dir():
+        print("\n1. Unpacking bundled offline workspace payload...")
+        try:
+            if torusguard_target.exists() and force:
+                shutil.rmtree(torusguard_target)
+            shutil.copytree(
+                payload_dir,
+                torusguard_target,
+                ignore=shutil.ignore_patterns("runs", "*.pyc", "__pycache__", ".git*")
+            )
+            print("  [SUCCESS] Copied template tree from local skill payload.")
+        except Exception as e:
+            print(f"  [ERROR] Failed to unpack payload: {e}")
+            return False
+    else:
+        # Fallback: create base structure
+        print("\n1. Bundled payload not found. Creating core skeleton...")
+        subdirs = [
+            "config", "agents", "workflows", "scripts", "templates",
+            "schemas", "references", "rules/active", "runs"
+        ]
+        for s in subdirs:
+            (torusguard_target / s).mkdir(parents=True, exist_ok=True)
+        print("  [WARN] Bare skeleton created; full assets should be pulled from repository.")
+
+    # 2. Ensure runs and rules/active directories exist
+    runs_dir = torusguard_target / "runs"
+    runs_dir.mkdir(parents=True, exist_ok=True)
+    gitkeep_runs = runs_dir / ".gitkeep"
+    if not gitkeep_runs.exists():
+        gitkeep_runs.write_text("", encoding="utf-8")
+
+    active_rules_dir = torusguard_target / "rules" / "active"
+    active_rules_dir.mkdir(parents=True, exist_ok=True)
+    gitkeep_rules = active_rules_dir / ".gitkeep"
+    if not gitkeep_rules.exists():
+        gitkeep_rules.write_text("", encoding="utf-8")
+
+    # 3. Stack Detection & Tailoring
+    print("\n2. Executing stack detection on target project...")
+    stack_detect_script = torusguard_target / "scripts" / "stack_detect.py"
+    detected_stack = {"language": "Unknown", "framework": "None", "data_layer": "None", "confidence": "Uncertain"}
+    
+    if stack_detect_script.exists():
+        try:
+            res = subprocess.run(
+                [sys.executable, str(stack_detect_script), str(target_root), "--json"],
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            if res.returncode == 0 and res.stdout.strip():
+                detected_stack = json.loads(res.stdout)
+                print(f"  [DETECTED] Language:   {detected_stack.get('language')}")
+                print(f"  [DETECTED] Framework:  {detected_stack.get('framework')}")
+                print(f"  [DETECTED] Data Layer: {detected_stack.get('data_layer')}")
+        except Exception as e:
+            print(f"  [WARN] Stack detection encountered error: {e}")
+
+    # 4. Update torusguard.json configuration
+    config_file = torusguard_target / "config" / "torusguard.json"
+    if config_file.exists():
+        try:
+            with open(config_file, "r", encoding="utf-8") as f:
+                cfg = json.load(f)
+            cfg["detected_stack"] = {
+                "language": detected_stack.get("language"),
+                "framework": detected_stack.get("framework"),
+                "data_layer": detected_stack.get("data_layer")
+            }
+            with open(config_file, "w", encoding="utf-8") as f:
+                json.dump(cfg, f, indent=2)
+            print("  [SUCCESS] Configured .torusguard/config/torusguard.json")
+        except Exception as e:
+            print(f"  [WARN] Failed to write stack details to config: {e}")
+
+    print("\n================================================================================")
+    print("[SUCCESS] TORUSGUARD WORKSPACE SCAFFOLDED SUCCESSFULLY!")
+    print("================================================================================")
+    print(f"Workspace Path: {torusguard_target}")
+    print("\nNext Steps:")
+    print("  1. Run `/torusguard audit` in your AI IDE to scan the project.")
+    print("  2. Run `/torusguard status` to verify active security posture.")
+    print("================================================================================")
+    return True
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="TorusGuard Autonomous Workspace Bootstrapper")
+    parser.add_argument("--target", type=str, help="Target project root directory")
+    parser.add_argument("--force", action="store_true", help="Force overwrite existing workspace")
+    args = parser.parse_args()
+
+    success = scaffold_workspace(target_root=args.target, force=args.force)
+    sys.exit(0 if success else 1)

package/.torusguard/skills/torusguard/references/auth-and-sessions.md

@@ -0,0 +1,56 @@
+# Authentication, Sessions, and Authorization
+
+## When to load
+
+Load during `/TorusGuard check auth`, login/signup/reset implementation, or resource route reviews.
+
+## Linked rules
+
+- [TG-AUTH-001](../../rules/TG-AUTH-001-weak-password-storage.md) — Weak Password Storage (Critical)
+- [TG-AUTH-002](../../rules/TG-AUTH-002-client-only-authorization.md) — Client-Only Authorization (High)
+- [TG-AUTH-003](../../rules/TG-AUTH-003-missing-object-authorization.md) — IDOR/BOLA (High)
+- [TG-AUTH-004](../../rules/TG-AUTH-004-insecure-session-cookie.md) — Insecure Session Cookie (High)
+- [TG-AUTH-005](../../rules/TG-AUTH-005-unsafe-password-reset.md) — Unsafe Password Reset (High)
+
+## Hard bans
+
+- No plaintext, MD5, or SHA1 password storage
+- No authorization enforced only in frontend routing
+- No trust in client-supplied user IDs or roles
+- No session cookies missing httpOnly/Secure/SameSite in production
+- No predictable or reusable password reset tokens
+
+## Safe defaults
+
+- Argon2id or bcrypt (cost ≥ 12) for passwords
+- httpOnly, Secure, SameSite cookies for browser sessions
+- Server-side role and ownership checks on every sensitive route
+- Neutral login/reset responses (no account enumeration)
+- CSRF protection for cookie-authenticated state changes
+- Reset tokens: random, single-use, expiring
+
+## IDOR test procedure
+
+For each route with a resource ID (`/api/users/:id`, `/api/orders/:orderId`):
+
+> Can User A change the ID and access User B's resource?
+
+If yes → fails TG-AUTH-003.
+
+## Audit checklist
+
+- [ ] Strong password hashing (TG-AUTH-001)
+- [ ] Server enforces authZ (TG-AUTH-002)
+- [ ] Object ownership verified (TG-AUTH-003)
+- [ ] Secure cookie flags (TG-AUTH-004)
+- [ ] Safe reset flow + rate limits (TG-AUTH-005)
+
+## Manual review
+
+- Organization/tenant-scoped authorization
+- Privilege escalation via mass assignment
+- Session fixation and logout invalidation
+
+## Related rules
+
+TG-RATE-001, TG-SEC-004, TG-INPUT-001

package/.torusguard/skills/torusguard/references/business-logic-and-abuse.md

@@ -0,0 +1,23 @@
+# Business Logic and Abuse
+
+## Topics
+- Coupon and discount abuse.
+- Trial and referral abuse.
+- Payment amount tampering.
+- Inventory manipulation.
+- OTP and verification workflow bypass.
+- Vote and rating manipulation.
+- Repeated one-time operations.
+- AI or third-party API cost abuse.
+- Replay and idempotency.
+- Per-user and per-account velocity.
+- Server-side state transitions.
+
+## Review Table
+| Flow | Value protected | Abuse action | Existing control | Missing control |
+|---|---|---|---|---|
+| Apply coupon | Discount amount | Reuse coupon | Database flag | Atomic update |
+| Send OTP | SMS cost | Repeated requests | IP limiter | Account limiter |
+| Create order | Inventory/payment | Modify quantity/price | Auth only | Server-side pricing |
+
+The agent must ask whether a user can execute a technically valid operation too many times. OWASP identifies sensitive business-flow abuse separately from ordinary authentication and resource-exhaustion concerns.

package/.torusguard/skills/torusguard/references/cache-and-sensitive-responses.md

@@ -0,0 +1,10 @@
+# Cache and Sensitive Responses
+
+- Cache-Control: private, no-store for sensitive responses where appropriate.
+- CDN cache-key isolation.
+- User-specific response separation.
+- Sensitive query parameters and tokens.
+- Referrer leakage.
+- Authenticated API responses.
+- Export/download URLs.
+- Signed URL expiry.

package/.torusguard/skills/torusguard/references/client-code-exposure.md

@@ -0,0 +1,55 @@
+# Client Code Exposure and Source Maps
+
+## When to load
+
+Load during `/TorusGuard check client`, production build review, or frontend bundle audits.
+
+## Linked rules
+
+- [TG-CLIENT-001](../../rules/TG-CLIENT-001-public-production-source-maps.md) — Public Production Source Maps (Medium)
+- [TG-CLIENT-002](../../rules/TG-CLIENT-002-sensitive-client-bundle-content.md) — Sensitive Bundle Content (High)
+
+## Important truth
+
+**Inspect Element and DevTools cannot be prevented.** Browser-delivered JavaScript is public. TorusGuard must never claim client code can be hidden. Security comes from server-side enforcement, not obfuscation.
+
+Obfuscation is a minor deterrent only — never a security control.
+
+## Hard bans
+
+- No secrets, privileged routes, or auth decisions only in client code
+- No production `console.log` of tokens, users, or config
+- No public `.map` files unless explicitly required
+
+## Safe defaults
+
+| Framework | Production setting |
+|-----------|-------------------|
+| Vite | `build.sourcemap: false` |
+| Next.js | `productionBrowserSourceMaps: false` |
+| CRA | `GENERATE_SOURCEMAP=false` |
+
+- Upload source maps privately to Sentry/monitoring — do not serve publicly
+- Verify public `.map` URLs return 404 when disabled
+- Add CSP where practical
+- Move authorization and secrets server-side
+
+## Audit checklist
+
+- [ ] Production source maps disabled or private (TG-CLIENT-001)
+- [ ] No secrets or privileged logic in bundle (TG-CLIENT-002)
+- [ ] No sensitive console logging
+- [ ] CSP configured appropriately
+
+## Manual review
+
+- Third-party script dependencies
+- Comments revealing internal routes or admin endpoints
+
+## Related rules
+
+TG-SEC-002, TG-AUTH-002, TG-PLATFORM-002
+
+## Framework guide
+
+[React/Vite Security](../../guides/react-vite-security.md)

package/.torusguard/skills/torusguard/references/csrf-and-cross-origin.md

@@ -0,0 +1,11 @@
+# CSRF and Cross-Origin
+
+- Cookie-authenticated state changes.
+- Synchronizer tokens.
+- Double-submit cookies.
+- SameSite behavior and limitations.
+- CORS and credentials.
+- Origin and Referer validation where appropriate.
+- JSON content-type restrictions.
+- Framework-native CSRF protections.
+- SPA/API architecture differences.

package/.torusguard/skills/torusguard/references/dependency-and-supply-chain.md

@@ -0,0 +1,22 @@
+# Dependency and Supply Chain
+
+- Lockfiles.
+- Dependency update policy.
+- Vulnerability audit commands by ecosystem.
+- Dependabot/Renovate.
+- GitHub Actions pinning.
+- CI secret exposure.
+- Pull-request workflow trust.
+- Install scripts.
+- Dependency provenance.
+- Review of new packages.
+
+## Audit Commands
+```bash
+npm audit
+pip-audit
+osv-scanner --lockfile=package-lock.json
+dotnet list package --vulnerable
+bundle audit
+govulncheck ./...
+```

package/.torusguard/skills/torusguard/references/django-security.md

@@ -0,0 +1,43 @@
+# TorusGuard Skill Reference: Django Security
+
+> **Loaded When:** A project is identified as a Django application (`manage.py`, `settings.py`, or `django` dependency detected).
+
+---
+
+## 🛡️ Key Inspection Areas & Rules
+
+### 1. Secrets & Production Configuration
+* `TG-SEC-001`: Verify `SECRET_KEY` is loaded via `os.environ` or a secrets manager, not hardcoded.
+* `TG-PLATFORM-003`: Verify `DEBUG = False` in production configs.
+* `TG-PLATFORM-001`: Ensure `ALLOWED_HOSTS` is restricted to legitimate hostnames.
+
+### 2. Authentication & Authorization
+* `TG-AUTH-001`: Ensure protected views use `@login_required` or `LoginRequiredMixin`.
+* `TG-AUTH-007`: Enforce object-level ownership checks (e.g. `get_object_or_404(Model, id=id, user=request.user)`). Avoid unrestricted numeric ID lookups.
+
+### 3. Mass Assignment
+* `TG-AUTH-006`: Ensure `ModelForm` definitions specify explicit `fields = [...]` lists instead of `fields = '__all__'`.
+
+### 4. Injection & Database Security
+* `TG-INPUT-003`: Ensure `Model.objects.raw()` or `cursor.execute()` uses parameterized inputs (`%s`), never f-strings or `.format()`.
+
+### 5. CSRF & Request Security
+* `TG-CSRF-001`: Verify `django.middleware.csrf.CsrfViewMiddleware` is active in `MIDDLEWARE`. Avoid indiscriminate `@csrf_exempt`.
+* `TG-CACHE-001`: Verify sensitive authenticated endpoints use `@never_cache`.
+
+---
+
+## 🛠️ Safe Patterns Summary
+```python
+# Safe Object Lookup
+item = get_object_or_404(Invoice, id=invoice_id, account=request.user.account)
+
+# Safe Form
+class ProfileForm(forms.ModelForm):
+    class Meta:
+        model = Profile
+        fields = ['bio', 'website_url', 'avatar']
+
+# Safe Raw SQL (if mandatory)
+cursor.execute("SELECT * FROM reports WHERE account_id = %s", [request.user.account_id])
+```

package/.torusguard/skills/torusguard/references/drf-security.md

@@ -0,0 +1,20 @@
+# TorusGuard Skill Reference: Django REST Framework (DRF)
+
+> **Loaded When:** Project uses `rest_framework` dependencies or imports.
+
+---
+
+## 🛡️ Key Inspection Areas & Rules
+
+### 1. Permissions & Endpoint Exposure
+* `TG-AUTH-001`: Inspect `settings.py` for `REST_FRAMEWORK['DEFAULT_PERMISSION_CLASSES']`. If missing or set to `AllowAny`, verify that individual views specify explicit `permission_classes`.
+* `TG-AUTH-007`: In `ModelViewSet` and API views, check if `get_queryset()` returns `Model.objects.all()` without filtering by `request.user` or tenant context.
+
+### 2. Serializer Field Whitelists & Mass Assignment
+* `TG-AUTH-006`: Inspect Serializer classes. Flag serializers where `fields = '__all__'` or where administrative/financial fields are not in `read_only_fields`.
+
+### 3. Throttling & Rate Limits
+* `TG-RATE-001`: Check authentication endpoints (login, password reset, register, OTP) for throttle classes (`UserRateThrottle`, `ScopedRateThrottle`).
+
+### 4. Pagination Caps
+* `TG-RATE-002`: Check custom pagination classes for `max_page_size`. If client-controlled `page_size_query_param` is enabled without a ceiling, flag as unbound resource risk.

package/.torusguard/skills/torusguard/references/fastapi-security.md

@@ -0,0 +1,20 @@
+# TorusGuard Skill Reference: FastAPI Security
+
+> **Loaded When:** Project uses `fastapi` dependencies or imports.
+
+---
+
+## 🛡️ Key Inspection Areas & Rules
+
+### 1. Route Authorization & Dependencies
+* `TG-AUTH-001` / `TG-AUTH-003`: Verify protected routes include security dependencies (`Depends(get_current_user)`).
+* `TG-AUTH-007`: In route handlers taking numeric/UUID path parameters (e.g. `profile_id`, `invoice_id`), verify that database queries filter by the authenticated user's ID.
+
+### 2. Request Models & Mass Assignment
+* `TG-AUTH-006`: Check that endpoints accept structured Pydantic `BaseModel` classes rather than raw `dict`, `Body(...)`, or unpacking `**payload` directly into ORM entities.
+
+### 3. Outbound Requests & SSRF
+* `TG-SSRF-001`: Inspect endpoints that fetch external URLs via `httpx` or `requests`. Verify scheme validation and private IP address filtering.
+
+### 4. Webhook Integrity
+* `TG-WEBHOOK-001`: In webhook endpoints, verify HMAC signature validation using `await request.body()` (raw bytes) before JSON parsing.

package/.torusguard/skills/torusguard/references/flask-security.md

@@ -0,0 +1,20 @@
+# TorusGuard Skill Reference: Flask Security
+
+> **Loaded When:** Project uses `flask` dependencies or imports.
+
+---
+
+## 🛡️ Key Inspection Areas & Rules
+
+### 1. Secret Key & Cookie Configuration
+* `TG-SEC-001`: Inspect `app.config['SECRET_KEY']`. Flag hardcoded string literals.
+* `TG-PLATFORM-003`: Verify `app.debug = False` in production configs.
+
+### 2. Authorization & Ownership (IDOR)
+* `TG-AUTH-007`: In route handlers querying database models by route variables (e.g. `<int:id>`), verify that the query filters by `current_user.id`.
+
+### 3. CSRF Protection
+* `TG-CSRF-001`: Verify that cookie-authenticated web forms initialize `flask_wtf.CSRFProtect`.
+
+### 4. File Uploads
+* `TG-INPUT-004`: Ensure uploaded filenames are filtered using `secure_filename()` and validate against an extension whitelist.