better-dsh 0.2.4 → 0.2.5

package/docs/80_upstream-docs-and-skills/hermes-dev-skill/src/docs/user-guide/skills/optional/research/research-blogwatcher.md

@@ -0,0 +1,162 @@
+---
+title: "Blogwatcher — Monitor blogs and RSS/Atom feeds via blogwatcher-cli tool"
+sidebar_label: "Blogwatcher"
+description: "Monitor blogs and RSS/Atom feeds via blogwatcher-cli tool"
+---
+
+{/* This page is auto-generated from the skill's SKILL.md by website/scripts/generate-skill-docs.py. Edit the source SKILL.md, not this page. */}
+
+# Blogwatcher
+
+Monitor blogs and RSS/Atom feeds via blogwatcher-cli tool.
+
+## Skill metadata
+
+| | |
+|---|---|
+| Source | Optional — install with `hermes skills install official/research/blogwatcher` |
+| Path | `optional-skills/research/blogwatcher` |
+| Version | `2.0.0` |
+| Author | JulienTant (fork of Hyaxia/blogwatcher) |
+| License | MIT |
+| Platforms | linux, macos, windows |
+| Tags | `RSS`, `Blogs`, `Feed-Reader`, `Monitoring` |
+
+## Reference: full SKILL.md
+
+:::info
+The following is the complete skill definition that Hermes loads when this skill is triggered. This is what the agent sees as instructions when the skill is active.
+:::
+
+# Blogwatcher
+
+Track blog and RSS/Atom feed updates with the `blogwatcher-cli` tool. Supports automatic feed discovery, HTML scraping fallback, OPML import, and read/unread article management.
+
+## Working with Hermes tools (read this first)
+
+`blogwatcher-cli` is the feed database; Hermes tools do the automation around it:
+
+- **Recurring watch — use the cronjob tool's `monitor` field, not a bare schedule.** `monitor` runs a script each tick and only wakes the agent when output changes: set it to a script that runs `blogwatcher-cli scan >/dev/null 2>&1 && blogwatcher-cli articles` (deterministic output; new articles = changed output = agent wakes with the diff injected). Unchanged ticks cost zero LLM calls. Set `deliver` to route digests to a chat/channel; add `continuity: true` so consecutive digests can dedupe.
+- **Reading an article the user asks about**: `web_extract([url])` on the article URL from `blogwatcher-cli articles` — do not re-scrape by hand.
+- **One-off "watch this page for changes" without feed semantics**: skip this skill; the cronjob tool's `monitor` field accepts an http(s) URL directly.
+- **One-off read of a feed or a site's latest posts, nothing to install**: the bundled `rss-feeds` skill (`scripts/feed.py read URL`); blogwatcher earns its install when you track many feeds with read/unread state.
+- **Company/competitor tracking with analysis and citations**: prefer the `competitor-news-monitor` skill; blogwatcher is the lighter raw-feed layer it can sit on.
+
+## Installation
+
+Pick one method:
+
+- **Go:** `go install github.com/JulienTant/blogwatcher-cli/cmd/blogwatcher-cli@latest`
+- **Docker:** `docker run --rm -v blogwatcher-cli:/data ghcr.io/julientant/blogwatcher-cli`
+- **Binary (Linux amd64):** `curl -sL https://github.com/JulienTant/blogwatcher-cli/releases/latest/download/blogwatcher-cli_linux_amd64.tar.gz | tar xz -C /usr/local/bin blogwatcher-cli`
+- **Binary (Linux arm64):** `curl -sL https://github.com/JulienTant/blogwatcher-cli/releases/latest/download/blogwatcher-cli_linux_arm64.tar.gz | tar xz -C /usr/local/bin blogwatcher-cli`
+- **Binary (macOS Apple Silicon):** `curl -sL https://github.com/JulienTant/blogwatcher-cli/releases/latest/download/blogwatcher-cli_darwin_arm64.tar.gz | tar xz -C /usr/local/bin blogwatcher-cli`
+- **Binary (macOS Intel):** `curl -sL https://github.com/JulienTant/blogwatcher-cli/releases/latest/download/blogwatcher-cli_darwin_amd64.tar.gz | tar xz -C /usr/local/bin blogwatcher-cli`
+
+All releases: https://github.com/JulienTant/blogwatcher-cli/releases
+
+### Docker with persistent storage
+
+By default the database lives at `~/.blogwatcher-cli/blogwatcher-cli.db`. In Docker this is lost on container restart. Use `BLOGWATCHER_DB` or a volume mount to persist it:
+
+```bash
+# Named volume (simplest)
+docker run --rm -v blogwatcher-cli:/data -e BLOGWATCHER_DB=/data/blogwatcher-cli.db ghcr.io/julientant/blogwatcher-cli scan
+
+# Host bind mount
+docker run --rm -v /path/on/host:/data -e BLOGWATCHER_DB=/data/blogwatcher-cli.db ghcr.io/julientant/blogwatcher-cli scan
+```
+
+### Migrating from the original blogwatcher
+
+If upgrading from `Hyaxia/blogwatcher`, move your database:
+
+```bash
+mv ~/.blogwatcher/blogwatcher.db ~/.blogwatcher-cli/blogwatcher-cli.db
+```
+
+The binary name changed from `blogwatcher` to `blogwatcher-cli`.
+
+## Common Commands
+
+### Managing blogs
+
+- Add a blog: `blogwatcher-cli add "My Blog" https://example.com`
+- Add with explicit feed: `blogwatcher-cli add "My Blog" https://example.com --feed-url https://example.com/feed.xml`
+- Add with HTML scraping: `blogwatcher-cli add "My Blog" https://example.com --scrape-selector "article h2 a"`
+- List tracked blogs: `blogwatcher-cli blogs`
+- Remove a blog: `blogwatcher-cli remove "My Blog" --yes`
+- Import from OPML: `blogwatcher-cli import subscriptions.opml`
+
+### Scanning and reading
+
+- Scan all blogs: `blogwatcher-cli scan`
+- Scan one blog: `blogwatcher-cli scan "My Blog"`
+- List unread articles: `blogwatcher-cli articles`
+- List all articles: `blogwatcher-cli articles --all`
+- Filter by blog: `blogwatcher-cli articles --blog "My Blog"`
+- Filter by category: `blogwatcher-cli articles --category "Engineering"`
+- Mark article read: `blogwatcher-cli read 1`
+- Mark article unread: `blogwatcher-cli unread 1`
+- Mark all read: `blogwatcher-cli read-all`
+- Mark all read for a blog: `blogwatcher-cli read-all --blog "My Blog" --yes`
+
+## Environment Variables
+
+All flags can be set via environment variables with the `BLOGWATCHER_` prefix:
+
+| Variable | Description |
+|---|---|
+| `BLOGWATCHER_DB` | Path to SQLite database file |
+| `BLOGWATCHER_WORKERS` | Number of concurrent scan workers (default: 8) |
+| `BLOGWATCHER_SILENT` | Only output "scan done" when scanning |
+| `BLOGWATCHER_YES` | Skip confirmation prompts |
+| `BLOGWATCHER_CATEGORY` | Default filter for articles by category |
+
+## Example Output
+
+```
+$ blogwatcher-cli blogs
+Tracked blogs (1):
+
+  xkcd
+    URL: https://xkcd.com
+    Feed: https://xkcd.com/atom.xml
+    Last scanned: 2026-04-03 10:30
+```
+
+```
+$ blogwatcher-cli scan
+Scanning 1 blog(s)...
+
+  xkcd
+    Source: RSS | Found: 4 | New: 4
+
+Found 4 new article(s) total!
+```
+
+```
+$ blogwatcher-cli articles
+Unread articles (2):
+
+  [1] [new] Barrel - Part 13
+       Blog: xkcd
+       URL: https://xkcd.com/3095/
+       Published: 2026-04-02
+       Categories: Comics, Science
+
+  [2] [new] Volcano Fact
+       Blog: xkcd
+       URL: https://xkcd.com/3094/
+       Published: 2026-04-01
+       Categories: Comics
+```
+
+## Notes
+
+- Auto-discovers RSS/Atom feeds from blog homepages when no `--feed-url` is provided.
+- Falls back to HTML scraping if RSS fails and `--scrape-selector` is configured.
+- Categories from RSS/Atom feeds are stored and can be used to filter articles.
+- Import blogs in bulk from OPML files exported by Feedly, Inoreader, NewsBlur, etc.
+- Database stored at `~/.blogwatcher-cli/blogwatcher-cli.db` by default (override with `--db` or `BLOGWATCHER_DB`).
+- Use `blogwatcher-cli <command> --help` to discover all flags and options.

package/docs/80_upstream-docs-and-skills/hermes-dev-skill/src/docs/user-guide/skills/optional/research/research-darwinian-evolver.md

@@ -0,0 +1,217 @@
+---
+title: "Darwinian Evolver — Evolve prompts/regex/SQL/code with Imbue's evolution loop"
+sidebar_label: "Darwinian Evolver"
+description: "Evolve prompts/regex/SQL/code with Imbue's evolution loop"
+---
+
+{/* This page is auto-generated from the skill's SKILL.md by website/scripts/generate-skill-docs.py. Edit the source SKILL.md, not this page. */}
+
+# Darwinian Evolver
+
+Evolve prompts/regex/SQL/code with Imbue's evolution loop.
+
+## Skill metadata
+
+| | |
+|---|---|
+| Source | Optional — install with `hermes skills install official/research/darwinian-evolver` |
+| Path | `optional-skills/research\darwinian-evolver` |
+| Version | `0.1.0` |
+| Author | Bihruze (Asahi0x), Hermes Agent |
+| License | MIT |
+| Platforms | linux, macos |
+| Tags | `evolution`, `optimization`, `prompt-engineering`, `research` |
+| Related skills | [`arxiv`](/docs/user-guide/skills/bundled/research/research-arxiv), [`jupyter-notebook`](/docs/user-guide/skills/optional/data-science/data-science-jupyter-notebook) |
+
+## Reference: full SKILL.md
+
+:::info
+The following is the complete skill definition that Hermes loads when this skill is triggered. This is what the agent sees as instructions when the skill is active.
+:::
+
+# Darwinian Evolver
+
+Run Imbue's [darwinian_evolver](https://github.com/imbue-ai/darwinian_evolver) — an
+LLM-driven evolutionary search loop — to optimize a **prompt, regex, SQL query,
+or small code snippet** against a fitness function.
+
+Status: thin wrapper around the upstream tool. The skill installs it, walks the
+agent through writing a `Problem` definition (organism + evaluator + mutator),
+and drives the loop via the upstream CLI or a small custom Python driver.
+
+**License:** the upstream tool is **AGPL-3.0**. The skill ONLY ever invokes it
+via the upstream CLI or a `subprocess`/`uv run` call (mere aggregation). Do NOT
+import upstream classes into Hermes itself.
+
+## When to Use
+
+- User says "optimize this prompt", "evolve a regex for X", "auto-improve this
+  code/SQL", "search for a better instruction".
+- You have a scorer (exact match, regex pass-rate, unit test, LLM-judge, runtime
+  metric) AND a starting candidate (organism). If you don't have a scorer, stop
+  and define one first — that's the hard part.
+- Cost is OK: a typical run is 50–500 LLM calls. On gpt-4o-mini that's pennies;
+  on Claude Sonnet it can be a few dollars.
+
+Do **not** use this when:
+- The optimization target is differentiable (use gradient descent / DSPy).
+- You only need to try 2–3 variants — just write them by hand.
+- The fitness signal is purely subjective with no measurable criterion.
+
+## Prerequisites
+
+- Python ≥3.11
+- `git`, `uv` (or `pip`)
+- One of: `OPENROUTER_API_KEY`, `ANTHROPIC_API_KEY`, or `OPENAI_API_KEY`
+
+The skill ships a small `parrot_openrouter.py` driver that uses `OPENROUTER_API_KEY`
+via the OpenAI SDK, so any model on OpenRouter works. The upstream CLI itself
+hardcodes Anthropic and needs `ANTHROPIC_API_KEY`.
+
+## Install (One-Time)
+
+Run via the `terminal` tool:
+
+```bash
+mkdir -p ~/.hermes/cache/darwinian-evolver && cd ~/.hermes/cache/darwinian-evolver
+[ -d darwinian_evolver ] || git clone --depth 1 https://github.com/imbue-ai/darwinian_evolver.git
+cd darwinian_evolver && uv sync
+```
+
+Verify:
+
+```bash
+cd ~/.hermes/cache/darwinian-evolver/darwinian_evolver \
+  && uv run darwinian_evolver --help | head -5
+```
+
+## Quick Start — The Built-In Parrot Example
+
+Tiny smoke test (requires `ANTHROPIC_API_KEY`):
+
+```bash
+cd ~/.hermes/cache/darwinian-evolver/darwinian_evolver
+uv run darwinian_evolver parrot \
+  --num_iterations 2 \
+  --num_parents_per_iteration 2 \
+  --mutator_concurrency 2 --evaluator_concurrency 2 \
+  --output_dir /tmp/parrot_demo
+```
+
+Outputs:
+- `/tmp/parrot_demo/snapshots/iteration_N.pkl` — pickled population per iteration
+- `/tmp/parrot_demo/<jsonl>` — per-iteration JSON log (path printed at end)
+
+Open `~/.hermes/cache/darwinian-evolver/darwinian_evolver/darwinian_evolver/lineage_visualizer.html`
+in a browser and load the JSON log to see the evolutionary tree.
+
+## Quick Start — OpenRouter Driver (No Anthropic Key)
+
+The skill ships `scripts/parrot_openrouter.py` — same parrot problem, but the
+LLM call goes through OpenRouter so any provider works.
+
+```bash
+# From wherever the skill is installed:
+SKILL_DIR=~/.hermes/skills/research/darwinian-evolver
+DE_DIR=~/.hermes/cache/darwinian-evolver/darwinian_evolver
+
+cd "$DE_DIR" && \
+  EVOLVER_MODEL='openai/gpt-4o-mini' \
+  uv run --with openai python "$SKILL_DIR/scripts/parrot_openrouter.py" \
+    --num_iterations 3 --num_parents_per_iteration 2 \
+    --output_dir /tmp/parrot_or
+```
+
+Inspect the result with `scripts/show_snapshot.py`:
+
+```bash
+uv run --with openai python "$SKILL_DIR/scripts/show_snapshot.py" \
+  /tmp/parrot_or/snapshots/iteration_3.pkl
+```
+
+Expected output: 7 evolved prompt templates ranked by score, with the best
+landing around 0.6–0.8 (the seed `Say {{ phrase }}` scored 0.000).
+
+## Defining a Custom Problem
+
+The skill ships `templates/custom_problem_template.py` — copy, edit, run.
+Three things you must define:
+
+1. **`Organism`** — a Pydantic `BaseModel` subclass holding the artifact being
+   evolved (`prompt_template: str`, `regex_pattern: str`, `sql_query: str`,
+   `code_block: str`, etc.). Add a `run(*args)` method that exercises it.
+
+2. **`Evaluator`** — `.evaluate(organism) -> EvaluationResult(score=..., trainable_failure_cases=[...], holdout_failure_cases=[...], is_viable=True)`.
+   - **`score`** is in `[0, 1]`. Higher is better.
+   - **`trainable_failure_cases`** — what the mutator sees. Include enough
+     context (input, expected, actual) for the LLM to diagnose.
+   - **`holdout_failure_cases`** — kept out of the mutator's view. Use these
+     to detect overfitting.
+   - **`is_viable=True`** unless the organism is completely broken (raises,
+     returns None, etc.). A 0-score viable organism is fine — it just gets
+     down-weighted in parent selection.
+
+3. **`Mutator`** — `.mutate(organism, failure_cases, learning_log_entries) -> list[Organism]`.
+   Typically: build an LLM prompt that includes the current organism + a
+   failure case + an ask to propose a fix; parse the LLM's response; return
+   a new `Organism`. Return `[]` on parse failure — the loop handles it.
+
+Then write a driver script that wires `Problem(initial_organism, evaluator, [mutators])`
+into `EvolveProblemLoop` and iterates over `loop.run(num_iterations=N)` — the
+shipped `scripts/parrot_openrouter.py` is the reference.
+
+## Hyperparameters That Actually Matter
+
+| flag | default | when to change |
+|---|---|---|
+| `--num_iterations` | 5 | bump to 10–20 once you trust the evaluator |
+| `--num_parents_per_iteration` | 4 | drop to 2 for cheap exploration |
+| `--mutator_concurrency` | 10 | drop to 2–4 to avoid rate limits |
+| `--evaluator_concurrency` | 10 | same; evaluator hits the LLM too |
+| `--batch_size` | 1 | raise to 3–5 once your mutator handles multiple failures |
+| `--verify_mutations` | off | turn on once mutator is wasteful (>10× cost saving on later runs per Imbue) |
+| `--midpoint_score` | `p75` | leave alone unless scores cluster |
+| `--sharpness` | 10 | leave alone |
+
+## Pitfalls
+
+1. **`Initial organism must be viable`** — set `is_viable=True` in your
+   `EvaluationResult` even on a 0-score seed. The loop refuses non-viable
+   organisms because they imply the loop has nothing to evolve from.
+2. **Provider content filters kill runs.** Azure-backed OpenRouter models
+   reject phrases like "ignore previous instructions" with HTTP 400. Wrap
+   the LLM call in `try/except` and return `f"<LLM_ERROR: {e}>"` — the
+   evolver will just score that organism 0 and move on.
+3. **`loop.run()` is a generator** — calling it doesn't run anything until
+   you iterate. Use `for snap in loop.run(num_iterations=N):`.
+4. **Snapshots are nested pickles.** `iteration_N.pkl` contains a dict with
+   `population_snapshot` (more pickled bytes). To unpickle you must have the
+   `Organism` class importable under the same dotted path it was pickled at.
+5. **Concurrency defaults are aggressive.** 10/10 will hit rate limits on
+   most providers. Start with 2/2.
+6. **CLI is hardcoded to Anthropic.** `uv run darwinian_evolver <problem>`
+   reaches for `ANTHROPIC_API_KEY` and uses Claude Sonnet. To use any other
+   provider, write a driver like `parrot_openrouter.py`.
+7. **AGPL.** Never `from darwinian_evolver import ...` inside Hermes core.
+   Custom driver scripts under `~/.hermes/skills/...` are user-side and fine.
+8. **No PyPI package.** `pip install darwinian-evolver` will pull the wrong
+   thing. Always install from the GitHub repo.
+
+## Verification
+
+After install + a parrot run, exit code 0 from this is sufficient:
+
+```bash
+DE_DIR=~/.hermes/cache/darwinian-evolver/darwinian_evolver
+ls "$DE_DIR/darwinian_evolver/lineage_visualizer.html" >/dev/null && \
+cd "$DE_DIR" && uv run darwinian_evolver --help >/dev/null && \
+echo "darwinian-evolver: OK"
+```
+
+## References
+
+- [Imbue research post](https://imbue.com/research/2026-02-27-darwinian-evolver/)
+- [ARC-AGI-2 results](https://imbue.com/research/2026-02-27-arc-agi-2-evolution/)
+- [imbue-ai/darwinian_evolver](https://github.com/imbue-ai/darwinian_evolver) (AGPL-3.0)
+- [Darwin Gödel Machines](https://arxiv.org/abs/2505.22954)
+- [PromptBreeder](https://arxiv.org/abs/2309.16797)

package/docs/80_upstream-docs-and-skills/hermes-dev-skill/src/docs/user-guide/skills/optional/research/research-domain-intel.md

@@ -0,0 +1,121 @@
+---
+title: "Domain Intel — Passive recon of subdomains, SSL certs, WHOIS, and DNS"
+sidebar_label: "Domain Intel"
+description: "Passive recon of subdomains, SSL certs, WHOIS, and DNS"
+---
+
+{/* This page is auto-generated from the skill's SKILL.md by website/scripts/generate-skill-docs.py. Edit the source SKILL.md, not this page. */}
+
+# Domain Intel
+
+Passive recon of subdomains, SSL certs, WHOIS, and DNS.
+
+## Skill metadata
+
+| | |
+|---|---|
+| Source | Optional — install with `hermes skills install official/research/domain-intel` |
+| Path | `optional-skills/research\domain-intel` |
+| Version | `1.0.0` |
+| Author | FurkanL0, Hermes Agent |
+| License | MIT |
+| Platforms | linux, macos, windows |
+| Tags | `Domains`, `OSINT`, `DNS`, `Research` |
+
+## Reference: full SKILL.md
+
+:::info
+The following is the complete skill definition that Hermes loads when this skill is triggered. This is what the agent sees as instructions when the skill is active.
+:::
+
+# Domain Intelligence — Passive OSINT
+
+Passive domain reconnaissance using only Python stdlib.
+**Zero dependencies. Zero API keys. Works on Linux, macOS, and Windows.**
+
+## Helper script
+
+This skill includes `scripts/domain_intel.py` — a complete CLI tool for all domain intelligence operations.
+
+```bash
+# Subdomain discovery via Certificate Transparency logs
+python SKILL_DIR/scripts/domain_intel.py subdomains example.com
+
+# SSL certificate inspection (expiry, cipher, SANs, issuer)
+python SKILL_DIR/scripts/domain_intel.py ssl example.com
+
+# WHOIS lookup (registrar, dates, name servers — 100+ TLDs)
+python SKILL_DIR/scripts/domain_intel.py whois example.com
+
+# DNS records (A, AAAA, MX, NS, TXT, CNAME)
+python SKILL_DIR/scripts/domain_intel.py dns example.com
+
+# Domain availability check (passive: DNS + WHOIS + SSL signals)
+python SKILL_DIR/scripts/domain_intel.py available coolstartup.io
+
+# Bulk analysis — multiple domains, multiple checks in parallel
+python SKILL_DIR/scripts/domain_intel.py bulk example.com github.com google.com
+python SKILL_DIR/scripts/domain_intel.py bulk example.com github.com --checks ssl,dns
+```
+
+`SKILL_DIR` is the directory containing this SKILL.md file. All output is structured JSON.
+
+## Available commands
+
+| Command | What it does | Data source |
+|---------|-------------|-------------|
+| `subdomains` | Find subdomains from certificate logs | crt.sh (HTTPS) |
+| `ssl` | Inspect TLS certificate details | Direct TCP:443 to target |
+| `whois` | Registration info, registrar, dates | WHOIS servers (TCP:43) |
+| `dns` | A, AAAA, MX, NS, TXT, CNAME records | System DNS + Google DoH |
+| `available` | Check if domain is registered | DNS + WHOIS + SSL signals |
+| `bulk` | Run multiple checks on multiple domains | All of the above |
+
+## When to use this vs built-in tools
+
+- **Use this skill** for infrastructure questions: subdomains, SSL certs, WHOIS, DNS records, availability
+- **Use `web_search`** for general research about what a domain/company does
+- **Use `web_extract`** to get the actual content of a webpage
+- **Use `terminal` with `curl -I`** for a simple "is this URL reachable" check
+
+| Task | Better tool | Why |
+|------|-------------|-----|
+| "What does example.com do?" | `web_extract` | Gets page content, not DNS/WHOIS data |
+| "Find info about a company" | `web_search` | General research, not domain-specific |
+| "Is this website safe?" | `web_search` | Reputation checks need web context |
+| "Check if a URL is reachable" | `terminal` with `curl -I` | Simple HTTP check |
+| "Find subdomains of X" | **This skill** | Only passive source for this |
+| "When does the SSL cert expire?" | **This skill** | Built-in tools can't inspect TLS |
+| "Who registered this domain?" | **This skill** | WHOIS data not in web search |
+| "Is coolstartup.io available?" | **This skill** | Passive availability via DNS+WHOIS+SSL |
+
+## Platform compatibility
+
+Pure Python stdlib (`socket`, `ssl`, `urllib`, `json`, `concurrent.futures`).
+Works identically on Linux, macOS, and Windows with no dependencies.
+
+- **crt.sh queries** use HTTPS (port 443) — works behind most firewalls
+- **WHOIS queries** use TCP port 43 — may be blocked on restrictive networks
+- **DNS queries** use Google DoH (HTTPS) for MX/NS/TXT — firewall-friendly
+- **SSL checks** connect to the target on port 443 — the only "active" operation
+
+## Data sources
+
+All queries are **passive** — no port scanning, no vulnerability testing:
+
+- **crt.sh** — Certificate Transparency logs (subdomain discovery, HTTPS only)
+- **WHOIS servers** — Direct TCP to 100+ authoritative TLD registrars
+- **Google DNS-over-HTTPS** — MX, NS, TXT, CNAME resolution (firewall-friendly)
+- **System DNS** — A/AAAA record resolution
+- **SSL check** is the only "active" operation (TCP connection to target:443)
+
+## Notes
+
+- WHOIS queries use TCP port 43 — may be blocked on restrictive networks
+- Some WHOIS servers redact registrant info (GDPR) — mention this to the user
+- crt.sh can be slow for very popular domains (thousands of certs) — set reasonable expectations
+- The availability check is heuristic-based (3 passive signals) — not authoritative like a registrar API
+
+---
+
+*Contributed by [@FurkanL0](https://github.com/FurkanL0)*