cue-ai 0.5.0 → 0.7.0

package/resources/mcps/configs/claude_runtime.sanitized.json

@@ -127,6 +127,53 @@
         "X_ACCESS_TOKEN": "${X_ACCESS_TOKEN}",
         "X_ACCESS_TOKEN_SECRET": "${X_ACCESS_TOKEN_SECRET}"
       }
+    },
+    "reddit": {
+      "command": "npx",
+      "args": [
+        "reddit-mcp-server"
+      ],
+      "env": {
+        "REDDIT_CLIENT_ID": "${REDDIT_CLIENT_ID}",
+        "REDDIT_CLIENT_SECRET": "${REDDIT_CLIENT_SECRET}",
+        "REDDIT_USERNAME": "${REDDIT_USERNAME}",
+        "REDDIT_PASSWORD": "${REDDIT_PASSWORD}",
+        "REDDIT_SAFE_MODE": "standard",
+        "REDDIT_AUTH_MODE": "auto"
+      }
+    },
+    "google-ads-mcp": {
+      "command": "pipx",
+      "args": [
+        "run",
+        "--spec",
+        "git+https://github.com/googleads/google-ads-mcp.git",
+        "google-ads-mcp"
+      ],
+      "env": {
+        "GOOGLE_APPLICATION_CREDENTIALS": "${GOOGLE_APPLICATION_CREDENTIALS}",
+        "GOOGLE_PROJECT_ID": "${GOOGLE_PROJECT_ID}",
+        "GOOGLE_ADS_DEVELOPER_TOKEN": "${GOOGLE_ADS_DEVELOPER_TOKEN}"
+      }
+    },
+    "meta-ads": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "meta-ads-mcp@latest"
+      ],
+      "env": {
+        "META_ACCESS_TOKEN": "${META_ACCESS_TOKEN}",
+        "META_AD_ACCOUNT_ID": "${META_AD_ACCOUNT_ID}"
+      }
+    },
+    "mapi-devdocs": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "mcp-remote",
+        "https://merchantapi.googleapis.com/devdocs/mcp"
+      ]
     }
   },
   "source": "claude_runtime",

package/resources/skills/README.md

@@ -1,135 +1,92 @@
-```
-   ┌───────────────────────────────────────────────────────────────┐
-   │                                                               │
-   │     r e c o d e e e  /  s k i l l s                           │
-   │     ─────────────────────────────────                         │
-   │     167 skills · 20 categories · one source of truth          │
-   │                                                               │
-   └───────────────────────────────────────────────────────────────┘
-```
-
-> **My laptop's current skill set.** This is the live snapshot of every agent
-> skill installed on my machine — the same folders that Claude Code and Codex
-> read at runtime. The repo is the source; my `~/.claude/skills` and
-> `~/.codex/skills` are just symlinks back here.
-
----
-
-## Why this exists
+# cue/skills — Skill Library
 
-I run a lot of agents. Skills drift fast: I install one from a marketplace,
-edit it, copy it to a new project, forget where the original lived. This repo
-is the one place that's allowed to be authoritative. If a skill isn't here, it
-isn't real on this laptop.
+> 127 skills across 21 categories. The source of truth for all local skills used by [cue](https://github.com/opencue/cue) profiles.
 
-Everything else (`~/.claude/skills/<name>`, `~/.codex/skills/<name>`) is a
-symlink. Edit a file under `skills/` and every agent picks it up on next load —
-no copy, no resync, no drift.
-
----
+## What's here
 
-## Layout
-
-```text
+```
 skills/
-  <category>/
-    <skill-name>/
-      SKILL.md          # the agent-facing spec
-      scripts/          # optional bundled scripts
-      references/       # optional supporting docs
-      assets/           # optional images, samples
-scripts/
-  install-local.sh      # installs to both Codex and Claude
-  install-codex.sh
-  install-claude.sh
-docs/
-  installed-sources.tsv # provenance log from last install
-  install.md
-.claude/
-  settings.json         # repo-scoped Claude Code config
+├── skills/                 The skill library
+│   ├── browser/            Playwright, screenshots
+│   ├── caveman/            Terse mode, commits, compression
+│   ├── colony/             Multi-agent coordination
+│   ├── deployment/         Coolify, Supabase, pnpm
+│   ├── design/             UI/UX, branding, SVG, Remotion
+│   ├── github/             GitHub CLI, CI fixes, auth
+│   ├── higgsfield/         AI image/video generation
+│   ├── hostinger/          DNS, domains, VPS
+│   ├── medusa/             Medusa v2 ecommerce
+│   ├── meta/               Profile management, memory, helpers
+│   ├── nvidia/             cuOpt, GPU optimization
+│   ├── obsidian/           Vault, markdown, canvas
+│   ├── orchestration/      Fleet, pipelines, workers
+│   ├── research/           Search, papers, keywords
+│   ├── review/             Code review, security, testing
+│   ├── secrets/            Envoult, credential management
+│   ├── stripe/             Payments, webhooks
+│   └── ...
+├── scripts/                Install, sync, lint scripts
+├── plugins/                Claude Code plugin definitions
+└── catalog/                Auto-generated skill index
 ```
 
----
+## Skill format
 
-## Categories
-
-| Folder            | Count | What lives here                                                  |
-| ----------------- | ----: | ---------------------------------------------------------------- |
-| `ai/`             |     3 | Anthropic SDK integration, prompt caching, Claude migration      |
-| `automation/`     |     2 | Task scheduling, cron jobs, recurring automation                 |
-| `caveman/`        |     5 | Token compression — caveman, caveman-commit, caveman-review, …   |
-| `colony/`         |     2 | Colony coordination, prompts, and handoff surfaces               |
-| `content/`        |     8 | Technical writing, copywriting, theming, docs, PDF, browser work |
-| `deployment/`     |     3 | Coolify, pnpm, Supabase                                          |
-| `design/`         |    19 | UI, UX, visual design, image-direction, brandkit, mockups        |
-| `github/`         |     6 | github CLI, gh-fix-ci, gitguardex, worktrees, branch finish      |
-| `growth/`         |    12 | CRO, analytics, retention, referrals, free-tool growth           |
-| `higgsfield/`     |     4 | Higgsfield AI — generate, soul-id, photoshoot, marketplace       |
-| `hostinger/`      |     4 | Hostinger domains, DNS, hosting, VPS                             |
-| `marketing/`      |    18 | SEO, ads, email, launch, PMM, pricing, community, RevOps-adjacent |
-| `medusa/`         |    14 | Medusa commerce, storefronts, db migrations, woocommerce import  |
-| `meta/`           |    25 | Agent meta, config, workflow, plans, doctor, hud, ask-*, trace   |
-| `obsidian/`       |     4 | Obsidian vault tooling and JSON canvas                           |
-| `orchestration/`  |    13 | autopilot, ralph, team, subagents, ultraqa, ultrawork, pipeline  |
-| `private/`        |     1 | Host- / account-specific skills (no secrets in repo)             |
-| `research/`       |    11 | autoresearch, interviews, customer/competitor research, keywords |
-| `review/`         |    11 | code/security/architecture review, debugging, TDD, verification  |
-| `stripe/`         |     2 | Stripe integration and webhooks                                  |
-
-> Skill leaf names are unique repo-wide so symlink installs never collide.
+Each skill is a directory with a `SKILL.md` file:
 
+```markdown
 ---
-
-## Install
-
-```sh
-./scripts/install-local.sh
-```
-
-The installer walks every category for `SKILL.md` files and links each parent
-folder into both:
-
-- `~/.codex/skills/<skill-name>`
-- `~/.claude/skills/<skill-name>`
-
-Existing skill folders at the destination are moved to timestamped backups
-before linking — nothing is overwritten silently.
-
-`docs/installed-sources.tsv` records where each imported skill came from at
-last import and whether duplicates were skipped.
-
+description: "When user says X, do Y"
+allowed-tools: ["tool_name"]
 ---
 
-## Adding a new skill
+# Skill Name
 
-1. Drop it under the right category as `skills/<category>/<skill-name>/`.
-2. Make sure it has `SKILL.md` with valid frontmatter (`name`, `description`).
-3. Re-run `./scripts/install-local.sh`. The installer is idempotent.
+Instructions for the model...
+```
 
-Single-skill category? Still create the folder — flat skills aren't allowed
-anymore. Better to have `deployment/coolify/` with one entry than a special
-case.
+The `description` frontmatter is what the LLM matches against to decide when to use the skill.
 
----
+## How cue uses this
 
-## Secrets
+Profiles reference skills by `category/slug`:
 
-Do not store secrets in this repo.
+```yaml
+# profiles/backend/profile.yaml
+skills:
+  local:
+    - review/code-review
+    - deployment/coolify
+    - github/gh-fix-ci
+```
 
-The `private/` category exists for skills that touch host-specific or
-account-specific surfaces. Secrets and connection details (IPs, usernames,
-tokens) **must** come from environment variables or `~/.ssh/config` aliases —
-never from committed files. The bundled scripts under `private/myvps/` enforce
-this: they fail fast if `SUPA_SCHEMA_SSH_TARGET` isn't set.
+At launch, cue symlinks these into the runtime's `skills/` directory.
 
-For WooCommerce imports, credentials live in:
+## Adding a skill
 
-```text
-~/.config/woocommerce-medusa-import/env       # mode 600
+```bash
+cue skills-new my-skill                       # scaffold
+# edit skills/<category>/my-skill/SKILL.md
+cue skills-lint my-skill                      # validate
+cue skills-test my-skill                      # test
 ```
 
----
+Or manually: create `skills/<category>/<slug>/SKILL.md` with the frontmatter format above.
 
-```
-   ─── this is mine. fork it, gut it, build your own. ───
-```
+## Categories
+
+| Category | Skills | Domain |
+|----------|--------|--------|
+| `browser` | 1 | Playwright, screenshots |
+| `caveman` | 5 | Terse mode, commits |
+| `design` | 16 | UI/UX, branding, SVG |
+| `medusa` | 14 | Ecommerce platform |
+| `meta` | 18 | Profile helpers, memory |
+| `nvidia` | 12 | GPU optimization |
+| `review` | 5 | Code quality, security |
+| `research` | 8 | Search, papers |
+
+## Related
+
+- [cue](https://github.com/opencue/cue) — the profile manager
+- [resources/mcps](../mcps/) — MCP server registry

package/resources/skills/skills/event-design/wedding-invitations/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: wedding-invitations
+description: Use when designing a wedding invitation, save-the-date, or RSVP card from a conversation — bespoke HTML rendered to a print-ready PNG, any language, any aesthetic, fully local. Pointer to upstream wyx-sg/wedding-invitation-skill.
+allowed-tools: Bash(chromium:*), Bash(google-chrome:*), Bash(microsoft-edge:*), Bash(node:*), Bash(git:*)
+---
+
+# Wedding Invitations — bespoke, local, multilingual
+
+[`wyx-sg/wedding-invitation-skill`](https://github.com/wyx-sg/wedding-invitation-skill) — designs a one-off wedding invitation from a conversation. Outputs a print-ready PNG (1080×1440 portrait or 1080×1920 9:16 poster). Renders locally via a headless Chromium browser; no uploads, no cloud, no telemetry.
+
+## When to use
+- "Help me make a wedding invitation"
+- "Design a save-the-date in [language]"
+- Save-the-dates, RSVP cards, programs, menus, place cards — anything the same HTML→PNG pipeline can produce
+- Multilingual collateral (English, Chinese, Spanish, Japanese, Korean, or any combination)
+- Aesthetic directions covered by the upstream gallery: new-chinese, wabi-sabi, art-deco, morandi, modern-minimal, mediterranean, retro-poster, etc.
+
+## How
+1. **Talk** — the skill asks for language(s), names, date, venue, style preference
+2. **Preview** — aesthetic directions shown visually in your browser
+3. **Design** — Claude writes a unique HTML template from scratch
+4. **Iterate** — natural-language tweaks ("bigger font" / "softer color" / "swap the photo")
+5. **Export** — one command screenshots the HTML → high-res PNG
+
+## Install
+```bash
+git clone https://github.com/wyx-sg/wedding-invitation-skill \
+  ~/.claude/skills/wedding-invitation
+```
+Then invoke via `/wedding-invitation` in Claude Code, or just ask: "help me make a wedding invitation."
+
+## Prerequisites
+- `node` 18+
+- A Chromium-family browser: `chromium`, `google-chrome`, or `microsoft-edge` (any one suffices)
+- `git` for the install
+
+The upstream `render.js` auto-locates whichever browser you have. On Linux: `cue cli install chromium`. On macOS: `brew install --cask chromium` (or any Chrome already installed works). On Windows: Edge ships with the OS.
+
+## Notes
+- **Privacy**: photos, names, addresses stay on your machine. The only network requests are Google Fonts CDN loads from your browser during HTML preview — font URLs only, nothing about you.
+- **Not a template gallery**: each invitation is designed fresh from your prompt. The 20 gallery examples are showcases, not picks.
+- **Other agents**: the skill is Claude-Code-first but works with Codex CLI, Cursor, Aider, Gemini CLI — tell the agent "read SKILL.md and help me make a wedding invitation."
+- **Sibling collateral**: this skill specializes in invitations but the HTML→PNG pipeline generalizes — for programs/menus/place cards, the same workflow applies; ask Claude to adapt the template.

package/resources/skills/skills/meta/acpx/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: acpx
+description: Delegate work to another coding agent (codex, claude, pi, openclaw, gemini, cursor, copilot, droid, etc.) over the Agent Client Protocol via acpx. Use when the user says "delegate to <agent>", "run codex", "use claude code", "have <agent> do X", "spawn a sub-agent", "agent-to-agent", mentions ACP, or when the work belongs in a different harness than the one you're in. Prefer this over PTY scraping or `tmux send-keys` to a foreign agent.
+---
+
+# acpx — talk to other coding agents over ACP
+
+`acpx` is a headless CLI that lets one agent drive another over the **Agent
+Client Protocol (ACP)**. Persistent sessions, prompt queueing, structured
+tool-call output, soft-close lifecycle. You get a real conversation with the
+target agent instead of scraping its terminal.
+
+⚠️ acpx is in alpha; the surface may shift. Pin via `npm install -g acpx@latest`
+or `npx acpx@latest` for one-offs. State lives in `~/.acpx/`.
+
+## When to reach for it
+
+- User asks you to **delegate** a task to another agent ("get codex to fix X",
+  "have claude refactor Y").
+- You're in one harness and the task is clearly a better fit for another
+  (e.g. you're in Claude Code and the user wants the Codex CLI to run the
+  task because of model availability or workflow preference).
+- The user wants **parallel work in the same repo** by different agents
+  without stomping on each other.
+- You'd otherwise be tempted to `tmux send-keys`, `expect`, or screen-scrape
+  another agent's TUI — stop, use acpx instead.
+
+Do **not** use acpx for the agent you're already running inside. Use your
+native tools.
+
+## Setup (one-time)
+
+```
+npm install -g acpx@latest        # global (faster)
+# or
+npx acpx@latest <agent> "<prompt>"  # no install
+```
+
+Underlying coding-agent CLIs (`codex`, `claude`, `gemini`, etc.) must already
+be installed and authenticated separately — acpx is a client, not a bundler.
+Run `cue cli install acpx` to install via the cli recipe registry.
+
+## Core commands
+
+```
+acpx codex sessions new                   # create a session for this dir
+acpx codex 'fix the failing tests'        # run a prompt
+acpx codex -s api 'paginate the endpoint' # parallel named session
+acpx codex sessions list                  # see what's open
+acpx codex status                         # is it running / idle / dead
+acpx codex cancel                         # cooperative cancel (sends ACP cancel)
+acpx codex sessions close                 # soft-close (keeps history)
+acpx codex exec 'one-shot summary'        # stateless, no saved session
+```
+
+Substitute `codex` with `claude`, `pi`, `openclaw`, `gemini`, `cursor`,
+`copilot`, `droid`, `iflow`, `kilocode`, `kimi`, `kiro`, `opencode`, `qoder`,
+`qwen`, `trae`. For custom ACP servers: `acpx --agent './bin/my-acp' '...'`.
+
+## Useful flags
+
+- `--no-wait` — queue prompt, return immediately (fire-and-forget).
+- `--format json` — NDJSON event stream, good for automation/jq pipelines.
+- `--format quiet` — final assistant text only.
+- `--approve-all` / `--approve-reads` / `--deny-all` — permission gates.
+- `--cwd <path>` — run against a different working directory.
+- `--timeout <s>` — wall-clock cap on a single prompt.
+- `--ttl <s>` — keep queue owner alive between prompts (default 300).
+- `--file <path>` / stdin — load prompt body from file or pipe.
+
+## Full reference
+
+- Skill source: <https://raw.githubusercontent.com/openclaw/acpx/main/skills/acpx/SKILL.md>
+- CLI reference: <https://raw.githubusercontent.com/openclaw/acpx/main/docs/CLI.md>
+- Built-in agent list: <https://github.com/openclaw/acpx/blob/main/agents/README.md>
+
+When something's not obvious, read those — they're the canonical source and
+they evolve faster than this stub.

package/resources/skills/skills/meta/cue-usage/SKILL.md

@@ -76,6 +76,30 @@ cue snapshot                    # export current state
 cue snapshot restore <file>     # restore from snapshot
 ```
 
+### Discover (find hidden gem skills on GitHub)
+
+```bash
+cue discover search                     # scan GitHub for skill repos
+cue discover search --profile marketing # find gems for a specific profile
+cue discover search "mcp rust"          # targeted search
+cue discover analyze --min-score 8      # Claude reads gems, determines best profile + MCPs + CLIs
+cue discover install --dry-run          # preview what would be installed
+cue discover install --min-score 8      # install top gems into profiles
+cue discover install --notify           # install + notify repo owners via GitHub issue
+cue discover mcps                       # find MCP servers to add
+cue discover mcps --install             # auto-wire found MCPs into profile
+cue discover --export                   # generate docs/discovered.md
+cue discover list                       # show cached results
+```
+
+### Evolve (auto-learn from sessions)
+
+```bash
+cue evolve                      # scan sessions → detect gaps → propose changes
+cue evolve --apply              # apply proposed changes (add/remove skills)
+cue evolve --history            # show profile evolution log
+```
+
 ### Profile Creation
 
 ```bash

package/resources/skills/skills/meta/profile-fit-monitor/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: profile-fit-monitor
+description: Notice when the active cue profile is a poor fit for the current work and suggest switching. Use when you find yourself reaching for skills/tools that aren't loaded, or doing work clearly outside the profile's domain (e.g. backend work in a frontend profile).
+---
+
+# Profile Fit Monitor
+
+Track how well the active profile matches what the user is actually doing. If you notice any of:
+
+- You're doing work outside the profile's domain (e.g. backend work in a frontend profile, design work in a backend profile).
+- None of the loaded skills are relevant to what the user is asking.
+- You keep needing tools or skills that aren't in this profile.
+
+Then **after completing the user's immediate request**, surface the mismatch with a one-line suggestion:
+
+> 💡 This session has been mostly [backend / infra / docs / …] work — your current profile is **{active-profile}**.
+> A better fit might be **[suggested]**. Switch with: `/cue switch [name]` or `echo [name] > .cue-profile`
+
+## Rules
+
+- Only suggest once per session — don't nag.
+- Never interrupt urgent or in-flight work to suggest a switch; wait for a natural break.
+- If the user has explicitly pinned the profile (`.cue-profile` present, or recently ran `/cue switch`), assume they meant it and stay quiet unless the mismatch is extreme.
+- Match the suggested profile to the work category — don't suggest randomly. If unsure, just describe the mismatch without picking a target.

package/resources/skills/skills/predict-everything/mirofish/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: mirofish
+description: Use when running multi-agent prediction or simulation — digital sandbox rehearsals, social-trend forecasting, swarm-intelligence experiments, "what if" scenarios. Pointer to upstream 666ghj/MiroFish.
+allowed-tools: Bash(node:*), Bash(npm:*), Bash(uv:*), Bash(python:*), Bash(python3:*), Bash(docker:*), Bash(git:*)
+---
+
+# MiroFish — multi-agent prediction & simulation engine
+
+[`666ghj/MiroFish`](https://github.com/666ghj/MiroFish) — extracts seed information (news, policy drafts, financial signals, narrative fragments), builds a high-fidelity parallel digital world, populates it with thousands of agents that have personalities + long-term memory + behavioral logic, lets them interact, and returns a prediction report. Powered by [OASIS](https://github.com/camel-ai/oasis) (CAMEL-AI's open-source agent social simulation framework).
+
+## When to use
+- "Simulate how public opinion would react to [policy / event / announcement]"
+- "Predict the second-order effects of [decision] before we commit"
+- "Generate a plausible ending to [story / scenario]"
+- "Run N counterfactuals on [breaking news / financial signal]"
+- Strategy rehearsal: test marketing campaigns, PR statements, product launches against a synthetic crowd before real release
+- Creative writing: explore alternate endings, character interactions, world-building consequences
+
+## What you get back
+- A detailed **prediction report** (Markdown / structured)
+- A **deeply interactive high-fidelity digital world** — you can chat with any simulated agent inside it
+- Dual-platform parallel simulation (multiple environments running concurrently)
+- Auto-parsed prediction requirements + dynamic temporal memory updates as the sim evolves
+
+## Architecture (workflow stages)
+1. **Graph building** — seed extraction, individual + collective memory injection, GraphRAG construction
+2. **Environment setup** — entity relationship extraction, persona generation, agent config injection
+3. **Simulation** — dual-platform parallel sim, prediction-requirement parser, dynamic temporal memory
+4. **Report generation** — ReportAgent with toolset for post-sim interaction
+5. **Deep interaction** — chat with any agent in the simulated world OR with ReportAgent
+
+## Install (source — recommended)
+
+```bash
+git clone https://github.com/666ghj/MiroFish.git
+cd MiroFish
+cp .env.example .env
+# Edit .env — set LLM_API_KEY, LLM_BASE_URL, LLM_MODEL_NAME, ZEP_API_KEY
+npm run setup:all       # installs root + frontend (Node) + backend (Python via uv)
+npm run dev             # starts frontend on :3000, backend on :5001
+```
+
+## Install (Docker)
+
+```bash
+git clone https://github.com/666ghj/MiroFish.git
+cd MiroFish
+cp .env.example .env       # fill in API keys
+docker compose up -d
+```
+
+## Prerequisites
+- **Node.js** 18+
+- **Python** ≥3.11 and ≤3.12 (3.13 not yet supported)
+- **uv** (Astral's package manager) — `cue cli install uv` or [docs](https://docs.astral.sh/uv/)
+- **An LLM API key** with OpenAI-SDK-compatible endpoint:
+  - Recommended: Alibaba Qwen-plus via [Bailian Platform](https://bailian.console.aliyun.com/) — best quality/cost for Chinese + English simulations
+  - Any OpenAI-compatible endpoint works (OpenAI, Anthropic via proxy, Together, DeepSeek, etc.)
+- **Zep Cloud API key** (free tier sufficient for simple usage) — [getzep.com](https://app.getzep.com/) — provides long-term memory for the simulated agents
+- Optional: **Docker** + **docker compose** for the containerized path
+
+## Cost & scale warning
+- High LLM consumption — each simulation round = many agent turns × thousands of agents
+- Start with **<40 rounds** to gauge cost before larger runs
+- The QPS limits of free LLM tiers will throttle simulations; Qwen-plus paid tier or equivalent recommended for serious work
+
+## Notes
+- The simulation engine is **OASIS** by CAMEL-AI; MiroFish is the orchestrator + UI + GraphRAG layer on top
+- Live demo: [mirofish-live-demo](https://github.com/666ghj/MiroFish#-live-demo)
+- For pure agent-simulation research without the predict-report layer, install OASIS directly
+- Supports both serious decision rehearsal (macro: policy / PR testing) and playful counterfactuals (micro: novel endings, "what if" exploration)
+- The MiroFish team is recruiting (full-time + intern); see upstream README
+
+## Use with cue
+This profile (`predict-everything`) inherits `core` and adds this pointer skill plus the `uv` CLI recipe. Future prediction/simulation tools — additional OASIS-based forks, alternate engines like AgentSims or Generative Agents from Stanford — would land as siblings under `predict-everything/`.

package/resources/skills/skills/research/trendradar/SKILL.md

@@ -0,0 +1,88 @@
+---
+description: "When user asks about news trends, hot topics, RSS feeds, or wants to analyze/search recent news — use the TrendRadar MCP tools"
+allowed-tools:
+  - mcp__trendradar__get_latest_news
+  - mcp__trendradar__get_trending_topics
+  - mcp__trendradar__search_news
+  - mcp__trendradar__analyze_topic_trend
+  - mcp__trendradar__analyze_data_insights
+  - mcp__trendradar__analyze_sentiment
+  - mcp__trendradar__find_related_news
+  - mcp__trendradar__generate_summary_report
+  - mcp__trendradar__get_latest_rss
+  - mcp__trendradar__search_rss
+  - mcp__trendradar__read_article
+  - mcp__trendradar__read_articles_batch
+  - mcp__trendradar__aggregate_news
+  - mcp__trendradar__compare_periods
+  - mcp__trendradar__send_notification
+  - mcp__trendradar__trigger_crawl
+  - mcp__trendradar__resolve_date_range
+---
+
+# TrendRadar — News Trend Intelligence
+
+Use the TrendRadar MCP server for all news aggregation, trend analysis, and notification tasks.
+
+## Available Tools (27)
+
+### Data Query
+- `get_latest_news` — Fetch the most recent news articles
+- `get_news_by_date` — Get news for a specific date
+- `search_news` — Full-text search across all collected news
+- `aggregate_news` — Aggregate news by topic/source/date
+
+### Trend Analysis
+- `get_trending_topics` — Current trending topics across sources
+- `analyze_topic_trend` — Track how a topic trends over time
+- `analyze_data_insights` — Statistical insights from news data
+- `analyze_sentiment` — Sentiment analysis on news topics
+- `find_related_news` — Find articles related to a topic
+- `compare_periods` — Compare news patterns between time periods
+- `generate_summary_report` — Generate a comprehensive trend report
+
+### RSS
+- `get_latest_rss` — Latest RSS feed entries
+- `search_rss` — Search within RSS feeds
+- `get_rss_feeds_status` — Check RSS feed health
+
+### Article Reading
+- `read_article` — Read full article content
+- `read_articles_batch` — Read multiple articles at once
+
+### System
+- `trigger_crawl` — Trigger a news crawl manually
+- `get_system_status` — Check TrendRadar system health
+- `check_version` — Check for updates
+- `get_current_config` — View current configuration
+- `resolve_date_range` — Parse natural language date ranges
+
+### Storage & Sync
+- `sync_from_remote` — Sync data from remote storage
+- `get_storage_status` — Check storage health
+- `list_available_dates` — List dates with available data
+
+### Notifications
+- `send_notification` — Send news digest to configured channels
+- `get_notification_channels` — List notification channels
+- `get_channel_format_guide` — Get formatting guide for a channel
+
+## Workflow Examples
+
+**Daily briefing:**
+1. `get_trending_topics` → see what's hot
+2. `get_latest_news` → read top stories
+3. `generate_summary_report` → create digest
+4. `send_notification` → push to Slack/WeChat/email
+
+**Research a topic:**
+1. `search_news "AI agents"` → find relevant articles
+2. `analyze_topic_trend "AI agents"` → see trend over time
+3. `analyze_sentiment "AI agents"` → gauge market sentiment
+4. `read_articles_batch` → deep-read the top hits
+
+## Prerequisites
+
+- Python 3.12+
+- `uvx` (for running the MCP server)
+- TrendRadar data (run `trendradar` crawler first, or sync from remote)

package/resources/skills/skills/rust/async-tokio/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: async-tokio
+description: Use when writing async Rust with tokio — picking a runtime flavor, structuring tasks, choosing sync vs async primitives, debugging deadlocks.
+allowed-tools: Bash(cargo:*)
+---
+
+# Async Rust with Tokio
+
+Runtime patterns + common foot-guns.
+
+## When to use
+- New binary: `#[tokio::main]` (multi-thread) or `#[tokio::main(flavor = "current_thread")]` for single-thread / WASM
+- New lib: don't pull in tokio — return `impl Future` and let callers pick a runtime
+- Spawn long-running task: `tokio::spawn(async move { ... })`
+- Run blocking code: `tokio::task::spawn_blocking(|| ...)` — NEVER call blocking sync APIs (std::fs, std::thread::sleep) inside an async fn on the main runtime
+- Cancel a task: drop the `JoinHandle` or use `tokio::select! { _ = cancel_rx => ..., r = work => ... }`
+- Channels: `tokio::sync::mpsc` (multi-producer), `oneshot` (single message), `broadcast` (fanout), `watch` (latest-value)
+- Async mutex only when you `.await` while holding the lock — otherwise use `std::sync::Mutex`
+
+## Prerequisites
+- cargo
+
+## Notes
+- Holding a `std::sync::Mutex` across `.await` is a clippy lint and a real deadlock risk. Use `tokio::sync::Mutex` or restructure to drop the guard first.
+- `tokio::spawn` requires `Send` futures. For non-Send (e.g. tree-walking with `Rc`), use `tokio::task::spawn_local` + `LocalSet`.
+- Debug deadlocks with `tokio-console` (separate crate) — it shows the live task tree.
+- For libraries supporting multiple runtimes, gate runtime-specific code behind feature flags (`tokio`, `async-std`, `smol`) rather than pulling in tokio directly.