torusguard 0.9.2

package/.torusguard/config/scope.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "../schemas/authorization.schema.json",
+  "authorization": {
+    "target": "localhost",
+    "owner_confirmed": false,
+    "scope_type": "source_code_only",
+    "allowed_hosts": [
+      "localhost",
+      "127.0.0.1"
+    ],
+    "allowed_paths": [
+      "/api/*",
+      "/auth/*"
+    ],
+    "excluded_paths": [
+      "/admin/delete*",
+      "/system/shutdown*"
+    ],
+    "duration_hours": 24,
+    "authorized_at": null,
+    "authorized_by": null,
+    "notes": "Default authorization scope template. Run /torusguard authorize to activate for live targets."
+  }
+}

package/.torusguard/config/slash-commands.json

@@ -0,0 +1,102 @@
+{
+  "commands": [
+    {
+      "name": "/torusguard init",
+      "description": "Initialize TorusGuard in the workspace: detect project stack, activate tailored TG-* rules, and verify SECURITY.md.",
+      "usage": "/torusguard init",
+      "workflow": ".torusguard/workflows/init.md",
+      "agent": "profiler",
+      "modifies_code": false
+    },
+    {
+      "name": "/torusguard authorize",
+      "description": "Capture target ownership, allowed hosts, permitted endpoints, and write scope.json for runtime validation.",
+      "usage": "/torusguard authorize [target_url]",
+      "workflow": ".torusguard/workflows/authorize.md",
+      "agent": "reviewer",
+      "modifies_code": false
+    },
+    {
+      "name": "/torusguard audit",
+      "description": "Execute static AST code audit against active rules, assign Stable Fingerprints, cluster findings, and score confidence.",
+      "usage": "/torusguard audit [target_dir]",
+      "workflow": ".torusguard/workflows/audit.md",
+      "agent": "auditor",
+      "modifies_code": false
+    },
+    {
+      "name": "/torusguard verify",
+      "description": "Validate evidence sufficiency, audit AST source matches, and compute 0–100 confidence score.",
+      "usage": "/torusguard verify [finding_id]",
+      "workflow": ".torusguard/workflows/verify.md",
+      "agent": "validator",
+      "modifies_code": false
+    },
+    {
+      "name": "/torusguard web-validate",
+      "description": "Dispatch authorized HTTP and API runtime probes with token redaction to test practical reachability.",
+      "usage": "/torusguard web-validate [target_url]",
+      "workflow": ".torusguard/workflows/web-validate.md",
+      "agent": "validator",
+      "modifies_code": false,
+      "requires_authorization": true
+    },
+    {
+      "name": "/torusguard exploit-check",
+      "description": "Execute bounded, safe exploitability confirmation for approved vulnerability classes (SQLi, SSRF, XSS, auth bypass).",
+      "usage": "/torusguard exploit-check [target_url]",
+      "workflow": ".torusguard/workflows/exploit-check.md",
+      "agent": "validator",
+      "modifies_code": false,
+      "requires_authorization": true
+    },
+    {
+      "name": "/torusguard harden",
+      "description": "Generate structured remediation bundles with framework-native before/after diffs enriched by runtime findings.",
+      "usage": "/torusguard harden [run_id]",
+      "workflow": ".torusguard/workflows/harden.md",
+      "agent": "remediator",
+      "modifies_code": false
+    },
+    {
+      "name": "/torusguard apply",
+      "description": "Apply surgical, governed patches with strict line addition (<=35) and deletion (<=25) boundaries.",
+      "usage": "/torusguard apply [bundle_id]",
+      "workflow": ".torusguard/workflows/apply.md",
+      "agent": "remediator",
+      "modifies_code": true
+    },
+    {
+      "name": "/torusguard recheck",
+      "description": "Re-scan modified files to verify fix integrity and detect potential regressions.",
+      "usage": "/torusguard recheck [run_id]",
+      "workflow": ".torusguard/workflows/recheck.md",
+      "agent": "reviewer",
+      "modifies_code": false
+    },
+    {
+      "name": "/torusguard report",
+      "description": "Generate unified Markdown executive report, finding cards, and multi-analysis OASIS SARIF v2.1.0 output.",
+      "usage": "/torusguard report [run_id]",
+      "workflow": ".torusguard/workflows/report.md",
+      "agent": "reviewer",
+      "modifies_code": false
+    },
+    {
+      "name": "/torusguard status",
+      "description": "Display current security posture, active run history, configuration, and activated rule count.",
+      "usage": "/torusguard status",
+      "workflow": ".torusguard/workflows/status.md",
+      "agent": null,
+      "modifies_code": false
+    },
+    {
+      "name": "/torusguard full",
+      "description": "Execute the complete 7-stage end-to-end security pipeline: init, authorize, audit, validate, harden, apply, recheck, and report.",
+      "usage": "/torusguard full",
+      "workflow": "skills/torusguard-full/SKILL.md",
+      "agent": null,
+      "modifies_code": true
+    }
+  ]
+}

package/.torusguard/config/torusguard.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "../schemas/torusguard-config.schema.json",
+  "version": "0.9.2",
+  "product": "TorusGuard Security Skill Kit",
+  "severity_threshold": "medium",
+  "auto_detect_stack": true,
+  "runs_dir": ".torusguard/runs",
+  "authorization_required_for_runtime": true,
+  "sarif_export": true,
+  "governance": {
+    "max_patch_additions": 35,
+    "max_patch_deletions": 25,
+    "require_user_approval_for_apply": true,
+    "dry_run_sensitive_paths": true
+  },
+  "runtime_validation": {
+    "default_timeout_seconds": 10,
+    "max_concurrent_probes": 3,
+    "auto_redact_tokens": true,
+    "safe_methods_only": true
+  },
+  "ignored_rules": [],
+  "custom_rules_dir": null,
+  "report_format": "markdown",
+  "detected_stack": {
+    "language": "TypeScript",
+    "framework": "None",
+    "data_layer": "None"
+  }
+}

package/.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/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/references/express-security.md

@@ -0,0 +1,103 @@
+# Express Security Guide
+
+## When to use
+
+Load during audits of Node.js Express APIs serving web or mobile clients.
+
+**Related rules:** TG-INPUT-001, TG-INPUT-002, TG-AUTH-003, TG-AUTH-004, TG-RATE-001, TG-PLATFORM-001 … TG-PLATFORM-004
+
+## Checklist
+
+- [ ] Helmet or equivalent security headers (TG-PLATFORM-002)
+- [ ] CORS explicit allowlist — never `*` with credentials (TG-PLATFORM-001)
+- [ ] `express.json({ limit: '100kb' })` or appropriate cap (TG-PLATFORM-004)
+- [ ] Zod/Joi validation on every mutating route (TG-INPUT-001)
+- [ ] Parameterized SQL or ORM — no concatenation (TG-INPUT-002)
+- [ ] Rate limits on login, reset, OTP (TG-RATE-001)
+- [ ] Central error handler — generic client messages (TG-PLATFORM-003)
+- [ ] Secure cookie flags for sessions (TG-AUTH-004)
+- [ ] Ownership middleware on resource routes (TG-AUTH-003)
+
+## Baseline server setup
+
+```javascript
+import express from 'express';
+import helmet from 'helmet';
+import cors from 'cors';
+import rateLimit from 'express-rate-limit';
+
+const app = express();
+const allowedOrigins = ['https://app.example.com'];
+
+app.use(helmet());
+app.use(cors({
+  origin(origin, cb) {
+    if (!origin || allowedOrigins.includes(origin)) cb(null, true);
+    else cb(new Error('Not allowed by CORS'));
+  },
+  credentials: true,
+}));
+app.use(express.json({ limit: '100kb' }));
+
+const loginLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 5,
+  standardHeaders: true,
+  message: { error: 'Too many attempts' },
+});
+app.post('/api/login', loginLimiter, loginHandler);
+```
+
+## Validation middleware
+
+```javascript
+import { z } from 'zod';
+
+function validate(schema) {
+  return (req, res, next) => {
+    const parsed = schema.safeParse({ body: req.body, query: req.query, params: req.params });
+    if (!parsed.success) return res.status(400).json({ error: 'Invalid input' });
+    req.validated = parsed.data;
+    next();
+  };
+}
+```
+
+## Ownership middleware
+
+```javascript
+async function requireOrderOwner(req, res, next) {
+  const order = await db.order.findUnique({ where: { id: req.params.id } });
+  if (!order || order.userId !== req.user.id) {
+    return res.status(403).json({ error: 'Forbidden' });
+  }
+  req.order = order;
+  next();
+}
+```
+
+## Error handler
+
+```javascript
+app.use((err, req, res, next) => {
+  console.error({ err, requestId: req.id });
+  res.status(err.status || 500).json({
+    error: process.env.NODE_ENV === 'production' ? 'Internal server error' : err.message,
+  });
+});
+```
+
+## Distributed rate limiting
+
+Use Redis or similar shared store in multi-instance production — in-memory limiters alone are insufficient (TG-RATE-001).
+
+## Manual review
+
+- Enumerate all `app.use` order (auth before routes)
+- Verify upload routes have size/type/auth checks
+- Run dependency audit before deploy
+
+## Related documentation
+
+- [rules/TG-PLATFORM-001-wildcard-cors-with-credentials.md](../rules/TG-PLATFORM-001-wildcard-cors-with-credentials.md)
+- [skills/TorusGuard/references/platform-hardening.md](../skills/TorusGuard/references/platform-hardening.md)

package/.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/references/firebase-security.md

@@ -0,0 +1,78 @@
+# Firebase Security Guide
+
+## When to use
+
+Load during audits of Firebase Auth, Firestore, Realtime Database, or Storage.
+
+**Related rules:** TG-DB-003, TG-AUTH-002, TG-AUTH-003, TG-SEC-002
+
+## Key distinction
+
+| SDK | Where | Purpose |
+|-----|-------|---------|
+| **Firebase client SDK** | Browser/mobile | User-facing ops constrained by Security Rules |
+| **Firebase Admin SDK** | Server only | Privileged operations — never in frontend |
+
+## Checklist
+
+- [ ] Admin SDK credentials server-only (TG-DB-003)
+- [ ] Firestore/RTDB Security Rules deployed and tested
+- [ ] Storage rules restrict paths by `request.auth.uid`
+- [ ] Client rules do not trust client-supplied ownership fields alone
+- [ ] Custom claims used for roles verified server-side for sensitive ops
+- [ ] Emulator tests for rule changes
+
+## Client SDK (safe with rules)
+
+```javascript
+import { initializeApp } from 'firebase/app';
+import { getFirestore, doc, getDoc } from 'firebase/firestore';
+
+const app = initializeApp(firebaseConfig); // public config is OK
+const db = getFirestore(app);
+```
+
+## Firestore rules example
+
+```javascript
+rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    match /users/{userId} {
+      allow read, write: if request.auth != null && request.auth.uid == userId;
+    }
+    match /orders/{orderId} {
+      allow read: if request.auth != null
+        && resource.data.ownerId == request.auth.uid;
+    }
+  }
+}
+```
+
+## Admin SDK (server only)
+
+```javascript
+// functions or server/index.js — never in React src/
+import admin from 'firebase-admin';
+admin.initializeApp({ credential: admin.credential.cert(serviceAccount) });
+```
+
+Never commit service account JSON; use environment or secret manager (TG-SEC-001, TG-SEC-003).
+
+## Manual rules review checklist
+
+1. Default-deny: are unmatched paths blocked?
+2. Can users read/write other users' documents by guessing IDs?
+3. Are admin collections inaccessible to normal users?
+4. Do Storage paths include user ID validation?
+5. Run emulator tests for allow/deny cases
+
+## Auth token validation
+
+For custom backends verifying Firebase ID tokens, use Admin SDK `verifyIdToken` — do not decode JWT without signature verification.
+
+## Related documentation
+
+- [rules/TG-DB-003-frontend-admin-sdk.md](../rules/TG-DB-003-frontend-admin-sdk.md)
+- [rules/TG-AUTH-003-missing-object-authorization.md](../rules/TG-AUTH-003-missing-object-authorization.md)
+- [skills/TorusGuard/references/frontend-no-db.md](../skills/TorusGuard/references/frontend-no-db.md)

package/.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/.torusguard/references/nextjs-security.md

@@ -0,0 +1,96 @@
+# Next.js Security Guide
+
+## When to use
+
+Load during audits of Next.js App Router or Pages Router applications.
+
+**Related rules:** TG-SEC-002, TG-DB-003, TG-AUTH-002, TG-AUTH-003, TG-CLIENT-001, TG-PLATFORM-002
+
+## Server vs client boundary
+
+| Location | Can use secrets? | Can access DB? |
+|----------|------------------|----------------|
+| Server Components, Route Handlers, Server Actions | Yes (env without `NEXT_PUBLIC_`) | Yes (server SDK) |
+| Client Components (`'use client'`) | No | No |
+
+Never import server-only modules (Prisma, `pg`, Firebase Admin, service-role Supabase) into Client Components.
+
+## Checklist
+
+- [ ] No `NEXT_PUBLIC_*` variables hold secrets (TG-SEC-002)
+- [ ] Route handlers and Server Actions validate input and authorize users
+- [ ] `productionBrowserSourceMaps: false` in production
+- [ ] Cookie sessions use httpOnly, Secure, SameSite (TG-AUTH-004)
+- [ ] CSRF considered for cookie-authenticated mutations
+- [ ] Sensitive data not over-cached in public CDN routes
+- [ ] Security headers via `next.config` or middleware/Helmet on custom server
+
+## Environment variables
+
+```env
+# Server-only
+DATABASE_URL=postgresql://...
+JWT_SECRET=...
+
+# Client-safe
+NEXT_PUBLIC_API_URL=https://api.example.com
+```
+
+## Route handler pattern
+
+```typescript
+// app/api/orders/[id]/route.ts
+import { z } from 'zod';
+import { getSession } from '@/lib/session';
+import { db } from '@/lib/db';
+
+const paramsSchema = z.object({ id: z.string().uuid() });
+
+export async function GET(req: Request, { params }: { params: { id: string } }) {
+  const session = await getSession();
+  if (!session) return Response.json({ error: 'Unauthorized' }, { status: 401 });
+
+  const parsed = paramsSchema.safeParse(params);
+  if (!parsed.success) return Response.json({ error: 'Invalid input' }, { status: 400 });
+
+  const order = await db.order.findFirst({
+    where: { id: parsed.data.id, userId: session.userId },
+  });
+  if (!order) return Response.json({ error: 'Not found' }, { status: 404 });
+
+  return Response.json(order);
+}
+```
+
+## Server Actions
+
+Validate and authorize at the start of every Server Action. Do not trust hidden form fields for `role` or `userId`.
+
+## Source maps
+
+```javascript
+// next.config.js
+const nextConfig = {
+  productionBrowserSourceMaps: false,
+};
+export default nextConfig;
+```
+
+## CSRF and sessions
+
+When using cookie-based auth with Server Actions or form POSTs, verify Origin/Referer or use CSRF tokens for state-changing requests.
+
+## Cache and privacy
+
+Avoid caching personalized responses at CDN edge unless intentionally public. Review `fetch` cache options and `revalidate` settings for user-specific data.
+
+## Manual review
+
+- Trace every `'use client'` file for accidental secret imports
+- Test IDOR on dynamic `[id]` routes (TG-AUTH-003)
+- Review middleware auth coverage
+
+## Related documentation
+
+- [rules/TG-AUTH-003-missing-object-authorization.md](../rules/TG-AUTH-003-missing-object-authorization.md)
+- [guides/express-security.md](express-security.md) (custom server)

package/.torusguard/references/react-vite-security.md

@@ -0,0 +1,97 @@
+# React + Vite Security Guide
+
+## When to use
+
+Load during audits of React + Vite frontends with a separate or proxied API backend.
+
+**Related rules:** TG-SEC-002, TG-DB-001, TG-DB-002, TG-AUTH-002, TG-CLIENT-001, TG-CLIENT-002, TG-INPUT-003
+
+## Core truth: the browser bundle is public
+
+If the browser receives JavaScript, users can read it in DevTools, Sources, and network tabs. TorusGuard cannot block Inspect Element. Never put secrets, database credentials, or authorization decisions only in client code.
+
+## Checklist
+
+- [ ] No secrets in `VITE_*` environment variables
+- [ ] No SQL, ORM, or DB driver imports in `src/`
+- [ ] Private data fetched only through authenticated API calls
+- [ ] `build.sourcemap: false` for production (TG-CLIENT-001)
+- [ ] No `console.log` of tokens, users, or config in production paths
+- [ ] Route guards are UX only — server enforces authorization (TG-AUTH-002)
+- [ ] User HTML rendered as text unless sanitized (TG-INPUT-003)
+- [ ] CSP configured at hosting/API layer where applicable
+
+## Environment variables
+
+Only intentionally public values belong in Vite client env:
+
+```env
+# .env.example — safe for client
+VITE_API_URL=http://localhost:3001
+VITE_APP_NAME=MyApp
+
+# NEVER prefix secrets with VITE_
+# JWT_SECRET, DATABASE_URL, STRIPE_SECRET_KEY → server only
+```
+
+```javascript
+// vite.config.js — disable public production source maps
+export default defineConfig({
+  build: { sourcemap: false },
+  server: {
+    proxy: { '/api': 'http://localhost:3001' },
+  },
+});
+```
+
+## Data access pattern
+
+```javascript
+// client/src/api/users.js — safe
+export async function fetchMyProfile() {
+  const res = await fetch('/api/users/me', { credentials: 'include' });
+  if (!res.ok) throw new Error('Unauthorized');
+  return res.json();
+}
+```
+
+Never construct SQL or import `pg`, `@prisma/client`, or Supabase service-role client in `src/`.
+
+## Client route guards
+
+```jsx
+// UX redirect only — NOT security
+function AdminRoute({ children }) {
+  const { user } = useAuth();
+  if (!user?.role) return <Navigate to="/login" />;
+  return children;
+}
+```
+
+Every admin action must still fail on the server without proper role checks.
+
+## Safe rendering
+
+```jsx
+// Safe — React escapes text by default
+<p>{user.bio}</p>
+
+// High risk — only with trusted/sanitized HTML
+<div dangerouslySetInnerHTML={{ __html: sanitizedHtml }} />
+```
+
+## CSP considerations
+
+Define CSP at the reverse proxy or Express/Next layer. Account for Vite dev server in development; tighten for production with explicit `script-src`, `connect-src`, and `img-src` origins.
+
+## Manual review
+
+- Verify API endpoints enforce auth for every sensitive client call
+- Confirm no secret accidentally added to `import.meta.env` usage
+- Review third-party scripts loaded in `index.html`
+
+## Related documentation
+
+- [rules/TG-SEC-002-public-environment-secrets.md](../rules/TG-SEC-002-public-environment-secrets.md)
+- [rules/TG-CLIENT-001-public-production-source-maps.md](../rules/TG-CLIENT-001-public-production-source-maps.md)
+- [skills/TorusGuard/references/client-code-exposure.md](../skills/TorusGuard/references/client-code-exposure.md)

package/.torusguard/references/sqlalchemy-security.md

@@ -0,0 +1,16 @@
+# TorusGuard Skill Reference: SQLAlchemy Security
+
+> **Loaded When:** Project uses `sqlalchemy` dependencies or imports.
+
+---
+
+## 🛡️ Key Inspection Areas & Rules
+
+### 1. SQL Injection in Raw Query Clauses
+* `TG-INPUT-003`: Search for `text(f"...")`, `text("..." + ...)`, or `.format()` inside `text()` constructs. Ensure parameter mapping `text("... WHERE col = :val")` is used.
+
+### 2. Tenant Scoping & Object Ownership
+* `TG-AUTH-007`: Verify queries on tenant-isolated tables include tenant/user ID predicates in `.filter()` or `.filter_by()`.
+
+### 3. Mass Assignment via Bulk Updates
+* `TG-AUTH-006`: Inspect `.update(dict)` calls to ensure input dictionaries are filtered against permitted field allowlists.