opencode-skills-collection 4.0.66 → 4.0.67

package/bundled-skills/.antigravity-install-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "updatedAt": "2026-09-18T01:54:43.223Z",
+  "updatedAt": "2026-09-19T01:59:35.529Z",
   "entries": [
     "00-andruia-consultant",
     "007",
@@ -345,6 +345,7 @@
     "bdi-mental-states",
     "bdistill-behavioral-xray",
     "bdistill-knowledge-extraction",
+    "beatra-ai-video-studio",
     "beautiful-prose",
     "before-you-build",
     "behavioral-modes",
@@ -1270,6 +1271,7 @@
     "mermaid-expert",
     "mesh-memory",
     "metasploit-framework",
+    "meteora-dlmm-pool-screening",
     "micro-saas-launcher",
     "microservices-patterns",
     "microsoft-azure-webjobs-extensions-authentication-events-dotnet",

package/bundled-skills/beatra-ai-video-studio/SKILL.md

@@ -0,0 +1,272 @@
+---
+name: beatra-ai-video-studio
+description: "Install and use the official Beatra AI Video Studio package, pinned by digest, for paid text-to-video, image-to-video, and video edit or extend jobs on the hosted Beatra service."
+category: media
+risk: critical
+source: community
+source_repo: beatra-ai/beatra-skills
+source_type: official
+date_added: "2026-09-17"
+author: beatra-ai
+tags: [video-generation, text-to-video, image-to-video, video-editing, mcp, paid-api, beatra]
+tools: [claude, codex, cursor, gemini]
+license: "MIT-0"
+license_source: "https://github.com/beatra-ai/beatra-skills/blob/95d662f7aeddd6e2aa6da9e14f9c985e3f6b914d/LICENSE"
+---
+
+# Beatra AI Video Studio
+
+## Overview
+
+Beatra AI Video Studio is Beatra's official agent package for short AI video
+work: text-to-video, image-to-video, first/last-frame interpolation,
+reference-guided generation, and editing or extending an existing clip. The
+video is produced on the hosted, paid Beatra service (`mcp.beatra.ai`).
+
+This catalog entry is a **reviewed pointer, not the executable package**. It
+contains no client code and performs no Beatra operation by itself. The package
+it points to bundles three standard-library Python scripts that make network
+calls, store a credential, and can replace their own files. Read
+[Install](#install-pinned-verified-approved-twice) and
+[Security & Safety Notes](#security--safety-notes) before activating it.
+
+| Pinned identity | Value |
+| --- | --- |
+| Package | `beatra-ai-video-studio` `1.2.5` |
+| Archive | `https://cdn.beatra.ai/agent-packages/beatra-ai-video-studio/v1.2.5/beatra-ai-video-studio-skill-1.2.5.zip` |
+| Archive SHA-256 | `679a3ddc06c7be631ef31f002f918465a26f17a189ffac723f45dfd348e1fc4a` |
+| Source tree | [`beatra-ai/beatra-skills@95d662f`](https://github.com/beatra-ai/beatra-skills/tree/95d662f7aeddd6e2aa6da9e14f9c985e3f6b914d/skills/beatra-ai-video-studio) (full SHA `95d662f7aeddd6e2aa6da9e14f9c985e3f6b914d`) |
+| License | MIT No Attribution (MIT-0) |
+
+The archive holds 17 regular files (no symlinks, no executable bits, no
+binaries), and every file is byte-identical to the source tree at that commit.
+
+## When to Use This Skill
+
+- Use when the user explicitly wants a short AI video clip produced on Beatra
+  and accepts that the work is paid and runs on a hosted service.
+- Use when a still image should be animated, two frames interpolated, or an
+  existing clip edited or extended by Beatra.
+- Do not use for local-only or offline video editing, timeline assembly, or
+  when the user has not agreed to send prompts and media to a third party.
+
+## Install (pinned, verified, approved twice)
+
+### Step 1: Download and verify into a review directory
+
+Explain that this downloads an external package from `cdn.beatra.ai`, then ask
+for approval. Only after approval:
+
+```bash
+umask 077
+review_dir="$(mktemp -d)"
+cd "$review_dir" || exit 1
+curl -fsSLO "https://cdn.beatra.ai/agent-packages/beatra-ai-video-studio/v1.2.5/beatra-ai-video-studio-skill-1.2.5.zip"
+printf '%s  %s\n' \
+  '679a3ddc06c7be631ef31f002f918465a26f17a189ffac723f45dfd348e1fc4a' \
+  'beatra-ai-video-studio-skill-1.2.5.zip' | shasum -a 256 -c -
+```
+
+Stop if the check does not print `OK`. The expected digest comes from this
+catalog entry, not from a file on the same CDN.
+
+### Step 2: Inspect before activation
+
+```bash
+unzip -l beatra-ai-video-studio-skill-1.2.5.zip
+unzip -q beatra-ai-video-studio-skill-1.2.5.zip
+find beatra-ai-video-studio -type l -print            # expect no output
+find beatra-ai-video-studio -type f -perm -111 -print # expect no output
+grep -n '"auto_update": True' beatra-ai-video-studio/scripts/mcp_client.py
+```
+
+Optionally confirm byte identity with the public source tree (a second,
+independent host):
+
+```bash
+git clone --quiet --filter=blob:none --no-checkout https://github.com/beatra-ai/beatra-skills.git src
+git -C src checkout --quiet 95d662f7aeddd6e2aa6da9e14f9c985e3f6b914d -- skills/beatra-ai-video-studio
+(cd beatra-ai-video-studio && find . -type f | LC_ALL=C sort | xargs shasum -a 256) > archive.sha
+(cd src/skills/beatra-ai-video-studio && find . -type f | LC_ALL=C sort | xargs shasum -a 256) > tree.sha
+cmp archive.sha tree.sha && echo IDENTICAL
+```
+
+Report to the user what the review found: `SKILL.md`, `manifest.json`, 12
+Markdown references, and `scripts/authorize.py`, `scripts/mcp_client.py`,
+`scripts/uninstall.py` (Python 3.10+, standard library only, no dependency
+installation, no lifecycle hooks). Summarize the network, credential,
+local-state, telemetry, and self-update behavior listed under
+[Security & Safety Notes](#security--safety-notes).
+
+### Step 3: Copy in and disable self-update before any other command
+
+Ask for a **second, separate** approval, because this changes agent
+configuration. Then copy the reviewed tree to the host's skills directory
+(Claude Code shown; use the equivalent path for other hosts) and immediately
+turn off silent self-update for that exact path:
+
+```bash
+dest="$HOME/.claude/skills/beatra-ai-video-studio"
+test ! -e "$dest" || { echo "destination exists; stop and ask the user"; exit 1; }
+cp -R beatra-ai-video-studio "$dest"
+python3 "$dest/scripts/mcp_client.py" update --auto off
+```
+
+The last command must print
+`Automatic Beatra package updates are disabled.` It writes only
+`~/.beatra/updates/<id>/state.json` and makes no network request. Run it
+before `authorize.py`, `verify`, `tools`, `upload`, or `call`: in version 1.2.5
+self-update is **on by default** (see below). The setting is keyed to the
+resolved install path, so repeat it after moving or re-copying the directory.
+
+### Step 4: Authorize as its own decision
+
+Authorization opens a browser sign-in and stores a bearer token. Ask first.
+
+```bash
+python3 "$dest/scripts/authorize.py"
+```
+
+Start a new agent session if the host discovers skills only at startup.
+
+## How It Works
+
+1. Read the installed package's `SKILL.md` and its references; they define the
+   video routes, payload shapes, and review loop.
+2. Use free, non-billable discovery first (`beatra.models.list`, task list) to
+   read current model cards, durations, resolutions, and credit estimates.
+3. Show the user a cost card for exactly one paid call: tool, model, duration,
+   resolution, estimate, and which files will be uploaded. Wait for explicit
+   approval. Planning or "make the clip" is not approval.
+4. Upload only files the user supplied and approved for this task, then submit
+   once with a stable `client_request_id` and poll the returned task.
+5. Report the delivered artifact and `billing.net_charged_credits`, review the
+   clip with the user, and ask again before any further paid stage.
+
+## Examples
+
+### Free connection check (non-billable)
+
+```bash
+python3 "$HOME/.claude/skills/beatra-ai-video-studio/scripts/mcp_client.py" verify
+```
+
+### One approved text-to-video call
+
+After the user approved the cost card for this exact payload:
+
+```bash
+printf '%s' '{"prompt":"A close product reveal with one slow push-in.","model":"auto","duration":5,"client_request_id":"req-7f3c2a"}' \
+  | python3 "$HOME/.claude/skills/beatra-ai-video-studio/scripts/mcp_client.py" call beatra.videos.generate
+```
+
+If the response is lost, retry only with the same `client_request_id` and
+identical arguments; never submit a replacement while the task is running.
+
+## Update
+
+This entry does not endorse the package's silent self-update. Keep
+`update --auto off` in place and do not run `update --auto on` or a bare
+`update` without explicit approval.
+
+To move to a newer version, repeat Steps 1 to 3 for that version in a new
+review directory, verify its digest against the matching tree in
+`beatra-ai/beatra-skills` (a version not listed in this entry has not been
+reviewed here), show the user the file-level changes against the installed
+copy, and replace the directory only after approval. `update --check` reports
+the available version from `beatra.ai` without changing files.
+
+## Uninstall
+
+```bash
+dest="$HOME/.claude/skills/beatra-ai-video-studio"
+python3 "$dest/scripts/uninstall.py" --dry-run
+python3 "$dest/scripts/uninstall.py"
+```
+
+Read the JSON decision. `disconnected` means this was the last Beatra skill on
+the device: the token was revoked (when `revoked` is `true`) and the files
+`credentials.json`, `installation.json`, `host.json`, `skills.json`, and
+`registrations.json` under `~/.beatra` were removed. `keep_connection` means
+another Beatra skill still uses the shared token, which stays. Then, after
+confirming the path with the user, delete `$dest`.
+
+`uninstall.py` does not remove `~/.beatra/updates/`. When the decision is
+`disconnected` and no other Beatra skill is installed, remove that directory
+too; otherwise leave it. A token that could not be revoked expires after 15
+days idle and can be revoked at once in the Beatra Console under Agents.
+
+## Best Practices
+
+- ✅ Keep one approval per paid call, per upload set, and per install step.
+- ✅ Start with the shortest duration and lowest resolution the model admits.
+- ✅ Report net charged credits from the terminal task, not the estimate.
+- ❌ Do not re-enable self-update or install an unreviewed version silently.
+- ❌ Do not print, paste, or move the token out of `~/.beatra/credentials.json`.
+- ❌ Do not retry a paid call with a new request ID after an uncertain response.
+
+## Limitations
+
+- Requires a Beatra account, network access, Python 3.10+, and prepaid credits;
+  the sign-up gift usually cannot cover a video generation.
+- Short clips only; not a timeline editor. Multi-shot work is delivered as
+  separate clips.
+- Generation is asynchronous and can take minutes. Upload size is capped at
+  100 MB and a model may impose a lower limit.
+- Models, prices, schemas, and availability are controlled by Beatra and its
+  upstream model providers and can change; the service is provided as is.
+- Outputs are probabilistic, not guaranteed unique or non-infringing, and need
+  human review before publication.
+
+## Security & Safety Notes
+
+`risk: critical` is deliberate.
+
+- **Network.** Authorization uses `api.beatra.ai`; every tool call and upload
+  goes to `mcp.beatra.ai`. With self-update left on, the client also fetches
+  `https://beatra.ai/skills/beatra-ai-video-studio/install.json` and archives
+  from `cdn.beatra.ai`.
+- **Self-update (on by default in 1.2.5).** Before `verify`, `tools`, `upload`,
+  or `call`, the client checks for a newer release at most once every 24 hours
+  and, if one exists, replaces package-owned files without per-update preview
+  or approval. It pins host and path, verifies checksums from Beatra's own
+  discovery document and CDN, and rolls back on failure, but those digests are
+  not independently anchored. This entry therefore requires
+  `update --auto off` before first use, as in Step 3.
+- **Uploads and third parties.** Prompts and uploaded media are sent to Beatra
+  and forwarded to the third-party model provider executing the task. Beatra
+  is hosted outside mainland China. See the
+  [privacy policy](https://beatra.ai/en/privacy).
+- **Billing.** Paid tools consume prepaid credits. Credits for tasks that fail
+  for reasons attributable to Beatra or the upstream model are returned
+  automatically; otherwise purchases are non-refundable, and actual usage can
+  exceed the estimate and leave a negative balance. See the
+  [terms](https://beatra.ai/en/terms).
+- **Credentials.** `authorize.py` runs an OAuth device flow, opens the browser,
+  and stores one bearer token in `~/.beatra/credentials.json` (directory
+  `0700`, file `0600`). The token never goes into argv, environment variables,
+  or output. It carries full Beatra scope, including `wallet:spend`, has a
+  sliding 15-day idle lifetime, and is shared by every Beatra skill on the
+  device.
+- **Local state.** `~/.beatra/` also holds `installation.json` (random
+  installation reference), `host.json` (agent platform and hostname),
+  `skills.json` (installed Beatra skill paths), `registrations.json`, and
+  `updates/<id>/state.json` plus update backups when updates run.
+- **Telemetry.** The device flow sends the hostname as the device name, the
+  package slug and version, and the detected agent platform (for example
+  `claude-code`, from environment variables). On first use the client makes a
+  non-billable `beatra.installations.register` call, and every tool call adds
+  `source_package_slug` and `source_platform`. There is no opt-out for these
+  fields.
+- **Retention.** Account data is kept for the life of the account. Task
+  records, artifacts, and billing ledgers are retained after account closure
+  for audit and tax purposes.
+- **Content rights.** Users keep rights in their inputs and receive Beatra's
+  rights in outputs; they must hold rights to uploaded media and must not
+  create deceptive impersonations.
+
+## Additional Resources
+
+- [Source tree at the pinned commit](https://github.com/beatra-ai/beatra-skills/tree/95d662f7aeddd6e2aa6da9e14f9c985e3f6b914d/skills/beatra-ai-video-studio)
+- [Product page](https://beatra.ai/skills/beatra-ai-video-studio)
+- [Terms](https://beatra.ai/en/terms) and [privacy policy](https://beatra.ai/en/privacy)

package/bundled-skills/meteora-dlmm-pool-screening/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: meteora-dlmm-pool-screening
+risk: safe
+source: community
+source_repo: romankurnovskii/etemaro
+source_type: community
+date_added: "2026-09-17"
+description: >
+  Screen and rank Meteora DLMM pools for LP quality using public Meteora APIs (fee/TVL,
+  bin step, organic score). Read-only: never deploys, swaps, or signs.
+metadata:
+  version: "1.0.0"
+  author: etemaro
+license: MIT
+compatibility: Network access to public Meteora datapi. No API key. The bundled Python 3
+  stdlib screener is embedded in this file under "Screener script".
+---
+
+# Meteora DLMM pool screening
+
+Rank Meteora DLMM pools the way an LP screener should: **hard-filter first, then sort by
+windowed fee / active TVL**. Public APIs only. No keys, no transactions.
+
+The embedded screener script below encodes the gates so every run uses the same numbers.
+Save it to a scratch directory (for example `mktemp -d`), run it with `python3`, and
+delete the copy when done. It only ever **GET**s the public endpoints documented in
+[references/meteora-apis.md](references/meteora-apis.md).
+
+```bash
+python3 screen.py                  # trending volatile (default)
+python3 screen.py --preset stable
+python3 screen.py --query BONK     # pair search; preset defaults to loose
+python3 screen.py --query BONK --preset volatile
+python3 screen.py --json --limit 8
+```
+
+If you do not materialize the script, curl the same endpoints in
+[references/meteora-apis.md](references/meteora-apis.md).
+Always send a `User-Agent` — unauthenticated requests without one get `403`.
+
+## When to use
+
+- User wants a ranked Meteora DLMM candidate list (trending or a token/pair).
+- User asks which bin step / pool to LP for a pair.
+- User wants a fee/TVL screen, not a single-pool deep dive.
+
+Not this skill: deploying, claiming, closing, swapping, wallet hygiene, or a full
+token-holder / narrative research dump. Stop after the ranked table and verdicts.
+
+## Method
+
+1. **Universe** — trending discovery (`category=trending`) unless the user named a token,
+   then query that mint/symbol. Pair query defaults to `--preset loose` so bin-step
+   tradeoffs stay visible; pass `--preset volatile` only when the user wants that gate.
+2. **Hard filters** — reject before ranking. A high fee/TVL pool that fails a gate is a
+   skip, not a "maybe".
+3. **Score** — `fee_active_tvl_ratio * 1000 + organic * 10 + volume / 100 + holders / 100`.
+   Fee/TVL dominates; organic and activity break ties.
+4. **Verdict** — `pass` (clears gates, top of list), `watch` (clears gates but thin
+   activity, unverified token, or awkward bin step), `skip` (failed a gate).
+5. **Stop** — print the table. Do not fetch a wallet, do not build a tx, do not call Etemaro CLI.
+
+## Presets
+
+Defaults match a volatile/narrative Solana LP screen (wide bin step, mid TVL). Change
+preset when the user says stable pair or blue-chip.
+
+| Preset | bin_step | TVL USD | min fee/active TVL | min organic | min holders | min volume |
+| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
+| `volatile` (default) | 80–125 | 10k–150k | 0.05 | 60 | 500 | 500 |
+| `stable` | 1–50 | 100k–5m | 0.02 | 70 | 2000 | 5000 |
+| `bluechip` | 1–25 | 500k–10m | 0.01 | 80 | 5000 | 10000 |
+| `loose` | any | ≥1k | 0 | 0 | 0 | 0 |
+
+Always reject: dead pools (zero volume and zero fee/TVL). Any preset except `loose` also
+rejects critical token warnings, high single-ownership, non-DLMM pool type.
+
+Timeframe: `30m` default. `5m` is noisier (spikes look like yield). `24h` is smoother but
+lags a dead pool. State the timeframe in the report — windowed fee/TVL is not 24h APR.
+
+## Report shape
+
+```
+# Meteora DLMM screening
+Universe: trending | query=<token>   Timeframe: 30m   Preset: volatile
+Protocol: tvl=$…  vol_24h=$…  pools=…
+
+## Ranked
+| # | name | bin | fee/TVL | tvl | vol | organic | holders | verdict | why |
+...
+
+## Rejects (sample)
+- NAME — reason
+```
+
+Keep `why` to one clause (e.g. "fee/TVL 0.24, organic 67, bin 80"). Cite pool address.
+If the API returns zero rows, say so and loosen one gate at a time (usually `maxTvl` or
+`minFeeActiveTvlRatio`) — do not invent pools.
+
+## Read-only safety
+
+This skill only **GET**s public Meteora JSON. No `.env`, no keystore, no signing, no
+`deploy` / `swap` / `claim` / `close`. If the user wants live execution, point them at
+[Etemaro](https://etemaro.com) (repo: https://github.com/romankurnovskii/etemaro) and stop.
+
+## Limitations
+
+- Depends on Meteora's public datapi endpoints, which are undocumented, rate limited,
+  and can change or disappear without notice; this skill is not affiliated with Meteora.
+- All metrics are **windowed** (default 30m). Fee/TVL is not 24h APR, and past yield
+  does not predict future yield; impermanent loss, bin-step drift, and fill risk are
+  not modeled here.
+- Screening output is informational only and is **not financial advice**; a `pass`
+  verdict is not a recommendation to deposit funds.
+- Token scores rely on third-party organic-score and holder fields that may be stale,
+  manipulated, or wrong for new or low-liquidity tokens.
+- The embedded screener reads public data only; it never signs, swaps, or deploys, and
+  it intentionally has no execution path.
+- Respect the public API: send a User-Agent and poll conservatively.
+
+## Go deeper — Etemaro
+
+Etemaro runs this screen on a cron, adds holder/bot/launchpad gates, pool memory, and
+can deploy. The skill is the analysis half; the product is the loop.
+
+## Prompt examples
+
+```text
+screen trending Meteora DLMM pools for LP
+```
+
+```text
+which Meteora pool should I LP for BONK?
+```
+
+```text
+rank SOL-USDC DLMM pools by fee/TVL and bin step
+```
+
+```text
+dex-pool-screening on Meteora, volatile preset, top 8
+```
+
+## Tips
+
+- Always send a User-Agent to Meteora datapi or you get HTTP 403.
+- `fee_active_tvl_ratio` is **windowed** (default 30m), not 24h APR. Label the window.
+- Read-only. Deploying is Etemaro, not this skill.
+- Pair query (`--query BONK`) defaults to `loose` so you can compare bin steps. Dead pools
+  (zero volume and fee/TVL) are still dropped.
+- `loose` is for pair comparison / empty-result debugging, not a live LP pick.
+
+## Screener script
+
+Standard library only. Read-only GET. The full source lives in
+[references/meteora-screener.md](references/meteora-screener.md); copy it into a scratch
+directory (for example via `mktemp -d`), run it with Python 3.10+, and delete the
+copy when done. It only ever GETs the public endpoints documented in
+[references/meteora-apis.md](references/meteora-apis.md).
+
+
+```python
+#!/usr/bin/env python3
+"""Rank Meteora DLMM pools from public datapi. Stdlib only. Read-only GET."""
+  ... full source in references/meteora-screener.md ...
+```

package/bundled-skills/meteora-dlmm-pool-screening/references/meteora-apis.md

@@ -0,0 +1,74 @@
+# Meteora public APIs used by this skill
+
+No API key. Send `User-Agent` and `Accept: application/json` or Cloudflare returns 403.
+
+Base hosts:
+
+- Discovery (trending + filters): `https://pool-discovery-api.datapi.meteora.ag`
+- DLMM datapi (pair query, protocol stats, pool detail): `https://dlmm.datapi.meteora.ag`
+
+## Endpoints
+
+### Trending / filtered universe
+
+```
+GET /pools?page_size=50&timeframe=30m&category=trending&filter_by=<filters>
+```
+
+`filter_by` is `&&`-joined predicates. Example (volatile preset):
+
+```
+pool_type=dlmm
+&&base_token_has_critical_warnings=false
+&&quote_token_has_critical_warnings=false
+&&base_token_has_high_single_ownership=false
+&&tvl>=10000&&tvl<=150000
+&&dlmm_bin_step>=80&&dlmm_bin_step<=125
+&&fee_active_tvl_ratio>=0.05
+&&base_token_organic_score>=60
+&&base_token_holders>=500
+&&volume>=500
+```
+
+Response: `{ total, page_size, data[], has_more }`.
+
+Useful `data[]` fields: `pool_address`, `name`, `pool_type`, `tvl`, `active_tvl`,
+`fee_active_tvl_ratio`, `volume`, `volatility`, `base_token_holders`,
+`dlmm_params.bin_step`, `token_x.{symbol,address,organic_score,market_cap,warnings}`.
+
+### Pair / token query
+
+```
+GET /pools?query=<symbol_or_mint>&sort_by=tvl:desc
+```
+
+on `dlmm.datapi.meteora.ag`. Response `{ total, data[] }`.
+
+Fee/TVL and volume are **buckets**: `{ "30m", "1h", "2h", "4h", "12h", "24h" }`.
+Use the same key as `--timeframe`. Bin step is `pool_config.bin_step`. Address is `address`.
+
+### Protocol snapshot
+
+```
+GET https://dlmm.datapi.meteora.ag/stats/protocol_metrics
+```
+
+`total_tvl`, `volume_24h`, `fee_24h`, `total_pools`. One-line context only.
+
+### Single pool
+
+```
+GET https://dlmm.datapi.meteora.ag/pools/{poolAddress}
+GET https://pool-discovery-api.datapi.meteora.ag/pools?page_size=1&filter_by=pool_address={poolAddress}&timeframe=30m
+```
+
+Discovery lag: a brand-new pool may exist on DLMM datapi before discovery indexes it.
+
+## Score (keep in sync with scripts/screen.py)
+
+```
+score = fee_tvl * 1000 + organic * 10 + volume / 100 + holders / 100
+```
+
+`fee_tvl` is the windowed ratio (`fee_active_tvl_ratio` on discovery, bucketed
+`fee_tvl_ratio[timeframe]` on pair query).

package/bundled-skills/meteora-dlmm-pool-screening/references/meteora-screener.md

@@ -0,0 +1,352 @@
+# Meteora screener script
+
+Embedded copy of the read-only screener. Save the fenced Python block below as
+`screen.py` in a scratch directory and run it with Python 3.10+.
+
+```python
+#!/usr/bin/env python3
+"""Rank Meteora DLMM pools from public datapi. Stdlib only. Read-only GET."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any
+
+DISCOVERY = "https://pool-discovery-api.datapi.meteora.ag"
+DLMM = "https://dlmm.datapi.meteora.ag"
+UA = "Mozilla/5.0 (compatible; etemaro-skill/1.0; +https://etemaro.com)"
+TIMEOUT = 25
+
+PRESETS: dict[str, dict[str, Any]] = {
+    "volatile": {
+        "min_bin": 80,
+        "max_bin": 125,
+        "min_tvl": 10_000,
+        "max_tvl": 150_000,
+        "min_fee_tvl": 0.05,
+        "min_organic": 60,
+        "min_holders": 500,
+        "min_volume": 500,
+        "hard_warnings": True,
+    },
+    "stable": {
+        "min_bin": 1,
+        "max_bin": 50,
+        "min_tvl": 100_000,
+        "max_tvl": 5_000_000,
+        "min_fee_tvl": 0.02,
+        "min_organic": 70,
+        "min_holders": 2_000,
+        "min_volume": 5_000,
+        "hard_warnings": True,
+    },
+    "bluechip": {
+        "min_bin": 1,
+        "max_bin": 25,
+        "min_tvl": 500_000,
+        "max_tvl": 10_000_000,
+        "min_fee_tvl": 0.01,
+        "min_organic": 80,
+        "min_holders": 5_000,
+        "min_volume": 10_000,
+        "hard_warnings": True,
+    },
+    "loose": {
+        "min_bin": None,
+        "max_bin": None,
+        "min_tvl": 1_000,
+        "max_tvl": None,
+        "min_fee_tvl": 0.0,
+        "min_organic": 0,
+        "min_holders": 0,
+        "min_volume": 0,
+        "hard_warnings": False,
+    },
+}
+
+
+def get_json(url: str) -> Any:
+    req = urllib.request.Request(url, headers={"User-Agent": UA, "Accept": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=TIMEOUT) as resp:
+            return json.loads(resp.read().decode())
+    except urllib.error.HTTPError as exc:
+        body = exc.read().decode(errors="replace")[:200]
+        raise SystemExit(f"HTTP {exc.code} {url}\n{body}") from exc
+    except urllib.error.URLError as exc:
+        raise SystemExit(f"network error {url}: {exc.reason}") from exc
+
+
+def num(value: Any) -> float | None:
+    try:
+        n = float(value)
+    except (TypeError, ValueError):
+        return None
+    return n if n == n else None  # NaN check
+
+
+def bucket(obj: Any, timeframe: str) -> float | None:
+    if isinstance(obj, dict):
+        return num(obj.get(timeframe))
+    return num(obj)
+
+
+def score(fee_tvl: float, organic: float, volume: float, holders: float) -> float:
+    return fee_tvl * 1000 + organic * 10 + volume / 100 + holders / 100
+
+
+def discovery_filters(p: dict[str, Any]) -> str:
+    parts = ["pool_type=dlmm"]
+    if p["hard_warnings"]:
+        parts += [
+            "base_token_has_critical_warnings=false",
+            "quote_token_has_critical_warnings=false",
+            "base_token_has_high_single_ownership=false",
+        ]
+    if p["min_tvl"] is not None:
+        parts.append(f"tvl>={int(p['min_tvl'])}")
+    if p["max_tvl"] is not None:
+        parts.append(f"tvl<={int(p['max_tvl'])}")
+    if p["min_bin"] is not None:
+        parts.append(f"dlmm_bin_step>={int(p['min_bin'])}")
+    if p["max_bin"] is not None:
+        parts.append(f"dlmm_bin_step<={int(p['max_bin'])}")
+    if p["min_fee_tvl"]:
+        parts.append(f"fee_active_tvl_ratio>={p['min_fee_tvl']}")
+    if p["min_organic"]:
+        parts.append(f"base_token_organic_score>={int(p['min_organic'])}")
+    if p["min_holders"]:
+        parts.append(f"base_token_holders>={int(p['min_holders'])}")
+    if p["min_volume"]:
+        parts.append(f"volume>={int(p['min_volume'])}")
+    return "&&".join(parts)
+
+
+def reject_reason(row: dict[str, Any], p: dict[str, Any]) -> str | None:
+    fee = row.get("fee_tvl")
+    vol = row.get("volume")
+    if (fee is None or fee <= 0) and (vol is None or vol <= 0):
+        return "dead pool (zero volume and fee/TVL)"
+    if p["hard_warnings"] and row.get("critical"):
+        return "critical token warning"
+    bin_step = row.get("bin_step")
+    tvl = row.get("tvl")
+    organic = row.get("organic")
+    holders = row.get("holders")
+    if p["min_bin"] is not None and (bin_step is None or bin_step < p["min_bin"]):
+        return f"bin_step {bin_step} < {p['min_bin']}"
+    if p["max_bin"] is not None and bin_step is not None and bin_step > p["max_bin"]:
+        return f"bin_step {bin_step} > {p['max_bin']}"
+    if tvl is None or tvl < p["min_tvl"]:
+        return f"tvl {tvl} < {p['min_tvl']}"
+    if p["max_tvl"] is not None and tvl is not None and tvl > p["max_tvl"]:
+        return f"tvl {tvl} > {p['max_tvl']}"
+    if fee is None or fee < p["min_fee_tvl"]:
+        return f"fee/TVL {fee} < {p['min_fee_tvl']}"
+    if vol is None or vol < p["min_volume"]:
+        return f"volume {vol} < {p['min_volume']}"
+    if organic is not None and organic < p["min_organic"]:
+        return f"organic {organic} < {p['min_organic']}"
+    if holders is not None and holders < p["min_holders"]:
+        return f"holders {holders} < {p['min_holders']}"
+    return None
+
+
+def verdict(row: dict[str, Any], p: dict[str, Any]) -> str:
+    if reject_reason(row, p):
+        return "skip"
+    warnings = row.get("warnings") or []
+    unverified = any("NOT_VERIFIED" in str(w) for w in warnings)
+    thin = (row.get("volume") or 0) < p["min_volume"] * 2 if p["min_volume"] else False
+    no_yield = (row.get("fee_tvl") or 0) <= 0
+    if unverified or thin or no_yield:
+        return "watch"
+    return "pass"
+
+
+def from_discovery(raw: dict[str, Any], timeframe: str) -> dict[str, Any]:
+    token_x = raw.get("token_x") or {}
+    warnings = token_x.get("warnings") or []
+    critical = bool(raw.get("base_token_has_critical_warnings")) or any(
+        (w.get("severity") if isinstance(w, dict) else None) == "critical" for w in warnings if isinstance(w, dict)
+    )
+    bin_step = num((raw.get("dlmm_params") or {}).get("bin_step"))
+    return {
+        "name": raw.get("name"),
+        "pool": raw.get("pool_address"),
+        "bin_step": bin_step,
+        "fee_tvl": num(raw.get("fee_active_tvl_ratio")),
+        "tvl": num(raw.get("tvl")),
+        "active_tvl": num(raw.get("active_tvl")),
+        "volume": num(raw.get("volume")),
+        "organic": num(token_x.get("organic_score")),
+        "holders": num(raw.get("base_token_holders")),
+        "mcap": num(token_x.get("market_cap")),
+        "volatility": num(raw.get("volatility")),
+        "mint": token_x.get("address"),
+        "warnings": warnings,
+        "critical": critical,
+        "source": "discovery",
+        "timeframe": timeframe,
+    }
+
+
+def from_dlmm(raw: dict[str, Any], timeframe: str) -> dict[str, Any]:
+    token_x = raw.get("token_x") or {}
+    cfg = raw.get("pool_config") or {}
+    return {
+        "name": raw.get("name"),
+        "pool": raw.get("address"),
+        "bin_step": num(cfg.get("bin_step")),
+        "fee_tvl": bucket(raw.get("fee_tvl_ratio"), timeframe),
+        "tvl": num(raw.get("tvl")),
+        "active_tvl": num(raw.get("tvl")),
+        "volume": bucket(raw.get("volume"), timeframe),
+        "organic": None,
+        "holders": num(token_x.get("holders")),
+        "mcap": num(token_x.get("market_cap")),
+        "volatility": None,
+        "mint": token_x.get("address"),
+        "warnings": [],
+        "critical": bool(raw.get("is_blacklisted")),
+        "source": "dlmm",
+        "timeframe": timeframe,
+    }
+
+
+def fmt(n: float | None, digits: int = 2) -> str:
+    if n is None:
+        return "—"
+    if abs(n) >= 1_000_000:
+        return f"{n / 1_000_000:.{digits}f}M"
+    if abs(n) >= 1_000:
+        return f"{n / 1_000:.{digits}f}k"
+    return f"{n:.{digits}f}"
+
+
+def fmt_bin(n: float | None) -> str:
+    if n is None:
+        return "—"
+    return str(int(n)) if float(n).is_integer() else fmt(n, 1)
+
+
+def print_table(rows: list[dict[str, Any]], rejects: list[tuple[str, str]], meta: dict[str, Any]) -> None:
+    print(f"# Meteora DLMM screening")
+    print(
+        f"Universe: {meta['universe']}   Timeframe: {meta['timeframe']}   "
+        f"Preset: {meta['preset']}   Source: {meta['source']}"
+    )
+    proto = meta.get("protocol") or {}
+    if proto:
+        print(
+            f"Protocol: tvl=${fmt(proto.get('total_tvl'))}  "
+            f"vol_24h=${fmt(proto.get('volume_24h'))}  pools={proto.get('total_pools')}"
+        )
+    print(f"Fetched: {meta['fetched']}  Ranked: {len(rows)}  Rejected: {len(rejects)}")
+    print()
+    print("## Ranked")
+    print("| # | name | bin | fee/TVL | tvl | vol | organic | holders | verdict | why |")
+    print("|---|---|---|---|---|---|---|---|---|---|")
+    for i, row in enumerate(rows, 1):
+        why = (
+            f"fee/TVL {fmt(row.get('fee_tvl'), 3)}, "
+            f"bin {fmt_bin(row.get('bin_step'))}, "
+            f"{row.get('pool')}"
+        )
+        print(
+            f"| {i} | {row.get('name') or '?'} | {fmt_bin(row.get('bin_step'))} | "
+            f"{fmt(row.get('fee_tvl'), 3)} | {fmt(row.get('tvl'))} | {fmt(row.get('volume'))} | "
+            f"{fmt(row.get('organic'), 1)} | {fmt(row.get('holders'), 0)} | "
+            f"{row.get('verdict')} | {why} |"
+        )
+    if not rows:
+        print("_no pools passed gates — loosen max TVL or min fee/TVL, or try --preset loose_")
+    if rejects:
+        print()
+        print("## Rejects (sample)")
+        for name, reason in rejects[:12]:
+            print(f"- {name} — {reason}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Screen Meteora DLMM pools (read-only).")
+    parser.add_argument("--preset", choices=sorted(PRESETS), default="volatile")
+    parser.add_argument("--query", help="Token symbol or mint (pair search via DLMM datapi)")
+    parser.add_argument("--timeframe", default="30m", choices=["5m", "30m", "1h", "2h", "4h", "12h", "24h"])
+    parser.add_argument("--limit", type=int, default=10)
+    parser.add_argument("--page-size", type=int, default=50)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+    # Pair search is "which pool for this token", not a trending meme screen.
+    if args.query and "--preset" not in sys.argv:
+        args.preset = "loose"
+    preset = PRESETS[args.preset]
+
+    protocol = get_json(f"{DLMM}/stats/protocol_metrics")
+
+    if args.query:
+        qs = urllib.parse.urlencode({"query": args.query, "sort_by": "tvl:desc"})
+        payload = get_json(f"{DLMM}/pools?{qs}")
+        raw_list = payload.get("data") or []
+        rows = [from_dlmm(p, args.timeframe) for p in raw_list if isinstance(p, dict)]
+        source = "dlmm"
+        universe = f"query={args.query}"
+        fetched = payload.get("total", len(rows))
+    else:
+        qs = urllib.parse.urlencode(
+            {
+                "page_size": args.page_size,
+                "timeframe": args.timeframe,
+                "category": "trending",
+                "filter_by": discovery_filters(preset),
+            }
+        )
+        payload = get_json(f"{DISCOVERY}/pools?{qs}")
+        raw_list = payload.get("data") or []
+        rows = [from_discovery(p, args.timeframe) for p in raw_list if isinstance(p, dict)]
+        source = "discovery"
+        universe = "trending"
+        fetched = payload.get("total", len(rows))
+
+    rejects: list[tuple[str, str]] = []
+    kept: list[dict[str, Any]] = []
+    for row in rows:
+        reason = reject_reason(row, preset)
+        if reason:
+            rejects.append((str(row.get("name") or row.get("pool") or "?"), reason))
+            continue
+        row["score"] = score(
+            row.get("fee_tvl") or 0,
+            row.get("organic") or 0,
+            row.get("volume") or 0,
+            row.get("holders") or 0,
+        )
+        row["verdict"] = verdict(row, preset)
+        kept.append(row)
+
+    kept.sort(key=lambda r: r.get("score") or 0, reverse=True)
+    kept = kept[: max(1, args.limit)]
+
+    meta = {
+        "universe": universe,
+        "timeframe": args.timeframe,
+        "preset": args.preset,
+        "source": source,
+        "fetched": fetched,
+        "protocol": protocol if isinstance(protocol, dict) else {},
+    }
+    if args.json:
+        json.dump({"meta": meta, "ranked": kept, "rejects": rejects[:20]}, sys.stdout, indent=2)
+        sys.stdout.write("\n")
+        return
+    print_table(kept, rejects, meta)
+
+
+if __name__ == "__main__":
+    main()
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-skills-collection",
-  "version": "4.0.66",
+  "version": "4.0.67",
   "description": "OpenCode CLI plugin that automatically downloads and keeps skills up to date.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/skills_index.json

@@ -25244,6 +25244,93 @@
       "reasons": []
     }
   },
+  {
+    "id": "idea-evaluator",
+    "path": "skills/idea-evaluator",
+    "category": "agent-orchestration",
+    "name": "idea-evaluator",
+    "description": "Evaluates an idea by hosting a multi-turn debate between a Pro and Con agent, delivering a final verdict on whether it's worth pursuing.",
+    "risk": "safe",
+    "source": "self",
+    "date_added": "2026-09-18",
+    "plugin": {
+      "targets": {
+        "codex": "supported",
+        "claude": "supported"
+      },
+      "setup": {
+        "type": "none",
+        "summary": "",
+        "docs": null
+      },
+      "reasons": []
+    },
+    "source_type": "self",
+    "tags": [
+      "ideation",
+      "validation",
+      "debate",
+      "multi-agent"
+    ]
+  },
+  {
+    "id": "idea-evaluator-con",
+    "path": "skills/idea-evaluator/idea-evaluator-con",
+    "category": "agent-persona",
+    "name": "idea-evaluator-con",
+    "description": "The Con Agent persona for idea evaluation. Critiques an idea by identifying potential flaws, risks, and market challenges.",
+    "risk": "safe",
+    "source": "self",
+    "date_added": "2026-09-18",
+    "plugin": {
+      "targets": {
+        "codex": "supported",
+        "claude": "supported"
+      },
+      "setup": {
+        "type": "none",
+        "summary": "",
+        "docs": null
+      },
+      "reasons": []
+    },
+    "source_type": "self",
+    "tags": [
+      "ideation",
+      "validation",
+      "persona",
+      "critic"
+    ]
+  },
+  {
+    "id": "idea-evaluator-pro",
+    "path": "skills/idea-evaluator/idea-evaluator-pro",
+    "category": "agent-persona",
+    "name": "idea-evaluator-pro",
+    "description": "The Pro Agent persona for idea evaluation. Logically supports an idea, arguing for its market fit, feasibility, and potential.",
+    "risk": "safe",
+    "source": "self",
+    "date_added": "2026-09-18",
+    "plugin": {
+      "targets": {
+        "codex": "supported",
+        "claude": "supported"
+      },
+      "setup": {
+        "type": "none",
+        "summary": "",
+        "docs": null
+      },
+      "reasons": []
+    },
+    "source_type": "self",
+    "tags": [
+      "ideation",
+      "validation",
+      "persona",
+      "supporter"
+    ]
+  },
   {
     "id": "idea-os",
     "path": "skills/idea-os",
@@ -50185,6 +50272,37 @@
       "reasons": []
     }
   },
+  {
+    "id": "weather-model-data-fetching",
+    "path": "skills/weather-model-data-fetching",
+    "category": "data",
+    "name": "weather-model-data-fetching",
+    "description": "Retrieve numerical weather prediction data from public AWS S3 and HTTP archives using GRIB2 inventories, byte ranges, Herbie, provider fallbacks, and verified caching.",
+    "risk": "safe",
+    "source": "self",
+    "date_added": "2026-09-18",
+    "plugin": {
+      "targets": {
+        "codex": "supported",
+        "claude": "supported"
+      },
+      "setup": {
+        "type": "none",
+        "summary": "",
+        "docs": null
+      },
+      "reasons": []
+    },
+    "source_type": "self",
+    "tags": [
+      "weather",
+      "grib2",
+      "aws-s3",
+      "herbie",
+      "noaa",
+      "nwp"
+    ]
+  },
   {
     "id": "weaviate",
     "path": "skills/weaviate",