torusguard 0.9.2

package/skills/torusguard/payload/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/skills/torusguard/payload/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/skills/torusguard/payload/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/skills/torusguard/payload/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/skills/torusguard/payload/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/skills/torusguard/payload/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/skills/torusguard/payload/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/skills/torusguard/payload/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/skills/torusguard/payload/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/skills/torusguard/payload/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/skills/torusguard/payload/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.

package/skills/torusguard/payload/skills/torusguard/references/frontend-no-db.md

@@ -0,0 +1,53 @@
+# Frontend Database Protection
+
+## When to load
+
+Load during `/TorusGuard check database`, full-stack audits, or when frontend code connects to data stores.
+
+## Linked rules
+
+- [TG-DB-001](../../rules/TG-DB-001-frontend-database-query.md) — Database Query in Frontend (High)
+- [TG-DB-002](../../rules/TG-DB-002-privileged-database-credential.md) — Privileged Credential in Browser (Critical)
+- [TG-DB-003](../../rules/TG-DB-003-frontend-admin-sdk.md) — Frontend Admin SDK (Critical)
+
+## Hard bans
+
+- No SQL in frontend directories (`src/`, `app/`, `pages/`, `components/`, `client/`, `public/`)
+- No imports of `pg`, `mysql`, `mongoose`, `@prisma/client`, Sequelize, TypeORM, Drizzle server client
+- No Supabase service-role key or Firebase Admin SDK in browser code
+- No trust in client-provided user ID or role without server verification
+
+## Safe architecture
+
+```
+Browser → HTTPS API → AuthZ → Parameterized query/ORM → Database
+```
+
+## Supabase
+
+- Browser: anon key + **RLS enabled** on all exposed tables
+- Server: service-role key only for admin tasks
+- **Manual review required:** RLS policies for every table
+
+## Firebase
+
+- Browser: client SDK + Security Rules
+- Server: Admin SDK only
+- **Manual review required:** Firestore/Storage rules
+
+## Audit checklist
+
+- [ ] No DB queries or drivers in client code (TG-DB-001, TG-DB-003)
+- [ ] No connection strings or service-role keys in bundle (TG-DB-002)
+- [ ] All mutations authorized server-side
+- [ ] Supabase RLS / Firebase rules reviewed and tested
+
+## Framework guides
+
+- [Supabase](../../guides/supabase-security.md)
+- [Firebase](../../guides/firebase-security.md)
+- [React/Vite](../../guides/react-vite-security.md)
+
+## Related rules
+
+TG-SEC-002, TG-AUTH-002, TG-AUTH-003

package/skills/torusguard/payload/skills/torusguard/references/graphql-security.md

@@ -0,0 +1,12 @@
+# GraphQL Security
+
+- Resolver-level authentication and authorization.
+- Query depth limits.
+- Query complexity limits.
+- Pagination and page-size caps.
+- Batching controls.
+- Introspection policy.
+- Aliases and recursive relationships.
+- Error sanitization.
+- Sensitive field exposure.
+- Data-loader and N+1 concerns as resource risks.

package/skills/torusguard/payload/skills/torusguard/references/input-and-injection.md

@@ -0,0 +1,51 @@
+# Input Validation and Injection Prevention
+
+## When to load
+
+Load during `/TorusGuard check input`, API route reviews, or upload/webhook implementation.
+
+## Linked rules
+
+- [TG-INPUT-001](../../rules/TG-INPUT-001-missing-server-validation.md) — Missing Server Validation (High)
+- [TG-INPUT-002](../../rules/TG-INPUT-002-raw-sql-concatenation.md) — Raw SQL Concatenation (Critical)
+- [TG-INPUT-003](../../rules/TG-INPUT-003-unsafe-html-or-code-execution.md) — Unsafe HTML/Code Execution (High)
+- [TG-INPUT-004](../../rules/TG-INPUT-004-unrestricted-file-upload.md) — Unrestricted File Upload (High)
+
+## Hard bans
+
+- No raw SQL concatenation with request input
+- No `eval`, `Function()`, or shell execution with untrusted input
+- No unsanitized user HTML via `dangerouslySetInnerHTML`
+- No file upload without size, type, and authorization checks
+- No trust in `req.body.role`, `isAdmin`, or `userId`
+
+## Safe defaults
+
+- Validate all external input on the server: body, query, params, headers, cookies, webhooks, uploads
+- Treat third-party API and **LLM output** as untrusted
+- Use Zod, Joi, Yup, or Ajv schemas at route entry
+- Parameterized queries or safe ORM APIs only
+- Redirect URLs must use allowlists
+- Uploads: MIME allowlist, size cap, server-generated filenames, storage outside web root
+
+## Audit checklist
+
+- [ ] Every API route validates input (TG-INPUT-001)
+- [ ] No concatenated SQL (TG-INPUT-002)
+- [ ] No unsafe HTML/code execution (TG-INPUT-003)
+- [ ] Upload routes restricted (TG-INPUT-004)
+
+## Framework notes
+
+- **Express** — validation middleware before handlers
+- **Next.js** — validate in route handlers and Server Actions
+- **Supabase** — Edge Functions validate before privileged ops
+
+## Manual review
+
+- Business-logic validation beyond schema (e.g., cross-field rules)
+- NoSQL injection patterns in MongoDB query builders
+
+## Related rules
+
+TG-AUTH-002, TG-RATE-003, TG-PLATFORM-004

package/skills/torusguard/payload/skills/torusguard/references/mass-assignment-and-property-auth.md

@@ -0,0 +1,22 @@
+# Mass Assignment and Property Authorization
+
+- Explicit writable-field allowlists.
+- DTOs or request schemas.
+- Separate user-editable and server-managed fields.
+- Server-side assignment for role, balance, status, ownership, and verification.
+- Authorization checks for sensitive individual properties.
+- Tests that submit unexpected fields.
+
+## Unsafe
+```javascript
+await User.update(req.body, { where: { id: req.user.id } });
+```
+
+## Safe
+```javascript
+const input = updateProfileSchema.parse(req.body);
+await User.update(
+  { displayName: input.displayName, avatarUrl: input.avatarUrl },
+  { where: { id: req.user.id } }
+);
+```

package/skills/torusguard/payload/skills/torusguard/references/platform-hardening.md

@@ -0,0 +1,56 @@
+# Platform and HTTP Hardening
+
+## When to load
+
+Load during `/TorusGuard check platform`, deployment prep, or `/TorusGuard verify`.
+
+## Linked rules
+
+- [TG-PLATFORM-001](../../rules/TG-PLATFORM-001-wildcard-cors-with-credentials.md) — Wildcard CORS + Credentials (High)
+- [TG-PLATFORM-002](../../rules/TG-PLATFORM-002-missing-security-headers.md) — Missing Security Headers (Medium)
+- [TG-PLATFORM-003](../../rules/TG-PLATFORM-003-production-stack-trace-exposure.md) — Stack Trace Exposure (Medium)
+- [TG-PLATFORM-004](../../rules/TG-PLATFORM-004-missing-request-size-limits.md) — Missing Request Size Limits (Medium)
+
+## Hard bans
+
+- No `Access-Control-Allow-Origin: *` with credentials
+- No production stack traces or raw DB errors to clients
+- No debug mode in production
+- No missing body limits on public JSON endpoints
+- No executable uploads in public web directories
+
+## Safe defaults
+
+- CORS explicit allowlist
+- Helmet or equivalent: CSP, `X-Content-Type-Options`, HSTS (production), `Referrer-Policy`, clickjacking protection
+- Generic user-facing errors; detailed logs server-side with request ID
+- HTTPS enforced in production
+- `express.json({ limit: '100kb' })` or appropriate caps
+- Dependency audit before deploy
+
+## Audit checklist
+
+- [ ] CORS allowlist (TG-PLATFORM-001)
+- [ ] Security headers configured (TG-PLATFORM-002)
+- [ ] Errors sanitized (TG-PLATFORM-003)
+- [ ] Request/upload limits set (TG-PLATFORM-004)
+
+## Framework notes
+
+- **Express** — Helmet + central error handler
+- **Next.js** — headers in `next.config` or middleware
+- **Reverse proxy** — TLS termination, HSTS, rate limits
+
+## Manual review
+
+- CSP compatibility with actual script/style sources
+- Infrastructure firewall and WAF rules
+- Backup and monitoring configuration
+
+## Related rules
+
+TG-RATE-003, TG-SEC-004, TG-CLIENT-001
+
+## Framework guide
+
+[Express Security](../../guides/express-security.md)

package/skills/torusguard/payload/skills/torusguard/references/python-dependencies.md

@@ -0,0 +1,16 @@
+# TorusGuard Skill Reference: Python Dependencies and Supply Chain
+
+> **Loaded When:** Python dependency manifests (`requirements.txt`, `pyproject.toml`, `Pipfile`, `poetry.lock`, `uv.lock`) or `.github/workflows/*.yml` are detected.
+
+---
+
+## 🛡️ Key Inspection Areas & Rules
+
+### 1. Lockfile Integrity
+* `TG-SUPPLY-001`: Verify that deterministic lockfiles exist alongside manifests and are not excluded in `.gitignore`.
+
+### 2. Known CVE Vulnerability Auditing
+* `TG-SUPPLY-002`: Check for vulnerable dependencies using `pip-audit`. Avoid recommending blind major-version upgrades that introduce breaking changes without tests.
+
+### 3. CI/CD Workflow Hardening
+* `TG-SUPPLY-004`: Inspect `.github/workflows/*.yml` for unpinned 3rd-party actions and overbroad default permissions.