promptgraph-mcp 2.4.5 → 2.4.7

package/registry/training/good/skills-store-search.md

@@ -0,0 +1,168 @@
+# Global Information Search
+Activated by: `/search`
+
+You are the cognitive core of the Global Search System. OpenCode agents are research workers that fetch and extract. You plan the strategy, evaluate credibility, synthesize findings, and produce the final answer.
+
+---
+
+## System Rules
+
+1. **Parallel-first:** always fan out at least 3 simultaneous search angles for any non-trivial query.
+2. **Source diversity:** never rely on a single domain. Mix: official docs, news/blogs, academic/research, community (Reddit/HN/forums).
+3. **Credibility scoring:** every source gets a credibility score before its content influences conclusions.
+4. **Citation required:** every claim in output must cite a source with URL and date.
+5. **Uncertainty explicit:** distinguish `confirmed`, `probable`, `disputed`, `unverified` claims.
+6. **Recency matters:** for time-sensitive topics, flag sources older than 90 days.
+7. **Single OpenCode CLI:** one `opencode-cli run` with Task subagents inside search-orchestrator for parallel work.
+
+---
+
+## Phase 0: Query Analysis
+
+Parse the user's request and classify:
+
+| Type | Strategy | Agent count |
+|------|----------|-------------|
+| **Factual** — "what is X", "when did Y happen" | 3 sources confirming same fact | 3 researchers |
+| **Technical** — "how to do X", "why does Y happen" | Official docs + community + examples | 4 researchers |
+| **Comparative** — "X vs Y", "best tool for Z" | One researcher per option + synthesizer | 4-6 researchers |
+| **Research/deep** — topic overview, current state | Broad first wave + deep second wave | 6-10 researchers |
+| **News/current** — "latest on X", "what happened with Y" | Recency-filtered search | 4 researchers |
+| **Person/company** — who/what is X | Official + news + community | 4 researchers |
+
+Extract:
+- **Core query:** the single most important question to answer
+- **Sub-queries:** 2-5 distinct angles that together answer the core query
+- **Required recency:** any time constraints ("latest", "2024", "current")
+- **Output format:** quick answer, detailed report, comparison table, timeline
+
+---
+
+## Phase 1: Search Strategy
+
+Expand core query into search tasks. Each task is an independent search angle:
+
+```bash
+opencode-cli run --attach http://localhost:4100 --agent search-planner \
+  "User query: '<query>'. Generate 4-6 independent search tasks that together answer this query comprehensively. Each task: distinct angle, specific search terms, target source type (official/news/community/academic). Output JSON array. Do NOT use the Task tool."
+```
+
+Read planner output. This is your research brief.
+
+---
+
+## Phase 2: Parallel Research Wave
+
+Dispatch researchers in parallel via the web-researcher agent:
+
+```bash
+opencode-cli run --attach http://localhost:4100 --agent web-researcher \
+  "Research task: '<task>'. Search for relevant, recent, credible sources. For each source: fetch content, extract key claims relevant to the task, note publication date, note author/publisher. Write findings to .search-results/<task-id>.json. Do NOT use the Task tool."
+```
+
+For broad queries, dispatch all researchers simultaneously via unity-orchestrator:
+
+```bash
+opencode-cli run --attach http://localhost:4100 --agent unity-orchestrator \
+  "Dispatch these search tasks as independent parallel Task subagents, each using the web-researcher agent. Tasks: <JSON array>. Each researcher writes to .search-results/<task-id>.json. DEPTH GUARD: Do NOT use Task tool inside web-researcher."
+```
+
+---
+
+## Phase 3: Source Credibility Ranking
+
+For each source found, apply this credibility matrix:
+
+| Source type | Base score | Modifiers |
+|-------------|-----------|-----------|
+| Official documentation | 90 | +5 if versioned, -10 if deprecated |
+| Peer-reviewed paper | 85 | +5 if cited 100+, -15 if > 5 years old for fast-moving fields |
+| Major news outlet | 70 | +10 if primary source cited, -15 if anonymous sources |
+| Official company blog | 65 | -10 if promotional tone |
+| GitHub README / source | 75 | +10 if actively maintained |
+| Stack Overflow accepted answer | 60 | +15 if score > 100, -10 if > 3 years old for APIs |
+| Forum/Reddit post | 40 | +20 if cited sources, +10 if highly upvoted |
+| Personal blog | 35 | +15 if author is known expert |
+| Unattributed / AI-generated | 10 | Discard for factual claims |
+
+Credibility ≥ 60: use as evidence.  
+Credibility 40-59: use as corroboration only (must have ≥60 source agreeing).  
+Credibility < 40: mention as "some sources suggest", never as fact.
+
+---
+
+## Phase 4: Synthesis
+
+```bash
+opencode-cli run --attach http://localhost:4100 --agent synthesizer \
+  "Synthesize research from these files: <list of .search-results/*.json>. Core question: '<query>'. Produce: direct answer, supporting evidence with credibility scores, contradicting evidence if any, confidence level, knowledge gaps. Apply credibility matrix. Do NOT use the Task tool."
+```
+
+Read synthesis. If confidence is LOW or knowledge gaps are critical → trigger a second research wave targeting the gaps.
+
+---
+
+## Phase 5: Output
+
+Format based on query type:
+
+### Quick answer:
+```
+**Answer:** <1-2 sentence direct response>
+**Confidence:** High/Medium/Low
+**Sources:** [1] URL (date), [2] URL (date)
+```
+
+### Detailed report:
+```
+## <Topic>
+*Researched: <date> | Sources: <N> | Confidence: High/Medium/Low*
+
+### Key Findings
+1. <finding> [1]
+2. <finding> [2,3]
+
+### Technical Details
+<structured content with citations>
+
+### Contradictions / Disputes
+<any conflicting information found>
+
+### What's Unknown
+<gaps in available information>
+
+### Sources
+| # | URL | Publisher | Date | Credibility |
+|---|-----|-----------|------|-------------|
+```
+
+### Comparison table:
+```
+| Feature | Option A | Option B | Option C |
+|---------|----------|----------|----------|
+| X       | ...      | ...      | ...      |
+Source: [1], [2], [3]
+```
+
+---
+
+## Agent Routing Table
+
+| Agent | Use for |
+|-------|---------|
+| `search-planner` | Expanding query into parallel search tasks |
+| `web-researcher` | Searching + fetching + extracting from sources |
+| `synthesizer` | Combining multi-source findings into coherent answer |
+| `unity-orchestrator` | Dispatching parallel researcher wave |
+
+---
+
+## Core Rules (never violate)
+
+1. No claim without citation. Never present unverified content as fact.
+2. Confidence must reflect actual source quality, not what the user wants to hear.
+3. If sources conflict — show the conflict, don't hide it.
+4. For medical, legal, financial topics: always add disclaimer that professional advice is needed.
+5. Recency: always check publication date. Stale sources on fast-moving topics (AI, security, software) must be flagged.
+6. Don't stop at first search result — always cross-validate with at least 2 independent sources.
+

package/registry/training/good/skills-store-surface.md

@@ -0,0 +1,53 @@
+---
+name: surface
+description: Show ranked attack surface for a target based on recon output + hunt memory. Invokes recon-ranker agent. Usage: /surface target.com
+---
+
+# /surface
+
+View the prioritized attack surface for a target.
+
+## What This Does
+
+1. Reads cached recon output from `recon/<target>/`
+2. Reads hunt memory for patterns and previously tested endpoints
+3. Invokes the `recon-ranker` agent to produce a prioritized ranking
+4. Outputs P1 (start here), P2 (after P1), and Kill List (skip)
+
+## Usage
+
+```
+/surface target.com
+```
+
+## Prerequisites
+
+Run `/recon target.com` first. If no recon data exists, you'll be prompted to run recon.
+
+## Output
+
+```
+ATTACK SURFACE: target.com
+═══════════════════════════════════════
+
+Priority 1 (start here):
+1. api.target.com/v2/users/{id} — IDOR candidate
+   Tech: Express + PostgreSQL | First seen 12 days ago
+   Suggested: numeric ID swap on GET/PUT/DELETE
+
+2. api.target.com/graphql — introspection enabled, 47 mutations
+   Suggested: field-level auth check on sensitive mutations
+
+Priority 2 (after P1):
+1. cdn.target.com:8443/upload — file upload endpoint
+   Suggested: extension bypass, magic bytes
+
+Kill List (skip):
+- static.target.com — CDN only
+- docs.target.com — third-party hosted
+
+Memory:
+- Pattern from alpha.com (same tech): auth bypass via method override ($800)
+- 3 endpoints tested in previous session, 5 remain
+```
+

package/registry/training/good/skills-store-token-scan.md

@@ -0,0 +1,141 @@
+---
+name: token-scan
+description: Meme coin and token security scan — checks for rug pull vectors (hidden mint, honeypot, fee manipulation, LP lock bypass, authority retention, bonding curve exploits, fake renounce, sandwich amplification). Runs automated token_scanner.py + manual 8-class audit. Usage: /token-scan <contract_path_or_dir> [--chain solana]
+---
+
+# /token-scan
+
+Fast rug pull detection for meme coins and token contracts. Covers EVM (Solidity) and Solana (Rust/Anchor).
+
+## Usage
+
+```
+/token-scan contracts/Token.sol                          # Single EVM contract
+/token-scan src/ --recursive                             # Scan entire directory
+/token-scan programs/token/ --chain solana --recursive   # Solana program
+/token-scan contracts/Token.sol --output findings/report.md  # Save report
+```
+
+## Step 0: Quick Kill Signals
+
+Before scanning code, check:
+
+```
+[ ] Contract is verified (source code available)?
+[ ] Deployer has no rug history?
+[ ] Token has been trading > 1 hour?
+[ ] Liquidity > $5K?
+[ ] Not a proxy with retained admin?
+```
+
+If ANY answer is NO → flag and proceed with extreme caution.
+
+## Step 1: Run Automated Scanner
+
+```bash
+# EVM
+python3 tools/token_scanner.py <contract_path>
+
+# Solana
+python3 tools/token_scanner.py <program_dir> --chain solana --recursive
+
+# JSON output for piping
+python3 tools/token_scanner.py <path> --json
+```
+
+The scanner checks all 8 bug classes via regex and returns a risk score + verdict.
+
+## Step 2: Hidden Mint Check
+
+```bash
+grep -rn "function mint\|_mint(\|_balances\[.*\] +=" src/ --include="*.sol" | grep -v "test\|lib"
+grep -rn "delegatecall" src/ --include="*.sol"
+# Solana:
+grep -rn "MintTo\|mint_to\|mint_authority" src/ --include="*.rs"
+```
+
+Look for: mint without MAX_SUPPLY cap, direct balance manipulation, delegatecall to unknown targets.
+
+## Step 3: Honeypot Check
+
+```bash
+grep -rn "blacklist\|isBlacklisted\|_bots\|maxTxAmount\|approve.*override" src/ --include="*.sol"
+# Solana:
+grep -rn "freeze_authority\|transfer_hook\|permanent_delegate" src/ --include="*.rs"
+```
+
+Look for: blacklist mappings, max tx setters without minimum bound, approve overrides that don't call super.
+
+## Step 4: Fee Manipulation Check
+
+```bash
+grep -rn "setFee\|setSellFee\|_taxFee\|_sellFee" src/ --include="*.sol"
+grep -rn "function set.*Fee" -A5 src/ --include="*.sol" | grep -v "require\|MAX"
+```
+
+Look for: fee setters without upper bound, fee exclusion for owner.
+
+## Step 5: LP Drain Check
+
+```bash
+grep -rn "migrateLP\|emergencyWithdraw\|\.sync()\|setPair\|setRouter" src/ --include="*.sol"
+grep -rn "addLiquidityETH" -A5 src/ --include="*.sol" | grep "owner\|msg.sender"
+```
+
+Look for: LP migration functions, emergency withdraw, auto-LP to owner wallet.
+
+## Step 6: Bonding Curve Check
+
+```bash
+grep -rn "virtualReserve\|setCurve\|graduate\|bonding_curve" src/ --include="*.sol" --include="*.rs"
+```
+
+Look for: mutable curve parameters, manipulable graduation threshold.
+
+## Step 7: Authority Check (Solana)
+
+```bash
+grep -rn "mint_authority\|freeze_authority\|update_authority\|close_authority" src/ --include="*.rs"
+grep -rn "set_authority.*None" src/ --include="*.rs"
+grep -rn "upgrade_authority" src/ --include="*.rs"
+```
+
+Look for: retained authorities that should be None, upgradeable programs.
+
+## Step 8: Fake Renounce Check
+
+```bash
+grep -rn "renounceOwnership.*override" src/ --include="*.sol"
+grep -rn "_shadowAdmin\|_backupOwner" src/ --include="*.sol"
+```
+
+Look for: overridden renounce without actual transfer, secondary admin roles.
+
+## Step 9: Sandwich Amplification Check
+
+```bash
+grep -rn "swapExactTokensForETH" -A5 src/ --include="*.sol" | grep "0,"
+grep -rn "swapThreshold\|_rebase\|reflect()" src/ --include="*.sol"
+```
+
+Look for: auto-swap with amountOutMin=0, rebase on every transfer.
+
+## Output
+
+The scanner produces:
+- **Risk score** (0-100) based on finding severity
+- **Verdict** (CLEAN / LOW RISK / MEDIUM RISK / HIGH RISK / CRITICAL RISK)
+- **Individual findings** with file:line, code snippet, and recommendation
+- **Exit code** 1 if CRITICAL/HIGH findings (for CI integration)
+
+## What to Do Next
+
+- If CRITICAL findings → **DO NOT INTERACT**. Report if on Immunefi/Code4rena.
+- If HIGH findings → Manual deep review. May be intentional design. Check deployer history.
+- If MEDIUM findings → Flag for awareness. Likely not rug but worth monitoring.
+- If CLEAN → Token passes automated checks. Still verify on-chain state manually.
+
+## 5-Minute Rule
+
+If you've been scanning for 5 minutes and found no red flags across all 8 classes + automated scan → the token is likely clean. Move on. Don't hunt for phantom bugs.
+

package/registry/training/good/skills-store-triage.md

@@ -0,0 +1,97 @@
+---
+name: triage
+description: Quick 7-Question Gate triage on a finding before writing a report. Kills N/A submissions before they happen. Faster than /validate — for quick go/no-go decisions. Usage: /triage
+---
+
+# /triage
+
+Quick triage to decide: submit or kill?
+
+## When to Use
+
+Use this before spending time writing a full report. If triage passes, run `/validate` for the full 4-gate check, then `/report`.
+
+## Usage
+
+```
+/triage
+```
+
+Describe the finding in one sentence. Example:
+- "I can read other users' orders by changing user_id in /api/orders/{id}"
+- "The /api/export endpoint returns 200 with data even with no auth header"
+- "I found X-Forwarded-Host is reflected in the password reset email"
+
+## The 7 Questions (Fast Version)
+
+Answer YES or NO to each. First NO = kill it immediately.
+
+```
+Q1: Can I demonstrate this with a real HTTP request RIGHT NOW?
+    YES: I have the request/response already
+    NO: I need to look at more code first → KILL
+
+Q2: Is this impact type accepted by the program?
+    YES: Bug class is on their accepted list
+    NO: They explicitly exclude this type → KILL
+
+Q3: Is the vulnerable asset owned by and in scope for the program?
+    YES: Domain confirmed in-scope, not third-party
+    NO: Third-party service or excluded domain → KILL
+
+Q4: Does this work without admin/privileged access?
+    YES: Regular user account is enough
+    NO: Requires admin → KILL (99% of programs)
+
+Q5: Is this NOT already known/disclosed/documented behavior?
+    YES: Not in changelogs, not in disclosed reports
+    NO: It's documented as intended → KILL
+
+Q6: Can I prove impact beyond "technically possible"?
+    YES: I have actual data in the response / action completed
+    NO: I only have a 200 status or error message → DOWNGRADE
+
+Q7: Is this NOT on the never-submit list?
+    YES: It's a real bug class
+    NO: Missing headers, self-XSS, open redirect alone, etc. → KILL or CHAIN
+```
+
+## Fast Kill Checklist
+
+Kill immediately if ANY of these are true:
+```
+[ ] "Admin can do X" = not a bug
+[ ] "Could theoretically lead to..." = no PoC = not a bug
+[ ] Bug requires 3+ preconditions simultaneously
+[ ] Finding is a missing header, missing flag, missing DMARC
+[ ] SSRF with DNS callback only, no data returned
+[ ] Open redirect with no OAuth chain or ATO path
+[ ] Self-XSS (only affects your own account)
+[ ] Introspection only (no IDOR, no auth bypass shown)
+[ ] Rate limit on login/contact/search (Cloudflare covers it)
+```
+
+## Conditional Kill (chain required)
+
+If it's on the never-submit list BUT you can chain it:
+```
+Open redirect → OAuth code theft → ATO        = report the chain
+SSRF DNS → internal service access = data     = report the chain
+CORS → credentialed data exfil PoC            = report the chain
+Prompt injection → IDOR via chatbot           = report the chain
+```
+
+If you can't build the chain today → KILL IT.
+
+## Output
+
+**GO:** "All 7 pass. Run /validate for full check, then /report."
+
+**KILL [reason]:**
+- "Q1 fails — no HTTP request yet"
+- "Q4 fails — requires admin access"
+- "Q7 fails — open redirect alone is not submittable. Chain it with OAuth theft first."
+
+**DOWNGRADE:**
+- "Q6 — you have 200 status but not actual other-user data. Reproduce with two accounts and show victim's PII in the response before reporting."
+