@ryuenn3123/agentic-senior-core 6.16.2 → 6.16.5

package/.agents/plugins/agentic-senior-core/hooks/session-start.js

@@ -1,23 +1,35 @@
 #!/usr/bin/env node
 // Agentic Senior Core — SessionStart hook
-// Injects universal coding rules on every session start.
-// Supports Claude Code, Codex CLI, and GitHub Copilot CLI.
+// Injects universal coding rules on session start for Claude Code, Codex CLI, and Copilot CLI.
+// If invoked under Antigravity SessionStart, returns valid JSON (rules/agentic-senior-core.md
+// is already loaded natively via plugin rules/).
 
 const fs = require('fs');
 const path = require('path');
+const { isAntigravityPayload } = require('./path-util.cjs');
 
 const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT || path.resolve(__dirname, '..');
 const isCopilot = Boolean(process.env.COPILOT_PLUGIN_DATA);
 const isCodex = !isCopilot && Boolean(process.env.PLUGIN_DATA);
+const isAntigravityEnv = Boolean(
+  process.env.ANTIGRAVITY_LS_ADDRESS ||
+  process.env.ANTIGRAVITY_CSRF_TOKEN ||
+  process.env.ANTIGRAVITY_CLI
+);
 
-let content;
-try {
-  content = fs.readFileSync(path.join(pluginRoot, 'rules', 'agentic-senior-core.md'), 'utf8');
-} catch (e) {
-  process.exit(0);
-}
+function emitForHost(stdinData) {
+  if (isAntigravityEnv || isAntigravityPayload(stdinData)) {
+    process.stdout.write('{}\n');
+    return;
+  }
+
+  let content;
+  try {
+    content = fs.readFileSync(path.join(pluginRoot, 'rules', 'agentic-senior-core.md'), 'utf8');
+  } catch (_) {
+    return;
+  }
 
-try {
   if (isCopilot) {
     process.stdout.write(JSON.stringify({ additionalContext: content }));
   } else if (isCodex) {
@@ -31,6 +43,45 @@ try {
   } else {
     process.stdout.write(content);
   }
-} catch (e) {
-  // Silent fail — stdout closed/EPIPE at hook exit must not surface as a hook failure
 }
+
+if (process.stdin.isTTY) {
+  try { emitForHost(null); } catch (_) {}
+  process.exit(0);
+}
+
+let handled = false;
+let inputBuffer = '';
+const timer = setTimeout(function () {
+  if (!handled) {
+    handled = true;
+    try { emitForHost(null); } catch (_) {}
+    process.exit(0);
+  }
+}, 250);
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', function (chunk) {
+  inputBuffer += chunk;
+  try {
+    const parsed = JSON.parse(inputBuffer);
+    if (!handled) {
+      handled = true;
+      clearTimeout(timer);
+      emitForHost(parsed);
+      process.exit(0);
+    }
+  } catch (_) {}
+});
+
+process.stdin.on('end', function () {
+  if (handled) return;
+  handled = true;
+  clearTimeout(timer);
+  let parsed = null;
+  if (inputBuffer.trim()) {
+    try { parsed = JSON.parse(inputBuffer); } catch (_) {}
+  }
+  try { emitForHost(parsed); } catch (_) {}
+  process.exit(0);
+});

package/.agents/plugins/agentic-senior-core/hooks.json

@@ -1,120 +1,30 @@
 {
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "startup|resume|clear|compact",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node hooks/session-start.js",
-            "commandWindows": "node hooks/session-start.js",
-            "timeout": 5,
-            "statusMessage": "Loading ASC rules..."
-          }
-        ]
-      }
-    ],
-    "SubagentStart": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node hooks/subagent-start.js",
-            "commandWindows": "node hooks/subagent-start.js",
-            "timeout": 5,
-            "statusMessage": "Loading ASC rules..."
-          }
-        ]
-      }
-    ],
+  "agentic-senior-core": {
     "PreToolUse": [
       {
-        "matcher": "Edit|Write|replace_file_content|write_to_file|write_file|multi_replace_file_content",
-        "hooks": [
-          {
-            "type": "command",
-            "if": "Edit(**/package.json)|Edit(**/requirements.txt)|Edit(**/pyproject.toml)|Edit(**/go.mod)|Edit(**/Cargo.toml)|Edit(**/Gemfile)",
-            "command": "node hooks/pre-tool-dependency-gate.js",
-            "commandWindows": "node hooks/pre-tool-dependency-gate.js",
-            "timeout": 5,
-            "statusMessage": "ASC Pre-tool dependency check (Edit)..."
-          },
-          {
-            "type": "command",
-            "if": "Write(**/package.json)|Write(**/requirements.txt)|Write(**/pyproject.toml)|Write(**/go.mod)|Write(**/Cargo.toml)|Write(**/Gemfile)",
-            "command": "node hooks/pre-tool-dependency-gate.js",
-            "commandWindows": "node hooks/pre-tool-dependency-gate.js",
-            "timeout": 5,
-            "statusMessage": "ASC Pre-tool dependency check (Write)..."
-          }
-        ]
-      },
-      {
-        "matcher": "Bash|run_command|run_shell_command|terminal|execute_command",
+        "matcher": "edit_file|write_file|replace_file_content|multi_replace_file_content|write_to_file|run_command",
         "hooks": [
           {
             "type": "command",
             "command": "node hooks/pre-tool-dependency-gate.js",
-            "commandWindows": "node hooks/pre-tool-dependency-gate.js",
-            "timeout": 5,
-            "statusMessage": "ASC Pre-tool dependency check (Terminal)..."
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "Edit|Write|replace_file_content|write_to_file|write_file|multi_replace_file_content",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node hooks/post-edit-enforce.js",
-            "commandWindows": "node hooks/post-edit-enforce.js",
-            "timeout": 5,
-            "statusMessage": "ASC ladder & spec gate check..."
-          },
-          {
-            "type": "command",
-            "command": "node hooks/dedup-gate.js",
-            "commandWindows": "node hooks/dedup-gate.js",
-            "timeout": 15,
-            "statusMessage": "ASC duplicate-code scan..."
+            "timeout": 5
           }
         ]
       }
     ],
     "PreInvocation": [
-      {
-        "type": "command",
-        "command": "node hooks/session-pulse.js",
-        "commandWindows": "node hooks/session-pulse.js",
-        "timeout": 5,
-        "statusMessage": "Loading ASC rules..."
-      },
       {
         "type": "command",
         "command": "node hooks/ladder-pulse.js",
-        "commandWindows": "node hooks/ladder-pulse.js",
-        "timeout": 5,
-        "statusMessage": "ASC ladder pulse..."
+        "timeout": 5
       }
     ],
     "PostInvocation": [
       {
         "type": "command",
         "command": "node hooks/post-edit-enforce.js",
-        "commandWindows": "node hooks/post-edit-enforce.js",
         "timeout": 15
       }
-    ],
-    "PreCompact": [
-      {
-        "type": "command",
-        "command": "node hooks/pre-compact-pin.js",
-        "commandWindows": "node hooks/pre-compact-pin.js",
-        "timeout": 5,
-        "statusMessage": "ASC constraint pinning..."
-      }
     ]
   }
 }

package/.agents/plugins/agentic-senior-core/plugin.json

@@ -1,16 +1,8 @@
 {
   "name": "agentic-senior-core",
-  "version": "6.16.2",
-  "description": "Universal AI coding rules. Because your AI writes code like it gets paid by the line.",
-  "contextFileName": "rules/agentic-senior-core.md",
-  "rules": [
-    "rules/"
-  ],
-  "commands": [
-    "commands/"
-  ],
-  "skills": [
-    "skills/"
-  ],
-  "hooks": "hooks.json"
+  "displayName": "Agentic Senior Core",
+  "version": "6.16.5",
+  "description": "Universal AI coding rules and workflows. Write code like a staff engineer.",
+  "author": "fatidaprilian",
+  "repository": "https://github.com/fatidaprilian/Agentic-Senior-Core"
 }

package/.agents/plugins/agentic-senior-core/rules/agentic-senior-core.md

@@ -42,7 +42,11 @@ When picking step 5 or 6 (unless trivial):
 - Early returns over deep nesting (keep happy path flat).
 - Three similar lines is better than a premature abstraction (duplication over wrong abstraction).
 - Single design source of truth: UI styling must reuse defined design tokens, theme variables, or existing page patterns. No ad-hoc palette, radius, or font deviations between pages.
-- UI copy & microcopy hygiene: Functional UI is a tool, not a brochure. Zero conversational filler or marketing buzzwords ("seamless", "empower", "robust"). Never echo heading text in redundant subheadings. Enforce strict single-language consistency without unidiomatic foreign loanwords or hybrid transliterations.
+- Human writing & prose hygiene: Functional communication is an operational tool, not marketing collateral. This applies to UI microcopy, READMEs, PR descriptions, and code comments alike:
+  - 50% reduction rule: Write the statement, then cut unnecessary words. Replace ornamental adjectives with measurable facts (not "a robust, blazing-fast parser", write "parses 50MB/s with zero heap allocations").
+  - Ban AI cadences: Never use the Tricolon ("Fast. Simple. Secure."), the Mad-Lib ("The AI-powered platform for modern teams"), the Rebuttal ("Not just a tool, it's a workflow"), or conversational throat-clearing ("In today's fast-paced landscape...").
+  - Buzzword blacklist: Never emit `seamless(ly)`, `robust`, `empower(ing)`, `supercharge`, `elevate`, `effortless(ly)`, `cutting-edge`, `delve`, `testament`, `pivotal`, `crucial`, `game-changing`, or `next-generation`.
+  - Strict single-language purity: Choose one language per document or surface. In Indonesian contexts, never prefix grammatical affixes to raw English stems (`di-submit`, `meng-generate`, `di-approve`, `me-restore`).
 - Code comment hygiene: Zero decorative character banners (// =====), zero line-by-line narration (// Step 1: validate), zero empty category tags (// Main logic), and zero signature echoes in docstrings. Keep only comments that document non-obvious operational constraints, security boundaries, concurrency hazards, or protocol contracts.
 - Delete code that carries no behavior, safety, or test value. Readability wins over brevity.
 - Detect and respect project linter/formatter configs. Do not restate style rules enforced by tooling.
@@ -83,6 +87,7 @@ When picking step 5 or 6 (unless trivial):
 ## Domain References & Skills (On-Demand)
 Detailed domain guidelines are loaded on-demand via skills or scoped rules:
 - **Testing, TDD, Verification, E2E & UAT** → run `/asc-test`
+- **Penetration Testing, DAST & API Security Fuzzing** → run `/asc-pentest`
 - **API Design, Database, Infrastructure, Resilience** → run `/asc-reference`
 - **Frontend UI/UX Engineering & Anti-Slop Design** → run `/asc-ui`
 - **Engineering Lifecycle & Features** → run `/asc-develop`

package/.agents/plugins/agentic-senior-core/skills/asc/SKILL.md

@@ -69,9 +69,12 @@ Synchronize ASC rules and skills across all installed AI coding tools.
 ### CLI Utility Commands
 ```bash
 asc status          # Detect installed AI coding tools
-asc global --all    # Install global rules and smart git hook dispatcher
+asc global          # Auto-detect installed AI tools and sync global rules/skills/hooks
+asc global --all    # Force-install global rules for all supported hosts
 asc adapter --all   # Generate workspace adapters for all detected IDEs
-asc adapter --cursor # Generate adapter specifically for Cursor
+asc dedup           # Scan codebase for Rule-of-Three structural/token clones
+asc bootstrap       # Configure project UI/architecture baseline bans (.agents/adaptive_preferences.json)
+asc preview <html/> # Open static HTML mockup or capture headless browser screenshot
 asc uninstall       # Clean up adapter files and hooks
 ```
 

package/.agents/plugins/agentic-senior-core/skills/asc-develop/SKILL.md

@@ -27,7 +27,7 @@ Use when creating a new application, service, or repository from zero.
    - Can standard library or native platform handle it?
    - Can this be one straightforward function?
 2. Build the core domain entities, data models, and services first before protocol/transport controllers.
-3. For frontend interfaces, follow the design standards in `/asc-ui`.
+3. For frontend interfaces, follow `/asc-ui`. For documentation and prose (READMEs, ADRs), enforce the Universal Prose Floor (zero AI throat-clearing, 50% word reduction, zero buzzwords).
 4. Generate a quality gate workflow (e.g., `.github/workflows/quality-gate.yml`) that runs linter, type-check, and tests.
 
 ### Step 3: Validation
@@ -51,11 +51,11 @@ Use when adding endpoints, components, pages, or capabilities to an existing cod
    - What happens on network/API failure or timeout?
    - What feedback does the user see? (Pending state, inline field error, toast/banner with retry).
    - How can the system recover? (Retry, cached fallback, degraded mode).
-3. If building UI, ensure compliance with `/asc-ui` (zero marketing fluff, single-language consistency, mobile reflow, WCAG AA contrast).
+3. If building UI or writing documentation, ensure compliance with the Universal Prose Floor and `/asc-ui` (zero marketing fluff, single-language consistency, mobile reflow, WCAG AA contrast).
 
 ### Step 3: Implement & Validate (TDD Integration)
 1. Follow the TDD cycle via `/asc-test`: write the failing test first (RED), write minimal code to pass (GREEN), then refactor.
-2. **Zero-Fake-Done Testing**: Run the project test suite (`ascx test`, `npm test`, `pytest`, `cargo test`). The test runner **MUST** exit with code 0.
+2. **Zero-Fake-Done Testing**: Run the project test suite (`ascx npm test`, `ascx pytest`, `ascx cargo test`). The test runner **MUST** exit with code 0.
 3. Never weaken or delete test assertions to simulate a passing run. Fix the underlying business logic.
 
 ---

package/.agents/plugins/agentic-senior-core/skills/asc-pentest/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: asc-pentest
+description: >
+  Trigger this skill when the user is: conducting penetration testing, dynamic application security testing (DAST), API security audits, BOLA/IDOR verification, fuzzing endpoints, probing attack surfaces, or validating security vulnerabilities on running servers. Also trigger when the user says: "pentest this", "security scan", "check IDOR", "test API security", "audit DAST", "fuzz this endpoint", "uji penetrasi", "cari celah runtime", "cek keamanan api".
+---
+
+# Adversarial Penetration Testing & DAST Router (`asc-pentest`)
+
+Staff-grade adversarial security testing and dynamic vulnerability validation. Enforces deterministic assessment state and non-destructive proof-of-exploit verification.
+
+Grounded in: USENIX Security (PentestGPT architecture), OWASP API Security Top 10, ProjectDiscovery Nuclei DSL, and Schemathesis BOLA verification.
+
+---
+
+## 1. Safety & Non-Destructive Invariants
+
+> [!CAUTION]
+> `asc-pentest` operates exclusively in a defensive, non-destructive posture against authorized local development environments or designated staging servers.
+> - **Local/Staging Targets Only:** Never probe external production endpoints without explicit written authorization.
+> - **Canary Data Only:** All destructive or mutating test cases must use isolated canary records (e.g. `canary_asc_test_user`). Never tamper with production user data.
+> - **No Volumetric Floods:** Never execute brute-force or volumetric DoS attacks that risk system starvation.
+> - **Deterministic Evidence:** Every reported finding must provide an exact, reproducible `curl` reproduction script or automated assertion.
+
+---
+
+## 2. Pre-Flight Ingestion & Reference Loading (BLOCKING)
+
+> [!IMPORTANT]
+> **Reference Path Resolution:**
+> Reference files do NOT reside in the user workspace root. They are located adjacent to this `SKILL.md` file:
+> `<skill_directory>/references/<file>.md`
+> Prepend this skill's directory path when calling `read_file`.
+
+Before sending network requests, probing endpoints, or asserting vulnerabilities:
+1. **Mandatory Ingestion (BLOCKING GATE):** Call `read_file` on the reference matching the security assessment phase BEFORE taking action:
+   - Stateful multi-step penetration workflow & task tree ➔ `references/pentest-task-tree.md`
+   - Baseline DAST, security headers, CORS & open redirects ➔ `references/dast-baseline.md`
+   - BOLA / IDOR horizontal privilege & token tampering ➔ `references/api-security-idor.md`
+   - Nuclei-style request mutations & boundary fuzzing ➔ `references/fuzzing-dsl.md`
+   *Do NOT generate payloads or report vulnerability claims until the relevant reference is loaded.*
+
+---
+
+## 3. The 4-Phase Pentesting Decision Tree
+
+```
+                       Is target a running local/staging server?
+                                      │
+                      ┌───────────────┴───────────────┐
+                     YES                              NO
+                      │                               │
+              ┌───────────────┐               ┌───────────────┐
+              │  PHASE 1:     │               │ Delegate to   │
+              │ Surface Recon │               │ asc-review    │
+              └───────┬───────┘               │ (Static SAST) │
+                      │                       └───────────────┘
+              Does it have authenticated endpoints / multiple users?
+                      │
+              ┌───────┴───────┐
+             YES              NO
+              │               │
+      ┌───────────────┐ ┌───────────────┐
+      │  PHASE 2:     │ │  PHASE 3:     │
+      │ BOLA / IDOR   │ │ DAST Baseline │
+      │ & Auth Probe  │ │ & Fuzzing DSL │
+      └───────┬───────┘ └───────┬───────┘
+              │                 │
+              └────────┬────────┘
+                       ▼
+              ┌─────────────────┐
+              │    PHASE 4:     │
+              │ Exploit Proof & │
+              │ Remediation Log │
+              └─────────────────┘
+```
+
+---
+
+## 4. On-Demand Reference Library
+
+| Assessment Phase / Focus Area | Mandatory Reference Path |
+|---|---|
+| Stateful Task Tree (DISCOVER $\to$ ENUMERATE $\to$ TEST $\to$ EXPLOIT $\to$ VERIFY) | `references/pentest-task-tree.md` |
+| Baseline DAST, CORS, CSP, HSTS & Information Leaks | `references/dast-baseline.md` |
+| BOLA / IDOR, Dual-Identity Probing & Mass Assignment | `references/api-security-idor.md` |
+| Multi-part Request Fuzzing (Replace, Prefix, Postfix) | `references/fuzzing-dsl.md` |
+
+---
+
+## 5. Verification & Handoff Sweep
+
+Before completing any penetration testing engagement:
+1. **Claim Verification:** Confirm every reported vulnerability has an empirical `curl` proof or automated test reproducing the exact failure.
+2. **State Cleanliness:** Confirm all temporary canary test data (`canary_asc_*`) created during the audit has been purged.
+3. **Remediation Precision:** Provide the smallest safe code fix (e.g. policy middleware, parameterized query, input schema constraint).
+4. **No Assumption Claims:** Never declare an application "100% secure"; state the exact assessed surface and tested vector parameters.
+

package/.agents/plugins/agentic-senior-core/skills/asc-pentest/references/api-security-idor.md

@@ -0,0 +1,105 @@
+# API Security, BOLA / IDOR & Authorization Probing
+
+Derived from the authorization verification engine of **Schemathesis** (`specs/openapi/object_authorization.py`) and the OWASP API Security Top 10.
+
+---
+
+## 1. BOLA / IDOR Dual-Identity Replay Protocol
+
+Broken Object Level Authorization (BOLA / IDOR) is the most pervasive and critical API security flaw. It occurs when an endpoint accepts a resource identifier without verifying whether the requesting user owns or has access to that specific record.
+
+### The Algorithmic Dual-Identity Verification Flow
+
+```
+┌───────────────────────────────────────┐
+│ 1. OWNER READ (Identity A)            │
+│ GET /api/v1/documents/doc_101         │
+│ Authorization: Bearer TOKEN_USER_A    │
+└──────────────────┬────────────────────┘
+                   │
+                   ▼ Expected: 200 OK + Valid Payload
+┌───────────────────────────────────────┐
+│ 2. PEER REPLAY (Identity B)           │
+│ GET /api/v1/documents/doc_101         │
+│ Authorization: Bearer TOKEN_USER_B    │
+└──────────────────┬────────────────────┘
+                   │
+                   ├───────────────────────────────────┐
+                   ▼                                   ▼
+        Status 200 OK + Data                Status 403 / 404
+    ┌─────────────────────────┐         ┌─────────────────────────┐
+    │ CRITICAL BOLA CONFIRMED │         │  SECURE (Access Denied) │
+    └─────────────────────────┘         └─────────────────────────┘
+```
+
+### Reproducible Proof Script (`curl`)
+To provide deterministic proof of a BOLA vulnerability, generate two reproducible requests:
+
+```bash
+# Step 1: Prove resource exists and belongs to User A
+curl -s -X GET "http://localhost:3000/api/v1/reports/409" \
+  -H "Authorization: Bearer canary_user_a_token" \
+  -H "Accept: application/json"
+
+# Step 2: Prove User B can retrieve User A's private resource without permission
+curl -s -X GET "http://localhost:3000/api/v1/reports/409" \
+  -H "Authorization: Bearer canary_user_b_token" \
+  -H "Accept: application/json"
+```
+
+**Remediation Rule**:
+Never query resources by primary key alone. Enforce tenant and user boundary scoping directly in database queries:
+```sql
+-- VULNERABLE:
+SELECT * FROM reports WHERE id = :id;
+
+-- SECURE:
+SELECT * FROM reports WHERE id = :id AND tenant_id = :authenticated_tenant_id;
+```
+
+---
+
+## 2. Mass Assignment & Attribute Tampering
+
+Attackers inject privileged or immutable properties into request bodies during entity creation (POST) or update (PUT/PATCH):
+
+### High-Risk Attribute Injection Matrix
+
+| Target Entity | Injected Attack Attributes | Impact |
+|---|---|---|
+| User Profile | `{"role": "admin", "isAdmin": true, "permissions": ["*"]}` | Privilege escalation to system administrator. |
+| Order / Checkout | `{"total_price": 0.01, "currency": "USD", "is_paid": true}` | Financial tampering and unauthorized checkout. |
+| Account / Tenant | `{"verified": true, "plan": "enterprise", "quota": 999999}` | Subscription and feature gate bypass. |
+| Ownership Binding | `{"user_id": "other_uuid", "tenant_id": "victim_org"}` | Hijacking entity association. |
+
+### Test Procedure
+1. Inspect endpoint schema and take factual inventory of allowed properties.
+2. Submit mutation payload containing extra privileged attributes.
+3. Inspect whether backend accepts the payload (200 OK) and persists the modified attributes in subsequent reads.
+
+**Remediation Rule**:
+Enforce explicit Data Transfer Object (DTO) allowlists (e.g. Zod, Pydantic, Laravel FormRequests). Never pass raw request payloads directly to ORM persistence methods (`Model.create(req.body)`).
+
+---
+
+## 3. Broken Function Level Authorization (BFLA)
+
+Verify whether administrative or management routes can be called by ordinary non-privileged users:
+
+1. Identify administrative endpoints (`/api/admin/*`, `/api/v1/users/delete`, `/api/manage/*`).
+2. Dispatch requests using the credentials of a standard user role.
+3. If the server returns `200 OK` or `204 No Content`, flag as **CRITICAL BFLA**. Expected response is strictly `403 Forbidden`.
+
+---
+
+## 4. Token & JWT Tampering
+
+For endpoints utilizing JSON Web Tokens (JWT) for authentication:
+
+| Test Case | Attack Vector | Expected Defense |
+|---|---|---|
+| Alg "None" Bypass | Change JWT header `{"alg": "none"}` and strip the signature portion. | Reject with 401 Unauthorized. |
+| Expired Token Replay | Replay token past its `exp` timestamp. | Reject with 401 Unauthorized. |
+| Secret Brute-force / Weak Keys | Verify whether JWT signing secret is weak (e.g. `secret`, `123456`). | Fail audit if signed with dictionary secret. |
+| Signature Stripping | Send JWT with `header.payload.` (trailing dot with empty signature). | Reject with 401 Unauthorized. |
+

package/.agents/plugins/agentic-senior-core/skills/asc-pentest/references/dast-baseline.md

@@ -0,0 +1,78 @@
+# Baseline Dynamic Application Security Testing (DAST)
+
+Standardized operational guidelines for scanning running web applications and APIs for fundamental infrastructure and configuration vulnerabilities.
+
+---
+
+## 1. Security Headers Audit
+
+For any web application serving HTML or JSON endpoints, probe the root (`/`) and primary API routes (`/api/`) and verify the presence and configuration of essential defense-in-depth headers:
+
+| Header | Expected Standard | Risk if Missing / Misconfigured |
+|---|---|---|
+| **`Content-Security-Policy`** | Restrictive script/object sources (`default-src 'self'; script-src 'self' ...`). Never permit `unsafe-inline` or wildcard `*` without nonces/hashes. | Unrestricted Cross-Site Scripting (XSS) and data exfiltration. |
+| **`X-Content-Type-Options`** | Strictly `nosniff`. | MIME-type confusion attacks where user-uploaded files are executed as scripts. |
+| **`Strict-Transport-Security`** | `max-age=31536000; includeSubDomains` (on HTTPS environments). | SSL stripping and man-in-the-middle downgrade attacks. |
+| **`X-Frame-Options`** | `DENY` or `SAMEORIGIN` (or CSP `frame-ancestors 'none'`). | Clickjacking attacks framing the application inside malicious host pages. |
+| **`Referrer-Policy`** | `strict-origin-when-cross-origin` or `no-referrer`. | PII or authorization tokens leaking in HTTP `Referer` headers to third-party endpoints. |
+
+### Header Probe Command
+```bash
+curl -I -s -X GET "http://localhost:3000/" | grep -iE "(content-security-policy|x-content-type|strict-transport|x-frame|referrer-policy)"
+```
+
+---
+
+## 2. CORS Misconfiguration Probing
+
+Verify that the backend does not echo arbitrary user-controlled origins while granting credential access:
+
+### Test Case: Dynamic Origin Echo
+Send a request with a hostile origin header:
+```bash
+curl -s -I -H "Origin: https://attacker.example.com" \
+  -H "Access-Control-Request-Method: GET" \
+  -X OPTIONS "http://localhost:3000/api/user/profile"
+```
+
+**Evaluate Response**:
+- **CRITICAL Vulnerability**:
+  `Access-Control-Allow-Origin: https://attacker.example.com` **AND** `Access-Control-Allow-Credentials: true`.
+  *Impact*: Malicious websites can read private user data via cross-origin `fetch` with browser cookies.
+- **Secure Behavior**:
+  No `Access-Control-Allow-Origin` header returned, or fixed whitelist match only (e.g. `http://localhost:3000`).
+
+---
+
+## 3. Open Redirect Probing
+
+Test all authentication and navigation endpoints that accept redirection query parameters (e.g. `?redirect=`, `?next=`, `?return_to=`, `?url=`):
+
+| Attack Vector | Payload Sample | Intent |
+|---|---|---|
+| Protocol-Relative URL | `//evil.com/phish` | Bypasses basic `http(s)://` string prefix filters. |
+| Backslash Obfuscation | `/\\evil.com` or `/\evil.com` | Browser treats as hostname on some platforms. |
+| URL Encoding Bypass | `%2F%2Fevil.com` | Double-decode vulnerabilities in routing handlers. |
+| Dot-Dot Slash Escape | `/redirect?url=https://legit.com@evil.com` | Exploits naive authority parsing. |
+
+**Remediation Standard**:
+Always validate redirects against a strict relative-path check (`target.startsWith('/') && !target.startsWith('//') && !target.startsWith('/\\')`) or an absolute origin whitelist.
+
+---
+
+## 4. Information Disclosure & Unhandled Sinks
+
+Probe application endpoints for stack trace exposure or sensitive metadata leakage:
+
+1. **Trigger Malformed HTTP Requests**:
+   - Send malformed JSON (`{"id": }`) to POST/PUT routes.
+   - Send unexpected data types (`/api/users/abc` where integer ID is expected).
+   - Check if response status 500 returns internal stack traces, database queries, framework versions, or file paths.
+2. **Sensitive Asset Probing (Development Residuals)**:
+   - Check if `.env`, `.git/HEAD`, or development build artifacts are accessible over HTTP:
+     ```bash
+     curl -s -o /dev/null -w "%{http_code}" "http://localhost:3000/.env"
+     curl -s -o /dev/null -w "%{http_code}" "http://localhost:3000/.git/HEAD"
+     ```
+   - Any status `200 OK` indicates a critical misconfiguration requiring immediate web server blocking.
+

package/.agents/plugins/agentic-senior-core/skills/asc-pentest/references/fuzzing-dsl.md

@@ -0,0 +1,66 @@
+# Request Mutation & Boundary Fuzzing DSL
+
+Derived directly from the rule DSL of **ProjectDiscovery Nuclei** (`pkg/fuzz/fuzz.go`) and the AST mutation engine of **Schemathesis** (`specs/openapi/negative/mutations.py`).
+
+---
+
+## 1. Multi-Part Mutation Taxonomy
+
+When fuzzing API endpoints and web services, payloads are injected across five distinct request segments using four mutation operators:
+
+### Mutation Placement Types (`pkg/fuzz/fuzz.go:12-24`)
+- **`replace`**: Replaces the original parameter value entirely with the fuzz payload.
+- **`prefix`**: Prepends the fuzz payload to the beginning of the legitimate parameter value (`payload + original`).
+- **`postfix`**: Appends the fuzz payload to the end of the legitimate parameter value (`original + payload`).
+- **`infix`**: Injects the fuzz payload into the middle of delimited parameter values (e.g. inside path segments or CSV values).
+
+### Request Part Targets
+1. **`query`**: URL query parameters (`?id=FUZZ&filter=FUZZ`).
+2. **`body`**: JSON keys, XML tags, or multipart form fields.
+3. **`header`**: HTTP request headers (`User-Agent`, `X-Forwarded-For`, `Authorization`).
+4. **`path`**: Dynamic route path parameters (`/api/v1/users/{id}`).
+5. **`cookie`**: Session identifiers and state cookies.
+
+---
+
+## 2. Canary-Safe Fuzzing Payloads
+
+All dynamic injection tests must use non-destructive canary strings. Never inject destructive SQL drop commands or system shutdown calls:
+
+### 2.1 SQL Injection Boundary Canary
+- `replace`: `' OR '1'='1`
+- `postfix`: `' OR 1=1--`
+- `postfix`: `" OR ""="`
+- *Oracle (Detection Criteria)*: Response returns records not belonging to the query scope, or database syntax error message is returned in the response body.
+
+### 2.2 Command Injection Delimiter Canary
+- `postfix`: `; echo ASC_CANARY_PROBE`
+- `postfix`: `| echo ASC_CANARY_PROBE`
+- `postfix`: `$(echo ASC_CANARY_PROBE)`
+- *Oracle (Detection Criteria)*: String `ASC_CANARY_PROBE` appears reflected unescaped in response output or execution log.
+
+### 2.3 Path Traversal Canary
+- `replace`: `../../../../etc/passwd`
+- `replace`: `..\..\..\windows\win.ini`
+- `replace`: `....//....//....//etc/passwd` (filter bypass)
+- *Oracle (Detection Criteria)*: Contents match `root:x:0:0` or `[fonts]`.
+
+### 2.4 Generative Boundary Fuzzing (Denial-of-Service / Crash Probing)
+- **Null Byte Injection**: `canary\0probe` (tests C-string termination bugs in native file/path handlers).
+- **Extreme Integer Overflow**: `9007199254740993` ($2^{53}+1$), `-1`, `2147483648` ($2^{31}$).
+- **Deeply Nested JSON Object**: `{"a":{"a":{"a":{"a": ... }}}}` (depth 100, tests parser stack exhaustion).
+- **Excessive String Payload**: String of $100,000$ random alphanumeric characters (tests memory allocation limits and regex catastrophic backtracking / ReDoS).
+
+---
+
+## 3. The Failure Oracle (Crash & Error Triage)
+
+When fuzzing an endpoint, every server response is categorized against three automated oracles:
+
+| Oracle Condition | Category | Severity | Remediation |
+|---|---|---|---|
+| Response status `500 Internal Server Error` with stack trace or unhandled exception. | Server Crash / Unhandled Sink | HIGH | Catch exception; return structured RFC 9457 error with HTTP 400 Bad Request. |
+| Server hangs / request times out after $> 5000\text{ms}$ on malformed input. | ReDoS / Resource Starvation | HIGH | Set parser size limits; optimize non-backtracking regex (e.g. `re2`). |
+| Injected canary string executed or private peer data returned. | Arbitrary Execution / Auth Bypass | CRITICAL | Parameterize query; enforce authorization policy boundary. |
+| Server responds with HTTP `400 Bad Request` or `422 Unprocessable Entity` with safe JSON error. | Resilient Validation | PASS | Input boundary properly enforced. |
+