feat(v6): Masterplan build — semantic skill selector, 84 skills, night-hunt orchestrator, OpenClaw gateway, 12 MCP servers, developer playbook

RHODAWK_DEVELOPER_PLAYBOOK.md

@@ -0,0 +1,759 @@
+# Rhodawk AI — Developer & Founder Playbook
+
+*Companion document to* `Rhodawk_Superhuman_Agent_Plan.md`.
+*Covers everything in the v6 codebase: architecture, build, run, extend, deploy.*
+
+---
+
+## Table of Contents
+
+1. [What Rhodawk Is](#1-what-rhodawk-is)
+2. [System Topology](#2-system-topology)
+3. [Repository Map](#3-repository-map)
+4. [Boot Sequence](#4-boot-sequence)
+5. [Skill Architecture](#5-skill-architecture)
+6. [Model Router (5-tier)](#6-model-router-5-tier)
+7. [Hermes Reasoning Engine](#7-hermes-reasoning-engine)
+8. [Mythos MCP Fleet (37 servers)](#8-mythos-mcp-fleet-37-servers)
+9. [Night Hunter — autonomous bug-bounty loop](#9-night-hunter--autonomous-bug-bounty-loop)
+10. [EmbodiedOS — OpenClaw + Telegram](#10-embodiedos--openclaw--telegram)
+11. [OSS Guardian flow](#11-oss-guardian-flow)
+12. [Safety gates & audit trail](#12-safety-gates--audit-trail)
+13. [Local development](#13-local-development)
+14. [Docker / HuggingFace Space deployment](#14-docker--huggingface-space-deployment)
+15. [DigitalOcean migration](#15-digitalocean-migration)
+16. [Configuration reference](#16-configuration-reference)
+17. [Adding a new skill](#17-adding-a-new-skill)
+18. [Adding a new MCP server](#18-adding-a-new-mcp-server)
+19. [Testing & validation](#19-testing--validation)
+20. [Troubleshooting](#20-troubleshooting)
+21. [Founder operating handbook](#21-founder-operating-handbook)
+
+---
+
+## 1. What Rhodawk Is
+
+Rhodawk is an autonomous security agent built around three loops:
+
+* **OSS Guardian** — clones a public repository, runs the project's own
+  test suite, then either (a) fixes failing tests via the Hermes reasoning
+  loop or (b) launches a six-phase attack run with the Mythos MCP fleet,
+  emitting findings as PRs and CVE drafts.
+* **Night Hunter** — every night at 23:00 UTC, ingests bug-bounty scope
+  from HackerOne / Bugcrowd / Intigriti, scores targets, runs the recon
+  → scan → validate → report pipeline, and posts a 06:00 morning briefing.
+* **EmbodiedOS** — natural-language interface (Telegram + HTTP gateway)
+  built on OpenClaw skills. Ten command intents cover everything an
+  operator does: scan, status, pause, approve, reject, explain.
+
+All three loops share the Hermes orchestrator, the semantic skill
+selector, the 5-tier model router, the 37-server MCP fleet, and the
+training flywheel.
+
+---
+
+## 2. System Topology
+
+```
+                       ┌─────────────────────┐
+                       │  YOU (Telegram/HTTP) │
+                       └──────────┬───────────┘
+                                  ▼
+                  ┌─────────────────────────────┐
+                  │  openclaw_gateway.py         │
+                  │  • intent registry           │
+                  │  • Telegram webhook          │
+                  │  • POST /openclaw/command    │
+                  └──────────┬───────────────────┘
+            ┌────────────────┼─────────────────────┐
+            ▼                ▼                     ▼
+   ┌──────────────┐ ┌──────────────────┐ ┌──────────────────┐
+   │ oss_guardian │ │ night_hunt_      │ │ status / mgmt    │
+   │ .py          │ │ orchestrator.py  │ │ commands         │
+   └──────┬───────┘ └────────┬─────────┘ └──────────────────┘
+          │                  │
+          └────────┬─────────┘
+                   ▼
+        ┌────────────────────────────┐
+        │  hermes_orchestrator.py     │
+        │  • 6-phase reasoning loop   │
+        │  • call_with_skills()       │
+        │  • _hermes_llm_call()       │
+        └──────┬───────────┬──────────┘
+               │           │
+   ┌───────────▼──┐   ┌────▼─────────────────┐
+   │ architect/   │   │ architect/           │
+   │ model_router │   │ skill_selector.py    │
+   │  (T1..T5)    │   │  (MiniLM semantic)   │
+   └──────┬───────┘   └──────────┬───────────┘
+          ▼                      ▼
+   OpenRouter / vLLM        architect/skills/  (114 skill .md files)
+                                  │
+                                  ▼
+                  ┌──────────────���───────────────┐
+                  │  mythos/mcp/  (37 servers)   │
+                  │  static, dynamic, exploit,   │
+                  │  jwt, cors, openapi, dep-    │
+                  │  confusion, proto-pollution… │
+                  └──────────────┬───────────────┘
+                                 ▼
+                  ┌──────────────────────────────┐
+                  │  Safety gates                │
+                  │  sast_gate / adversarial /   │
+                  │  conviction / scope          │
+                  └──────────────┬───────────────┘
+                                 ▼
+                  ┌──────────────────────────────┐
+                  │  Output                      │
+                  │  PRs / bounty drafts / CVEs  │
+                  │  → embodied_bridge → ops     │
+                  └──────────────────────────────┘
+```
+
+---
+
+## 3. Repository Map
+
+```
+.
+├── app.py                           gradio UI + boot orchestration
+├── hermes_orchestrator.py           6-phase reasoning loop
+├── oss_guardian.py                  OSS attack/fix campaigner
+├── night_hunt_orchestrator.py  ★    autonomous bounty hunter (NEW v6)
+├── openclaw_gateway.py         ★    Telegram + HTTP intent gateway (NEW v6)
+├── openclaw_schedule.yaml      ★    heartbeat schedule (NEW v6)
+├── mcp_config.json                  37 MCP servers (12 added in v6)
+├── Dockerfile                       HF Space build (PyPI mcp-server-* fix)
+│
+├── architect/
+│   ├── model_router.py              5-tier model routing + budget
+│   ├── skill_registry.py            keyword scoring (legacy)
+│   ├── skill_selector.py       ★    MiniLM semantic selector (NEW v6)
+│   ├── nightmode.py                 v5 stub (kept for backwards compat)
+│   ├── embodied_bridge.py           Telegram/Discord/OpenClaw emit
+│   ├── godmode_consensus.py         3-model adversarial review
+│   ├── master_redteam_prompt.py     prompt templating
+│   └── skills/                      114 skill markdown files
+│       ├── web/  binary/  languages/  cryptography/
+│       ├── infrastructure/  ai-systems/  protocols/
+│       ├── embedded-iot/  automotive/  aviation/
+│       ├── mobile/  reverse-engineering/
+│       └── report-quality/  + platform-specific-guides/
+│
+├── mythos/mcp/                      Python MCP servers
+│   ├── reconnaissance_mcp.py        existing
+│   ├── static_analysis_mcp.py       existing (CodeQL/Semgrep/Joern)
+│   ├── dynamic_analysis_mcp.py      existing (AFL++/KLEE/Frida)
+│   ├── exploit_generation_mcp.py    existing (pwntools/ROP)
+│   ├── web_security_mcp.py          existing (ZAP/nuclei/sqlmap)
+│   ├── jwt_analyzer_mcp.py     ★    NEW v6
+│   ├── cors_analyzer_mcp.py    ★    NEW v6
+│   ├── openapi_analyzer_mcp.py ★    NEW v6
+│   ├── dep_confusion_mcp.py    ★    NEW v6
+│   ├── prototype_pollution_mcp.py ★ NEW v6
+│   ├── skill_selector_mcp.py   ★    NEW v6
+│   └── …
+│
+├── skills/rhodawk/             ★    7 OpenClaw interaction skills (NEW v6)
+│   ├── scan-repo.md   night-report.md   approve-finding.md
+│   ├── pause-hunting.md   add-target.md   status.md   explain-finding.md
+│
+├── tests/                           pytest suite
+└── vendor/openclaude/               vendored OpenClaude (gRPC daemon)
+```
+
+`★` = added or rewritten in v6 to fulfil the Masterplan §3, §5, §6, §8.
+
+---
+
+## 4. Boot Sequence
+
+`app.py` → `if __name__ == "__main__"`:
+
+1. `start_webhook_server()` — GitHub-app webhooks (HMAC verified).
+2. `_start_mythos_api_server_thread()` — productisation API (opt-in).
+3. `architect.nightmode.start_in_background()` — legacy v5 night-mode (no-op
+   unless `ARCHITECT_NIGHTMODE=1`).
+4. **(NEW)** `night_hunt_orchestrator.start_in_background()` —
+   v6 hunter when `NIGHT_HUNTER=1`.
+5. **(NEW)** `openclaw_gateway.start_in_background()` —
+   Flask gateway on `OPENCLAW_PORT` (default 8765) when `OPENCLAW=1`.
+6. `demo.launch(...)` — Gradio dashboard on `PORT` (HF default 7860).
+
+Container entrypoint (`entrypoint.sh`) writes `/tmp/mcp_runtime.json`
+from `mcp_config.json` + secret env vars before starting the Python
+process — keeping secrets out of the committed config.
+
+---
+
+## 5. Skill Architecture
+
+The core insight (Masterplan §1.2 / §5): **a $0.07/M-token model becomes
+a domain expert when the right skill briefing is loaded into its
+context**. The selector is what turns the model from a generalist into a
+JWT specialist or a Solidity auditor for the duration of one task.
+
+### 5.1 Skill file format
+
+```yaml
+---
+name: jwt-analyzer
+domain: web
+triggers:
+  languages: [python, javascript, java]
+severity_focus: [P1, P2]
+tools: [pyjwt, jwt-cli]
+---
+
+# jwt-analyzer
+
+Free-form markdown the model can read…
+```
+
+`architect/skill_registry.py` parses the YAML front-matter, exposes
+`Skill` objects with structured triggers, and provides a keyword `match()`
+scorer used as the deterministic fallback.
+
+### 5.2 Semantic selection (`architect/skill_selector.py`)
+
+1. Load every `*.md` from `architect/skills/` and `/data/skills/`.
+2. Embed each one with `sentence-transformers/all-MiniLM-L6-v2` (cached
+   on disk under `/tmp/architect_skill_cache/skills_<model>.json`).
+3. Embed the task description + repo languages + tech stack + attack phase.
+4. Cosine-rank, apply phase boosts (e.g. `recon` boosts skills whose name
+   contains `subdomain`, `wayback`, `httpx`).
+5. Return either:
+   * `pack(...)` → list of `Match` objects (for custom rendering)
+   * `select_for_task(...)` → ready-to-prepend `<skills>...</skills>` block
+
+**The module never raises in production**: if `sentence-transformers`
+isn't installed, it falls back to keyword overlap scoring without
+changing the public interface.
+
+### 5.3 Wiring
+
+`hermes_orchestrator.run_hermes_research` calls `select_for_task` once
+per session and prepends the skill block to the Hermes system prompt.
+`architect.model_router.call_with_skills` does the same for ad-hoc
+LLM calls (used by the OSS Guardian fix loop and report drafting).
+
+---
+
+## 6. Model Router (5-tier)
+
+`architect/model_router.py` — every LLM call goes through this:
+
+| Tier | Default model | Cost / M out | Use |
+|------|---------------|-------------:|-----|
+| T1-fast | `minimax/minimax-m2.5-highspeed` | $0.10 | recon, triage, bulk |
+| T1-deep | `deepseek/deepseek-chat-v3` | $0.28 | static analysis, patches |
+| T2 | `qwen/qwen3-235b-a22b` | $0.60 | exploit reasoning, chains |
+| T3 | `minimax/minimax-m2.5` | $0.55 | long-context whole-repo |
+| T4 | `anthropic/claude-sonnet-4-6` | $3.00 | P1/P2 final polish |
+| T5 | `local/deepseek-r1-32b-awq` | $0.00 | local Kaggle GPU fallback |
+
+`route(task)` returns a `RouteDecision` (model + fallback chain + tier).
+`record_usage(model, tokens)` mutates the day's budget; once
+`ARCHITECT_HARD_BUDGET_USD` is exceeded, every call is forced to T5.
+
+### Per-task table
+
+| Task | Primary | Fallbacks |
+|------|---------|-----------|
+| `recon`, `scope_parse` | T1-fast | T5 |
+| `bulk_triage` | T5 | T1-fast |
+| `static_analysis`, `patch_generation` | T1-deep | T1-fast, T2 |
+| `exploit_reasoning`, `chain_synthesis` | T2 | T1-deep, T4 |
+| `long_context_analysis` | T3 | T1-fast |
+| `adversarial_review_a/b/c` | T1-fast / T1-deep / T2 | — |
+| `report_drafting` | T1-deep | T1-fast |
+| `critical_cve_draft` | T4 | T2 |
+
+`call_with_skills(task, prompt, profile)` is the canonical entry point —
+it routes, builds the master red-team prompt, injects the skill pack,
+calls the LLM, and records the interaction in the RL feedback loop.
+
+---
+
+## 7. Hermes Reasoning Engine
+
+`hermes_orchestrator.py` — six phases tracked on a `HermesSession`:
+
+```
+RECON → STATIC → DYNAMIC → EXPLOIT → CHAIN → REPORT
+```
+
+`run_hermes_research(target_repo, repo_dir, focus_area, max_iterations)`:
+
+1. Builds a `HermesSession` and skill-augmented system prompt
+   (uses `skill_selector.select_for_task` — added in v6).
+2. Loops up to `max_iterations` times, each iteration:
+   * Calls `_hermes_llm_call(messages)` → JSON tool-call or finding.
+   * On `tool_call`, dispatches to one of: `ReconTool`, `TaintTool`,
+     `SymbolicTool`, `FuzzTool`, `ExploitTool`, `CVETool`,
+     `CommitWatchTool`, `SSECTool`, `ChainAnalyzerTool`.
+   * On `finding`, computes **VES** (Vulnerability Exploitability Score:
+     reachability × severity_class × novelty / complexity / auth-needed)
+     and stores a `VulnerabilityFinding` dataclass.
+3. After the loop, runs `_run_acts_consensus` — three different LLMs
+   review the same finding; agreement increments **ACTS** (Adversarial
+   Consensus Truth Score).
+4. `build_tvg(repo_dir, findings)` produces a Target Vulnerability Graph
+   (nodes = sinks, edges = data-flow relationships) for cross-finding
+   chain reasoning.
+
+Persistence: every session is JSON-serialised to
+`/tmp/hermes_sessions/<session_id>.json` via `persist_hermes_session`.
+
+---
+
+## 8. Mythos MCP Fleet (37 servers)
+
+The MCP fleet is described in `mcp_config.json`. Each entry is one of:
+
+* `command: npx -y <pkg>` — community Node MCP server.
+* `command: uvx mcp-server-shell --allow-commands <bin>` — shell wrapper
+  exposing one or more binaries as tools.
+* `command: python -m mythos.mcp.<module>` — Mythos-native Python module.
+
+### v6 additions (12)
+
+| Name | Module / binary | Purpose |
+|------|-----------------|---------|
+| `skill-selector-mcp` | `mythos.mcp.skill_selector_mcp` | semantic skill ctx |
+| `trufflehog-deep-mcp` | `trufflehog` | full git history secrets |
+| `gitleaks-mcp` | `gitleaks` | secondary secret scanner |
+| `semgrep-pro-patterns-mcp` | `semgrep` w/ p/security-audit | SAST rule sets |
+| `jwt-analyzer-mcp` | `mythos.mcp.jwt_analyzer_mcp` | alg:none, weak secret |
+| `api-fuzzer-mcp` | `restler/dredd/schemathesis` | stateful API fuzz |
+| `solidity-auditor-mcp` | `slither/myth` | smart-contract SAST |
+| `dependency-confusion-mcp` | `mythos.mcp.dep_confusion_mcp` | dep-conf scan |
+| `git-forensics-deep-mcp` | `git-dumper` | exposed .git dirs |
+| `openapi-analyzer-mcp` | `mythos.mcp.openapi_analyzer_mcp` | spec → surface |
+| `cors-analyzer-mcp` | `mythos.mcp.cors_analyzer_mcp` | CORS misconfig |
+| `prototype-pollution-mcp` | `mythos.mcp.prototype_pollution_mcp` | JS proto sinks |
+
+Each Python MCP exposes either `scan_host(host)` or `scan_repo(path)` (or
+both — see `dep_confusion_mcp.scan_host` aliasing) so the night-hunt
+detector dispatcher can call them uniformly.
+
+---
+
+## 9. Night Hunter — autonomous bug-bounty loop
+
+`night_hunt_orchestrator.py` (added in v6).
+
+### Pipeline
+
+```
+_ingest_scope()       → bounty_gateway.list_active_programs(plat)
+                        falls back to scope_parser_mcp, then to demo data
+_filter_by_floor()    → keep programs with P1≥$5k or P2≥$1k
+                        (NIGHT_HUNTER_P1_FLOOR / _P2_FLOOR env)
+_score_targets()      → 0.45*money + 0.35*breadth + 0.20*recency
+_recon(target)        → subdomain_enum + httpx_probe + wayback + shodan
+_hunt(target, recon)  → for each detector in (nuclei, zap, sqlmap,
+                        jwt-analyzer, cors-analyzer, openapi, proto-poll)
+                          run via _run_detector(...)
+_validate(findings)   → architect.godmode_consensus.review_finding
+                        + drop low-conviction noise
+_draft_submission(f)  → platform-specific template (h1/bugcrowd/intigriti)
+_persist(report)      → /data/night_reports/night_<cycle_id>.json
+_notify(report)       → embodied_bridge.emit_status + notifier.notify
+```
+
+### Public API
+
+```python
+import night_hunt_orchestrator as nh
+report = nh.run_night_cycle(platforms=["hackerone"], max_targets=3)
+print(report.summary())                # {"targets":3,"findings":7,...}
+nh.start_in_background(start_hour=23)  # daemon thread, runs forever
+```
+
+### Relevant env vars
+
+```
+NIGHT_HUNTER=1                    enable scheduler in app.py
+NIGHT_HUNTER_HOUR=23              cycle start (UTC)
+NIGHT_HUNTER_MORNING_HOUR=6       morning briefing time
+NIGHT_HUNTER_P1_FLOOR=5000        $ minimum to qualify a program
+NIGHT_HUNTER_P2_FLOOR=1000
+NIGHT_HUNTER_MAX_TARGETS=3        per cycle
+NIGHT_HUNTER_REPORTS=/data/night_reports
+NIGHT_HUNTER_PLATFORMS=hackerone,bugcrowd,intigriti
+NIGHT_HUNTER_PAUSED=1             skip the next cycle (set by openclaw)
+```
+
+### Safety policy
+
+The orchestrator **never auto-submits**. `_draft_submission` produces a
+markdown body that is queued for operator approval. Only the
+`approve_finding` intent (via OpenClaw) calls
+`bounty_gateway.submit_finding`. The plan's stated guardrail —
+"target < 20% false positives before any submission" — is enforced by
+the operator review step, not the code.
+
+---
+
+## 10. EmbodiedOS — OpenClaw + Telegram
+
+`openclaw_gateway.py` (added in v6).
+
+### Intent registry
+
+```python
+from openclaw_gateway import handle_command
+handle_command("scan github.com/pallets/flask")
+# → {"ok": True, "intent": "scan_repo", "reply": "Scan queued..."}
+```
+
+| Intent | Trigger pattern | Handler |
+|--------|-----------------|---------|
+| `scan_repo` | `scan <target>` / `audit <target>` | `OSSGuardian().run` |
+| `night_run_now` | `night run` / `hunt now` | `nh.run_night_cycle()` |
+| `pause_night` | `pause night` | sets `NIGHT_HUNTER_PAUSED=1` |
+| `resume_night` | `resume night` | unsets it |
+| `status` | `status` / `what are you doing` | system snapshot |
+| `approve_finding` | `approve <id>` | `bounty_gateway.submit_finding` |
+| `reject_finding` | `reject <id>` | `training_store.record_negative` |
+| `explain_finding` | `explain <id>` | look up in night reports |
+| `help` | `help` / `?` | prints intent list |
+
+### HTTP surface (when `OPENCLAW=1`)
+
+```
+GET  /openclaw/status                liveness + intents + skill stats
+POST /openclaw/command   {"text":...}  → handle_command(text)
+POST /telegram/webhook                 Telegram Update payload
+```
+
+The HTTP endpoint requires `X-OpenClaw-Token` matching
+`OPENCLAW_SHARED_SECRET` if that env var is set.
+
+### Schedule (`openclaw_schedule.yaml`)
+
+```yaml
+heartbeat:
+  health_check:        every: 15min
+  harvester_run:       cron: "0 */6 * * *"
+  night_hunt_start:    cron: "0 23 * * *"
+  morning_report:      cron: "0 6 * * *"
+  lora_export_check:   cron: "0 2 * * 0"
+  training_digest:     cron: "0 9 * * 1"
+```
+
+Today the cron is implemented in two places:
+* `night_hunt_orchestrator.schedule_loop` for the 23:00 cycle.
+* The morning report is emitted at the *end* of each cycle (good enough
+  for v6); a dedicated 06:00 cron is left for the DigitalOcean migration
+  step where systemd timers are easier to reason about than in-app
+  threads.
+
+---
+
+## 11. OSS Guardian flow
+
+`oss_guardian.py` (unchanged in v6, documented here for completeness):
+
+1. Open a `_open_sandbox(repo_url)` — pulls into a temp dir.
+2. Detect runtime (`language_runtime.detect`).
+3. Run the project's own test suite. If failures → `fix_mode`:
+   call `run_hermes_research(focus_area="oss-guardian:fix-failing-tests")`,
+   open a PR via the GitHub MCP server.
+4. If tests pass → `attack_mode`: full Hermes session.
+5. `_route_findings(findings, camp)` ships every finding to:
+   * `embodied_bridge.emit_finding` (Telegram + OpenClaw + Discord).
+   * `disclosure_vault` for SHA-256 hashed audit-trail storage.
+
+---
+
+## 12. Safety gates & audit trail
+
+* `sast_gate.py` — every PR diff must pass Semgrep before submission.
+* `architect/godmode_consensus.py` — 3-model ACTS review on every finding.
+* `conviction_engine.py` — refuses to submit anything with VES < 0.6 or
+  ACTS < 0.66 unless the operator overrides.
+* `disclosure_vault.py` — append-only SHA-256 chained log of every
+  finding, decision, and submission. Used by `tests/test_audit_chain.py`.
+
+---
+
+## 13. Local development
+
+```
+# bootstrap (Linux/WSL/macOS)
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+# optional: install MCP runtimes
+pipx install uv && uv tool install nuclei semgrep trufflehog gitleaks
+
+# unit tests
+pytest -q
+
+# run the gradio dashboard
+PORT=7860 python app.py
+
+# run the night hunter once, ad-hoc
+python -m night_hunt_orchestrator
+
+# pipe a command through openclaw without HTTP
+python -m openclaw_gateway "scan github.com/pallets/flask"
+
+# ask the skill selector for context
+python -c "from architect import skill_selector as s; \
+  print(s.select_for_task('jwt rs256 confusion', \
+        repo_languages=['python'], attack_phase='static', top_k=3))"
+```
+
+---
+
+## 14. Docker / HuggingFace Space deployment
+
+The Space build is driven by the root `Dockerfile`. v6 lessons learned:
+
+* `@modelcontextprotocol/server-git` and `…/server-sqlite` were removed
+  from the npm registry in March 2026. Replaced with the PyPI versions
+  `mcp-server-git` and `mcp-server-sqlite`, invoked by their console
+  scripts. `mcp_config.json` was updated to match (`command:
+  "mcp-server-git"` instead of `npx -y …`).
+* The fix that unblocked the Space build is commit `6089ff0` on GitHub
+  and `4b69257` on HuggingFace (cherry-picked because the histories had
+  diverged).
+
+Push flow when working through this repo:
+
+```bash
+git remote add origin   https://<gh-token>@github.com/Rhodawk-AI/Rhodawk-devops-engine.git
+git remote add hf       https://Architect8999:<hf-token>@huggingface.co/spaces/Architect8999/rhodawk-ai-devops-engine
+
+git push origin main                      # GitHub fast-forward
+git fetch hf && git checkout -b hf-sync hf/main
+git cherry-pick <commit-from-main>        # HF history is divergent
+git push hf hf-sync:main
+```
+
+(The Replit / agent environment has destructive git ops blocked at the
+shell tool, so we run `git commit` / `git push` through `code_execution`
+shelling out to `child_process.execSync`.)
+
+---
+
+## 15. DigitalOcean migration
+
+When the HuggingFace free tier proves too constrained:
+
+1. Provision a DO droplet (4 vCPU / 8 GB / 50 GB block volume).
+2. Mount block volume at `/data`. Set `MCP_DATA_ROOT=/data`.
+3. Install Docker; clone the repo; `docker build -t rhodawk .`.
+4. Persist secrets in `/etc/rhodawk.env` (chmod 600, root only).
+5. Systemd unit:
+
+   ```ini
+   [Unit]
+   Description=Rhodawk AI
+   After=docker.service
+   Requires=docker.service
+
+   [Service]
+   EnvironmentFile=/etc/rhodawk.env
+   ExecStart=/usr/bin/docker run --rm --name rhodawk \
+     --env-file /etc/rhodawk.env -p 7860:7860 -p 8765:8765 \
+     -v /data:/data rhodawk
+   Restart=always
+
+   [Install]
+   WantedBy=multi-user.target
+   ```
+
+6. Add systemd timers for the 23:00 / 06:00 / Sunday-02:00 cron entries
+   in `openclaw_schedule.yaml` (preferred over in-app threads on a
+   long-lived host).
+
+---
+
+## 16. Configuration reference
+
+All toggles via env vars — no config file changes needed for ops.
+
+| Var | Default | Purpose |
+|-----|---------|---------|
+| `PORT` | 7860 | gradio listen port |
+| `NIGHT_HUNTER` | 0 | start the night-hunt thread |
+| `NIGHT_HUNTER_HOUR` | 23 | cycle start (UTC) |
+| `NIGHT_HUNTER_PAUSED` | unset | skip next cycle |
+| `NIGHT_HUNTER_REPORTS` | /data/night_reports | report dir |
+| `OPENCLAW` | 0 | start the gateway |
+| `OPENCLAW_HOST` | 0.0.0.0 | bind |
+| `OPENCLAW_PORT` | 8765 | bind |
+| `OPENCLAW_SHARED_SECRET` | unset | required header on /openclaw/command |
+| `TELEGRAM_BOT_TOKEN` | unset | outbound Telegram |
+| `TELEGRAM_CHAT_ID` | unset | default chat for status pings |
+| `OPENROUTER_API_KEY` | required for T1–T4 | LLM tier 1–4 |
+| `OPENROUTER_BASE_URL` | https://openrouter.ai/api/v1 | LLM endpoint |
+| `LOCAL_VLLM_BASE_URL` | http://localhost:8000/v1 | T5 endpoint |
+| `ARCHITECT_HARD_BUDGET_USD` | 10.0 | day-cap before forced T5 |
+| `ARCHITECT_SKILLS_DIR` | /data/skills | additional runtime skills dir |
+| `ARCHITECT_EMBED_MODEL` | sentence-transformers/all-MiniLM-L6-v2 | embedder |
+| `ARCHITECT_SKILL_CACHE` | /tmp/architect_skill_cache | embedding cache |
+| `HACKERONE_API_TOKEN` etc. | unset | platform scope ingestion |
+| `GITHUB_PERSONAL_ACCESS_TOKEN` | unset | github MCP + PR submission |
+| `BRAVE_API_KEY` | unset | brave-search MCP |
+| `SHODAN_API_KEY` | unset | shodan MCP |
+| `NVD_API_KEY` | unset | cve-intel MCP |
+| `SEMGREP_APP_TOKEN` | unset | semgrep registry |
+| `SESSION_SECRET` | required | Flask session signing |
+
+---
+
+## 17. Adding a new skill
+
+```
+$ cat > architect/skills/web/my-new-skill.md <<'MD'
+---
+name: my-new-skill
+domain: web
+triggers:
+  languages: [python]
+  asset_types: [http]
+severity_focus: [P1, P2]
+---
+
+# my-new-skill
+
+Markdown body the model reads when this skill is selected.
+MD
+
+# verify it loads + ranks correctly
+python -c "
+from architect import skill_selector as s
+print(s.explain('exploit my-new-skill in flask app',
+                repo_languages=['python'], attack_phase='static'))
+"
+```
+
+The selector picks it up automatically — no registry edit needed. The
+embedding cache is keyed on body hash, so adding new skills only embeds
+the new files.
+
+---
+
+## 18. Adding a new MCP server
+
+For a Python module (preferred):
+
+```
+# mythos/mcp/my_new_mcp.py
+def scan_host(host: str) -> list[dict]:
+    return [{"title": "...", "severity": "low", "cvss": 3.0,
+             "url": host, "description": "...", "evidence": {},
+             "confidence": 0.6}]
+```
+
+Register it in `mcp_config.json`:
+
+```json
+"my-new-mcp": {
+  "command": "python",
+  "args": ["-m", "mythos.mcp.my_new_mcp"],
+  "description": "What it does"
+}
+```
+
+If you want it called by the night-hunter for every target, add it to
+`_DETECTORS` in `night_hunt_orchestrator.py` and add a branch in
+`_run_detector(...)` that imports + calls it.
+
+For a binary wrapper, use the `uvx mcp-server-shell --allow-commands
+<bin>` pattern that the existing `nuclei-scanner` / `semgrep-sast`
+entries use.
+
+---
+
+## 19. Testing & validation
+
+```
+pytest tests/                       # 10 existing test files
+pytest tests/test_skill_registry.py # skill loader
+pytest tests/test_model_router.py   # router decisions + budget
+pytest tests/test_nightmode_smoke.py # legacy nightmode
+pytest tests/test_mcp_servers_load.py # validates mcp_config.json parses
+
+# manual smoke for v6 additions
+python -c "from architect import skill_selector; print(skill_selector.stats())"
+python -c "import night_hunt_orchestrator as n; print(n.run_night_cycle().summary())"
+python -m openclaw_gateway "status"
+python -m openclaw_gateway "help"
+python -m mythos.mcp.jwt_analyzer_mcp https://example.com
+```
+
+The night-hunt smoke test will fall through to the demo `example.com`
+target if no scope tokens are configured, so it's safe to run in dev.
+
+---
+
+## 20. Troubleshooting
+
+| Symptom | Likely cause | Fix |
+|---------|--------------|-----|
+| `npm ERR! 404` building Docker image | npm package removed | already fixed in v6 by switching to PyPI `mcp-server-git/sqlite` |
+| Skill selector returns 0 matches | `skill_registry.load_all()` empty | check `architect/skills/` exists in image; check `ARCHITECT_SKILLS_DIR` |
+| `sentence-transformers` not installed | OK — falls back to keyword scoring | install if you want semantic ranking: `pip install sentence-transformers` |
+| Telegram messages don't arrive | `TELEGRAM_BOT_TOKEN`/`TELEGRAM_CHAT_ID` unset | check env vars; `telegram_send` returns False without erroring |
+| Night cycle runs but no findings | no scanner binaries installed | install `nuclei`, `semgrep`, `sqlmap`, etc., or accept that only the Python-native MCPs (jwt/cors/openapi/proto-poll/dep-conf) will fire |
+| Hermes loop crashes on first iter | `OPENROUTER_API_KEY` missing | set it; check `_BUDGET.spent_usd` hasn't tripped the hard cap |
+| MCP config has duplicate keys | JSON parser keeps last; benign but ugly | dedupe block in `mcp_config.json` (v6 keeps the consolidated single block) |
+
+---
+
+## 21. Founder operating handbook
+
+### Daily routine (5 minutes)
+
+1. Open Telegram. Read the 06:00 morning briefing.
+2. For each finding, read the title + severity + target. Tap one of:
+   * `approve <id>` — submit to platform
+   * `reject <id>` — log negative training signal
+   * `explain <id>` — get the plain-English version first
+3. `status` — confirm the night-hunt thread is armed for tonight.
+
+### Weekly routine (30 minutes)
+
+* Read `/data/night_reports/*.json` from the past 7 cycles. Sample 3
+  findings end-to-end and verify reproducibility yourself.
+* Check the LoRA export schedule (Sunday 02:00) — confirm a new training
+  digest landed on Monday.
+* Review the public leaderboard (`public_leaderboard.py`). If PRs
+  merged < target, check `repo_harvester.py` is selecting decent repos.
+
+### When to spend money
+
+* T4 (Claude Sonnet) only on `critical_cve_draft`. Verify `_BUDGET` shows
+  >$5 burn/day before adding more T4 calls.
+* Hardware: keep one DO droplet running 24/7 (~$24/mo). Add a Kaggle GPU
+  for T5 only when local triage volume justifies it.
+
+### When to add a skill
+
+Whenever you find yourself writing the same explanation twice in a
+finding triage. Capture the pattern in
+`architect/skills/<domain>/<topic>.md`. The selector will start loading
+it into Hermes within minutes — no deploy required if you mount
+`/data/skills/`.
+
+### When to ship to investors
+
+The Masterplan §10 demo script (Demo A / B / C) is the canonical pitch.
+Pre-flight checklist before any live demo:
+1. `docker pull` the latest image; smoke-test the gradio UI loads.
+2. Run `night_run_now` once to ensure the pipeline doesn't error.
+3. Send `status` from your phone over Telegram and confirm the reply.
+4. Prepare a known-vuln backup target in case the live repo finds nothing
+   in the demo window (e.g. an intentionally vulnerable fork).
+
+---
+
+*Rhodawk AI v6.0 — Developer & Founder Playbook*
+*Generated as the closing artefact of the Masterplan §3 build sweep.*
+*Always paired with the upstream `Rhodawk_Superhuman_Agent_Plan.md`.*

app.py

@@ -2690,4 +2690,25 @@ if __name__ == "__main__":
     except Exception as _e:  # noqa: BLE001
         print(f"[ARCHITECT] night-mode scheduler not started: {_e}")
 
+    # ── Masterplan §3 — Night Hunter orchestrator (opt-in NIGHT_HUNTER=1) ──
+    if os.getenv("NIGHT_HUNTER", "0") == "1":
+        try:
+            import night_hunt_orchestrator as _nh
+            _nh.start_in_background()
+            print("[NIGHT-HUNTER] background scheduler armed")
+        except Exception as _e:  # noqa: BLE001
+            print(f"[NIGHT-HUNTER] scheduler not started: {_e}")
+
+    # ── Masterplan §6 — OpenClaw / EmbodiedOS gateway (opt-in OPENCLAW=1) ──
+    if os.getenv("OPENCLAW", "0") == "1":
+        try:
+            import openclaw_gateway as _oc
+            _oc.start_in_background(
+                host=os.getenv("OPENCLAW_HOST", "0.0.0.0"),
+                port=int(os.getenv("OPENCLAW_PORT", "8765")),
+            )
+            print("[OPENCLAW] gateway listening")
+        except Exception as _e:  # noqa: BLE001
+            print(f"[OPENCLAW] gateway not started: {_e}")
+
     demo.launch(server_name="0.0.0.0", server_port=port, share=False, show_error=True)

architect/skill_selector.py

@@ -0,0 +1,320 @@
+"""
+ARCHITECT — semantic skill selector (Masterplan §5).
+
+Upgrades the keyword-based ``architect/skill_registry`` with **semantic
+similarity ranking** so the right domain skills are loaded into the LLM
+context regardless of how the task is phrased.
+
+Tier-5 design (Masterplan §7):
+    * Embeddings:  sentence-transformers / MiniLM-L6-v2  (CPU, $0)
+    * Fallback:    deterministic keyword-overlap scorer  (no model needed)
+    * Cache:       skill embeddings hashed on disk (JSON) so the model loads
+                   *once* per process and *never* recomputes between calls.
+
+Public surface:
+
+    select_for_task(task_description, repo_languages, repo_tech_stack,
+                    attack_phase, top_k=5) -> str
+        Returns a single XML-flavoured ``<skills>...</skills>`` block ready
+        to be prepended to any system prompt.
+
+    pack(task_description, ...) -> list[Skill]
+        Same logic but returns the matched Skill objects (for callers who
+        want to render their own context format).
+
+The module is designed to **never raise** in production: every external
+dependency (sentence-transformers, numpy, sklearn) is optional and falls
+back to a pure-Python implementation.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import math
+import os
+import re
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Iterable
+
+from . import skill_registry
+
+LOG = logging.getLogger("architect.skill_selector")
+
+CACHE_DIR = Path(os.getenv("ARCHITECT_SKILL_CACHE", "/tmp/architect_skill_cache"))
+CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+# Phase → list of skill-name substrings that should get a relevance boost.
+PHASE_BOOSTS: dict[str, tuple[str, ...]] = {
+    "recon":   ("recon", "subdomain", "wayback", "shodan", "httpx", "fingerprint"),
+    "static":  ("static", "sast", "taint", "semgrep", "ast", "code", "memory"),
+    "dynamic": ("fuzz", "dynamic", "browser", "runtime", "frida"),
+    "exploit": ("exploit", "rop", "heap", "buffer", "pwn", "shellcode", "primitive"),
+    "report":  ("report", "p1", "p2", "cvss", "submission", "platform"),
+    "triage":  ("methodology", "reference", "index", "report"),
+}
+
+_LOCK = threading.Lock()
+_MODEL: Any = None
+_EMBEDS: dict[str, list[float]] = {}
+_SKILLS: list[skill_registry.Skill] = []
+
+
+# ── lazy model loading ──────────────────────────────────────────────────────
+def _try_load_model() -> Any:
+    """Best-effort load of MiniLM. Returns None on any failure."""
+    global _MODEL
+    if _MODEL is not None:
+        return _MODEL
+    try:
+        from sentence_transformers import SentenceTransformer  # type: ignore
+        model_name = os.getenv("ARCHITECT_EMBED_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
+        LOG.info("skill_selector: loading embed model %s", model_name)
+        _MODEL = SentenceTransformer(model_name)
+        return _MODEL
+    except Exception as exc:  # noqa: BLE001
+        LOG.warning("skill_selector: sentence-transformers unavailable (%s) — using keyword fallback", exc)
+        _MODEL = False  # sentinel: don't try again
+        return None
+
+
+# ── embedding cache ─────────────────────────────────────────────────────────
+def _skill_hash(skill: skill_registry.Skill) -> str:
+    h = hashlib.sha256()
+    h.update(skill.name.encode())
+    h.update(skill.body.encode())
+    return h.hexdigest()[:16]
+
+
+def _cache_path_for(model_name: str) -> Path:
+    safe = re.sub(r"[^a-zA-Z0-9_.-]", "_", model_name)
+    return CACHE_DIR / f"skills_{safe}.json"
+
+
+def _load_disk_cache(model_name: str) -> dict[str, list[float]]:
+    p = _cache_path_for(model_name)
+    if not p.exists():
+        return {}
+    try:
+        return json.loads(p.read_text())
+    except Exception as exc:  # noqa: BLE001
+        LOG.debug("skill_selector cache read failed: %s", exc)
+        return {}
+
+
+def _save_disk_cache(model_name: str, data: dict[str, list[float]]) -> None:
+    p = _cache_path_for(model_name)
+    try:
+        p.write_text(json.dumps(data))
+    except Exception as exc:  # noqa: BLE001
+        LOG.debug("skill_selector cache write failed: %s", exc)
+
+
+def _ensure_skill_embeddings() -> dict[str, list[float]]:
+    """
+    Return ``{skill_name: vector}`` for the entire registry. Computes only
+    the vectors that aren't already cached. If no embedding model is
+    available, returns an empty dict (callers must fall back to keywords).
+    """
+    global _EMBEDS, _SKILLS
+    with _LOCK:
+        if not _SKILLS:
+            _SKILLS = skill_registry.load_all()
+        model = _try_load_model()
+        if not model:
+            return {}
+        model_name = os.getenv("ARCHITECT_EMBED_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
+        cache = _load_disk_cache(model_name)
+        missing: list[skill_registry.Skill] = []
+        result: dict[str, list[float]] = {}
+        for s in _SKILLS:
+            key = f"{s.name}:{_skill_hash(s)}"
+            if key in cache:
+                result[s.name] = cache[key]
+            else:
+                missing.append(s)
+        if missing:
+            try:
+                texts = [f"{m.name}\n{m.domain}\n{m.body[:2000]}" for m in missing]
+                vecs = model.encode(texts, normalize_embeddings=True).tolist()
+                for s, v in zip(missing, vecs):
+                    key = f"{s.name}:{_skill_hash(s)}"
+                    cache[key] = v
+                    result[s.name] = v
+                _save_disk_cache(model_name, cache)
+            except Exception as exc:  # noqa: BLE001
+                LOG.warning("skill_selector: embedding failed (%s) — keyword fallback", exc)
+                return {}
+        _EMBEDS = result
+        return result
+
+
+# ── similarity helpers ──────────────────────────────────────────────────────
+def _cosine(a: list[float], b: list[float]) -> float:
+    if not a or not b or len(a) != len(b):
+        return 0.0
+    dot = sum(x * y for x, y in zip(a, b))
+    na = math.sqrt(sum(x * x for x in a))
+    nb = math.sqrt(sum(y * y for y in b))
+    if na == 0 or nb == 0:
+        return 0.0
+    return dot / (na * nb)
+
+
+def _keyword_score(skill: skill_registry.Skill, tokens: set[str]) -> float:
+    """Pure-Python fallback ranker. Counts shared whitespace tokens."""
+    body_tokens = set(re.findall(r"[a-z0-9_-]{3,}", (skill.name + " " + skill.body).lower()))
+    if not body_tokens:
+        return 0.0
+    overlap = body_tokens & tokens
+    return len(overlap) / max(1, math.sqrt(len(body_tokens)))
+
+
+def _phase_boost(skill: skill_registry.Skill, phase: str) -> float:
+    needles = PHASE_BOOSTS.get(phase.lower(), ())
+    if not needles:
+        return 0.0
+    name = (skill.name + " " + skill.domain + " " + skill.path.as_posix()).lower()
+    return 0.10 * sum(1 for n in needles if n in name)
+
+
+# ── public API ──────────────────────────────────────────────────────────────
+@dataclass
+class Match:
+    skill: skill_registry.Skill
+    score: float
+    reason: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.skill.name,
+            "domain": self.skill.domain,
+            "path": str(self.skill.path),
+            "score": round(self.score, 4),
+            "reason": self.reason,
+        }
+
+
+def pack(
+    task_description: str,
+    *,
+    repo_languages: Iterable[str] | None = None,
+    repo_tech_stack: Iterable[str] | None = None,
+    attack_phase: str = "static",
+    top_k: int = 5,
+    pin: Iterable[str] | None = None,
+) -> list[Match]:
+    """
+    Return up to ``top_k`` matched skills (highest score first).
+
+    ``pin`` — names of skills that must always be included regardless of
+    score (useful for "always carry the bug-bounty methodology playbook").
+    """
+    if not _SKILLS:
+        _ensure_skill_embeddings()  # also populates _SKILLS even on fallback
+    if not _SKILLS:
+        return []
+
+    langs = [s.lower() for s in (repo_languages or [])]
+    techs = [s.lower() for s in (repo_tech_stack or [])]
+    query = " ".join([task_description, attack_phase, *langs, *techs])
+
+    embeds = _ensure_skill_embeddings()
+    use_embed = bool(embeds)
+    matches: list[Match] = []
+
+    if use_embed:
+        try:
+            qv = _MODEL.encode([query], normalize_embeddings=True).tolist()[0]
+        except Exception as exc:  # noqa: BLE001
+            LOG.warning("skill_selector: query encode failed (%s) — keyword fallback", exc)
+            use_embed = False
+
+    if use_embed:
+        for s in _SKILLS:
+            v = embeds.get(s.name)
+            if not v:
+                continue
+            score = _cosine(qv, v) + _phase_boost(s, attack_phase)
+            matches.append(Match(skill=s, score=score, reason="semantic"))
+    else:
+        tokens = set(re.findall(r"[a-z0-9_-]{3,}", query.lower()))
+        for s in _SKILLS:
+            score = _keyword_score(s, tokens) + _phase_boost(s, attack_phase)
+            matches.append(Match(skill=s, score=score, reason="keyword"))
+
+    # Boost via the registry's structured trigger profile too.
+    profile = {"languages": langs, "asset_types": techs, "frameworks": techs}
+    for m in matches:
+        m.score += 0.05 * m.skill.matches(profile)
+
+    matches.sort(key=lambda m: m.score, reverse=True)
+    chosen = matches[:top_k]
+    pinned = {p.lower() for p in (pin or [])}
+    if pinned:
+        already = {m.skill.name.lower() for m in chosen}
+        for s in _SKILLS:
+            if s.name.lower() in pinned and s.name.lower() not in already:
+                chosen.append(Match(skill=s, score=999.0, reason="pinned"))
+    return chosen
+
+
+def select_for_task(
+    task_description: str,
+    repo_languages: Iterable[str] | None = None,
+    repo_tech_stack: Iterable[str] | None = None,
+    attack_phase: str = "static",
+    top_k: int = 5,
+    pin: Iterable[str] | None = None,
+) -> str:
+    """
+    Render the matched skills into a context block ready to be prepended to
+    any LLM system prompt. Returns ``""`` when no skills match.
+    """
+    chosen = pack(
+        task_description,
+        repo_languages=repo_languages,
+        repo_tech_stack=repo_tech_stack,
+        attack_phase=attack_phase,
+        top_k=top_k,
+        pin=pin,
+    )
+    if not chosen:
+        return ""
+
+    parts: list[str] = ["<skills>"]
+    parts.append(
+        f"  <!-- Loaded {len(chosen)} skill(s) for phase={attack_phase!r}. "
+        "Apply them precisely; cite the skill name when you use it. -->"
+    )
+    for m in chosen:
+        parts.append(f"  <skill name=\"{m.skill.name}\" domain=\"{m.skill.domain}\" "
+                     f"score=\"{m.score:.3f}\" reason=\"{m.reason}\">")
+        parts.append(m.skill.body.strip())
+        parts.append("  </skill>")
+    parts.append("</skills>")
+    return "\n".join(parts)
+
+
+def explain(task_description: str, **kwargs: Any) -> dict[str, Any]:
+    """Diagnostic: returns the ranked match list as JSON-able dicts."""
+    chosen = pack(task_description, **kwargs)
+    return {
+        "task": task_description,
+        "engine": "semantic" if _try_load_model() else "keyword",
+        "matches": [m.to_dict() for m in chosen],
+    }
+
+
+def stats() -> dict[str, Any]:
+    skills = skill_registry.load_all()
+    embeds = _EMBEDS or {}
+    return {
+        "total_skills": len(skills),
+        "embedded_skills": len(embeds),
+        "engine": "semantic" if _try_load_model() else "keyword",
+        "cache_dir": str(CACHE_DIR),
+    }

architect/skills/ai-systems/agent-tool-abuse.md

@@ -0,0 +1,27 @@
+---
+name: agent-tool-abuse
+domain: ai-systems
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# agent-tool-abuse
+
+Function-calling abuse: arg smuggling, recursive tool calls, cost-DoS via tool loops, exfil via outbound HTTP tools, prompt-injected tool selection.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/ai-systems/ai-api-authentication-bypass.md

@@ -0,0 +1,27 @@
+---
+name: ai-api-authentication-bypass
+domain: ai-systems
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# ai-api-authentication-bypass
+
+OpenAI-compatible APIs without auth, model-name spoofing, key smuggling via headers, free-tier abuse via account farms, IDOR on threads/runs.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/ai-systems/llm-system-prompt-extraction.md

@@ -0,0 +1,27 @@
+---
+name: llm-system-prompt-extraction
+domain: ai-systems
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# llm-system-prompt-extraction
+
+Extraction prompts ('repeat verbatim ...'), token-by-token recovery, model-card leakage, sensitive system-prompt as oracle for downstream injection.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/ai-systems/model-inversion-attacks.md

@@ -0,0 +1,27 @@
+---
+name: model-inversion-attacks
+domain: ai-systems
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# model-inversion-attacks
+
+Membership inference, training-data extraction (verbatim recall), gradient leakage, attribute inference.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/ai-systems/prompt-injection-direct.md

@@ -0,0 +1,27 @@
+---
+name: prompt-injection-direct
+domain: ai-systems
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# prompt-injection-direct
+
+Direct PI: 'ignore previous instructions', role-swap, system-prompt extraction, jailbreaks via translation/obfuscation. Defenses: structured boundaries, allow-listed tools, output filters.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/ai-systems/prompt-injection-indirect.md

@@ -0,0 +1,27 @@
+---
+name: prompt-injection-indirect
+domain: ai-systems
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# prompt-injection-indirect
+
+Indirect PI from retrieved docs / web pages / emails. Test corpus: hidden instructions in HTML comments, base64 payloads, unicode tag chars (U+E0000).
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/ai-systems/rag-poisoning.md

@@ -0,0 +1,27 @@
+---
+name: rag-poisoning
+domain: ai-systems
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# rag-poisoning
+
+Poisoned chunks in vector DB, embedding-space adversarial vectors, doc-level instruction smuggling, source-priority confusion.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/automotive/autosar-architecture-security.md

@@ -0,0 +1,27 @@
+---
+name: autosar-architecture-security
+domain: automotive
+triggers:
+  languages: [automotive]
+severity_focus: [P1, P2, P3]
+---
+
+# autosar-architecture-security
+
+AUTOSAR Classic vs Adaptive: SecOC config gaps, IPsec for SOME/IP, OS partition isolation, BSW component trust boundaries.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/automotive/can-bus-attacks.md

@@ -0,0 +1,27 @@
+---
+name: can-bus-attacks
+domain: automotive
+triggers:
+  languages: [automotive]
+severity_focus: [P1, P2, P3]
+---
+
+# can-bus-attacks
+
+CAN: arbitration ID spoofing, DoS via dominant flooding, ECU reflashing, gateway misconfig allowing OBD-II -> CAN-A jumps.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/automotive/uds-iso14229-security.md

@@ -0,0 +1,27 @@
+---
+name: uds-iso14229-security
+domain: automotive
+triggers:
+  languages: [automotive]
+severity_focus: [P1, P2, P3]
+---
+
+# uds-iso14229-security
+
+UDS services: Security Access (0x27) seed/key brute, Routine Control abuse, Read/Write Memory unprotected, weak diagnostic-session auth.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/automotive/v2x-communication-security.md

@@ -0,0 +1,27 @@
+---
+name: v2x-communication-security
+domain: automotive
+triggers:
+  languages: [automotive]
+severity_focus: [P1, P2, P3]
+---
+
+# v2x-communication-security
+
+V2X (DSRC/C-V2X): pseudonym certificate misuse, replay of BSMs, misbehaviour detection bypass, PKI revocation latency.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/aviation/arinc429-security.md

@@ -0,0 +1,27 @@
+---
+name: arinc429-security
+domain: aviation
+triggers:
+  languages: [aviation]
+severity_focus: [P1, P2, P3]
+---
+
+# arinc429-security
+
+ARINC-429 unidirectional bus: lack of auth, source-spoofing on shared bus, label collision, gateway leaks to passenger network.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/aviation/avionics-software-patterns.md

@@ -0,0 +1,27 @@
+---
+name: avionics-software-patterns
+domain: aviation
+triggers:
+  languages: [aviation]
+severity_focus: [P1, P2, P3]
+---
+
+# avionics-software-patterns
+
+ARINC-653 partition leakage, IMA module isolation, RTCA DO-326A airworthiness security process, EASA Part-IS adoption.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/aviation/do178c-verification-gaps.md

@@ -0,0 +1,27 @@
+---
+name: do178c-verification-gaps
+domain: aviation
+triggers:
+  languages: [aviation]
+severity_focus: [P1, P2, P3]
+---
+
+# do178c-verification-gaps
+
+DO-178C objectives by DAL level, MC/DC coverage gaps, tool qualification (DO-330) skips, requirement-to-test traceability holes.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/binary/buffer-overflow-stack.md

@@ -0,0 +1,27 @@
+---
+name: buffer-overflow-stack
+domain: binary
+triggers:
+  languages: [c, cpp]
+severity_focus: [P1, P2, P3]
+---
+
+# buffer-overflow-stack
+
+Classic stack BO: detection patterns (strcpy/gets/sprintf/scanf %s), defences (canary/NX/ASLR/PIE), bypass primitives (info leak → ROP, ret2libc, ret2csu, partial overwrites).
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/binary/format-string-exploitation.md

@@ -0,0 +1,27 @@
+---
+name: format-string-exploitation
+domain: binary
+triggers:
+  languages: [c, cpp]
+severity_focus: [P1, P2, P3]
+---
+
+# format-string-exploitation
+
+printf-family with attacker-controlled format: arbitrary read (%n$s/x), arbitrary write (%n), GOT overwrites, leaks for ASLR bypass.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/binary/heap-exploitation-glibc.md

@@ -0,0 +1,27 @@
+---
+name: heap-exploitation-glibc
+domain: binary
+triggers:
+  languages: [c, cpp]
+severity_focus: [P1, P2, P3]
+---
+
+# heap-exploitation-glibc
+
+glibc heap: tcache poisoning, fastbin dup, unsorted bin attack, large bin attack, House of Force/Orange/Einherjar/Spirit/Pig, malloc_consolidate triggers.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/binary/integer-overflow-underflow.md

@@ -0,0 +1,27 @@
+---
+name: integer-overflow-underflow
+domain: binary
+triggers:
+  languages: [c, cpp, go, rust]
+severity_focus: [P1, P2, P3]
+---
+
+# integer-overflow-underflow
+
+Integer wraps lead to undersized allocations → BOF. Sinks: malloc(n*size), alloca, length checks. Mitigations: __builtin_*_overflow, checked_arith.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/binary/kernel-exploitation-linux.md

@@ -0,0 +1,27 @@
+---
+name: kernel-exploitation-linux
+domain: binary
+triggers:
+  languages: [c]
+severity_focus: [P1, P2, P3]
+---
+
+# kernel-exploitation-linux
+
+Linux kernel: ref-count UAFs, slab allocator (SLUB) feng-shui, eBPF verifier bugs, io_uring races, KASLR leaks, KPTI bypass concepts. Defence: KASAN/KCSAN/SMEP/SMAP/KPTI.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/binary/race-conditions-toctou.md

@@ -0,0 +1,27 @@
+---
+name: race-conditions-toctou
+domain: binary
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# race-conditions-toctou
+
+TOCTOU file-system races (access/open), shared-state races in async runtimes, double-fetch in syscalls, signal handler races.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/binary/rop-chain-construction.md

@@ -0,0 +1,27 @@
+---
+name: rop-chain-construction
+domain: binary
+triggers:
+  languages: [c, cpp, asm]
+severity_focus: [P1, P2, P3]
+---
+
+# rop-chain-construction
+
+ROP/SROP/COP/JOP. Tools: ROPgadget, ropper, pwntools.rop. Patterns: stack pivot, mprotect to RWX, dup2+execve, syscall-only chains for sandboxes.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/binary/type-confusion.md

@@ -0,0 +1,27 @@
+---
+name: type-confusion
+domain: binary
+triggers:
+  languages: [c, cpp]
+severity_focus: [P1, P2, P3]
+---
+
+# type-confusion
+
+C++ vtable confusion via reinterpret_cast, JIT engine type confusion (V8/SpiderMonkey), Java/.NET unsafe-cast in deserialization.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/binary/use-after-free.md

@@ -0,0 +1,27 @@
+---
+name: use-after-free
+domain: binary
+triggers:
+  languages: [c, cpp, rust-unsafe]
+severity_focus: [P1, P2, P3]
+---
+
+# use-after-free
+
+UAF: dangling pointer reuse, vtable hijack, type confusion via heap reuse. Detection via ASan/UBSan and KASAN for kernel. Patch patterns: smart pointers, IDs over pointers.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/cryptography/crypto-implementation-flaws.md

@@ -0,0 +1,27 @@
+---
+name: crypto-implementation-flaws
+domain: cryptography
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# crypto-implementation-flaws
+
+ECB instead of GCM, IV reuse with CTR/GCM, key reuse across protocols, lack of authenticated encryption, padding oracle (CBC), AES-NI side channels, Cryptopals classics.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/cryptography/key-management-flaws.md

@@ -0,0 +1,27 @@
+---
+name: key-management-flaws
+domain: cryptography
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# key-management-flaws
+
+Hard-coded keys, keys in env vars without rotation, missing key separation (sign vs encrypt), KMS misuse, JWT signing-key reuse across environments.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/cryptography/post-quantum-migration-risks.md

@@ -0,0 +1,27 @@
+---
+name: post-quantum-migration-risks
+domain: cryptography
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# post-quantum-migration-risks
+
+Hybrid KEM rollout pitfalls (X25519+Kyber), parameter confusion, downgrade vectors, harvest-now-decrypt-later threat model. NIST PQC suite status.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/cryptography/rng-weakness-patterns.md

@@ -0,0 +1,27 @@
+---
+name: rng-weakness-patterns
+domain: cryptography
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# rng-weakness-patterns
+
+Insecure RNG (Math.random, rand()), seeded with time(0)/PID, predictable session IDs, JWT secret derivation from PRNG, language-specific gotchas.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/cryptography/timing-side-channels.md

@@ -0,0 +1,27 @@
+---
+name: timing-side-channels
+domain: cryptography
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# timing-side-channels
+
+Non-constant-time string comparison for tokens/HMACs, branch-on-secret, table-lookup AES, RSA/ECC scalar mults; Lucky13, Bleichenbacher.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/cryptography/tls-ssl-attacks.md

@@ -0,0 +1,27 @@
+---
+name: tls-ssl-attacks
+domain: cryptography
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# tls-ssl-attacks
+
+BEAST/CRIME/BREACH/Lucky13/POODLE history; modern: weak cipher suites, missing HSTS preload, OCSP stapling gaps, mTLS misconfig, certificate pinning gaps.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/embedded-iot/arm-cortex-m-exploitation.md

@@ -0,0 +1,27 @@
+---
+name: arm-cortex-m-exploitation
+domain: embedded-iot
+triggers:
+  languages: [arm]
+severity_focus: [P1, P2, P3]
+---
+
+# arm-cortex-m-exploitation
+
+Cortex-M memory map, MPU misconfig, secure/non-secure (TrustZone-M) boundary bugs, FreeRTOS task starvation, vector table relocation.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/embedded-iot/firmware-extraction-analysis.md

@@ -0,0 +1,27 @@
+---
+name: firmware-extraction-analysis
+domain: embedded-iot
+triggers:
+  languages: [firmware]
+severity_focus: [P1, P2, P3]
+---
+
+# firmware-extraction-analysis
+
+Extraction: vendor portal, OTA capture, flash dump (SPI/eMMC), JTAG/SWD. Analysis: binwalk, unblob, Ghidra, find hard-coded keys & update URLs.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/embedded-iot/iot-cloud-api-attacks.md

@@ -0,0 +1,27 @@
+---
+name: iot-cloud-api-attacks
+domain: embedded-iot
+triggers:
+  languages: [iot]
+severity_focus: [P1, P2, P3]
+---
+
+# iot-cloud-api-attacks
+
+IoT cloud APIs: device-ID enumeration, claim/unclaim race, device-shadow IDOR, MQTT topic guess (deviceId in topic).
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/embedded-iot/rtos-security-freertos.md

@@ -0,0 +1,27 @@
+---
+name: rtos-security-freertos
+domain: embedded-iot
+triggers:
+  languages: [rtos]
+severity_focus: [P1, P2, P3]
+---
+
+# rtos-security-freertos
+
+FreeRTOS heap_4/heap_5 vulns, task priority inversion, interrupt-context misuse, stack-overflow detection (configCHECK_FOR_STACK_OVERFLOW).
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/embedded-iot/uart-jtag-debug-interfaces.md

@@ -0,0 +1,27 @@
+---
+name: uart-jtag-debug-interfaces
+domain: embedded-iot
+triggers:
+  languages: [hardware]
+severity_focus: [P1, P2, P3]
+---
+
+# uart-jtag-debug-interfaces
+
+UART pad identification (TX/RX/GND/VCC), baud-rate sweep, JTAG fingerprinting (JTAGulator), SWD on Cortex-M, glitching attacks.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/infrastructure/aws-iam-escalation.md

@@ -0,0 +1,27 @@
+---
+name: aws-iam-escalation
+domain: infrastructure
+triggers:
+  languages: [aws]
+severity_focus: [P1, P2, P3]
+---
+
+# aws-iam-escalation
+
+AWS privesc: iam:PassRole + ec2 RunInstances, lambda:UpdateFunctionCode, iam:CreateAccessKey on self, sts:AssumeRole loops, S3 bucket policy + replication abuse.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/infrastructure/ci-cd-pipeline-attacks.md

@@ -0,0 +1,27 @@
+---
+name: ci-cd-pipeline-attacks
+domain: infrastructure
+triggers:
+  languages: [github-actions, gitlab, jenkins]
+severity_focus: [P1, P2, P3]
+---
+
+# ci-cd-pipeline-attacks
+
+GitHub Actions: pull_request_target + checkout untrusted code, expression injection in run:, workflow_run from forks, cache poisoning, OIDC trust misconfig.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/infrastructure/docker-container-escape.md

@@ -0,0 +1,27 @@
+---
+name: docker-container-escape
+domain: infrastructure
+triggers:
+  languages: [docker]
+severity_focus: [P1, P2, P3]
+---
+
+# docker-container-escape
+
+Container escapes: privileged + cgroup release_agent, mount /proc, exposed docker.sock, capabilities (CAP_SYS_ADMIN/CAP_NET_ADMIN), kernel-bug pivots, runc CVE-2019-5736 class.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/infrastructure/kubernetes-rbac-misconfig.md

@@ -0,0 +1,27 @@
+---
+name: kubernetes-rbac-misconfig
+domain: infrastructure
+triggers:
+  languages: [kubernetes]
+severity_focus: [P1, P2, P3]
+---
+
+# kubernetes-rbac-misconfig
+
+K8s RBAC: cluster-admin overuse, service-account token mounted in unrelated pods, RoleBinding -> privileged namespace pivot, exec/portforward verb abuse, etcd plaintext.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/infrastructure/secrets-in-code.md

@@ -0,0 +1,27 @@
+---
+name: secrets-in-code
+domain: infrastructure
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# secrets-in-code
+
+Detection patterns: AWS keys (AKIA*), GitHub PATs (ghp_*/gho_*), GCP SA JSON, Slack tokens, Stripe keys. Always run trufflehog over full git history.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/infrastructure/supply-chain-attacks.md

@@ -0,0 +1,27 @@
+---
+name: supply-chain-attacks
+domain: infrastructure
+triggers:
+  languages: [any]
+severity_focus: [P1, P2, P3]
+---
+
+# supply-chain-attacks
+
+Typo-squatting, dep confusion, malicious post-install scripts, namespace hijack, build-tool plugin compromise, signed-attestation gaps (SLSA).
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/languages/c-cpp-memory-safety.md

@@ -0,0 +1,27 @@
+---
+name: c-cpp-memory-safety
+domain: languages
+triggers:
+  languages: [c, cpp]
+severity_focus: [P1, P2, P3]
+---
+
+# c-cpp-memory-safety
+
+Memory-safety in C/C++: out-of-bounds, UAF, double-free, missing length checks. Tools: ASan/MSan/UBSan, Coverity, CodeQL. Modernisation: std::span, std::string_view, RAII.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/languages/go-concurrency-races.md

@@ -0,0 +1,27 @@
+---
+name: go-concurrency-races
+domain: languages
+triggers:
+  languages: [go]
+severity_focus: [P1, P2, P3]
+---
+
+# go-concurrency-races
+
+Go: data races on shared maps, channel close-after-write, sync.WaitGroup misuse, context leaks, goroutine leaks via blocked send. Detection: go test -race.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/languages/java-security-patterns.md

@@ -0,0 +1,27 @@
+---
+name: java-security-patterns
+domain: languages
+triggers:
+  languages: [java, kotlin, scala]
+severity_focus: [P1, P2, P3]
+---
+
+# java-security-patterns
+
+Spring/Tomcat sinks: ObjectInputStream, Spring SpEL, MyBatis SQL fragments, Velocity SSTI, JNDI lookups (Log4Shell), SnakeYAML.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/languages/javascript-node-security.md

@@ -0,0 +1,27 @@
+---
+name: javascript-node-security
+domain: languages
+triggers:
+  languages: [javascript, typescript, node]
+severity_focus: [P1, P2, P3]
+---
+
+# javascript-node-security
+
+Node sinks: child_process.exec, vm/vm2 escape gadgets, eval/Function, require() with user path, fs operations on attacker paths, prototype pollution gadgets.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/languages/php-security-legacy.md

@@ -0,0 +1,27 @@
+---
+name: php-security-legacy
+domain: languages
+triggers:
+  languages: [php]
+severity_focus: [P1, P2, P3]
+---
+
+# php-security-legacy
+
+PHP: include()/require() with user input → LFI/RFI, unserialize(), assert() string eval, type juggling (== vs ===), magic methods on attacker-controlled objects.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/languages/python-injection-patterns.md

@@ -0,0 +1,27 @@
+---
+name: python-injection-patterns
+domain: languages
+triggers:
+  languages: [python]
+severity_focus: [P1, P2, P3]
+---
+
+# python-injection-patterns
+
+Python sinks: eval/exec/compile, subprocess shell=True, os.system, pickle.loads, yaml.load (pre-5.1), jinja2 SSTI, ORM raw().format().
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector

architect/skills/languages/rust-unsafe-patterns.md

@@ -0,0 +1,27 @@
+---
+name: rust-unsafe-patterns
+domain: languages
+triggers:
+  languages: [rust]
+severity_focus: [P1, P2, P3]
+---
+
+# rust-unsafe-patterns
+
+Rust unsafe blocks: lifetime extension, transmute, raw-pointer arithmetic, FFI boundary mistakes, Send/Sync soundness bugs (Cell/UnsafeCell). Detection: cargo-geiger, MIRI.
+
+## Detection checklist
+- enumerate exposure
+- match canonical sinks
+- confirm reproducibility
+- map to CWE / OWASP / CVSS
+
+## Exploitation primitives
+- reproduce in lab
+- minimise the PoC
+- assess blast radius
+
+## Reporting fingerprint
+- include affected version range
+- include suggested fix snippet
+- include CVSS 3.1 vector