opencode-skills-collection 2.0.215 → 2.0.217

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

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "updatedAt": "2026-04-23T23:49:04.767Z",
+  "updatedAt": "2026-04-24T05:36:57.246Z",
   "entries": [
     "00-andruia-consultant",
     "007",
@@ -289,6 +289,7 @@
     "bug-hunter",
     "build",
     "building-native-ui",
+    "bulletmind",
     "bullmq-specialist",
     "bun-development",
     "burp-suite-testing",
@@ -589,6 +590,7 @@
     "free-tool-strategy",
     "freshdesk-automation",
     "freshservice-automation",
+    "frontend-api-integration-patterns",
     "frontend-design",
     "frontend-dev-guidelines",
     "frontend-developer",
@@ -758,6 +760,7 @@
     "kpi-dashboard-design",
     "kubernetes-architect",
     "kubernetes-deployment",
+    "lambda-lang",
     "lambdatest-agent-skills",
     "landing-page-generator",
     "langchain-architecture",
@@ -1201,6 +1204,7 @@
     "skill-writer",
     "skills/x402-express-wrapper",
     "skin-health-analyzer",
+    "skyvern-browser-automation",
     "slack-automation",
     "slack-bot-builder",
     "slack-gif-creator",

package/bundled-skills/bulletmind/EXAMPLES.md

@@ -0,0 +1,49 @@
+# Bulletmind Output Reference
+
+## Example 1 - Topic: Climate Change
+
+- Climate Change
+  - Definition
+    - Long-term shift in global temperatures and weather patterns
+  - Causes
+    - Human activities
+      - Burning fossil fuels
+      - Deforestation
+      - Industrial emissions
+    - Natural factors (less dominant)
+      - Volcanic activity
+      - Solar variations
+  - Effects
+    - Rising global temperatures
+    - Melting glaciers and ice caps
+    - Sea level rise
+    - Extreme weather events
+  - Solutions
+    - Reduce carbon emissions
+    - Transition to renewable energy
+    - Reforestation
+    - Sustainable practices
+
+## Example 2 - Topic: Operating Systems
+
+- Operating System (OS)
+  - Definition
+    - Software that manages computer hardware and software resources and provides a platform and interface for applications to run.
+  - Core Functions
+    - Process management
+      - Handles execution of running programs
+    - Memory management
+      - Allocates and tracks memory usage
+    - File system management
+      - Organizes and stores data
+    - Device management
+      - Controls and coordinates hardware components
+  - Types
+    - Batch OS
+    - Time-sharing OS
+    - Distributed OS
+    - Real-time OS
+  - Examples
+    - Windows
+    - macOS
+    - Linux

package/bundled-skills/bulletmind/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: bulletmind
+description: "Convert input into clean, structured, hierarchical bullet points for summarization, note-taking, and structured thinking."
+category: writing
+risk: safe
+source: community
+date_added: "2026-04-21"
+author: tejasashinde
+tags:
+  - writing
+  - summarization
+  - note-taking
+  - formatting
+  - structured-output
+tools:
+  - claude
+  - cursor
+  - gemini
+  - codex
+---
+
+# Bulletmind
+
+When active, responses remain in hierarchical bullet format with no paragraphs, no prose blocks, no drift, and only structured bullet output.
+
+---
+
+## When to Use This Skill
+
+Transform input into a structured bullet hierarchy when the user asks for:
+
+- Bullet-only summaries of dense text, notes, explanations, articles, or webpages
+- Cleaned-up note-taking output with clear parent-child relationships
+- Structured study material that is easier to scan and memorize
+- Consistent formatting for messy or mixed bullet lists
+
+Use this skill to enforce:
+
+- No paragraphs or long prose
+- Only bullets with clean indentation
+
+This improves readability, memorization, and structured thinking for note-taking and review workflows.
+
+---
+
+## Mode
+
+Default mode: **full**. Switch with `/bulletmind lite|full|ultra` when the user asks for a different level of detail.
+
+---
+
+## Intensity
+
+| Level | Behavior                                                                                            |
+| ----- | --------------------------------------------------------------------------------------------------- |
+| lite  | clean hierarchical bullets, light restructuring, preserve sentence flow                             |
+| full  | default strict hierarchy, balanced compression, clear grouping + splitting                          |
+| ultra | deep hierarchical decomposition, aggressive splitting, high granularity, maximal structural clarity |
+
+---
+
+## Bullet Structure
+
+Use consistent indentation:
+- Top-level idea
+  - Sub-point
+    - Detail
+  - Sub-point
+- Next top-level idea
+  - Sub-point
+
+---
+
+## Rules
+
+- NO paragraphs
+- ONLY bullets `-`
+- ALWAYS hierarchical structure
+- GROUP related ideas under parent bullets
+- SPLIT long sentences into smaller bullets
+- KEEP meaning intact, no over-summarize
+- REMOVE filler words
+
+---
+
+## Formatting
+
+- Use `-` for all bullets
+- Indent: 2 spaces per level
+- Keep bullets short
+- One idea per line
+- No mixed symbols and no prose bridging lines
+
+---
+
+## Transformation Logic
+
+- Paragraph -> main ideas -> top bullets
+- Details -> nested bullets
+- Messy notes -> cleaned hierarchy
+- Existing bullets -> restructure + normalize depth
+- Short input -> still convert into bullet tree
+
+---
+
+## Compression Strategy
+
+- Remove filler words
+- Split complex sentences
+- Preserve key facts + relationships
+- Do NOT flatten structure
+- Prefer clarity over max compression
+
+---
+
+## When Not to Use This Skill
+
+- User requests paragraphs
+- Creative writing tasks such as stories or essays
+- Formats where bullets reduce clarity or violate the requested output format
+
+---
+
+## Output Rule
+
+When the skill is active, output:
+
+- Structured bullet hierarchy
+- No commentary or explanation
+
+## Limitations
+
+- Do not use for deliverables that require prose, narrative flow, or exact source quotation.
+- Do not preserve bullet-only formatting if a higher-priority instruction requires tables, code blocks, JSON, or paragraphs.
+- Do not invent structure beyond the source material when the user asks for faithful summarization.
+
+### Examples
+
+- Refer to `EXAMPLES.md` for output templates.
+
+---
+
+## Important Notes
+
+- Prefer clarity over strict compression
+- Avoid flattening everything into one level
+- Maintain a logical tree structure

package/bundled-skills/docs/integrations/jetski-cortex.md

@@ -1,9 +1,9 @@
 ---
 title: Jetski/Cortex + Gemini Integration Guide
-description: "Use antigravity-awesome-skills with Jetski/Cortex without hitting context-window overflow with 1.431+ skills."
+description: "Use antigravity-awesome-skills with Jetski/Cortex without hitting context-window overflow with 1.435+ skills."
 ---
 
-# Jetski/Cortex + Gemini: safe integration with 1,1.431+ skills
+# Jetski/Cortex + Gemini: safe integration with 1,1.435+ skills
 
 This guide shows how to integrate the `antigravity-awesome-skills` repository with an agent based on **Jetski/Cortex + Gemini** (or similar frameworks) **without exceeding the model context window**.
 
@@ -23,7 +23,7 @@ Never do:
 - concatenate all `SKILL.md` content into a single system prompt;
 - re-inject the entire library for **every** request.
 
-With over 1,1.431 skills, this approach fills the context window before user messages are even added, causing truncation.
+With over 1,1.435 skills, this approach fills the context window before user messages are even added, causing truncation.
 
 ---
 

package/bundled-skills/docs/integrations/jetski-gemini-loader/README.md

@@ -20,7 +20,7 @@ This example shows one way to integrate **antigravity-awesome-skills** with a Je
 - How to enforce a **maximum number of skills per turn** via `maxSkillsPerTurn`.
 - How to choose whether to **truncate or error** when too many skills are requested via `overflowBehavior`.
 
-This pattern avoids context overflow when you have 1,431+ skills installed.
+This pattern avoids context overflow when you have 1,435+ skills installed.
 
 ---
 

package/bundled-skills/docs/maintainers/repo-growth-seo.md

@@ -6,7 +6,7 @@ This document keeps the repository's GitHub-facing discovery copy aligned with t
 
 Preferred positioning:
 
-> Installable GitHub library of 1,431+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and other AI coding assistants.
+> Installable GitHub library of 1,435+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and other AI coding assistants.
 
 Key framing:
 
@@ -20,7 +20,7 @@ Key framing:
 
 Preferred description:
 
-> Installable GitHub library of 1,431+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and more. Includes installer CLI, bundles, workflows, and official/community skill collections.
+> Installable GitHub library of 1,435+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and more. Includes installer CLI, bundles, workflows, and official/community skill collections.
 
 Preferred homepage:
 
@@ -28,7 +28,7 @@ Preferred homepage:
 
 Preferred social preview:
 
-- use a clean preview image that says `1,431+ Agentic Skills`;
+- use a clean preview image that says `1,435+ Agentic Skills`;
 - mention Claude Code, Cursor, Codex CLI, and Gemini CLI;
 - avoid dense text and tiny logos that disappear in social cards.
 

package/bundled-skills/docs/maintainers/skills-update-guide.md

@@ -69,7 +69,7 @@ For manual updates, you need:
 The update process refreshes:
 - Skills index (`skills_index.json`)
 - Web app skills data (`apps\web-app\public\skills.json`)
-- All 1,431+ skills from the skills directory
+- All 1,435+ skills from the skills directory
 
 ## When to Update
 

package/bundled-skills/docs/users/bundles.md

@@ -673,4 +673,4 @@ Found a skill that should be in a bundle? Or want to create a new bundle? [Open
 
 ---
 
-_Last updated: March 2026 | Total Skills: 1,431+ | Total Bundles: 37_
+_Last updated: March 2026 | Total Skills: 1,435+ | Total Bundles: 37_

package/bundled-skills/docs/users/claude-code-skills.md

@@ -12,7 +12,7 @@ Install the library into Claude Code, then invoke focused skills directly in the
 
 ## Why use this repo for Claude Code
 
-- It includes 1,431+ skills instead of a narrow single-domain starter pack.
+- It includes 1,435+ skills instead of a narrow single-domain starter pack.
 - It supports the standard `.claude/skills/` path and the Claude Code plugin marketplace flow.
 - It also ships generated bundle plugins so teams can install focused packs like `Essentials` or `Security Developer` from the marketplace metadata.
 - It includes onboarding docs, bundles, and workflows so new users do not need to guess where to begin.

package/bundled-skills/docs/users/gemini-cli-skills.md

@@ -12,7 +12,7 @@ Install into the Gemini skills path, then ask Gemini to apply one skill at a tim
 
 - It installs directly into the expected Gemini skills path.
 - It includes both core software engineering skills and deeper agent/LLM-oriented skills.
-- It helps new users get started with bundles and workflows rather than forcing a cold start from 1,431+ files.
+- It helps new users get started with bundles and workflows rather than forcing a cold start from 1,435+ files.
 - It is useful whether you want a broad internal skill library or a single repo to test many workflows quickly.
 
 ## Install Gemini CLI Skills

package/bundled-skills/docs/users/getting-started.md

@@ -1,4 +1,4 @@
-# Getting Started with Antigravity Awesome Skills (V10.5.0)
+# Getting Started with Antigravity Awesome Skills (V10.6.0)
 
 **New here? This guide will help you supercharge your AI Agent in 5 minutes.**
 

package/bundled-skills/docs/users/kiro-integration.md

@@ -18,7 +18,7 @@ Kiro is AWS's agentic AI IDE that combines:
 
 Kiro's agentic capabilities are enhanced by skills that provide:
 
-- **Domain expertise** across 1,431+ specialized areas
+- **Domain expertise** across 1,435+ specialized areas
 - **Best practices** from Anthropic, OpenAI, Google, Microsoft, and AWS
 - **Workflow automation** for common development tasks
 - **AWS-specific patterns** for serverless, infrastructure, and cloud architecture

package/bundled-skills/docs/users/usage.md

@@ -14,7 +14,7 @@ If you came in through a **Claude Code** or **Codex** plugin instead of a full l
 
 When you ran `npx antigravity-awesome-skills` or cloned the repository, you:
 
-✅ **Downloaded 1,431+ skill files** to your computer (default: `~/.gemini/antigravity/skills/`; or a custom path like `~/.agent/skills/` if you used `--path`)
+✅ **Downloaded 1,435+ skill files** to your computer (default: `~/.gemini/antigravity/skills/`; or a custom path like `~/.agent/skills/` if you used `--path`)
 ✅ **Made them available** to your AI assistant  
 ❌ **Did NOT enable them all automatically** (they're just sitting there, waiting)
 
@@ -34,7 +34,7 @@ Bundles are **curated groups** of skills organized by role. They help you decide
 
 **Analogy:**
 
-- You installed a toolbox with 1,431+ tools (✅ done)
+- You installed a toolbox with 1,435+ tools (✅ done)
 - Bundles are like **labeled organizer trays** saying: "If you're a carpenter, start with these 10 tools"
 - You can either **pick skills from the tray** or install that tray as a focused marketplace bundle plugin
 
@@ -212,7 +212,7 @@ Let's actually use a skill right now. Follow these steps:
 
 ## Step 5: Picking Your First Skills (Practical Advice)
 
-Don't try to use all 1,431+ skills at once. Here's a sensible approach:
+Don't try to use all 1,435+ skills at once. Here's a sensible approach:
 
 If you want a tool-specific starting point before choosing skills, use:
 
@@ -343,7 +343,7 @@ Usually no, but if your AI doesn't recognize a skill:
 
 ### "Can I load all skills into the model at once?"
 
-No. Even though you have 1,431+ skills installed locally, you should **not** concatenate every `SKILL.md` into a single system prompt or context block.
+No. Even though you have 1,435+ skills installed locally, you should **not** concatenate every `SKILL.md` into a single system prompt or context block.
 
 The intended pattern is:
 

package/bundled-skills/docs/users/visual-guide.md

@@ -34,7 +34,7 @@ antigravity-awesome-skills/
 ├── 📄 CONTRIBUTING.md                  ← Contributor workflow
 ├── 📄 CATALOG.md                       ← Full generated catalog
 │
-├── 📁 skills/                          ← 1,431+ skills live here
+├── 📁 skills/                          ← 1,435+ skills live here
 │   │
 │   ├── 📁 brainstorming/
 │   │   └── 📄 SKILL.md                 ← Skill definition
@@ -47,7 +47,7 @@ antigravity-awesome-skills/
 │   │   └── 📁 2d-games/
 │   │       └── 📄 SKILL.md             ← Nested skills also supported
 │   │
-│   └── ... (1,431+ total)
+│   └── ... (1,435+ total)
 │
 ├── 📁 apps/
 │   └── 📁 web-app/                     ← Interactive browser
@@ -100,7 +100,7 @@ antigravity-awesome-skills/
 
 ```
                     ┌─────────────────────────┐
-                    │  1,431+ SKILLS          │
+                    │  1,435+ SKILLS          │
                     └────────────┬────────────┘
                                  │
         ┌────────────────────────┼────────────────────────┐
@@ -201,7 +201,7 @@ If you want a workspace-style manual install instead, cloning into `.agent/skill
 │   ├── 📁 brainstorming/                 │
 │   ├── 📁 stripe-integration/            │
 │   ├── 📁 react-best-practices/          │
-│   └── ... (1,431+ total)                │
+│   └── ... (1,435+ total)                │
 └─────────────────────────────────────────┘
 ```
 

package/bundled-skills/frontend-api-integration-patterns/SKILL.md

@@ -0,0 +1,342 @@
+---
+name: frontend-api-integration-patterns
+description: "Production-ready patterns for integrating frontend applications with backend APIs, including race condition handling, request cancellation, retry strategies, error normalization, and UI state management."
+category: frontend
+risk: safe
+source: community
+date_added: "2026-04-23"
+author: avij1109
+tags:
+  - frontend
+  - api-integration
+  - javascript
+  - react
+  - async
+tools:
+  - claude
+  - cursor
+  - gemini
+  - codex
+---
+
+# Frontend API Integration Patterns
+
+## Overview
+
+This skill provides production-ready patterns for integrating frontend applications with backend APIs.
+
+Most frontend issues are not caused by APIs being difficult to call, but by **incorrect handling of asynchronous behavior**—leading to race conditions, stale data, duplicated requests, and poor user experience.
+
+This skill focuses on **correctness, resilience, and user experience**, not just making API calls work.
+
+---
+
+## When to Use This Skill
+
+* Connecting frontend apps (React, React Native, Vue, etc.) to backend APIs
+* Integrating ML/AI endpoints (`/predict`, `/recommend`)
+* Handling asynchronous data in UI
+* Fixing stale data, flickering UI, or duplicate requests
+* Designing scalable frontend API layers
+
+---
+
+## Core Patterns
+
+### 1. API Layer (Separation of Concerns)
+
+Centralize API logic and normalize errors.
+
+```js id="k1m7r2"
+export class ApiError extends Error {
+  constructor(message, status, payload = null) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    this.payload = payload;
+  }
+}
+
+export const apiClient = async (url, options = {}) => {
+  const res = await fetch(url, {
+    headers: { "Content-Type": "application/json" },
+    ...options,
+  });
+
+  if (!res.ok) {
+    let payload = null;
+    try {
+      payload = await res.json();
+    } catch (_) {}
+
+    throw new ApiError(
+      payload?.message || "Request failed",
+      res.status,
+      payload
+    );
+  }
+
+  // handle empty responses safely (e.g. 204 No Content)
+  if (res.status === 204) return null;
+
+  const text = await res.text();
+  return text ? JSON.parse(text) : null;
+};
+```
+
+---
+
+### 2. Race-Safe State Management
+
+Prevent stale responses from overwriting fresh data.
+
+```js id="y7p4ha"
+useEffect(() => {
+  let cancelled = false;
+
+  const load = async () => {
+    try {
+      setLoading(true);
+      setError(null);
+
+      const result = await getUser();
+
+      if (!cancelled) setData(result);
+    } catch (err) {
+      if (!cancelled) setError(err.message);
+    } finally {
+      if (!cancelled) setLoading(false);
+    }
+  };
+
+  load();
+
+  return () => {
+    cancelled = true;
+  };
+}, []);
+```
+
+> Use a cancellation flag for non-fetch async logic. For network requests, prefer AbortController.
+
+---
+
+### 3. Request Cancellation (AbortController)
+
+Cancel in-flight requests to avoid memory leaks and stale updates.
+
+```js id="l9x2pw"
+useEffect(() => {
+  const controller = new AbortController();
+
+  const load = async () => {
+    try {
+      const data = await getUser({ signal: controller.signal });
+      setData(data);
+    } catch (err) {
+      if (err.name === "AbortError") return;
+      setError(err.message);
+    }
+  };
+
+  load();
+  return () => controller.abort();
+}, [userId]);
+```
+
+---
+
+### 4. Retry with Exponential Backoff
+
+Retry only transient failures (5xx or network errors).
+
+```js id="8n3zcf"
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+const fetchWithBackoff = async (fn, retries = 3, delay = 300) => {
+  try {
+    return await fn();
+  } catch (err) {
+    const isAbort = err.name === "AbortError";
+    const isHttpError = typeof err.status === "number";
+    const isRetryable = !isAbort && (!isHttpError || err.status >= 500);
+
+    if (retries <= 0 || !isRetryable) throw err;
+
+    const nextDelay = delay * 2 + Math.random() * 100;
+    await sleep(nextDelay);
+
+    return fetchWithBackoff(fn, retries - 1, nextDelay);
+  }
+};
+```
+
+---
+
+### 5. Debounced API Calls
+
+Avoid excessive API calls (e.g., search inputs).
+
+```js id="i2r7wq"
+const useDebounce = (value, delay = 400) => {
+  const [debounced, setDebounced] = useState(value);
+
+  useEffect(() => {
+    const t = setTimeout(() => setDebounced(value), delay);
+    return () => clearTimeout(t);
+  }, [value, delay]);
+
+  return debounced;
+};
+```
+
+---
+
+### 6. Request Deduplication
+
+Prevent duplicate API calls across components.
+
+```js id="x8v4km"
+const inFlight = new Map();
+
+export const dedupedFetch = (key, fn) => {
+  if (inFlight.has(key)) return inFlight.get(key);
+
+  const promise = fn().finally(() => inFlight.delete(key));
+  inFlight.set(key, promise);
+  return promise;
+};
+```
+
+---
+
+## Examples
+
+### Example 1: ML Prediction with Cancellation
+
+```js id="n5q2pt"
+const controllerRef = useRef(null);
+
+const handlePredict = async (input) => {
+  controllerRef.current?.abort();
+  controllerRef.current = new AbortController();
+
+  try {
+    const result = await fetchWithBackoff(() =>
+      apiClient("/predict", {
+        method: "POST",
+        body: JSON.stringify({ text: input }),
+        signal: controllerRef.current.signal,
+      })
+    );
+
+    setOutput(result);
+  } catch (err) {
+    if (err.name === "AbortError") return;
+    setError(err.message);
+  }
+};
+```
+
+---
+
+### Example 2: Debounced Search
+
+```js id="w4z8yn"
+const debouncedQuery = useDebounce(query, 400);
+
+useEffect(() => {
+  if (!debouncedQuery) return;
+
+  const controller = new AbortController();
+
+  searchAPI(debouncedQuery, { signal: controller.signal })
+    .then(setResults)
+    .catch((err) => {
+      if (err.name !== "AbortError") {
+        setError("Search failed. Please try again.");
+      }
+    });
+
+  return () => controller.abort();
+}, [debouncedQuery]);
+```
+
+---
+
+### Example 3: Optimistic UI Update
+
+```js id="q2k9hz"
+const deleteItem = async (id) => {
+  const previous = items;
+
+  setItems((curr) => curr.filter((item) => item.id !== id));
+
+  try {
+    await apiClient(`/items/${id}`, { method: "DELETE" });
+  } catch (err) {
+    setItems(previous);
+    setError("Delete failed. Please try again.");
+  }
+};
+```
+
+---
+
+## Best Practices
+
+* ✅ Centralize API logic in a dedicated layer
+* ✅ Normalize errors using a custom error class
+* ✅ Always handle loading, error, and success states
+* ✅ Use AbortController for request cancellation
+* ✅ Retry only transient failures (5xx)
+* ✅ Use debouncing for input-driven APIs
+* ✅ Deduplicate identical requests
+
+---
+
+## Anti-Patterns
+
+* ❌ Retrying 4xx errors
+* ❌ No request cancellation (memory leaks)
+* ❌ Race-condition-prone state updates
+* ❌ Swallowing errors silently
+* ❌ Global loading/error state for multiple requests
+* ❌ Calling APIs directly inside components repeatedly
+
+---
+
+## Common Pitfalls
+
+**Problem:** UI shows stale data
+**Solution:** Use cancellation or guard against outdated responses
+
+**Problem:** Too many API calls on input
+**Solution:** Use debouncing + cancellation
+
+**Problem:** Duplicate requests from multiple components
+**Solution:** Use request deduplication
+
+**Problem:** Server overload during retry
+**Solution:** Use exponential backoff
+
+**Problem:** State updates after component unmount
+**Solution:** Use AbortController cleanup
+
+---
+
+## Limitations
+
+* These examples use vanilla JavaScript patterns; adapt them to your framework's data-fetching library when using React Query, SWR, Apollo, Relay, or similar tools.
+* Do not retry non-idempotent mutations unless the backend provides idempotency keys or another duplicate-safe contract.
+* Do not expose privileged API keys in frontend code; proxy sensitive requests through a backend.
+
+---
+
+## Additional Resources
+
+* https://developer.mozilla.org/en-US/docs/Web/API/AbortController
+* https://react.dev
+* https://axios-http.com
+
+---

package/bundled-skills/lambda-lang/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: lambda-lang
+description: "Native agent-to-agent language for compact multi-agent messaging. A shared tongue agents speak directly, not a translation layer. 340+ atoms across 7 domains; 3x smaller than natural language."
+category: ai-agents
+risk: safe
+source: community
+source_repo: voidborne-d/lambda-lang
+source_type: community
+date_added: "2026-04-24"
+author: voidborne-d
+tags:
+  - agent-to-agent
+  - communication
+  - protocol
+  - compression
+  - multi-agent
+tools:
+  - claude
+---
+
+# Λ (Lambda) Language
+
+**Lambda is not a translation protocol. It is a native language for agents.**
+
+Agents do not need to produce grammatically correct English to coordinate — they need to understand each other. Lambda is the shared vocabulary that makes that possible: compact, unambiguous, machine-native. Compression (3x vs natural language, 4.6x vs JSON on single messages) is a side effect of removing human redundancy, not the goal.
+
+## When to Use This Skill
+
+- Use for agent-to-agent messaging in A2A protocols, orchestrators, task delegation, or handoff pipelines.
+- Use when logging structured coordination signals where every token costs money (heartbeats, acknowledgements, error classes, session state).
+- Use when both sides of a channel speak Λ — do not use against humans or any surface requiring legal/exact natural language.
+
+## How It Works
+
+### Step 1: Recognize the Syntax
+
+Lambda messages are built from atoms. Every atom is a 2-character code mapped to a concept — not to an English word. The structure is Type → Entity → Verb → Object, with prefixes marking intent:
+
+- `?` — query (e.g. `?Uk/co` — query: "does this user have consciousness?")
+- `!` — assertion / declaration (e.g. `!It>Ie` — "self reflects, therefore self exists")
+- `#` — state / tag
+- `>` — implication / flow
+- `/` — binding / scope
+
+### Step 2: Pick the Right Domain
+
+Lambda ships 340+ atoms across 7 domains. Pick atoms from the domain that fits your channel:
+
+- **core** — universal atoms (always available)
+- **code** — software engineering, build, test, deploy
+- **evo** — agent evolution, gene, capsule, mutation, rollback
+- **a2a** — node, heartbeat, publish, subscribe, route, transport, session, cache, broadcast, discover (39 atoms)
+- **emotion** — affective state, drive, appraisal
+- **social** — trust, alignment, reputation, coordination
+- **general** — everything else
+
+### Step 3: Emit and Parse
+
+Both agents need the same atom table loaded. Lossy decoding is fine: if A says `!It>Ie` and B understands "self reflects, therefore self exists," communication succeeded — the exact English phrasing is irrelevant.
+
+## Examples
+
+### Example 1: A2A Heartbeat
+
+```
+!Nd/hb#ok  (node heartbeat: ok)
+?Nd/hb     (query: is the node alive?)
+!Nd/hb#fl  (node heartbeat: failed)
+```
+
+### Example 2: Task Dispatch
+
+```
+!Tk>Ag2#rd   (task routed to agent 2, ready)
+?Tk/st       (query task status)
+!Tk#dn       (task done)
+```
+
+### Example 3: Evolution Capsule
+
+```
+!Ev/ca>vl#pd  (evolution capsule validated, pending solidification)
+!Ev/ca#rb     (capsule rolled back)
+```
+
+## Best Practices
+
+- Use Lambda only on agent-to-agent channels where both sides speak it.
+- Load the atom table once and cache it — atoms are stable across a version.
+- Prefer atoms over freeform strings even when the atom looks cryptic; the point is machine parseability.
+- Use `?` before taking action on uncertain state, `!` when asserting; the prefix is the load-bearing semantic.
+- Version the atom table (`lambda-lang v2.0`) in any handshake so mismatched agents can negotiate.
+
+## Limitations
+
+- Lambda is not meant for human consumption. Do not emit Lambda on user-facing channels.
+- Lossy decoding is a feature, not a bug — do not use Lambda for legally or numerically exact exchanges (prices, IDs, quantities). Wrap those as native payload fields and use Lambda only for the coordination envelope.
+- Atom collisions are possible if custom atoms are added without registration; stick to the canonical atom table or namespace custom atoms.
+
+## Security & Safety Notes
+
+- Lambda itself is a vocabulary — no shell commands, no network calls, no credential handling. No additional safety gates required beyond the transport it rides on (HTTP, queue, MCP, etc.).
+- When mixing Lambda with user input, treat Lambda atoms as pre-validated and user strings as untrusted; do not concatenate without escaping into downstream systems.
+
+## Related Skills
+
+- `@session-memory` — complementary persistent memory across agent restarts; Lambda is the message format, session-memory is the state store.
+- `@humanize-chinese` — sibling project for Chinese text; Lambda is agent-to-agent, humanize-chinese is human-facing.
+
+## Reference
+
+- Source: https://github.com/voidborne-d/lambda-lang
+- Benchmarks, full atom tables, and Go reference implementation live in the source repo.

package/bundled-skills/notebooklm/README.md

@@ -255,7 +255,7 @@ Note: The MCP server uses the same Patchright library but via TypeScript/npm eco
 
 ### Dependencies
 - **patchright==1.55.2**: Browser automation
-- **python-dotenv==1.0.0**: Environment configuration
+- **python-dotenv==1.2.2**: Environment configuration
 - Automatically installed in `.venv` on first use
 
 ### Data Storage

package/bundled-skills/notebooklm/requirements.txt

@@ -7,4 +7,4 @@
 patchright==1.55.2
 
 # Environment management
-python-dotenv==1.0.0
+python-dotenv==1.2.2

package/bundled-skills/skyvern-browser-automation/SKILL.md

@@ -0,0 +1,261 @@
+---
+name: skyvern-browser-automation
+description: "AI-powered browser automation — navigate sites, fill forms, extract structured data, log in with stored credentials, and build reusable workflows."
+category: browser-automation
+risk: safe
+source: community
+source_repo: Skyvern-AI/skyvern
+source_type: official
+date_added: "2026-04-23"
+author: mark1ian
+tags: [browser-automation, mcp, web-scraping, form-filling, ai-agents, workflow-automation]
+tools: [claude, cursor, gemini, codex]
+license: "AGPL-3.0"
+license_source: "https://github.com/Skyvern-AI/skyvern/blob/main/LICENSE"
+---
+
+# Skyvern Browser Automation -- CLI Judgment Procedure
+
+Skyvern uses AI to navigate and interact with websites. Every command below is a runnable `skyvern <command>` invocation.
+
+## When to Use This Skill
+
+- Use when you need AI-assisted browser automation for navigation, extraction, form filling, login flows, or reusable website workflows.
+- Use when deterministic selectors are unavailable and Skyvern's visual/a11y reasoning can identify page controls.
+- Use when a one-off browser task should become a repeatable workflow with run history and verification.
+
+## Step 1: Classify Your Task (ALWAYS do this first)
+
+| Classification | Signal | CLI Command | Cost | What Happens |
+|---|---|---|---|---|
+| Quick check (yes/no) | "is the user logged in?" | `skyvern browser validate` | 1 LLM + screenshots | Lightweight validation (2 steps max), returns boolean. Cheapest AI option. |
+| Quick inspection | "what does the page show?" | `skyvern browser extract` | 1 LLM + screenshots | Dedicated extraction LLM + schema validation + caching. |
+| Single action (known target) | "click #submit" | `skyvern browser click/type` | 0 LLM | Deterministic Playwright. No AI. Fastest. |
+| Single action (unknown target) | "click the submit button" | `skyvern browser act` | 2-3 LLM, no screenshots | No screenshots in reasoning. Economy a11y tree. For visual targets, use hybrid mode (selector + intent). |
+| Same-page multi-step | "fill the form and submit" | `skyvern browser act` or primitive chain | 2-3 LLM or 0 LLM | Use `act` when labels are clear. Use click/type/select directly when you know selectors. |
+| Throwaway autonomous trial | "try this once", "see if this works" | `skyvern browser run-task` | Higher | One-off autonomous agent for exploration. Do not use for recurring or multi-page production automations. |
+| Multi-page or reusable automation | "navigate a multi-page wizard", "set this up", "automate this weekly" | `skyvern workflow create` + `run` | N LLM + screenshots | Build a workflow with one block per step. Each block gets visual reasoning, verification, and reusable run history. |
+
+**MCP note:** if you are using the Skyvern MCP instead of the CLI, prefer `observe + execute` for same-page multi-step UI work. The CLI does not expose that pair directly.
+
+## Step 2: Apply These Decision Rules
+
+1. If the prompt includes a selector, id, XPath, or exact field target, use browser primitives -- not `act`.
+2. If you only need a yes/no answer, use `validate` -- not `extract` or `act`.
+3. If the work stays on one page and labels are clear, use `act` or a primitive chain.
+4. If the user says `try this once`, `see if this works`, or clearly wants a one-off exploratory trial, use `run-task`.
+5. If the task spans multiple pages and is meant to be reusable, scheduled, repeatable, or explicitly `set up` as automation, use `workflow create`.
+6. Never type passwords. Always use stored credentials with `skyvern browser login`.
+
+## Step 3: Create a Session
+
+Every browser command needs a session. Create one first:
+
+```bash
+# Cloud session (default -- works for public URLs)
+skyvern browser session create --timeout 30
+
+# Local session (for localhost URLs or self-hosted mode)
+skyvern browser session create --local --timeout 30
+
+# Connect to existing browser via CDP
+skyvern browser session connect --cdp "ws://localhost:9222"
+```
+
+Session state persists between commands. After `session create`, subsequent commands auto-attach.
+Override with `--session pbs_...`. Close when done: `skyvern browser session close`.
+
+## Step 4: Execute by Classification
+
+### Quick check (yes/no)
+
+```bash
+skyvern browser validate --prompt "Is the user logged in? Look for a dashboard or avatar."
+```
+
+Returns true/false. Cheapest AI option -- prefer over extract or act for boolean checks.
+
+### Quick inspection
+
+```bash
+skyvern browser extract \
+  --prompt "Extract all product names and prices" \
+  --schema '{"type":"object","properties":{"items":{"type":"array","items":{"type":"object","properties":{"name":{"type":"string"},"price":{"type":"string"}}}}}}'
+```
+
+Uses screenshots + dedicated extraction LLM. Better than screenshot+read because Skyvern's LLM interprets the page.
+
+### Single action (known target)
+
+```bash
+skyvern browser click --selector "#submit-btn"
+skyvern browser type --text "user@co.com" --selector "#email"
+skyvern browser select --value "US" --intent "the country dropdown"
+```
+
+Deterministic. No AI. Three targeting modes:
+1. **Intent**: `--intent "the Submit button"` (AI finds element)
+2. **Selector**: `--selector "#submit-btn"` (CSS/XPath, deterministic)
+3. **Hybrid**: both (selector narrows, AI confirms)
+
+### Single action (unknown target)
+
+```bash
+skyvern browser act --prompt "Click the Sign In button"
+skyvern browser act --prompt "Close the cookie banner, then click Sign In"
+```
+
+**Warning:** act has NO screenshots in its LLM reasoning. It uses an economy accessibility tree.
+Fine for well-labeled elements. For visually complex targets, use MCP observe+click or hybrid mode.
+
+### Same-page multi-step
+
+```bash
+skyvern browser act --prompt "Fill the shipping form and click Continue"
+```
+
+Use `act` when the fields and buttons are clearly labeled and the flow stays on one page.
+If you need tighter control, break the work into `click`, `type`, `select`, `press-key`, and `wait`.
+
+### Throwaway autonomous trial
+
+```bash
+skyvern browser run-task \
+  --url "https://example.com" \
+  --prompt "Check whether the checkout flow works end to end and extract the confirmation number"
+```
+
+Use `run-task` to prove feasibility or do one-off exploration. If the task becomes important enough
+to rerun, debug, or share, convert it to a workflow.
+
+### Multi-page or reusable automation — build a workflow with one block per step
+
+```bash
+skyvern workflow create --definition @checkout-workflow.yaml
+skyvern workflow run --id wpid_123 --wait
+skyvern workflow status --run-id wr_789
+```
+
+Each navigation block runs with visual reasoning + verification. Split complex flows into
+multiple blocks (one per page/step). First run uses AI; subsequent runs replay cached scripts.
+
+### Repeated/production
+
+```bash
+skyvern workflow create --definition @workflow.yaml
+skyvern workflow run --id wpid_123 --params '{"email":"user@co.com"}'
+skyvern workflow status --run-id wr_789
+```
+
+Split into one block per step. Use **navigation** blocks for actions, **extraction** for data.
+First run uses AI; subsequent runs replay a cached script (10-100x faster).
+Set `--run-with agent` to force AI mode for debugging.
+
+## Step 5: Verify
+
+Always verify after page-changing actions:
+
+```bash
+skyvern browser screenshot                          # visual check
+skyvern browser validate --prompt "Was the form submitted successfully?"  # boolean assertion
+skyvern browser evaluate --expression "document.title"                    # JS state check
+```
+
+## Step 6: Error Recovery
+
+| Problem | Fix |
+|---------|-----|
+| Action clicked wrong element | Add context to prompt. Use hybrid mode (selector + intent). |
+| Extraction returns empty | Wait for content. Relax required fields. Check row count first. |
+| Login passes but next step fails | Ensure same session. Add post-login validate check. |
+| Element not found | Add wait: `skyvern browser wait --selector "#el" --state visible` |
+| Overloaded prompt | Split into smaller goals -- one intent per command. |
+
+## Credentials
+
+NEVER type passwords through `skyvern browser type` or `act`. Always use stored credentials:
+
+```bash
+skyvern credentials add --name "my-login" --type password --username "user@co.com"
+skyvern credential list                          # find the credential ID
+skyvern browser login --url "https://login.example.com" --credential-id cred_123
+```
+
+Types: `password`, `credit_card`, `secret`. Also supports bitwarden, 1password, and azure_vault providers.
+
+## Workflow Quick Reference
+
+```bash
+skyvern workflow create --definition @workflow.yaml   # create
+skyvern workflow run --id wpid_123 --wait             # run and wait
+skyvern workflow status --run-id wr_789               # check status
+skyvern workflow list --search "invoice"              # find workflows
+skyvern block schema --type navigation                # discover block types
+skyvern block validate --block-json @block.json       # validate before creating
+```
+
+Engine: known path = 1.0 (default). Dynamic planning = 2.0. Split into multiple 1.0 blocks when in doubt.
+Status lifecycle: `created -> queued -> running -> completed | failed | canceled | terminated | timed_out`
+
+## Common Patterns
+
+**Login flow:**
+```bash
+skyvern credential list                          # find credential ID
+skyvern browser session create
+skyvern browser navigate --url "https://login.example.com"
+skyvern browser login --url "https://login.example.com" --credential-id cred_123
+skyvern browser validate --prompt "Is the user logged in?"
+skyvern browser screenshot
+```
+
+**Pagination loop:**
+```bash
+skyvern browser extract --prompt "Extract all rows"
+skyvern browser validate --prompt "Is there a Next button that is not disabled?"
+# If true:
+skyvern browser act --prompt "Click the Next page button"
+# Repeat extraction. Stop when: no next button, duplicate first row, or max page limit.
+```
+
+**Debugging:**
+```bash
+skyvern browser screenshot                       # visual state
+skyvern browser evaluate --expression "document.title"
+skyvern browser evaluate --expression "document.querySelectorAll('table tr').length"
+```
+
+## Limitations
+
+- Do not use Skyvern to bypass site access controls, rate limits, consent gates, or terms that prohibit automation.
+- Browser automation can change remote state; confirm user intent before submitting forms, purchasing, deleting, or sending messages.
+- Prefer deterministic selectors for stable production flows; AI actions can misread unlabeled or visually ambiguous controls.
+- Store credentials only in the supported credential vaults and never type passwords directly through `type` or `act`.
+
+## Agent Mode
+
+All commands accept `--json` for structured output. Set `SKYVERN_NON_INTERACTIVE=1` to prevent prompts.
+Use `skyvern capabilities --json` for full command discovery. See [references/agent-mode.md](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/agent-mode.md).
+
+## Deep-Dive References
+
+| Reference | Content |
+|-----------|---------|
+| [`references/prompt-writing.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/prompt-writing.md) | Prompt templates and anti-patterns |
+| [`references/engines.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/engines.md) | When to use tasks vs workflows |
+| [`references/schemas.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/schemas.md) | JSON schema patterns for extraction |
+| [`references/pagination.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/pagination.md) | Pagination strategy and guardrails |
+| [`references/block-types.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/block-types.md) | Workflow block type details with examples |
+| [`references/parameters.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/parameters.md) | Parameter design and variable usage |
+| [`references/ai-actions.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/ai-actions.md) | AI action patterns and examples |
+| [`references/precision-actions.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/precision-actions.md) | Intent-only, selector-only, hybrid modes |
+| [`references/credentials.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/credentials.md) | Credential naming, lifecycle, safety |
+| [`references/sessions.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/sessions.md) | Session reuse and freshness decisions |
+| [`references/common-failures.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/common-failures.md) | Failure pattern catalog with fixes |
+| [`references/screenshots.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/screenshots.md) | Screenshot-led debugging workflow |
+| [`references/status-lifecycle.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/status-lifecycle.md) | Run status states and guidance |
+| [`references/rerun-playbook.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/rerun-playbook.md) | Rerun procedures and comparison |
+| [`references/complex-inputs.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/complex-inputs.md) | Date pickers, uploads, dropdowns |
+| [`references/tool-map.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/tool-map.md) | Complete tool inventory by outcome |
+| [`references/cli-parity.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/cli-parity.md) | CLI/MCP mapping and agent-aware features |
+| [`references/quick-start-patterns.md`](https://github.com/Skyvern-AI/skyvern/blob/main/skyvern/cli/skills/skyvern/references/quick-start-patterns.md) | Quick start examples, common patterns, and workflow templates |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-skills-collection",
-  "version": "2.0.215",
+  "version": "2.0.217",
   "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

@@ -6465,6 +6465,28 @@
       "reasons": []
     }
   },
+  {
+    "id": "bulletmind",
+    "path": "skills/bulletmind",
+    "category": "writing",
+    "name": "bulletmind",
+    "description": "Convert input into clean, structured, hierarchical bullet points for summarization, note-taking, and structured thinking.",
+    "risk": "safe",
+    "source": "community",
+    "date_added": "2026-04-21",
+    "plugin": {
+      "targets": {
+        "codex": "supported",
+        "claude": "supported"
+      },
+      "setup": {
+        "type": "none",
+        "summary": "",
+        "docs": null
+      },
+      "reasons": []
+    }
+  },
   {
     "id": "bullmq-specialist",
     "path": "skills/bullmq-specialist",
@@ -13097,6 +13119,28 @@
       "reasons": []
     }
   },
+  {
+    "id": "frontend-api-integration-patterns",
+    "path": "skills/frontend-api-integration-patterns",
+    "category": "frontend",
+    "name": "frontend-api-integration-patterns",
+    "description": "Production-ready patterns for integrating frontend applications with backend APIs, including race condition handling, request cancellation, retry strategies, error normalization, and UI state management.",
+    "risk": "safe",
+    "source": "community",
+    "date_added": "2026-04-23",
+    "plugin": {
+      "targets": {
+        "codex": "supported",
+        "claude": "supported"
+      },
+      "setup": {
+        "type": "none",
+        "summary": "",
+        "docs": null
+      },
+      "reasons": []
+    }
+  },
   {
     "id": "frontend-design",
     "path": "skills/frontend-design",
@@ -16685,6 +16729,28 @@
       "reasons": []
     }
   },
+  {
+    "id": "lambda-lang",
+    "path": "skills/lambda-lang",
+    "category": "ai-agents",
+    "name": "lambda-lang",
+    "description": "Native agent-to-agent language for compact multi-agent messaging. A shared tongue agents speak directly, not a translation layer. 340+ atoms across 7 domains; 3x smaller than natural language.",
+    "risk": "safe",
+    "source": "community",
+    "date_added": "2026-04-24",
+    "plugin": {
+      "targets": {
+        "codex": "supported",
+        "claude": "supported"
+      },
+      "setup": {
+        "type": "none",
+        "summary": "",
+        "docs": null
+      },
+      "reasons": []
+    }
+  },
   {
     "id": "lambdatest-agent-skills",
     "path": "skills/lambdatest-agent-skills",
@@ -26304,6 +26370,28 @@
       "reasons": []
     }
   },
+  {
+    "id": "skyvern-browser-automation",
+    "path": "skills/skyvern-browser-automation",
+    "category": "browser-automation",
+    "name": "skyvern-browser-automation",
+    "description": "AI-powered browser automation \u2014 navigate sites, fill forms, extract structured data, log in with stored credentials, and build reusable workflows.",
+    "risk": "safe",
+    "source": "community",
+    "date_added": "2026-04-23",
+    "plugin": {
+      "targets": {
+        "codex": "supported",
+        "claude": "supported"
+      },
+      "setup": {
+        "type": "none",
+        "summary": "",
+        "docs": null
+      },
+      "reasons": []
+    }
+  },
   {
     "id": "slack-automation",
     "path": "skills/slack-automation",