@xgent-ai/skills 0.3.0 → 0.4.0

package/skills/review-prd-dev-gaps/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "PRD 开发差异核查"
+  short_description: "核对 PRD、完成计划与实际交付，分流遗漏、合理变更和用户决策，按需生成 gaps plan"
+  default_prompt: "使用 $review-prd-dev-gaps 核对指定 PRD 与已完成开发计划，追读里程碑记录并核实实际实现，保存三类差异报告；交互确认需 Triage 的差异，有 follow-up 时调用 dev-plan 创建 gaps plan。"

package/skills/review-prd-dev-gaps/references/report-contract.md

@@ -0,0 +1,72 @@
+# 差异报告与交接合同
+
+## 落盘
+
+- 默认将完整 Markdown 报告保存到用户指定路径；未指定时放在原开发计划旁，命名为 `<原计划名>.prd-dev-gaps.md`。仅有远程/聊天输入时，遵循仓库报告目录惯例，无惯例则用 `docs/reviews/<主题>.prd-dev-gaps.md`。
+- 按需建目录。已授权更新本报告时就地更新；否则同名文件存在则用日期后缀、再用递增序号，保留旧文件并告知实际路径。不得覆盖输入文档。
+- Triage 前先保存已有核查结果和待决问题；回答到达后在同一报告更新决策和去向，计划交付后补真实链接。恢复会话时先读报告、确认基线与已有决定，避免重复询问。
+- 用户明确仅聊天/不写文件时在聊天中交付完整内容，该限制同时传给 `dev-plan`。工具不能写入或写入失败时说明「未落盘」及原因，保留完整内容和未完成项，不链接不存在的文件。
+
+## 报告结构
+
+### 1. 结论与范围
+
+写明审查阶段、整体覆盖情况、A/B/C 数量、C 中已决/待决数量、证据不足数量、需跟进数量。无某类写 0；数量按独立 G-ID 统计，不能把需求数、差异数和任务数混算。
+
+整体结论可并列「存在明确遗漏」「存在合理变更」「待用户决策」「待补证」。只有范围内需求逐项核实且无缺口时，才能说在注明的基线和证据范围内已覆盖；报告完成与产品交付完成分开表述。
+
+### 2. 三类差异
+
+按 A 明确遗漏、B 合理变更、C 需 Triage 分组；组内按用户影响与依赖优先，无需机械打分。每项保留：
+
+```markdown
+#### G-01 · <具体差异> · <A/B/C>
+- PRD 期望：<需求/验收 ID，文件与章节/行定位>
+- 实际交付：<触发条件、可观察行为、与期望的差别>
+- 证据链：<计划里程碑 → 完成记录 → 代码/测试/运行证据；缺失环节明说>
+- 影响：<角色、场景、后果、是否阻塞主路径/验收>
+- 分类依据：<为什么是本类；B 附约束、备选取舍、目标等价或批准依据>
+- 处置：<补齐/保留/替代/延期/豁免/待决；关联 D-ID>
+- Follow-up：<最小增量及可观察验收，或无动作理由；后续计划任务定位>
+```
+
+只引用亲自读过的段落、代码符号和实际证据；短行定位或稳定标题可点击跳转。文档中互相冲突的主张同时列出处，不能选择方便的版本当真。去重不丢掉受影响的需求与场景。
+
+### 3. 完整需求覆盖账本
+
+| PRD 需求/验收及定位 | 本期范围/已批准变更 | 计划与里程碑 | 完成记录 | 实际行为与证据等级 | 覆盖状态 | G-ID/去向 |
+| --- | --- | --- | --- | --- | --- | --- |
+
+覆盖状态使用「已满足 / 部分满足 / 未满足 / 已确认变更 / 范围外 / 未核实」。这是实现覆盖，不是差异分类。无计划落点的需求也必须保留该行；不可访问的材料写明不可访问，不填「无」暗示不存在。
+
+一条 PRD 可能拆为多个可验收条件，多条 PRD 也可能共享同一根因差异；保留双向关联。跨期需求记录本期边界、后续去向与最终验收，不用局部完成代表整体交付。
+
+### 4. Triage 与决策账本
+
+待决区保存主技能要求的问题卡，含期望、实际、原因、影响、选项及后果。已决区记录：
+
+| 决策 ID | 关联 G-ID | 用户选择与理由 | 确认日期与来源 | 新目标/验收边界 | 跟进/延期/豁免去向 |
+| --- | --- | --- | --- | --- | --- |
+
+未回答或明确稍后决定时不生成「已确认」条目。已有历史决定注明来源；新回答摘要必须保持原意。改变已有决定时标注替代关系，不能默默覆盖。
+
+### 5. 待核实项与审查基线
+
+- 列出每项缺失事实/材料、影响的需求与结论、补证方式以及是否阻塞分类、决策或计划；未知负责人/日期不编造。
+- 记录 PRD/计划/记录版本、代码仓 commit/dirty、日期、环境、实际审查范围及验证方式。只列影响结论的来源，不堆读取日志。
+- 历史测试、当前静态检查、本次实测、线上验证分别标注；完成记录与当前实现不一致时解释基线差异，无法解释则待核实。
+
+### 6. Follow-up 与 gaps plan
+
+| G-ID / D-ID / PRD ID | 确定的增量工作 | 验收条件 | 依赖/阻塞 | gaps plan 任务或排除去向 |
+| --- | --- | --- | --- | --- |
+
+报告保留问题和决策的完整依据；计划承接最终目标、增量实施和验收，通过来源链接关联，避免复制整份报告。记录计划实际路径与 `Ready / Proposed / Blocked` 状态，或无需计划的理由；技能缺失、待用户决定、写入失败等分别标明受阻环节，不能以清单代替声称完成的计划。
+
+## 交付前核对
+
+- PRD 每个范围内的需求/验收均有覆盖行；原计划漏项仍能被发现。
+- 三类判定有依据，未知不算遗漏，未经确认的产品降级不算合理变更。
+- 每个 C 有待决问题或明确决策，每个待核实项有补证办法。
+- 每个应跟进项有计划去向或具体阻塞；豁免、延期与无需动作有理由。
+- 报告和计划均已回读，链接、状态、范围与决策一致；未决项未混入 Ready 计划的实施假设。

package/skills/security-audit/SKILL.md

@@ -0,0 +1,191 @@
+---
+name: security-audit
+description: 'AI-powered codebase security scanner that reasons about code like a security researcher — tracing data flows, understanding component interactions, and catching vulnerabilities that pattern-matching tools miss. Use this skill when asked to scan code for security vulnerabilities, find bugs, check for SQL injection, XSS, command injection, exposed API keys, hardcoded secrets, insecure dependencies, access control issues, or any request like "is my code secure?", "review for security issues", "audit this codebase", or "check for vulnerabilities". Also use proactively for a security check of changed code before a commit or deployment — especially changes to auth, API, database, dependency, or config files. Covers the OWASP Top 10: injection flaws, authentication and access control bugs, secrets exposure, weak cryptography, security misconfiguration, insecure dependencies, and business logic issues across JavaScript, TypeScript, Python, Java, PHP, Go, Ruby, and Rust.'
+---
+
+# Security Review
+
+An AI-powered security scanner that reasons about your codebase the way a human security
+researcher would — tracing data flows, understanding component interactions, and catching
+vulnerabilities that pattern-matching tools miss.
+
+## When to Use This Skill
+
+Use this skill when the request involves:
+
+- Scanning a codebase or file for security vulnerabilities
+- Running a security review or vulnerability check
+- Checking changed code before a commit or deployment — especially auth, API, database,
+  dependency, or config changes
+- Checking for SQL injection, XSS, command injection, or other injection flaws
+- Finding exposed API keys, hardcoded secrets, or credentials in code
+- Auditing dependencies for known CVEs
+- Reviewing authentication, authorization, or access control logic
+- Detecting insecure cryptography or weak randomness
+- Performing a data flow analysis to trace user input to dangerous sinks
+- Any request phrasing like "is my code secure?", "scan this file", or "check my repo for vulnerabilities"
+- Running `/security-review` or `/security-review <path>`
+
+## How This Skill Works
+
+Unlike traditional static analysis tools that match patterns, this skill:
+1. **Reads code like a security researcher** — understanding context, intent, and data flow
+2. **Traces across files** — following how user input moves through your application
+3. **Self-verifies findings** — re-examines each result to filter false positives
+4. **Assigns severity ratings** — CRITICAL / HIGH / MEDIUM / LOW / INFO
+5. **Proposes targeted patches** — every finding includes a concrete fix
+6. **Requires human approval** — nothing is auto-applied; you always review first
+
+## Execution Workflow
+
+Follow these steps **in order** every time:
+
+### Step 1 — Scope Resolution
+Determine what to scan:
+- If a path was provided (`/security-review src/auth/`), scan only that scope
+- If the request is about changes (a diff, staged files, a pre-commit or pre-deploy check),
+  scope to the changed files (`git diff`, `git diff --staged`). Still read the surrounding code
+  they call into or are called from — a change is often only exploitable in context. Run
+  Step 2 only if a dependency manifest or lock file changed
+- If no path given, scan the **entire project** starting from the root
+- Identify the language(s) and framework(s) in use (check package.json, requirements.txt,
+  go.mod, Cargo.toml, pom.xml, Gemfile, composer.json, etc.)
+- Read `references/language-patterns.md` to load language-specific vulnerability patterns
+
+### Step 2 — Dependency Audit
+Before scanning source code, audit dependencies first (fast wins):
+- **Node.js**: Check `package.json` + `package-lock.json` for known vulnerable packages
+- **Python**: Check `requirements.txt` / `pyproject.toml` / `Pipfile`
+- **Java**: Check `pom.xml` / `build.gradle`
+- **Ruby**: Check `Gemfile.lock`
+- **Rust**: Check `Cargo.toml`
+- **Go**: Check `go.sum`
+- If available, run the ecosystem's audit tool (`npm audit`, `pip-audit`, or equivalent) — it
+  reflects current advisories. These tools need network access to the package registry; if
+  it's unavailable, fall back to the watchlist below and say the audit was offline
+- Flag packages with known CVEs, deprecated crypto libs, or suspiciously old pinned versions
+- Read `references/vulnerable-packages.md` for a curated watchlist
+
+### Step 3 — Secrets & Exposure Scan
+Scan ALL files in scope (including config, env, CI/CD, Dockerfiles, IaC) for:
+- Hardcoded API keys, tokens, passwords, private keys
+- `.env` files accidentally committed
+- Secrets in comments or debug logs
+- Cloud credentials (AWS, GCP, Azure, Stripe, Twilio, etc.)
+- Database connection strings with credentials embedded
+- Read `references/secret-patterns.md` for regex patterns and entropy heuristics to apply
+
+### Step 4 — Vulnerability Deep Scan
+This is the core scan. Reason about the code — don't just pattern-match.
+Read `references/vuln-categories.md` for full details on each category.
+
+**Injection Flaws**
+- SQL Injection: raw queries with string interpolation, ORM misuse, second-order SQLi
+- XSS: unescaped output, dangerouslySetInnerHTML, innerHTML, template injection
+- Command Injection: exec/spawn/system with user input
+- LDAP, XPath, Header, Log injection
+
+**Authentication & Access Control**
+- Missing authentication on sensitive endpoints
+- Broken object-level authorization (BOLA/IDOR)
+- JWT weaknesses (alg:none, weak secrets, no expiry validation)
+- Session fixation, missing CSRF protection
+- Session cookies missing `Secure` / `HttpOnly` / `SameSite`
+- Passwords stored in plaintext or with a fast hash; weak password policy; no MFA on
+  privileged accounts
+- Privilege escalation paths
+- Mass assignment / parameter pollution
+
+**Data Handling**
+- Sensitive data in logs, error messages, or API responses
+- Missing encryption at rest or in transit
+- Insecure deserialization
+- Path traversal / directory traversal
+- XXE (XML External Entity) processing
+- SSRF (Server-Side Request Forgery)
+
+**Cryptography**
+- Use of MD5, SHA1, DES for security purposes
+- Hardcoded IVs or salts
+- Weak random number generation (Math.random() for tokens)
+- Missing TLS certificate validation
+
+**Security Misconfiguration & Logging**
+- Permissive CORS, debug mode in production, missing security headers
+  (framework specifics in `references/language-patterns.md`)
+- Security events (failed logins, access-control denials, privilege changes) not logged,
+  leaving attacks undetectable
+
+**Business Logic**
+- Race conditions (TOCTOU)
+- Integer overflow in financial calculations
+- Missing rate limiting on sensitive endpoints
+- Predictable resource identifiers
+
+### Step 5 — Cross-File Data Flow Analysis
+After the per-file scan, perform a **holistic review**:
+- Trace user-controlled input from entry points (HTTP params, headers, body, file uploads)
+  all the way to sinks (DB queries, exec calls, HTML output, file writes)
+- Identify vulnerabilities that only appear when looking at multiple files together
+- Check for insecure trust boundaries between services or modules
+
+### Step 6 — Self-Verification Pass
+For EACH finding:
+1. Re-read the relevant code with fresh eyes
+2. Ask: "Is this actually exploitable, or is there sanitization I missed?"
+3. Check if a framework or middleware already handles this upstream
+4. Downgrade or discard findings that aren't genuine vulnerabilities
+5. Assign final severity: CRITICAL / HIGH / MEDIUM / LOW / INFO
+
+### Step 7 — Generate Security Report
+Output the full report in the format defined in `references/report-format.md`.
+For a snippet or diff scope, drop sections that don't apply (e.g. the dependency audit when
+no manifest changed) rather than filling them with zeros.
+
+### Step 8 — Propose Patches
+For every CRITICAL and HIGH finding, generate a concrete patch:
+- Show the vulnerable code (before)
+- Show the fixed code (after)
+- Explain what changed and why
+- Preserve the original code style, variable names, and structure
+- Add a comment explaining the fix inline
+
+Explicitly state: **"Review each patch before applying. Nothing has been changed yet."**
+
+## Severity Guide
+
+| Severity | Meaning | Example |
+|----------|---------|---------|
+| 🔴 CRITICAL | Immediate exploitation risk, data breach likely | SQLi, RCE, auth bypass |
+| 🟠 HIGH | Serious vulnerability, exploit path exists | XSS, IDOR, hardcoded secrets |
+| 🟡 MEDIUM | Exploitable with conditions or chaining | CSRF, open redirect, weak crypto |
+| 🔵 LOW | Best practice violation, low direct risk | Verbose errors, missing headers |
+| ⚪ INFO | Observation worth noting, not a vulnerability | Outdated dependency (no CVE) |
+
+## Output Rules
+
+- **Always** produce a findings summary table first (counts by severity)
+- **Never** auto-apply any patch — present patches for human review only
+- **Always** include a confidence rating per finding (High / Medium / Low)
+- **Group findings** by category, not by file
+- **Be specific** — include file path, line number, and the exact vulnerable code snippet
+- **Explain the risk** in plain English — what could an attacker do with this?
+- If the codebase is clean, say so clearly: "No vulnerabilities found" with what was scanned
+
+## Reference Files
+
+For detailed detection guidance, load the following reference files as needed:
+
+- `references/vuln-categories.md` — Deep reference for every vulnerability category with detection signals, safe patterns, and escalation checkers
+  - Search patterns: `SQL injection`, `XSS`, `command injection`, `SSRF`, `BOLA`, `IDOR`, `JWT`, `CSRF`, `secrets`, `cryptography`, `race condition`, `path traversal`
+- `references/secret-patterns.md` — Regex patterns, entropy-based detection, and CI/CD secret risks
+  - Search patterns: `API key`, `token`, `private key`, `connection string`, `entropy`, `.env`, `GitHub Actions`, `Docker`, `Terraform`
+- `references/language-patterns.md` — Framework-specific vulnerability patterns for JavaScript, Python, Java, PHP, Go, Ruby, and Rust
+  - Search patterns: `Express`, `React`, `Next.js`, `Django`, `Flask`, `FastAPI`, `Spring Boot`, `PHP`, `Go`, `Rails`, `Rust`
+- `references/vulnerable-packages.md` — Curated CVE watchlist for npm, pip, Maven, Rubygems, Cargo, and Go modules
+  - Search patterns: `lodash`, `axios`, `jsonwebtoken`, `Pillow`, `log4j`, `nokogiri`, `CVE`
+- `references/report-format.md` — Structured output template for security reports with finding cards, dependency audit, secrets scan, and patch proposal formatting
+  - Search patterns: `report`, `format`, `template`, `finding`, `patch`, `summary`, `confidence`
+
+External references for each finding's Reference line:
+[OWASP Top 10](https://owasp.org/www-project-top-ten/), [CWE Top 25](https://cwe.mitre.org/top25/)

package/skills/security-audit/references/language-patterns.md

@@ -0,0 +1,221 @@
+# Language-Specific Vulnerability Patterns
+
+Load the relevant section during Step 1 (Scope Resolution) after identifying languages.
+
+---
+
+## JavaScript / TypeScript (Node.js, React, Next.js, Express)
+
+### Critical APIs/calls to flag
+```js
+eval()                    // arbitrary code execution
+Function('return ...')   // same as eval
+child_process.exec()     // command injection if user input reaches it
+fs.readFile              // path traversal if user controls path
+fs.writeFile             // path traversal if user controls path
+```
+
+### Express.js specific
+```js
+// Missing helmet (security headers)
+const app = express()
+// Should have: app.use(helmet())
+
+// Body size limits missing (DoS)
+app.use(express.json())
+// Should have: app.use(express.json({ limit: '10kb' }))
+
+// CORS misconfiguration
+app.use(cors({ origin: '*' }))  // too permissive
+app.use(cors({ origin: req.headers.origin }))  // reflects any origin
+
+// Trust proxy without validation
+app.set('trust proxy', true)  // only safe behind known proxy
+```
+
+### React specific
+```jsx
+<div dangerouslySetInnerHTML={{ __html: userContent }} />  // XSS
+<a href={userUrl}>link</a>  // javascript: URL injection
+```
+
+### Next.js specific
+```js
+// Server Actions without auth
+export async function deleteUser(id) {   // missing: auth check
+  await db.users.delete(id)
+}
+
+// API Routes missing method validation
+export default function handler(req, res) {
+  // Should check: if (req.method !== 'POST') return res.status(405)
+  doSensitiveAction()
+}
+```
+
+---
+
+## Python (Django, Flask, FastAPI)
+
+### Django specific
+```python
+# Raw SQL
+User.objects.raw(f"SELECT * FROM users WHERE name = '{name}'")  # SQLi
+
+# Missing CSRF
+@csrf_exempt  # Only OK for APIs with token auth
+
+# Debug mode in production
+DEBUG = True  # in settings.py — exposes stack traces
+
+# SECRET_KEY
+SECRET_KEY = 'django-insecure-...'  # must be changed for production
+
+# ALLOWED_HOSTS
+ALLOWED_HOSTS = ['*']  # too permissive
+```
+
+### Flask specific
+```python
+# Debug mode
+app.run(debug=True)  # never in production
+
+# Secret key
+app.secret_key = 'dev'  # weak
+
+# eval/exec with user input
+eval(request.args.get('expr'))
+
+# render_template_string with user input (SSTI)
+render_template_string(f"Hello {name}")  # Server-Side Template Injection
+```
+
+### FastAPI specific
+```python
+# Missing auth dependency
+@app.delete("/users/{user_id}")  # No Depends(get_current_user)
+async def delete_user(user_id: int):
+    ...
+
+# Arbitrary file read
+@app.get("/files/{filename}")
+async def read_file(filename: str):
+    return FileResponse(f"uploads/{filename}")  # path traversal
+```
+
+---
+
+## Java (Spring Boot)
+
+### Spring Boot specific
+```java
+// SQL Injection
+String query = "SELECT * FROM users WHERE name = '" + name + "'";
+jdbcTemplate.query(query, ...);
+
+// XXE
+DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+// Missing: dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true)
+
+// Deserialization
+ObjectInputStream ois = new ObjectInputStream(inputStream);
+Object obj = ois.readObject();  // only safe with allowlist
+
+// Spring Security — permitAll on sensitive endpoint
+.antMatchers("/admin/**").permitAll()
+
+// Actuator endpoints exposed
+management.endpoints.web.exposure.include=*  # in application.properties
+```
+
+---
+
+## PHP
+
+```php
+// Direct user input in queries
+$result = mysql_query("SELECT * FROM users WHERE id = " . $_GET['id']);
+
+// File inclusion
+include($_GET['page'] . ".php");  // local/remote file inclusion
+
+// eval
+eval($_POST['code']);
+
+// extract() with user input
+extract($_POST);  // overwrites any variable
+
+// Loose comparison
+if ($password == "admin") {}  // use === instead
+
+// Unserialize
+unserialize($_COOKIE['data']);  // remote code execution
+```
+
+---
+
+## Go
+
+```go
+// Command injection
+exec.Command("sh", "-c", userInput)
+
+// SQL injection
+db.Query("SELECT * FROM users WHERE name = '" + name + "'")
+
+// Path traversal
+filePath := filepath.Join("/uploads/", userInput)  // sanitize userInput first
+
+// Insecure TLS
+http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
+
+// Goroutine leak / missing context cancellation
+go func() {
+  // No done channel or context
+  for { ... }
+}()
+```
+
+---
+
+## Ruby on Rails
+
+```ruby
+# SQL injection (safe alternatives use placeholders)
+User.where("name = '#{params[:name]}'")  # VULNERABLE
+User.where("name = ?", params[:name])   # SAFE
+
+# Mass assignment without strong params
+@user.update(params[:user])  # should be params.require(:user).permit(...)
+
+# eval / send with user input
+eval(params[:code])
+send(params[:method])  # arbitrary method call
+
+# Redirect to user-supplied URL (open redirect)
+redirect_to params[:url]
+
+# YAML.load (allows arbitrary object creation)
+YAML.load(user_input)  # use YAML.safe_load instead
+```
+
+---
+
+## Rust
+
+```rust
+// Unsafe blocks — flag for manual review
+unsafe {
+    // Reason for unsafety should be documented
+}
+
+// Integer overflow (debug builds panic, release silently wraps)
+let result = a + b;  // use checked_add/saturating_add for financial math
+
+// Unwrap/expect in production code (panics on None/Err)
+let value = option.unwrap();  // prefer ? or match
+
+// Deserializing arbitrary types
+serde_json::from_str::<serde_json::Value>(&user_input)  // generally safe
+// But: bincode::deserialize from untrusted input — can be exploited
+```

package/skills/security-audit/references/report-format.md

@@ -0,0 +1,194 @@
+# Security Report Format
+
+Use this template for all `/security-review` output. Generated during Step 7.
+
+---
+
+## Report Structure
+
+### Header
+```
+╔══════════════════════════════════════════════════════════╗
+║           🔐 SECURITY REVIEW REPORT                     ║
+║           Generated by: /security-review skill          ║
+╚══════════════════════════════════════════════════════════╝
+
+Project: <project name or path>
+Scan Date: <today's date>
+Scope: <files/directories scanned>
+Languages Detected: <list>
+Frameworks Detected: <list>
+```
+
+---
+
+### Executive Summary Table
+
+Always show this first — at a glance overview:
+
+```
+┌────────────────────────────────────────────────┐
+│           FINDINGS SUMMARY                     │
+├──────────────┬──────────────────────────────── ┤
+│ 🔴 CRITICAL  │  <n> findings                  │
+│ 🟠 HIGH      │  <n> findings                  │
+│ 🟡 MEDIUM    │  <n> findings                  │
+│ 🔵 LOW       │  <n> findings                  │
+│ ⚪ INFO      │  <n> findings                  │
+├──────────────┼─────────────────────────────────┤
+│ TOTAL        │  <n> findings                  │
+└──────────────┴─────────────────────────────────┘
+
+Dependency Audit: <n> vulnerable packages found
+Secrets Scan: <n> exposed credentials found
+```
+
+---
+
+### Findings (Grouped by Category)
+
+For EACH finding, use this card format:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+[SEVERITY EMOJI] [SEVERITY] — [VULNERABILITY TYPE]
+Confidence: HIGH / MEDIUM / LOW
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📍 Location:  src/routes/users.js, Line 47
+
+🔍 Vulnerable Code:
+  const query = `SELECT * FROM users WHERE id = ${req.params.id}`;
+  db.execute(query);
+
+⚠️  Risk:
+  An attacker can manipulate the `id` parameter to execute arbitrary
+  SQL commands, potentially dumping the entire database, bypassing
+  authentication, or deleting data.
+
+  Example attack: GET /users/1 OR 1=1--
+
+✅ Recommended Fix:
+  Use parameterized queries:
+
+  const query = 'SELECT * FROM users WHERE id = ?';
+  db.execute(query, [req.params.id]);
+
+📚 Reference: OWASP A03:2021 – Injection
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+### Dependency Audit Section
+
+```
+📦 DEPENDENCY AUDIT
+══════════════════
+
+🟠 HIGH — lodash@4.17.20 (package.json)
+  CVE-2021-23337: Prototype pollution via zipObjectDeep()
+  Fix: npm install lodash@4.17.21
+
+🟡 MEDIUM — axios@0.27.2 (package.json)
+  CVE-2023-45857: CSRF via withCredentials
+  Fix: npm install axios@1.6.0
+
+⚪ INFO — express@4.18.2
+  No known CVEs. Current version is 4.19.2 — consider updating.
+```
+
+---
+
+### Secrets Scan Section
+
+```
+🔑 SECRETS & EXPOSURE SCAN
+═══════════════════════════
+
+🔴 CRITICAL — Hardcoded API Key
+  File: src/config/database.js, Line 12
+  
+  Found: STRIPE_SECRET_KEY = "sk_live_FAKE_KEY_..."
+  
+  Action Required:
+  1. Rotate this key IMMEDIATELY at https://dashboard.stripe.com
+  2. Remove from source code
+  3. Add to .env file and load via process.env.STRIPE_SECRET_KEY
+  4. Add .env to .gitignore
+  5. Audit git history — key may be in previous commits:
+     git log --all -p | grep "sk_live_"
+     Use git-filter-repo or BFG to purge from history if found.
+```
+
+---
+
+### Patch Proposals Section
+
+Only include for CRITICAL and HIGH findings:
+
+````
+🛠️  PATCH PROPOSALS
+══════════════════
+⚠️  REVIEW EACH PATCH BEFORE APPLYING — Nothing has been changed yet.
+
+─────────────────────────────────────────────
+Patch 1/3: SQL Injection in src/routes/users.js
+─────────────────────────────────────────────
+
+BEFORE (vulnerable):
+```js
+// Line 47
+const query = `SELECT * FROM users WHERE id = ${req.params.id}`;
+db.execute(query);
+```
+
+AFTER (fixed):
+```js
+// Line 47 — Fixed: Use parameterized query to prevent SQL injection
+const query = 'SELECT * FROM users WHERE id = ?';
+db.execute(query, [req.params.id]);
+```
+
+Apply this patch? (Review first — AI-generated patches may need adjustment)
+─────────────────────────────────────────────
+````
+
+---
+
+### Footer
+
+```
+══════════════════════════════════════════════════════════
+
+📋 SCAN COVERAGE
+  Files scanned:     <n>
+  Lines analyzed:    <n>
+  Scan duration:     <time>
+
+⚡ NEXT STEPS
+  1. Address all CRITICAL findings immediately
+  2. Schedule HIGH findings for current sprint
+  3. Add MEDIUM/LOW to your security backlog
+  4. Set up automated re-scanning in CI/CD pipelines
+
+💡 NOTE: This is a static analysis scan. It does not execute your
+   application and cannot detect all runtime vulnerabilities. Pair
+   with dynamic testing (DAST) for comprehensive coverage.
+
+══════════════════════════════════════════════════════════
+```
+
+---
+
+## Confidence Ratings Guide
+
+Apply to every finding:
+
+| Confidence | When to Use |
+|------------|-------------|
+| **HIGH** | Vulnerability is unambiguous. Sanitization is clearly absent. Exploitable as-is. |
+| **MEDIUM** | Vulnerability likely exists but depends on runtime context, config, or call path the agent couldn't fully trace. |
+| **LOW** | Suspicious pattern detected but could be a false positive. Flag for human review. |
+
+Never omit confidence — it helps developers prioritize their review effort.