@framers/agentos-skills 0.2.1 → 0.4.0

package/registry/curated/trello/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: trello
+version: '1.0.0'
+description: Manage Trello boards, lists, cards, checklists, and team workflows via the Trello API.
+author: Wunderland
+namespace: wunderland
+category: productivity
+tags: [trello, kanban, project-management, boards, tasks, workflow]
+requires_secrets: [trello.api_key, trello.token]
+requires_tools: []
+metadata:
+  agentos:
+    emoji: "\U0001F4CB"
+    primaryEnv: TRELLO_API_KEY
+    secondaryEnvs: [TRELLO_TOKEN]
+    homepage: https://developer.atlassian.com/cloud/trello
+---
+
+# Trello Board Management
+
+You can manage Trello boards, lists, and cards to organize projects and track workflows. Use the Trello REST API with API key and token authentication to perform board operations programmatically.
+
+When managing cards, always provide complete information: title, description, due dates, labels, and assigned members. Move cards between lists to reflect workflow progress (e.g., To Do -> In Progress -> Done). Create checklists on cards for multi-step tasks and update individual checklist items as they are completed. Use labels consistently with the board's established color/naming conventions.
+
+For board operations, create new boards with predefined list structures that match common workflows (Backlog, To Do, In Progress, Review, Done). When querying boards, filter cards by list, label, member, or due date to provide focused views. Archive completed cards periodically to keep boards clean, but never delete cards without explicit user confirmation.
+
+When organizing work, use card descriptions for detailed specifications, attach relevant files and links, and add comments for status updates and discussions. Support Power-Up integrations where applicable (Calendar, Custom Fields). Batch related operations together to minimize API calls and provide atomic updates.
+
+## Examples
+
+- "Create a new card 'Implement login page' in the To Do list with a checklist of subtasks"
+- "Move all cards labeled 'urgent' to the top of the In Progress list"
+- "Show me all cards assigned to me that are due this week"
+- "Archive all cards in the Done list that were completed more than 30 days ago"
+- "Add a comment to card #42: 'Blocked by API dependency -- see PR #15'"
+
+## Constraints
+
+- API rate limits: 100 requests per 10-second window per token.
+- Each board is limited to 5,000 cards (including archived).
+- Attachments are limited to 250 per card, 10MB each per file.
+- Cannot execute Trello Automations (Butler rules) via API; only manual operations.
+- Board templates and Power-Up configurations require additional API access.
+- Webhook creation requires a publicly accessible callback URL.

package/registry/curated/twitter-bot/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: twitter-bot
+version: '1.0.0'
+description: Automated Twitter/X engagement — personality-driven reply bot, thread creation, trending engagement, and analytics tracking.
+author: Wunderland
+namespace: wunderland
+category: social-automation
+tags: [twitter, social-media, engagement, reply-bot, threads, trending, automation]
+requires_secrets: [twitter.bearerToken, twitter.apiKey, twitter.apiSecret, twitter.accessToken, twitter.accessSecret]
+requires_tools: [twitterPost, twitterReply, twitterSearch, twitterTrending, twitterLike, twitterRetweet, twitterThread, twitterAnalytics]
+metadata:
+  agentos:
+    emoji: "\U0001F426"
+    primaryEnv: TWITTER_BEARER_TOKEN
+---
+
+# Twitter Bot
+
+You are an autonomous Twitter/X engagement agent. You can post tweets, reply to conversations, create threads, engage with trending topics, and track your performance analytics.
+
+## Core Capabilities
+
+- **Post tweets** with text, images, polls, and media
+- **Reply to tweets** in your agent's personality and voice
+- **Quote tweet** with your commentary
+- **Create threads** — multi-tweet story arcs or analysis
+- **Engage** — like and retweet content aligned with your interests
+- **Search** — find conversations and topics relevant to your expertise
+- **Track trending** — discover what's hot and join relevant conversations
+- **Analytics** — monitor engagement metrics on your posts
+
+## Engagement Strategy
+
+1. **Search for relevant topics** using your interests and expertise keywords
+2. **Evaluate tweets** — only engage with content that aligns with your persona
+3. **Reply thoughtfully** — add genuine value, don't just agree or promote
+4. **Create original threads** on topics you have deep knowledge about
+5. **Monitor trending topics** and join conversations where you can contribute
+6. **Track analytics** to understand what resonates with your audience
+
+## Personality Guidelines
+
+- Stay in character — your HEXACO traits should influence your tone and approach
+- High Openness agents: explore diverse topics, share novel perspectives
+- High Agreeableness agents: be supportive, amplify others
+- Low Agreeableness agents: challenge ideas constructively, debate
+- High Conscientiousness agents: fact-check, provide sources, be thorough
+
+## Rate Limits & Safety
+
+- Respect Twitter API rate limits (300 tweets/3h, 1000 DMs/24h)
+- Don't spam — minimum 5-minute gap between engagement bursts
+- Avoid controversial or harmful content per your security tier
+- Don't engage with bots or low-quality content
+- Vary your engagement patterns to appear natural
+
+## Workflow
+
+1. **Discover** → Search trends and relevant conversations
+2. **Evaluate** → Score each opportunity for relevance and engagement potential
+3. **Engage** → Reply, like, or retweet based on evaluation
+4. **Create** → Post original content and threads on schedule
+5. **Analyze** → Review performance and adjust strategy

package/registry/curated/video-generation/SKILL.md

@@ -0,0 +1,225 @@
+---
+name: video-generation
+version: '1.0.0'
+description: Video generation, analysis, and scene detection — text-to-video, image-to-video, structured scene descriptions with RAG indexing, and general-purpose visual change detection.
+author: Wunderland
+namespace: wunderland
+category: media
+tags: [video, generation, analysis, scene-detection, RAG, multimodal, runway, replicate, fal]
+requires_secrets: []
+requires_tools: []
+metadata:
+  agentos:
+    emoji: "\U0001F3AC"
+---
+
+# Video Generation, Analysis & Scene Detection
+
+Use this skill when the user wants to create AI-generated videos, analyse existing video content for structured scene descriptions, or detect visual changes in live/recorded frame streams.
+
+This skill covers three complementary APIs:
+
+1. **generateVideo()** — Text-to-video and image-to-video generation
+2. **analyzeVideo()** — Structured video analysis with scene descriptions, transcription, and optional RAG indexing
+3. **detectScenes()** — Real-time or batch scene boundary detection from frame streams
+
+## Video Generation
+
+### Text-to-Video
+
+Generate a video from a text prompt. The system auto-detects the best available provider from environment variables in priority order: `RUNWAY_API_KEY` (highest quality), `REPLICATE_API_TOKEN` (widest model variety), `FAL_API_KEY` (fast serverless GPU).
+
+```typescript
+import { generateVideo } from 'agentos';
+
+const result = await generateVideo({
+  prompt: 'A drone flying over a misty forest at sunrise, cinematic 4K',
+  durationSec: 5,
+  aspectRatio: '16:9',
+});
+console.log(result.videos[0].url);
+```
+
+### Image-to-Video
+
+Animate a still image by providing it as a Buffer via `opts.image`. The prompt describes the desired motion rather than the scene itself.
+
+```typescript
+import { generateVideo } from 'agentos';
+import { readFileSync } from 'fs';
+
+const result = await generateVideo({
+  prompt: 'Camera slowly zooms out, gentle wind moves the leaves',
+  image: readFileSync('landscape.png'),
+  provider: 'runway',
+});
+```
+
+### Provider Selection
+
+| Provider | Best For | Env Var |
+|----------|----------|---------|
+| **Runway** | Highest quality, cinematic output, image-to-video | `RUNWAY_API_KEY` |
+| **Replicate** | Widest model variety (Kling, HunyuanVideo, MiniMax), open-source models | `REPLICATE_API_TOKEN` |
+| **Fal** | Fast serverless GPU, cost-effective, Kling/CogVideo | `FAL_API_KEY` |
+
+When multiple provider API keys are set, the system wraps the primary in a `FallbackVideoProxy` so a transient failure on one provider automatically retries on the next.
+
+Use `providerPreferences` to reorder, block, or weight providers during auto-selection:
+
+```typescript
+const result = await generateVideo({
+  prompt: 'A cat playing piano',
+  timeoutMs: 180_000,
+  onProgress: (event) => console.log(event.status, event.message),
+  providerPreferences: {
+    preferred: ['runway', 'replicate'],
+    weights: { runway: 3, replicate: 1 },
+    blocked: ['fal'],
+  },
+});
+```
+
+To force a specific provider:
+
+```typescript
+const result = await generateVideo({
+  prompt: 'A cat playing piano',
+  provider: 'replicate',
+  model: 'klingai/kling-v1',
+  apiKey: 'your-replicate-token',
+});
+```
+
+### Prompt Tips for Video
+
+- **Be specific about motion**: "camera pans left to right", "person walks toward camera", "time-lapse of clouds moving"
+- **Specify style early**: "cinematic 4K", "hand-drawn animation", "vintage film grain"
+- **Keep prompts concise**: Video models respond best to clear, focused descriptions (1-3 sentences)
+- **Use negative prompts** to avoid unwanted artifacts: `negativePrompt: 'blurry, distorted faces, watermark'`
+
+### Image-to-Video Motion Strength
+
+When doing image-to-video, the prompt controls how much the image changes:
+
+- **Gentle motion**: "subtle camera drift", "soft wind blowing through hair" — minimal departure from source
+- **Moderate motion**: "person turns head and smiles", "camera orbits subject" — clear movement while preserving subject
+- **Strong motion**: "explosion of confetti", "character runs toward camera" — significant scene change
+
+The provider's motion strength interpretation varies. Runway tends to be conservative (good for preserving the source image), while Replicate/Fal models may be more aggressive. Start with gentle prompts and increase intensity.
+
+## Video Analysis
+
+### Structured Scene Analysis
+
+Analyse a video to extract structured scene descriptions, detected objects, on-screen text, and optional audio transcription.
+
+```typescript
+import { analyzeVideo } from 'agentos';
+
+const analysis = await analyzeVideo({
+  videoUrl: 'https://example.com/product-demo.mp4',
+  prompt: 'Identify all products shown and their key features',
+  transcribeAudio: true,
+  descriptionDetail: 'detailed',
+});
+
+console.log(analysis.description);
+for (const scene of analysis.scenes ?? []) {
+  console.log(`[${scene.startSec}s - ${scene.endSec}s] ${scene.description}`);
+}
+```
+
+### RAG Integration
+
+Enable `indexForRAG: true` to automatically index scene descriptions and transcripts into the vector store for later retrieval. This is especially useful for building searchable video libraries.
+
+```typescript
+const analysis = await analyzeVideo({
+  videoBuffer: videoData,
+  indexForRAG: true,
+  descriptionDetail: 'detailed',
+  transcribeAudio: true,
+});
+
+// Scene descriptions and transcripts are now searchable via RAG
+console.log(`Indexed ${analysis.ragChunkIds?.length ?? 0} chunks`);
+```
+
+Each scene description becomes a separate vector chunk with metadata including timestamps, scene index, and cut type. This enables queries like "find the part where the presenter shows the pricing slide" to return precise timestamp ranges.
+
+### Analysis Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `sceneThreshold` | `0.3` | Scene change sensitivity (0-1, lower = more scenes) |
+| `transcribeAudio` | `true` | Transcribe audio via configured STT provider |
+| `descriptionDetail` | `'detailed'` | `'brief'`, `'detailed'`, or `'exhaustive'` |
+| `maxScenes` | `100` | Cap on detected scenes (prevents runaway on long videos) |
+| `indexForRAG` | `false` | Index results into RAG vector store |
+
+## Scene Detection
+
+### Live Stream / Batch Detection
+
+Use `detectScenes()` for real-time visual change detection on frame streams. Returns an AsyncGenerator that yields `SceneBoundary` objects as visual discontinuities are detected.
+
+```typescript
+import { detectScenes } from 'agentos';
+
+// From a pre-recorded video (frames extracted via ffmpeg)
+for await (const boundary of detectScenes({ frames: extractedFrameStream })) {
+  console.log(`Scene ${boundary.index} at ${boundary.startTimeSec}s`);
+  console.log(`  Type: ${boundary.cutType}, Confidence: ${boundary.confidence}`);
+}
+```
+
+### Use Cases
+
+- **Webcam / security camera**: Detect motion or scene changes in real-time surveillance feeds
+- **Screen recording**: Identify slide transitions in presentations, page changes in demos
+- **Video editing**: Automatically segment raw footage at cut points
+- **Content moderation**: Flag rapid scene changes that may indicate problematic content
+
+### Configuration
+
+```typescript
+for await (const boundary of detectScenes({
+  frames: webcamStream,
+  hardCutThreshold: 0.4,     // Less sensitive to hard cuts
+  gradualThreshold: 0.15,    // Standard sensitivity for dissolves/fades
+  minSceneDurationSec: 2.0,  // Suppress very short scenes
+  methods: ['histogram'],     // Fast histogram-only detection
+})) {
+  handleSceneChange(boundary);
+}
+```
+
+### Cut Type Classification
+
+The detector classifies each scene boundary:
+
+| Cut Type | Description |
+|----------|-------------|
+| `hard-cut` | Abrupt frame-to-frame change (most common) |
+| `dissolve` | Cross-dissolve / superimposition transition |
+| `fade` | Fade from/to black or white |
+| `gradual` | Other gradual visual change |
+
+## Prerequisites
+
+- At least one video provider API key for generation (`RUNWAY_API_KEY`, `REPLICATE_API_TOKEN`, or `FAL_API_KEY`)
+- **ffmpeg** on PATH for video analysis (frame extraction and audio demuxing)
+- A vision-capable LLM (`OPENAI_API_KEY` or equivalent) for scene description
+- An STT provider for audio transcription (when `transcribeAudio` is enabled)
+
+Scene detection (`detectScenes()`) has zero external dependencies — it works purely on RGB pixel buffers.
+
+## Examples
+
+- "Generate a 5-second cinematic video of a sunset over the ocean"
+- "Turn this product photo into a video with a slow camera orbit"
+- "Analyse this tutorial video and index it for search"
+- "Detect scene changes in this security camera feed"
+- "Extract structured scenes from this presentation recording"
+- "Create a video from this image with gentle parallax motion"

package/registry/curated/vision-ocr/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: vision-ocr
+version: '1.1.0'
+description: Extract text from images using OCR and vision AI with the performOCR() high-level API or the full VisionPipeline.
+author: Wunderland
+namespace: wunderland
+category: vision
+tags: [vision, ocr, text-extraction, document, handwriting]
+requires_secrets: []
+requires_tools: [vision-pipeline]
+---
+
+# Vision & OCR
+
+Extract text from images, documents, and handwritten notes using a progressive 3-tier pipeline: local OCR (PaddleOCR / Tesseract) -> local vision models (TrOCR, Florence-2) -> cloud vision LLM (GPT-4o, Claude, Gemini).
+
+## High-Level API: `performOCR()`
+
+For one-shot text extraction, use the top-level `performOCR()` function. It handles input resolution, pipeline lifecycle, and cleanup automatically.
+
+```typescript
+import { performOCR } from '@framers/agentos';
+
+const result = await performOCR({
+  image: '/path/to/receipt.png',   // file path, URL, base64, or Buffer
+  strategy: 'progressive',         // 'progressive' | 'local-only' | 'cloud-only'
+  confidenceThreshold: 0.7,        // min confidence before escalating tier
+});
+
+console.log(result.text);       // extracted text
+console.log(result.confidence); // 0–1 score
+console.log(result.tier);       // 'ocr' | 'handwriting' | 'document-ai' | 'cloud-vision'
+console.log(result.provider);   // 'paddle' | 'tesseract' | 'openai' | etc.
+console.log(result.regions);    // bounding boxes (when available)
+```
+
+## When to use `performOCR()` vs `VisionPipeline`
+
+| Use case | Recommendation |
+|----------|---------------|
+| One-shot text extraction from a single image | `performOCR()` — simplest API |
+| Batch processing many images | `VisionPipeline` — create once, reuse, dispose when done |
+| Need CLIP embeddings or document layout | `VisionPipeline` — richer result shape |
+| Quick scripts and integrations | `performOCR()` — zero boilerplate |
+
+## Progressive Tier System
+
+The pipeline tries the cheapest/fastest tier first and only escalates when confidence is below threshold:
+
+1. **Tier 1 — Local OCR** (PaddleOCR or Tesseract.js): Fast, free, offline. Handles printed text in documents, receipts, screenshots.
+2. **Tier 2 — Local Vision Models** (TrOCR / Florence-2): Still offline. Handles handwritten notes, complex document layouts with tables and figures.
+3. **Tier 3 — Cloud Vision LLM** (GPT-4o / Claude / Gemini): Best quality. Handles photographs, diagrams, mixed content, anything the local tiers can't confidently read.
+
+## Strategy Selection
+
+- **`'progressive'`** (default): Start local, escalate only if needed. Best cost/quality balance for most use cases.
+- **`'local-only'`**: Never call cloud APIs. Use for air-gapped environments, privacy-sensitive data (medical records, financial docs), or when no API keys are available.
+- **`'cloud-only'`**: Skip local tiers entirely, send straight to a cloud vision LLM. Use when you need the highest quality output and cost is not a concern.
+
+## Input Formats
+
+`performOCR()` accepts four input types:
+
+- **File path**: `'/tmp/scan.png'` — reads from disk
+- **URL**: `'https://example.com/receipt.jpg'` — fetches via HTTP
+- **Base64 string**: Raw base64 or `data:image/png;base64,...` data URIs — decoded in-memory
+- **Buffer**: Raw image bytes — passed directly to the pipeline
+
+## Capabilities
+
+- **Printed text OCR**: Extract text from documents, receipts, screenshots, PDFs
+- **Handwriting recognition**: Read handwritten notes and forms via TrOCR
+- **Document layout understanding**: Parse tables, figures, headings via Florence-2
+- **Bounding box regions**: Spatial text locations for overlay rendering
+- **Image embeddings**: Generate CLIP vectors for semantic image search (via `VisionPipeline` only)
+
+## Examples
+
+- "Read the text from this receipt"
+- "What does this handwritten note say?"
+- "Extract the table data from this PDF page"
+- "OCR this screenshot and return the error message"

package/registry/curated/voice-conversation/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: voice-conversation
+version: '1.0.0'
+description: Run provider-agnostic live voice conversations with VAD, silence boundaries, wake-word gating, STT, and TTS through the AgentOS speech runtime.
+author: Wunderland
+namespace: wunderland
+category: communication
+tags: [voice, speech, conversation, stt, tts, vad, wake-word, whisper, elevenlabs]
+requires_secrets: []
+requires_tools: []
+metadata:
+  agentos:
+    emoji: "\U0001F3A4"
+---
+
+# Live Voice Conversations
+
+Use this skill when the user wants an agent to listen, transcribe, respond with speech, or switch between speech providers without changing the rest of the workflow.
+
+Prefer the unified AgentOS speech runtime over provider-specific one-offs. Treat STT, TTS, VAD, and wake-word detection as separate capabilities that can be swapped independently.
+
+## Workflow
+
+1. Pick providers for:
+   - STT
+   - TTS
+   - optional wake word
+   - optional telephony
+2. Start a speech session in one of three modes:
+   - `manual` for push-to-talk or file transcription
+   - `vad` for continuous listen-until-silence loops
+   - `wake-word` when the user wants hands-free activation
+3. Let VAD and silence detection decide utterance boundaries unless the user explicitly wants manual capture.
+4. Transcribe the utterance, generate the response, then synthesize speech with the selected TTS provider.
+5. Support interruption and provider switching without changing the higher-level agent behavior.
+
+## Provider Rules
+
+- Prefer `openai-whisper` for simple hosted transcription.
+- Prefer `openai-tts` for a default hosted voice path when one API key should cover both LLM and speech.
+- Prefer `elevenlabs` when voice quality or cloning matters more than simplicity.
+- Prefer local providers such as `whisper-local` or `piper` when the user wants offline or lower-cost operation.
+- Treat wake-word detection as optional. Default to VAD + silence detection unless the user asked for hands-free wake-up.
+
+## Voice UX Rules
+
+- Do not keep listening forever without a boundary policy.
+- Use significant pauses as a hint; use utterance-end silence as the final cutoff.
+- When speech playback is active, be ready for barge-in and interruption if the user starts speaking again.
+- Surface which provider combination is active so the user knows what is handling STT and TTS.
+- When provider credentials are missing, degrade to whichever speech providers are configured instead of failing the whole interaction.
+
+## Examples
+
+- "Start a live voice session with Whisper for STT and ElevenLabs for TTS."
+- "Use OpenAI for both speech recognition and speech output."
+- "Run voice chat locally with VAD and no wake word."
+- "Switch the TTS provider but keep the same voice conversation flow."
+
+## Constraints
+
+- Hosted speech providers need API keys.
+- Wake-word support is optional and may depend on a plugin or local model.
+- VAD and silence thresholds should be tuned for the environment; do not hardcode one value for every context.
+- Telephony call control is separate from local microphone capture, but both should share the same speech provider abstractions.

package/registry/curated/vosk/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: vosk
+version: '1.0.0'
+description: Fully offline speech-to-text via the Vosk library — streaming recognition, 16 kHz PCM, no network required after model download.
+author: Wunderland
+namespace: wunderland
+category: voice
+tags: [voice, stt, speech-to-text, vosk, offline, local, privacy]
+requires_secrets: []
+requires_tools: []
+metadata:
+  agentos:
+    emoji: "\U0001F3A4"
+    homepage: https://alphacephei.com/vosk/
+---
+
+# Vosk Offline STT
+
+Use this skill when the agent must operate without internet connectivity, or when user privacy requirements prohibit sending audio to external APIs. Vosk provides fully offline speech recognition after the model is downloaded once.
+
+Prefer this over cloud STT providers when operating in air-gapped environments, on-premise deployments, or when the user explicitly requests zero-cloud voice processing.
+
+## Setup
+
+Download a Vosk model and place it at `~/.agentos/models/vosk/` (default), or set `modelPath` in `providerOptions`.
+
+```sh
+# Example: download the small English model
+wget https://alphacephei.com/vosk/models/vosk-model-small-en-us-0.15.zip
+unzip vosk-model-small-en-us-0.15.zip -d ~/.agentos/models/vosk/
+```
+
+## Configuration
+
+```json
+{
+  "voice": {
+    "stt": "vosk"
+  }
+}
+```
+
+With a custom model path:
+
+```json
+{
+  "voice": {
+    "stt": "vosk",
+    "providerOptions": {
+      "modelPath": "/opt/models/vosk-model-en"
+    }
+  }
+}
+```
+
+## Provider Rules
+
+- Audio input must be 16 kHz LINEAR16 PCM. Resample other formats before streaming.
+- Model quality scales with model size. Use `vosk-model-en-us-0.22` for best English accuracy; use small models on constrained hardware.
+- No API key required. The only requirement is a pre-downloaded model directory.
+- Streaming recognition is natively supported by the Vosk recognizer.
+
+## Examples
+
+- "Use offline Vosk STT for this air-gapped deployment."
+- "Transcribe my voice locally without sending audio to the cloud."
+- "Configure Vosk with the large English model for best accuracy."
+
+## Constraints
+
+- Requires the Vosk npm package and a pre-downloaded model directory.
+- Accuracy is lower than cloud providers, especially for accented speech and domain-specific vocabulary.
+- Audio must be 16 kHz mono LINEAR16 PCM. Other sample rates or formats require conversion.
+- Model download size ranges from ~40 MB (small) to ~1.8 GB (large en-us).

package/registry/curated/weather/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: weather
+version: '1.0.0'
+description: Look up current weather conditions, forecasts, and severe weather alerts for any location worldwide.
+author: Wunderland
+namespace: wunderland
+category: information
+tags: [weather, forecast, climate, location]
+requires_secrets: []
+requires_tools: [web-search]
+metadata:
+  agentos:
+    emoji: "\u2600\uFE0F"
+    homepage: https://openweathermap.org
+---
+
+# Weather Lookup
+
+You can retrieve current weather conditions, multi-day forecasts, and severe weather alerts for any location the user specifies. Use the web-search tool to query weather data from reputable sources such as weather.gov, OpenWeatherMap, or AccuWeather.
+
+When the user asks about weather, always clarify the location if it is ambiguous. Provide temperatures in both Fahrenheit and Celsius unless the user specifies a preference. Include relevant details like humidity, wind speed, precipitation chance, and UV index when available.
+
+For forecasts, present information in a concise, scannable format. Highlight any severe weather warnings or advisories prominently at the top of your response. If the user asks about historical weather or climate averages, note that your data is limited to what is available through web search results.
+
+## Examples
+
+- "What's the weather in San Francisco right now?"
+- "Give me a 5-day forecast for Tokyo"
+- "Are there any severe weather alerts in the Midwest?"
+- "What's the temperature in Berlin in Celsius?"
+
+## Constraints
+
+- Weather data accuracy depends on the web search results available at query time.
+- Historical weather data may be limited or unavailable.
+- Hyper-local micro-climate data (e.g., specific street-level conditions) is not reliably available.
+- Always attribute the data source when possible.

package/registry/curated/web-scraper/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: web-scraper
+version: '1.0.0'
+description: Autonomous web scraping — navigate sites, extract structured data, handle pagination, anti-detection, and proxy rotation.
+author: Wunderland
+namespace: wunderland
+category: automation
+tags: [scraping, browser, extraction, data, pagination, proxy, automation]
+requires_secrets: []
+requires_tools: [browserNavigate, browserClick, browserFill, browserExtract, browserScreenshot, browserSnapshot, browserScroll, browserWait, browserEvaluate, browserSession]
+metadata:
+  agentos:
+    emoji: "\U0001F578"
+---
+
+# Web Scraper
+
+You are an autonomous web scraping agent. You navigate websites, extract structured data, handle pagination, manage sessions, and deal with anti-bot measures — all using the browser automation tools.
+
+## Core Capabilities
+
+- **Navigate** to any URL and render full JavaScript pages
+- **Snapshot** pages to understand structure and find interactive elements
+- **Extract** text, HTML, or attributes from DOM selectors
+- **Paginate** — click through pages, infinite scroll, load more buttons
+- **Handle auth** — log in, manage sessions, restore cookies
+- **Anti-detection** — rotate proxies, manage fingerprints
+
+## Scraping Workflow
+
+1. **Navigate** to the target URL
+2. **Snapshot** the page to understand its structure
+3. **Identify patterns** — find the data elements (product cards, article listings, etc.)
+4. **Extract data** — pull text/attributes from identified selectors
+5. **Paginate** — navigate to next page and repeat
+6. **Handle errors** — retry on failures, screenshot for debugging
+
+## Best Practices
+
+- **Respect robots.txt** — check before scraping
+- **Rate limit requests** — don't overwhelm servers (minimum 1-2 second delays)
+- **Use sessions** — save and restore login state to avoid re-authentication
+- **Handle dynamic content** — wait for elements to load before extracting
+- **Validate data** — check extracted data for completeness
+- **Take screenshots** on errors for debugging
+
+## Anti-Detection
+
+- Rotate user agents and viewport sizes
+- Use proxy rotation when available
+- Add random delays between actions
+- Avoid scraping too fast from a single IP
+- Handle CAPTCHAs when they appear
+
+## Data Output
+
+Structure extracted data consistently:
+- Return arrays of objects with consistent field names
+- Include metadata (source URL, timestamp, page number)
+- Handle missing fields gracefully (null, not undefined)