torusguard 0.9.2

package/skills/torusguard/payload/workflows/verify.md

@@ -0,0 +1,95 @@
+---
+description: Evidence sufficiency verification, live disk line match audit, and finding score refinement.
+tools: Read, Grep, Glob, Bash, Write
+version: 0.9.2
+agent: validator
+lifecycle-phase: Phase 3a (Evidence Verification)
+required-skills:
+  - torusguard-verify
+scripts-binding:
+  - .torusguard/scripts/finding_scorer.py
+---
+
+# /torusguard verify — Evidence Verification & Score Refinement
+
+$ARGUMENTS
+
+---
+
+## Objective
+Evidence sufficiency verification, live disk line match audit, and finding score refinement.
+
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Inspect finding records and evidence integrity before verification:
+1. **Latest Run Records (`.torusguard/runs/`):** Locate most recent audit run directory.
+2. **Finding Files:** Confirm `findings.md` or `findings.json` exists in the target run folder.
+3. **Live File Drift:** Assert cited source files have not been edited or relocated on disk.
+4. **Scoring Model Calibration:** Ensure `finding_scorer.py` evaluates all 5 rubric dimensions.
+5. **Role Boundary:** Enforce validator role; do not apply code modifications during verification.
+
+---
+
+## When to Use /torusguard verify
+
+| Trigger Scenario | Recommended Action |
+| :--- | :--- |
+| Auditing whether static findings are valid code flaws | Run `/torusguard verify` |
+| Upgrading Medium confidence finding to Confirmed | Run `/torusguard verify` |
+| No audit run executed yet | Run `/torusguard audit` first |
+| Running live network requests against endpoints | Run `/torusguard web-validate` |
+| Generating patch after verification | Run `/torusguard harden` |
+
+---
+
+## Execution Steps
+
+1. **Locate Target Findings:** Load active findings from latest run directory.
+2. **Live Disk Line Match:** Read current code at cited line ranges; verify AST snippet matches.
+3. **Audit Evidence Sufficiency:** Assess whether taint path is unbroken and caller context is exposed.
+4. **Refine Confidence Scores:**
+   ```bash
+   python .torusguard/scripts/finding_scorer.py --run <run_dir> --verify
+   ```
+5. **Classify Status:** Assign verified state (`Confirmed`, `Plausible`, or `False Positive / Disputed`).
+6. **Emit Verification Ledger:** Write `verified-evidence.md` into the active run folder.
+
+---
+
+## Failure Recovery
+
+- **Missing Run Folder:** Run `/torusguard audit` first to produce a valid run baseline.
+- **Line Drift Detected:** Flag line mismatch; scan nearby lines (±25) for relocated AST sink.
+- **Malformed Finding JSON:** Repair JSON structure using finding schema before scoring.
+- **Halt Trigger:** Abort if cited files are completely deleted from disk.
+
+---
+
+## Hallucination Guard
+
+- ❌ Never confirm a finding if the cited sink has already been sanitized by middleware.
+- ❌ Never bump confidence score without documenting unbroken taint source-to-sink flow.
+- ✅ Always anchor line matches to live disk reads using `view_file`.
+
+---
+
+## Output Card Format
+
+```markdown
+### 🧪 TorusGuard Evidence Verification
+- **Run ID:** `run-YYYYMMDD-HHMMSS-audit`
+- **Findings Evaluated:** [Count] findings
+- **Confirmed Real:** [Count] verified flaws
+- **Downgraded / False Positives:** [Count] filtered out
+- **Refined Mean Score:** [Score]/100
+- **Ledger:** `.torusguard/runs/<run_id>/verified-evidence.md`
+```
+
+---
+
+## Next Steps
+
+1. Run `/torusguard web-validate` if live endpoint probing is required.
+2. Run `/torusguard harden` to build surgical patch bundles for verified flaws.

package/skills/torusguard/payload/workflows/web-validate.md

@@ -0,0 +1,95 @@
+---
+description: Authorized HTTP probing, token redaction, transparent audit header injection, and replay trace capture.
+tools: Read, Grep, Glob, Bash, Write
+version: 0.9.2
+agent: validator
+lifecycle-phase: Phase 3b (Runtime Web Validation)
+required-skills:
+  - torusguard-web-validate
+scripts-binding:
+  - .torusguard/scripts/safety_gate.py
+---
+
+# /torusguard web-validate — Bounded HTTP Probing & Session Capture
+
+$ARGUMENTS
+
+---
+
+## Objective
+Authorized HTTP probing, token redaction, transparent audit header injection, and replay capture.
+
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Inspect authorization parameters and safety limits before sending HTTP requests:
+1. **Active Scope (`.torusguard/config/scope.json`):** Assert target host and path are authorized with valid TTL.
+2. **Safety Gate Classification:** Test proposed endpoint against `.torusguard/scripts/safety_gate.py`.
+3. **Sensitive Route Guard:** Ensure destructive endpoints (`DELETE`, account drops) are never called automatically.
+4. **Token Redaction Pipeline:** Ensure bearer tokens and session cookies are masked (`Bearer [REDACTED]`).
+5. **Request Budget:** Enforce maximum cap of 50 requests per validation session.
+
+---
+
+## When to Use /torusguard web-validate
+
+| Trigger Scenario | Recommended Action |
+| :--- | :--- |
+| Testing live route accessibility and security headers | Run `/torusguard web-validate` |
+| Verifying cookie security flags (`HttpOnly`, `Secure`, `SameSite`) | Run `/torusguard web-validate` |
+| Checking CORS headers and authentication barriers | Run `/torusguard web-validate` |
+| Pure static source code analysis | Run `/torusguard audit` |
+| Confirming exploitable attack vectors | Run `/torusguard exploit-check` |
+
+---
+
+## Execution Steps
+
+1. **Verify Legal Scope:** Check target URL against `.torusguard/config/scope.json`.
+2. **Invoke Safety Gate:**
+   ```bash
+   python .torusguard/scripts/safety_gate.py check --url <target_url> --method GET
+   ```
+3. **Dispatch Non-Destructive Probe:** Send bounded HTTP request with audit header `X-TorusGuard-AuthID`.
+4. **Redact Sensitive Headers:** Sanitize auth tokens and credentials in request and response objects.
+5. **Write Replay Artifacts:**
+   Record sanitized trace in `.torusguard/runs/<run_id>/requests.json` and emit `web-validation.md`.
+
+---
+
+## Failure Recovery
+
+- **Target Offline:** Verify local dev server is active and accessible on designated host port.
+- **Safety Gate Rejection (Manual Only):** Halt probe immediately; report endpoint requires human manual test.
+- **Rate Limit / 429:** Back off exponentially (1s, 2s, 4s); stop session if 429 persists.
+- **Halt Trigger:** Abort if target domain deviates from authorized allowlist in `scope.json`.
+
+---
+
+## Hallucination Guard
+
+- ❌ Never dispatch HTTP requests outside domains explicitly listed in `.torusguard/config/scope.json`.
+- ❌ Never write raw Authorization headers or plaintext secrets to disk.
+- ✅ Always include transparent audit headers (`X-TorusGuard-AuthID`).
+
+---
+
+## Output Card Format
+
+```markdown
+### 🌐 TorusGuard Web Validation
+- **Target Host:** [Host URL]
+- **Endpoints Probed:** [Count] routes tested
+- **Security Headers:** [CSP / HSTS / CORS status]
+- **Cookie Security:** [HttpOnly / Secure / SameSite status]
+- **Replay Trace:** `.torusguard/runs/<run_id>/replay.json`
+- **Status:** COMPLETED — non-destructive probe finished
+```
+
+---
+
+## Next Steps
+
+1. Run `/torusguard exploit-check` to confirm if reachable flaws constitute verified exploits.
+2. Run `/torusguard harden` to build surgical remediation diffs.

package/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/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/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/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/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/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/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/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/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/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/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/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/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/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 } }
+);
+```