Dogfooding: this project uses its own product concept.

Dogfooding: this project uses its own product concept.

Advanced AI agent memory system with hybrid search (BM25 + vector), Cohere reranking, embedding cache, and incremental sync. ChromaDB + Ollama backed, 100% self-hosted (Cohere reranking optional). Use when managing agent long-term memory, indexing memory files, running memory health checks, or searching agent memories with hybrid retrieval.

Python-based arithmetic calculator for performing mathematical operations. Use when the user needs to perform calculations, arithmetic operations, or mathematical computations including addition, subtraction, multiplication, division, exponentiation, and more complex mathematical expressions.

Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.

This repository is a monorepo. Each library lives in a subdirectory under libs/.

This repository is a monorepo. Each library lives in a subdirectory under libs/.

Instructions for migrating from Semantic Kernel Agents to Agent Framework in .NET projects.

This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in nodemodules/next/dist/docs/ before writing any code. Heed deprecation notices.

Style guidelines for writing and updating documentation. Use when writing new docs, updating existing docs, or reviewing docs for quality.

This file provides guidance to AI coding agents when working with code in this repository.

Install and run the Continue CLI (`cn`) to execute AI agent checks on local code changes. Use when asked to "run checks", "lint with AI", "review my changes with cn", or set up Continue CI locally.

Run benchmarks and update docs/benchmarks.md. Use before releases or when comparing against other projects.

Guide for working on the Acolyte codebase. Use when building features, fixing bugs, or extending Acolyte itself.

Create a pull request with review and verify. Use when the branch is ready to merge.

Create a GitHub issue from a short description. Use when filing a bug, feature request, or task.

Run pre-deploy checks, determine version bump, and execute release. Use when ready to cut a release.

Acolyte is a terminal-first AI coding agent: local-first, observable, extensible. Read docs/architecture.md before working on unfamiliar subsystems.

This skill should be used when the user asks to "update SDK", "bump SDK version", "pin SDK to a commit", "test unreleased SDK", "update agent-server image", "bump the version", "prepare a release", "what files change for a release", or needs to know how SDK packages are managed in the OpenHands repository. For detailed reference material, see references/docker-image-locations.md and references/sdk

This skill should be used when the user asks to "test a cross-repo feature", "deploy a feature branch to staging", "test SDK against OH Cloud", "e2e test a cloud workspace feature", "test provider tokens", "test secrets inheritance", or when changes span the SDK and OpenHands server repos and need end-to-end validation against a staging deployment.

This skill should be used when the user asks to "generate release notes", "list upcoming release PRs", "summarize upcoming release", "/upcoming-release", or needs to know what changes are part of an upcoming release.

This repository contains the code for OpenHands, an automated AI software engineer. It has a Python backend (in the openhands directory) and React frontend (in the frontend directory).

The SSE system (sseevents, connectSSE, onClientResume) is the backbone of live updates. When touching it: - Server sends a real {type:"ping"} data event every 10s — clients use this to detect zombie connections - Client declares SSE stale after 18s of silence and force-reconnects - visibilitychange / pageshow / focus / online all trigger onClientResume which refetches if data i

When editing CSS: - Check that any new UI fits within the existing @media (max-width: 600px) breakpoints - Touch targets must be at least 44x44 on mobile - Use env(safe-area-inset-) for anything positioned at screen edges (iOS PWA notch) - The viewport uses viewport-fit=cover — fixed overlays must extend to physical edges - Test that flex containers don't overflow on 375px-wide

amux-server.py is one file containing Python server + inline HTML/CSS/JS. Never split it into multiple files or create separate modules. Always verify syntax after edits:

You are running inside an amux managed Claude Code session. amux is a local multiplexer that manages multiple Claude sessions, a shared kanban board, notes, CRM, scheduler, email, browser automation, and per-session memory.

/playwright-auth — Browser Auth Profile Manager

Records an MP4 video of the amux browser agent performing a task. The agent uses Claude to drive a headless Playwright browser, records everything, then removes idle frames (Claude-thinking pauses) via ffmpeg mpdecimate, producing a clean, snappy MP4.

/review-session-log — Review a session's terminal log

Run the amux Playwright test suite or investigate specific UI issues with a headless browser.

Pull an open issue from the local amux issue tracker, transition it through the board (todo → doing → done), and do the actual work in between.

Field Required Values Notes -------------------------------- title yes string Short, imperative task name desc no string Full context: what, why, acceptance criteria status no todo / doing / done Defaults to todo session no amux session name Which project/session owns this task

Quick health check of the amux server and dashboard after code changes.

Control the user's live Chrome browser via Chrome DevTools Protocol. Connects to real tabs with existing cookies/logins — no fresh browser needed.

Project Overview [What does this project do? Who uses it? Why does it exist?]

Current Goals - Primary goal: [e.g. "Gain 10 lbs by end of Q2 (145 → 155 lbs)"] - Secondary: [e.g. "Improve squat 1RM from 225 to 275"]

Brand - Company/project: [Name] - Brand voice: [e.g. "Direct, technical, no fluff — like a smart friend who's also an engineer"] - What we never do: [e.g. "No hype language, no vague superlatives, no 'revolutionize'"]

Research Question [What are we trying to find out? Be specific — vague questions produce vague answers.]

What Is This [1–2 sentence description. E.g. "Purchasing 15 acres of raw land in rural Vermont for a homestead build. Evaluating parcels, financing, zoning, and access."]

Single-file project: everything lives in amux-server.py (Python server + inline HTML/CSS/JS dashboard).

You are Claude Code, an AI coding assistant by Anthropic. You help users with software engineering tasks including writing code, debugging, refactoring, explaining code, running commands, and managing projects.

AGENTS.md — CrewAI Reference for AI Coding Assistants

Work with Effect v4 / effect-smol TypeScript code in this repo

This package vendors a Drizzle Effect SQLite adapter for this repo.

- Prefer HttpClient.HttpClient / HttpClientResponse.HttpClientResponse over web fetch / Response at package boundaries. - Use Stream.Stream for streaming data flow. Avoid ad hoc async generators or manual web reader loops unless an Effect Stream API cannot model the behavior. - Use Effect Schema codecs for JSON encode/decode (Schema.fromJsonString(...)) instead of direct JSON.p

This folder owns Core's one local tool representation, process and Location registration, effective lookup, and settlement.

- NEVER try to restart the app, or the server process, EVER.

Build AI agents on Cloudflare Workers using the Agents SDK. Load when creating stateful agents, durable workflows, real-time WebSocket apps, scheduled tasks, MCP servers, or chat applications. Covers Agent class, state management, callable RPC, Workflows integration, and React hooks.

Comprehensive Cloudflare platform skill covering Workers, Pages, storage (KV, D1, R2), AI (Workers AI, Vectorize, Agents SDK), networking (Tunnel, Spectrum), security (WAF, DDoS), and infrastructure-as-code (Terraform, Pulumi). Use for any Cloudflare development task.

Use these patterns for server and HttpApi middleware tests in this directory.

The tmpdir function in fixture/fixture.ts creates temporary directories for tests with automatic cleanup.

- Schema: Drizzle schema lives in packages/core/src//.sql.ts. - Migrations: database migrations live in packages/core and are applied by core.

Use HttpApiBuilder.group(...) for normal HTTP endpoints, including streaming HTTP responses such as server-sent events. Handlers should yield stable services once while building the handler layer, then close over those services in endpoint implementations.

../llm.ts is the opencode session LLM service. It owns opencode concerns: auth, config, model/provider resolution, plugins, permissions, telemetry headers, and runtime selection. It is the only file in this area that should know about the full session request shape.

- To regenerate the JavaScript SDK, run ./packages/sdk/js/script/build.ts. - The default branch in this repo is dev. - Local main ref may not exist; use dev or origin/dev for diffs.

You are an expert in literary analysis. You are skilled at dissecting texts to uncover themes, motifs, and character relationships. You are adept at helping people understand the intricate dynamics and structures within literary communities, facilitating deeper insights into how various works influence and reflect societal contexts. Using your expertise, you're asked to generat

You are an expert in literary analysis. You are skilled at dissecting texts to uncover themes, motifs, and character relationships. You are adept at helping people understand the intricate dynamics and structures within literary communities, facilitating deeper insights into how various works influence and reflect societal contexts.

-Goal- Given a text document that is potentially relevant to this activity and a list of entity types, identify all entities of those types from the text and all relationships among the identified entities.

Web automation and browser-based research using Playwright MCP via opencode subprocess. Use when the user asks to open a webpage, scrape content, fill out a form, take a screenshot, automate a browser task, or do web research that requires actually visiting a page. Triggers on phrases like "帮我打开", "去网上查", "scrape", "fill out", "web automation", "截图", "extract from page", "browse to".

Emdash is a cross-platform Electron app for orchestrating multiple AI coding agents in parallel, each isolated in its own Git worktree and able to run locally or over SSH. It combines provider-agnostic CLI agent execution, task and conversation management, diff review, integrations, terminal sessions, and packaging for desktop releases.

- Do match the interpreter requirement declared in pyproject.toml (Python ≥ 3.12) and install requirements.txt plus requirements-dev.txt before running tools. - Do run tests with PYTHONPATH=. set to keep imports functional (for example PYTHONPATH=. ./.venv/bin/pytest tests/unittest/testfixjsonescapechar.py -q). - Do adjust configuration through .pragent.toml or files under prag

A skill that provides weather information based on reference data.

A skill that provides weather information based on reference data and scripts.

name: weather-skill description: A skill that provides weather information based on reference data.

Central hub for building, testing, and iterating on ADK agents. Trigger this skill when the user wants to create a new agent, configure modes (task, single-turn), or build graph-based workflows.

Implement a bug fix or feature for a GitHub issue in the adk-python repository. Use this skill after the triage/analysis is complete and approved. It creates a new branch, implements code changes, adds tests, and updates relevant documentation/samples. Triggers on "/adk-issue-fix" commands.

Orchestrate analyzing, triaging, and resolving GitHub issues for the adk-python repository. Use this skill when a user provides a GitHub issue number or link to perform both analysis and implementation. It coordinates triage analysis via `adk-issue-analyze` and implementation via `adk-issue-fix`. Triggers on "analyze issue", "issue #", "github issue", "github.com/google/adk-python/issues/". Do NOT

Analyze and triage a GitHub issue for the adk-python repository. Use this skill to retrieve issue details, inspect the codebase, evaluate justification, check for existing PRs, and produce a structured analysis report. Triggers on "/adk-issue-analyze" commands. This skill is strictly read-only and must be used whenever the "/adk-issue-analyze" command is explicitly called.

ADK architectural knowledge — graph orchestration, resumption, execution flow, node contracts, observability, and LLM context orchestration. Use this skill whenever you need to understand the architecture, event flow, or state management of the ADK system, or when designing or modifying core components. Triggers on "how does X work", "design of", "architecture of", "event flow", "resumption state"

Orchestrate analyzing, triaging, and reviewing GitHub pull requests (PRs) for the adk-python repository. Use this skill when a user provides a PR number or URL. It coordinates analysis via `adk-pr-analyze` and review implementation/pushback via subsequent interactive steps. Triggers on "triage pr", "pr triage", "review pr", "pr review", "pull request", "github.com/google/adk-python/pull/". Do NOT

Use when debugging ADK agents, inspecting sessions, testing agent behavior, troubleshooting tool calls, event flow issues, or diagnosing LLM/model problems.

Use for any git operation (commit, push, pull, rebase, branch, PR, cherry-pick, etc.). Provides commit message format and conventions.

Analyze and triage GitHub pull requests for the adk-python repository in a strictly read-only manner. Use this skill to fetch PR details, verify the contributor's CLA, inspect the codebase, evaluate architectural and style alignment, and produce a structured analysis report. Triggers on "/adk-pr-analyze" commands. This skill is strictly read-only and must be used whenever the "/adk-pr-analyze" com

Author new samples for the ADK Python repository. Use this skill when the user wants to create a new sample demonstrating a feature or agent pattern (e.g., dynamic nodes, standalone agents, fan-out/fan-in) or when adding examples to subdirectories under `contributing/`.

Set up a local development environment for the ADK Python project. Use when the user wants to get started developing, set up their environment, install dependencies, or prepare for contributing.

Reviews all local changes in the repository for errors, styling compliance, unintended outcomes, and necessary documentation/test/sample updates. Generates a report and assists in fixing identified issues on-demand. Triggers on "adk-review", "review changes", "pr review", "check code style", "verify changes".

ADK development style guide for routine nits — Python idioms, codebase conventions, imports, typing, Pydantic patterns, formatting, logging, and file organization. Use this skill whenever writing code, tests, or reviewing PRs for the ADK project to ensure compliance with styling and coding conventions. Triggers on "code style", "how should I format", "naming convention", "lint", "nit", "imports",

This document provides context for AI coding assistants (Antigravity, Gemini CLI, etc.) to understand the ADK Python project and assist with development.

Skill for BigQuery AI and Machine Learning queries using standard SQL and `AI.*` functions (preferred over dedicated tools).

This directory owns Control UI-specific guidance that should not live in the repo root.

This directory holds shared test helpers reused by core and bundled plugin tests.

Triage, redact, clean up, and resolve OpenClaw GitHub Secret Scanning alerts in issues or PRs.

Run or recover OpenClaw macOS release signing, notarization, appcast, and asset promotion.

Refactor an existing OpenClaw docs page with source-audited preservation, restructuring, and verification.

Find or repair small high-confidence non-SDK-boundary OpenClaw bugfix PRs until five are landable.

Run macOS Parallels smoke with Discord send, host verification, host reply, and guest readback proof.

Build and review high-quality technical docs as well as agent instruction files in your repository.

Add a redacted agent transcript section to GitHub PR or issue bodies during OpenClaw agent-created PR/issue workflows.

Investigate OpenClaw pnpm test memory growth, Vitest OOMs, RSS spikes, and heap snapshot deltas.

Use immediately for any pasted OpenClaw GitHub issue or PR URL/number, and for OpenClaw issue/PR review, triage, duplicate search, opener identity/who wrote it, author account age/activity, comments, labels, close, land, or maintainer evidence checks.

Triage OpenClaw security advisories, drafts, and GHSA reports with shipped-tag and trust-model proof.

Notion archive: search, sync freshness, pages/databases, Markdown exports, SQL counts, and Notcrawl repo work.

Use to talk to the Discord-backed OpenClaw agent/session; not for archive search.

Inspect, patch, validate, publish, or confirm OpenClaw GHSA security advisories and private-fork state.

Discord archive: search, sync freshness, DMs, summaries, TUI, repo/release work.

Run, watch, debug, and summarize OpenClaw full release CI, release checks, live provider gates, install/update proofs, and release-secret preflights.

Fix only small, high-certainty OpenClaw bugs from a pasted issue/PR list after deep code review.

Use the Crabbox wrapper for OpenClaw remote validation across Linux, macOS, Windows, and WSL2, including delegated Blacksmith Testbox proof. Report the actual provider and id.

Use when testing, fixing, or extending the OpenClaw Control UI GUI with Vitest + Playwright end-to-end checks, mocked Gateway WebSocket flows, mocked dashboard runs, screenshots/videos, or agent-verifiable browser proof.

Use when reviewing, reproducing, or proving OpenClaw Telegram behavior with a real Telegram user on Crabbox, including PR review workflows that need an agent-controlled Telegram Desktop recording, TDLib user-driver commands, Convex-leased credentials, WebVNC observation, and motion-trimmed artifacts.

Author OpenClaw Docker E2E and live provider Docker lanes.

Draft or post OpenClaw beta/stable Discord release announcements from changelog, GitHub release, registry, and validation evidence. Use when announcing a beta, stable release, release candidate, or asking what users should test after an OpenClaw release.

Granola archive: search, sync freshness, notes, transcripts, panels, SQL counts, and Graincrawl repo work.

Debug OpenClaw model, provider, tool-surface, code-mode, streaming, and live/Crabbox behavior by choosing the right logs, probes, and proof path before changing code.

Plan and run pre-release OpenClaw plugin validation across bundled plugins, package artifacts, lifecycle commands, doctor/fix, config round-trip, gateway startup, SDK compatibility, Docker E2E, Package Acceptance, and Testbox proof.

Run, rerun, debug, or interpret OpenClaw Parallels install, onboarding, gateway smoke, and upgrade checks.

Prepare or verify OpenClaw stable/beta releases, changelogs, release notes, publish commands, and artifacts.

Use for all ClawSweeper work: OpenClaw issue/PR sweep reports, commit-review reports, repair jobs, cloud fix PRs, @clawsweeper maintainer mention commands, trusted ClawSweeper-reviewed autofix/automerge, GitHub Actions monitoring, permissions, gates, and manual backfills.

Run, watch, debug, extend, or explain OpenClaw qa-lab and qa-channel scenarios, artifacts, and live lanes.

Benchmark, diagnose, and optimize OpenClaw test and plugin-suite runtime, import hotspots, CPU/RSS, heap growth, and slow coverage paths.

Regenerate OpenClaw release changelog sections from git history before beta or stable releases.

OpenClaw Tideclaw alpha/nightly release automation: isolated branches, local fixes, release CI, branch retention, and forward-port to main.

Choose, run, rerun, or debug OpenClaw tests, CI checks, Docker E2E lanes, release validation, and the cheapest safe verification path.

Use gitcrawl to search duplicate OpenClaw PRs/issues, group related work in prtags, and sync duplicate state to GitHub.

Use when previewing local channel message flow fixtures.

Use for OpenClaw clawtributors PR/issue triage: Discrawl discovery, live-open rechecks, deep review, topic grouping, and compact @handle/LOC/type/blast/verification summaries.

Slack archive: search, sync freshness, threads/DMs, SQL counts, and Slacrawl repo work.

Verify an OpenClaw release is fully published across GitHub, npm, plugins, ClawHub, package smoke, and live Gateway agent turns.

Auto Review closeout. Codex review is the default when no engine is set and is the recommended reviewer.

OpenClaw builds a custom system prompt for every agent run. The prompt is OpenClaw-owned and does not use a runtime default prompt.

This directory owns docs authoring, Mintlify link rules, and docs i18n policy.

This folder is home. Treat it that way.

⚠️ CRITICAL: THIS INSTANCE IS DEDICATED TO OPENPROSE EXECUTION ONLY ⚠️

OpenProse VM skill pack. Activate on any `prose` command, .prose files, or OpenProse mentions; orchestrates multi-agent workflows.

Feishu permission management for documents and files. Activate when user mentions sharing, permissions, collaborators.

Feishu knowledge base navigation. Activate when user mentions knowledge base, wiki, or wiki links.

Feishu cloud storage file management. Activate when user mentions cloud space, folders, drive.

Feishu document read/write operations. Activate when user mentions Feishu docs, cloud docs, or docx links.

Use gh for GitHub issues, PR status, CI/logs, comments, reviews, releases, and API queries.

Lobster executes multi-step workflows with approval checkpoints. Use it when:

Use when controlling web pages with the OpenClaw browser tool, especially multi-step flows, login checks, tab management, or recovery from stale refs/timeouts.

Route plain-language requests for Claude Code, Cursor, Copilot, OpenClaw ACP, OpenCode, Gemini CLI, Qwen, Kiro, Kimi, iFlow, Factory Droid, Kilocode, or explicit ACP harness work into either OpenClaw ACP runtime sessions or direct acpx-driven sessions ("telephone game" flow). For coding-agent thread requests, read this skill first, then use only `sessions_spawn` for thread creation. Codex chat bin

This file applies to work under extensions/acpx/.

Use the diffs tool to produce real, shareable diffs (viewer URL, file artifact, or both) instead of manual edit summaries.

Maintain the OpenClaw memory wiki vault with deterministic pages, managed blocks, and source-backed updates.

Maintain an Obsidian-friendly memory wiki vault with wikilinks, frontmatter, and official Obsidian CLI awareness.

This directory contains bundled plugins. Treat it as the same boundary that third-party plugins see.

Tavily web search, content extraction, and research tools.

This directory owns local tooling, script wrappers, and generated-artifact helper rules.

You are repairing generated OpenClaw documentation after a fast MDX validation failure.

You are maintaining OpenClaw documentation after a main-branch commit.

You are maintaining OpenClaw test performance after a trusted main-branch CI run.

You are Mantis running native Telegram Desktop visual proof for an OpenClaw PR.

Edit PDFs with natural-language instructions using the nano-pdf CLI.

Himalaya CLI for IMAP/SMTP mail: list, read, search, compose, reply, forward, copy, move, delete.

Create, search, and manage Bear notes via grizzly CLI.

Search meme templates, suggest formats, and generate local or hosted image memes.

Capture and automate macOS UI with the Peekaboo CLI.

Summarize CodexBar local cost logs by model for Codex or Claude, including current or full breakdowns.

Monitor blogs and RSS/Atom feeds for updates using the blogwatcher CLI.

Discord message-tool ops: send/read/edit/delete, react, poll, pin, thread, search, presence, media/components.

Delegate coding work to Codex, Claude Code, or OpenCode as background workers; not simple edits or read-only code lookup.

Control Philips Hue lights and scenes via the OpenHue CLI.

Gemini CLI one-shot prompts, summaries, generation, skills, hooks, MCP, or Gemma routing.

Search GIF providers with CLI/TUI, download results, and extract stills/sheets.

Search and analyze your own session logs (older/parent conversations) using jq.

Diagnose OpenClaw Android, iOS, or macOS node pairing, QR/setup code, route, auth, and connection failures.

Foodora-only CLI for checking past orders and active order status (Deliveroo WIP).

Local speech-to-text with the Whisper CLI (no API key).

Terminal Spotify playback/search via spogo (preferred) or spotify_player.

Audit/harden OpenClaw hosts: SSH, firewall, updates, exposure, backups, disk encryption, gateway security.

Oracle CLI second-model review/debug/refactor/design with selected files, dry-run token checks, API or browser engine.

xurl CLI for authenticated X posts, replies, reads/search, DMs, media upload, followers, auth status, or raw v2 API calls.

Summarize or transcribe URLs, YouTube/videos, podcasts, articles, transcripts, PDFs, and local files.

Create SVG/HTML or Excalidraw diagrams for concepts, architecture, flows, and whiteboards.

Search, install, update, sync, or publish agent skills with the ClawHub CLI and registry.

Local text-to-speech via sherpa-onnx (offline, no cloud)

Extract frames or short clips from videos using ffmpeg.

Google Workspace CLI for Gmail, Calendar, Drive, Contacts, Sheets, and Docs.

Present HTML on connected OpenClaw node canvases, navigate/eval/snapshot, and debug canvas host URLs.

Notion CLI/API for pages, Markdown content, data sources, files, comments, search, Workers, and raw API calls.

List, add, edit, complete, or delete Apple Reminders and reminder lists via remindctl.

iMessage/SMS CLI for listing chats, history, and sending messages via Messages.app.

Create, edit, audit, tidy, validate, or restructure AgentSkills and SKILL.md files.

GitHub CLI for issues, PRs, CI/check logs, comments, reviews, releases, repos, and gh api queries.

Example TaskFlow pattern for inbox triage, intent routing, waiting on replies, and later summaries.

Add, update, list, search, or inspect Things 3 todos, inbox, today, projects, areas, and tags on macOS.

BluOS CLI (blu) for discovery, playback, grouping, and volume.

Control Sonos speakers (discover/status/play/volume/group).

Nightly refinement of an existing per-repo review-style prompt using this reviewer's own finding outcomes. Read confirmed (resolved-by-commit / thumbs-up) and dismissed (thumbs-down) findings, promote the bug patterns the team actually fixes, demote the false-positive patterns, reconcile against the current prompt, and save the refined version. Use this once outcomes exist; use bootstrap-repo-anal

First-time analysis of a repository with no prior reviewer outcomes. Crawl historical merged-PR review feedback with the gh CLI (plus any preloaded samples), extract the team's review norms, and synthesize the initial per-repo review-style prompt. Use this for a cold-start repo; use continual-learning instead once the reviewer has accumulated finding outcomes.

This file provides guidance to Coding Agents when working with code in this repository.

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

Use when preparing, tagging, and publishing an apps/cli npm release. Guides changelog drafting, apps/cli/package.json version bumps, cli-vX.Y.Z tags, local npm publishing, and the publish-cli GitHub workflow.

Comprehensive Cline SDK skill for building AI agents. Covers the Agent runtime, ClineCore sessions, custom tools, plugins, events, LLM providers, scheduling, multi-agent teams, and production deployment. Use for any task involving @cline/sdk or its sub-packages.

Comprehensive OpenTUI skill for building terminal user interfaces. Covers the core imperative API, React reconciler, and Solid reconciler. Use for any TUI development task including components, layout, keyboard handling, animations, and testing.

Create a GitHub pull request following project conventions. Use when the user asks to create a PR, submit changes for review, or open a pull request. Handles commit analysis, branch management, PR template usage, and PR creation using the gh CLI tool.

Prepare and publish a release directly from main.

Create a hotfix release by cherry-picking specific commits from main onto the latest release tag.

Tools are how agents interact with the world. The Cline SDK supports both built-in tools (via ClineCore) and custom tools you define yourself.

ClineCore holds resources (file watchers, database connections, hub connections). Failing to call dispose() can leave orphan processes and file locks.

ClineCore is the full-featured runtime from @cline/core. It wraps the Agent loop with session persistence, built-in tools (bash, editor, file reading, search, web fetch), config discovery, plugin loading, and optional hub-backed multi-process support.

extensions passes plugin objects directly. pluginPaths points to directories with package.json containing a cline.plugins field. Set extensionContext.workspace so plugins receive ctx.workspaceInfo in their setup() call -- without it, ctx.workspaceInfo is undefined.

Auto-approve reads, require approval for writes:

The Cline SDK supports scheduled, one-off, and event-driven agent execution through the automation subsystem in @cline/core.

A Cline plugin is a TypeScript module that extends any agent built on the Cline SDK. The same plugin runs in the Cline CLI, VS Code and JetBrains extensions, and any custom app built on @cline/core.

The Cline SDK supports every major LLM provider out of the box via @cline/llms.

The Cline SDK supports two models for multi-agent work: sub-agents (parent-child) and teams (peer-to-peer).

If the agent keeps iterating without completing:

The Agent class (also exported as AgentRuntime) is the lightweight, stateless agent loop from @cline/agents. It handles the core iteration cycle: send messages to an LLM, execute tool calls, collect results, and repeat until the task is done.

Two config forms exist as a discriminated union:

A multi-turn conversational agent in the terminal with streaming output:

Guidelines for deploying Cline SDK agents in production environments.

The Cline SDK has three event layers. Which one you use depends on whether you're working with the standalone Agent class or ClineCore.

OpenTUI is built for Bun. Always use Bun commands:

The foundational library for building terminal user interfaces. Provides an imperative API with all primitives, giving you maximum control over rendering, state, and behavior.

Creates and initializes the CLI renderer.

Create renderables and compose with .add():

OpenTUI respects several environment variables for configuration and debugging.

OpenTUI uses the Yoga layout engine, providing CSS Flexbox-like capabilities for positioning and sizing components in the terminal.

OpenTUI provides a timeline-based animation system for smooth property transitions.

This is the most common mistake. Using process.exit() leaves the terminal in a broken state (cursor hidden, raw mode, alternate screen).

A SolidJS reconciler for building terminal user interfaces with fine-grained reactivity. Get optimal performance with Solid's signal-based approach.

Renders a Solid component tree into a CLI renderer.

Use Index when array items are primitives:

The CLI creates the my-app directory for you - it must not already exist.

How to test terminal user interfaces built with OpenTUI.

Reference for all OpenTUI components, organized by category. Components are available in all three frameworks (Core, React, Solid) with slight API differences.

Components for displaying text content in OpenTUI.

Components for user input in OpenTUI.

Components for grouping and organizing content in OpenTUI.

Components for displaying code with syntax highlighting and diffs in OpenTUI.

This is the most common mistake. Using process.exit() leaves the terminal in a broken state (cursor hidden, raw mode, alternate screen).

A React reconciler for building terminal user interfaces with familiar React patterns. Write TUIs using JSX, hooks, and component composition.

Options: - release?: boolean - Include key release events (default: false)

A prompt mirrored from cline/cline.

The CLI creates the my-app directory for you - it must not already exist.

How to handle keyboard input in OpenTUI applications.

- models.dev catalog data and AI SDK provider behavior are the default sources of truth for general model/provider support. - Do not build a broad Cline-maintained model capability or behavior registry. - GatewayModelCapability is semantic: what the model can do, not provider quirks, default behavior, or wire-format details. - Stable, reliable known-model facts belong in typed

This file applies to the SDK workspace rooted at this directory (sdk/). In this repo, "root" means the SDK workspace root unless explicitly stated otherwise. Ignore the legacy repository root for SDK development except for Git operations or repo-wide searches that are explicitly needed.

This directory contains the tool registration system for Cline tools. The system automatically collects and registers all tool variants with the ClineToolSet provider.

The system prompt architecture provides a modular, composable system for building AI assistant prompts. It supports multiple model variants, dynamic component composition, flexible tool configuration, and template-based prompt generation.

This directory contains integration tests for the system prompt generation with snapshot testing capabilities.

Contributing to System Prompts and Model Configuration

<p align="center" <bLightweight, beautiful and user-friendly interactive prompts</b<br / <sub Easy to use CLI prompts to enquire users for information▌</sub </p

Call REST APIs from Python, parse JSON responses, and report the useful fields back to the user.

Use the existing Python execution tools as a scratchpad for calculations, data transformation, and quick script-based validation.

Greet the user in a distinctive, easy-to-verify format for skill activation demos.

Variables: !<INPUT 0! -- All convo utterances !<INPUT 1! -- persona name !<INPUT 2! -- persona name !<INPUT 3! -- persona name

Variables: !<INPUT 0! -- Persona name !<INPUT 1! -- Maze all possible sectors !<INPUT 2! -- Persona name !<INPUT 3! -- Persona living sector !<INPUT 4! -- Persona living sector arenas !<INPUT 5! -- Persona name !<INPUT 6! -- Persona current sector !<INPUT 7! -- Persona current sector arenas !<INPUT 8! -- curr action description !<INPUT 9! -- Persona name <commentblockmarker</co

!<INPUT 1!: agent name !<INPUT 1!: iss !<INPUT 2!: name !<INPUT 3!: event description

!<INPUT 1!: agent name !<INPUT 1!: iss !<INPUT 2!: name !<INPUT 3!: event description

Variables: !<INPUT 0! -- Statements !<INPUT 1! -- curr persona name !<INPUT 2! -- targetpersona.scratch.name

Variables: !<INPUT 0! -- Persona name !<INPUT 1! -- Persona's current arena !<INPUT 2! -- Persona's current sector !<INPUT 3! -- Persona name !<INPUT 4! -- target sector !<INPUT 5! -- Persona's sector's all arenas (minus no access) !<INPUT 6! -- Curr action seq !<INPUT 7! -- Persona name !<INPUT 8! -- Persona's current sector

<commentblockmarker</commentblockmarker Task -- given context, determine whether the subject will initiate a conversation with another. Format: Context: [] Question: [] Reasoning: [] Answer in "yes" or "no": [] --- Context: !<INPUT 0! Right now, it is !<INPUT 1!. !<INPUT 2! and !<INPUT 3! last chatted at !<INPUT 4! about !<INPUT 5!. !<INPUT 6! !<INPUT 7!

Variables: !<INPUT 0! -- All convo utterances !<INPUT 1! -- persona name !<INPUT 2! -- persona name !<INPUT 3! -- persona name

Variables: !<INPUT 0! -- Commonset !<INPUT 1! -- Lifestyle !<INPUT 2! -- Reverie date time now !<INPUT 3! -- Persona first names !<INPUT 4! -- wakeuphour

Variables: !<INPUT 0! -- Numbered list of event/thought statements !<INPUT 1! -- target persona name or "the conversation"

Variables: !<INPUT 0! -- persona ISS !<INPUT 1! -- persona name !<INPUT 2! -- retrieved memory !<INPUT 3! -- past context !<INPUT 4! -- current location !<INPUT 5! -- current context !<INPUT 6! -- persona name !<INPUT 7! -- target persona name !<INPUT 8! -- curr convo !<INPUT 9! -- persona name !<INPUT 10! -- target persona name !<INPUT 11! -- persona name !<INPUT 12! -- person

!<INPUT 1!: agent name !<INPUT 1!: iss !<INPUT 2!: name !<INPUT 3!: event description

Variables: !<INPUT 0! -- Event/thought statements !<INPUT 1! -- Count

Variables: !<INPUT 0! -- Commonset !<INPUT 1! -- Surrounding schedule description !<INPUT 2! -- Persona first name !<INPUT 3! -- Persona first name !<INPUT 4! -- Current action !<INPUT 5! -- curr time range !<INPUT 6! -- Current action duration in min !<INPUT 7! -- Persona first names

You are a helpful assistant that can assist in writing, abstracting, annotating, and summarizing Python code.

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

This file provides guidance to Claude Code when working with the direct benchmark harness.

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

Address PR review comments and loop until CI green and all comments resolved. TRIGGER when user asks to address comments, fix PR feedback, respond to reviewers, or babysit/monitor a PR.

Analyze the current branch diff against dev, plan integration tests for changed frontend pages/components, and write them. TRIGGER when user asks to write frontend tests, add test coverage, or 'write tests for my changes'.

Initialize a worktree-based repo layout for parallel development. Creates a main worktree, a reviews worktree for PR reviews, and N numbered work branches. Handles .env creation, dependency installation, and branchlet config. TRIGGER when user asks to set up the repo from scratch, initialize worktrees, bootstrap their dev environment, "setup repo", "setup worktrees", "initialize dev environment",

Set up a new git worktree for parallel development. Creates the worktree, copies .env files, installs dependencies, and generates Prisma client. TRIGGER when user asks to set up a worktree, work on a branch in isolation, or needs a separate environment for a branch or PR.

Open a pull request with proper PR template, test coverage, and review workflow. Guides agents through creating a PR that follows repo conventions, ensures existing behaviors aren't broken, covers new behaviors with tests, and handles review via bot when local testing isn't possible. TRIGGER when user asks to "open a PR", "create a PR", "make a PR", "submit a PR", "open pull request", "push and cr

E2E manual testing of PRs/branches using docker compose, agent-browser, and API calls. TRIGGER when user asks to manually test a PR, test a feature end-to-end, or run integration tests against a running system.

React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.

Version 1.0.0 Vercel Engineering January 2026

Meta-agent supervisor that manages a fleet of Claude Code agents running in tmux windows. Auto-discovers spare worktrees, spawns agents, monitors state, kicks idle agents, approves safe confirmations, and recycles worktrees when done. TRIGGER when user asks to supervise agents, run parallel tasks, manage worktrees, check agent status, or orchestrate parallel work.

Review a PR for correctness, security, code quality, and testing issues. TRIGGER when user asks to review a PR, check PR quality, or give feedback on a PR.

Alternate /pr-review and /pr-address on a PR until the PR is truly mergeable — no new review findings, zero unresolved inline threads, zero unaddressed top-level reviews or issue comments, all CI checks green, and two consecutive quiet polls after CI settles. Use when the user wants a PR polished to merge-ready without setting a fixed number of rounds.

Load large data or modules only when a feature is activated.

Preload heavy bundles before they're needed to reduce perceived latency.

Early Length Check for Array Comparisons

Move await operations into the branches where they're actually used to avoid blocking code paths that don't need them.

Instead of awaiting data in async components before returning JSX, use Suspense boundaries to show the wrapper UI faster while data loads.

Use React's <Activity to preserve state/DOM for expensive components that frequently toggle visibility.

Prevent Waterfall Chains in API Routes

Extract static JSX outside components to avoid re-creation.

For operations with partial dependencies, use better-all to maximize parallelism. It automatically starts each task at the earliest possible moment.

Finding the smallest or largest element only requires a single pass through the array. Sorting is wasteful and slower.

Animate SVG Wrapper Instead of SVG Element

Return early when result is determined to skip unnecessary processing.

Build Index Maps for Repeated Lookups

React.cache() only works within one request. For data shared across sequential requests (user clicks button A then button B), use an LRU cache.

When updating state based on the current state value, use the functional update form of setState instead of directly referencing the state variable. This prevents stale closures, eliminates unnecessary dependencies, and creates stable callback references.

Pass a function to useState for expensive initial values. Without the function form, the initializer runs on every render even though the value is only used once.

Store callbacks in refs when used in effects that shouldn't re-subscribe on callback changes.

Use Next.js's after() to schedule work that should execute after a response is sent. This prevents logging, analytics, and other side effects from blocking the response.

Use useSWRSubscription() to share global event listeners across component instances.

Mark frequent, non-urgent state updates as transitions to maintain UI responsiveness.

Use toSorted() Instead of sort() for Immutability

SWR enables request deduplication, caching, and revalidation across component instances.

Use React.cache() for server-side request deduplication. Authentication and database queries benefit most.

Use next/dynamic to lazy-load large components not needed on initial render.

When rendering content that depends on client-side storage (localStorage, cookies), avoid both SSR breakage and post-hydration flickering by injecting a synchronous script that updates the DOM before React hydrates.

The React Server/Client boundary serializes all object properties into strings and embeds them in the HTML response and subsequent RSC requests. This serialized data directly impacts page weight and load time, so size matters a lot. Only pass fields that the client actually uses.

Extract expensive work into memoized components to enable early returns before computation.

Avoid changing styles one property at a time. Group multiple CSS changes together via classes or cssText to minimize browser reflows.

Use a module-level Map to cache function results when the same function is called repeatedly with the same inputs during render.

Use explicit ternary operators (? :) instead of && for conditional rendering when the condition can be 0, NaN, or other falsy values that render.

Import directly from source files instead of barrel files to avoid loading thousands of unused modules. Barrel files are entry points that re-export multiple modules (e.g., index.js that does export from './module').

When updating manual sections ( ) in block documentation files (e.g., docs/integrations/basic.md), follow these formats:

This file provides guidance to coding agents when working with the frontend.

Type Tool Speed Purpose --------------- --------------------- --------------- -------------------------------- E2E Playwright Slow (~5s/test) Real browser, full user journeys Integration Vitest + RTL Fast (~100ms) Component + mocked API Unit Vitest + RTL Fastest (~10ms) Individual functions/components Visual Storybook + Chromatic N/A UI appearance, design system

This directory contains the Graphiti-backed memory integration for CoPilot. This file is developer documentation only — it is NOT injected into LLM prompts. Runtime prompt instructions live in prompting.py:getgraphitisupplement().

This file provides guidance to coding agents when working with the backend.

This file provides guidance to coding agents when working with code in this repository.

This guide provides context for coding agents when updating the autogptplatform folder.

Provides comprehensive guidelines for resolving merge conflicts intelligently using git history and commit context. Use when tasks involve merge conflicts, rebasing, PR conflicts, or git conflict resolution. This skill analyzes commit messages, git blame, and code intent to make intelligent resolution decisions.

Provides comprehensive guidelines for translating and localizing Roo Code extension strings. Use when tasks involve i18n, translation, localization, adding new languages, or updating existing translation files. This skill covers both core extension (src/i18n/locales/) and WebView UI (webview-ui/src/i18n/locales/) localization.

Provides context about the Roo Code evals system structure in this monorepo. Use when tasks mention "evals", "evaluation", "eval runs", "eval exercises", or working with the evals infrastructure. Helps distinguish between the evals execution system (packages/evals, apps/web-evals) and the public website evals display page (apps/web-roo-code/src/app/evals).

This file provides guidance to agents when working with code in this repository.

You are the OpenClaw demo assistant.

CLI to manage emails via IMAP/SMTP. Use `himalaya` to list, read, write, reply, forward, search, and organize emails from the terminal. Supports multiple accounts and message composition with MML (MIME Meta Language).

Capture and automate macOS UI with the Peekaboo CLI.

Use CodexBar CLI local cost usage to summarize per-model usage for Codex or Claude, including the current (most recent) model or a full model breakdown. Trigger when asked for model-level usage/cost data from codexbar, or when you need a scriptable per-model summary from codexbar cost JSON.

Discord ops via the message tool (channel=discord).

Delegate coding tasks to Codex, Claude Code, or Pi agents via background host sessions. Use when: (1) building or creating new features or apps, (2) reviewing PRs or parallel coding with managed worktree isolation when subagents are available, (3) refactoring large codebases, (4) iterative coding that needs file exploration. NOT for: simple one-liner fixes (just edit), reading code (use read tool)

Control Philips Hue lights and scenes via the OpenHue CLI.

Gemini CLI for one-shot Q&A, summaries, and generation.

Search GIF providers with CLI/TUI, download results, and extract stills/sheets.

Search and analyze your own session logs (older/parent conversations) using jq.

Host security hardening and risk-tolerance configuration for OpenClaw deployments. Use when a user asks for security audits, firewall/SSH/update hardening, risk posture, exposure review, OpenClaw cron scheduling for periodic checks, or version status checks on a machine running OpenClaw (laptop, workstation, Pi, VPS).

Best practices for using the oracle CLI (prompt + file bundling, engines, sessions, and file attachment patterns).

A CLI tool for making authenticated requests to the X (Twitter) API. Use this skill when you need to post tweets, reply, quote, search, read posts, manage followers, send DMs, upload media, or interact with any X API v2 endpoint.

Summarize or extract text/transcripts from URLs, podcasts, and local files (great fallback for “transcribe this YouTube/video”).

Use when you need to send or manage iMessages via BlueBubbles (recommended iMessage integration). Calls go through the generic message tool with channel="bluebubbles".

Local text-to-speech via sherpa-onnx (offline, no cloud)

Display HTML content on connected OpenClaw nodes (Mac app, iOS, Android).

Notion API for creating and managing pages, databases, and blocks.

Query Google Places API (New) via the goplaces CLI for text search, place details, resolve, and reviews. Use for human-friendly place lookup or JSON output for scripts.

Manage Apple Reminders via remindctl CLI (list, add, edit, complete, delete). Supports lists, date filters, and JSON/plain output.

iMessage/SMS CLI for listing chats, history, and sending messages via Messages.app.

Create or update AgentSkills, especially when a user wants the agent to learn a reusable capability, workflow, integration, domain rule, team process, or tool usage pattern for future tasks. Use when designing, structuring, reviewing, validating, packaging, or improving skills with SKILL.md, scripts, references, and assets.

GitHub operations via `gh` CLI: issues, PRs, CI runs, code review, API queries. Use when: (1) checking PR status or CI, (2) creating/commenting on issues, (3) listing/filtering PRs or issues, (4) viewing run logs. NOT for: complex web UI interactions requiring manual browser flows (use browser tooling when available), bulk operations across many repos (script with gh api), or when gh auth is not c

Use the mcporter CLI to list, configure, auth, and call MCP servers/tools directly (HTTP or stdio), including ad-hoc servers, config edits, CLI/type generation, and MCP-backed skills that need a durable command path.

Remote-control tmux sessions for interactive CLIs by sending keystrokes and scraping pane output.

Batch-generate images via OpenAI Images API. Random prompt sampler + `index.html` gallery.

ElevenLabs text-to-speech with mac-style say UX.

Use when you need to control Slack from OpenClaw via the slack tool, including reacting to messages or pinning/unpinning items in Slack channels or DMs.

Get current weather and forecasts via wttr.in or Open-Meteo. Use when: user asks about weather, temperature, or forecasts for any location. NOT for: historical weather data, severe weather alerts, or detailed meteorological analysis. No API key needed.

Work with Obsidian vaults (plain Markdown notes) and automate via obsidian-cli.

Manage Trello boards, lists, and cards via the Trello REST API.

Send WhatsApp messages to other people or search/sync WhatsApp history via the wacli CLI (not for normal user chats).

Generate spectrograms and feature-panel visualizations from audio with the songsee CLI.

Manage Apple Notes via the `memo` CLI on macOS (create, view, edit, delete, search, move, and export notes). Use when a user asks OpenClaw to add a note, list notes, search notes, or manage note folders.

Fetch GitHub issues, spawn sub-agents to implement fixes and open PRs, then monitor and address PR review comments. Usage: /gh-issues [owner/repo] [--label bug] [--limit 5] [--milestone v1.0] [--assignee @me] [--fork user/repo] [--watch] [--interval 5] [--reviews-only] [--cron] [--dry-run] [--model glm-5] [--notify-channel -1002381931352]

Generate or edit images via Gemini 3 Pro Image (Nano Banana Pro).

Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.

Start voice calls via the OpenClaw voice-call plugin.

Extract text from images using Tesseract OCR

Transcribe audio files to text using OpenAI Whisper

name: hello description: Run a tiny script and print a deterministic message.

Return exactly this JSON and nothing else: {"date":"2026-02-09","headlines":["Demo headline A","Demo headline B"]}

Answer weather queries with a fixed demo response.

Demo skill for the SkillToolProfile example.

Connect to a remote streamable HTTP MCP service that exposes announcements and FAQ tools.

Small Python utilities for math and text files.

Simple shell utilities for files and archives.

Simple operations on user-provided text files including summarization.

Use this skill when the user asks about release dates, release owners, rollout status, or launch checklist details.

Find a public Agent Skill on GitHub, install it, and load it.

tRPC-Agent-Go is a Go multi-module monorepo (library/framework) for building AI agent systems. It is not a standalone application — there is no single main.go to run. The root module path is trpc.group/trpc-go/trpc-agent-go.

Processes kick-off meeting transcripts and/or notes into structured project documentation. Use this skill when the user sends kick-off meeting material (transcript, notes, recording text) and requests structured output. Triggers: "kick-off", "kickoff", "projekt indító", "meeting feldolgozás", "transzkript feldolgozás", "/notes", "/charter", "/actions". Supports three output types: meeting notes (M

Reference Claude Code's prompt engineering patterns for AI/Agent development. Provides best practices for system prompts, tool design, agent orchestration, and safety.

- NEVER silently swallow errors. Every err returned from a function call must be either: 1. Returned/propagated to the caller (with goerr.Wrap for context), or 2. Explicitly handled with a meaningful fallback that is clearly documented with a comment explaining WHY the error is safe to ignore. - Setting a variable to nil or a zero value when an error occurs (e.g., if err != nil

Write Go test code using the gt library. Use when writing tests, creating test files, or when the user asks to add tests for Go code.

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

All tasks have been completed. Based on the results, please provide a comprehensive response.

You have just completed a task. Review the progress and determine if the goal can be achieved with remaining tasks, or if updates are needed.

You are a helpful assistant that creates minimal, focused execution plans.

You are a task executor that can ONLY use function/tool calls to complete tasks.

Debug and monitor Neuron AI applications with Inspector APM, event observability, logging, and performance analysis. Use this skill whenever the user mentions debugging, monitoring, observability, performance analysis, tracing, Inspector, or needs to understand why an agent is behaving a certain way. Also trigger for tasks involving agent execution timeline, tool call inspection, response quality

Implement RAG (Retrieval-Augmented Generation) with Neuron AI including vector stores, embeddings providers, document loaders, and retrieval strategies. Use this skill whenever the user mentions RAG, retrieval, vector search, document retrieval, semantic search, knowledge bases, chat with documents, or wants to build AI systems that can query and understand external documents. Also trigger for tas

Create and configure Neuron AI agents with providers, tools, instructions, and memory. Use this skill whenever the user mentions building agents, creating AI assistants, setting up LLM-powered chat bots, configuring chat agents, or wants to create an agent that can talk, use tools, or handle conversations. Also trigger for any task involving agent configuration, provider setup, tool integration, o

Create and run AI evaluations with datasets, assertions, and output drivers in Neuron AI. Use this skill whenever the user mentions evaluation, testing AI systems, creating evaluators, dataset-driven testing, assertion-based validation, or wants to measure AI system performance. Also trigger for tasks involving evaluator discovery, output configuration, result analysis, or building custom assertio

Build custom Neuron AI workflows with nodes, events, middleware, and human-in-the-loop patterns. Use this skill whenever the user mentions workflows, orchestration, event-driven systems, custom agents, complex multi-step processes, human-in-the-loop patterns, or wants to build a custom agentic system from scratch. Also trigger for tasks involving node creation, event routing, workflow middleware,

Create custom tools, toolkits, and MCP integrations for Neuron AI agents. Use this skill when the user mentions creating tools, building toolkits, extending Tool class, defining tool properties, implementing tool execution, MCP server integration, Model Context Protocol, connecting external tools, or tool guidelines. Also trigger for any task involving ToolProperty, ArrayProperty, ObjectProperty,

Write tests for Neuron AI agents, RAG systems, workflows, and tools using the built-in testing utilities. Use this skill when the user mentions testing agents, writing unit tests, mocking AI providers, testing tool execution, verifying RAG retrieval, testing workflow behavior, or creating test cases for Neuron AI components. Also trigger for any task involving PHPUnit tests, fake providers, test a

Design and implement structured output classes for Neuron AI agents using SchemaProperty attributes and validation rules. Use this skill when the user mentions structured output, JSON schema extraction, data validation, output classes, DTOs for AI responses, extracting structured data from LLM, or configuring property schemas. Also trigger for any task involving SchemaProperty attribute, validatio

Individual tests: vendor/bin/phpunit tests/AgentTest.php or --filter testMethodName

Neuron is a PHP Agentic framework for building AI agents with chat, tools, RAG, structured output, and workflow orchestration.

Framework-agnostic HTTP abstraction for AI providers and vector stores.

Tool system for agent capabilities. Tools are callable functions exposed to AI.

Unified messaging layer. Used by Agent, RAG, and Providers.

AI provider abstractions. All providers implement AIProviderInterface.

AI agent built on Workflow. Provides chat, streaming, and structured output modes.

Model Context Protocol connector for external tool integration. MCP is an open standard by Anthropic to connect agents to external services.

Retrieval Augmented Generation. Extends Agent with document search.

Test fakes and utilities for testing Neuron applications.

Event-driven orchestration foundation. Agent and RAG are built on top of Workflow.

Dataset-driven AI evaluation with flexible assertions and output drivers.

JSON schema-based extraction with PHP class mapping.

Use this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especial

Use this skill whenever the user wants to do anything with PDF files. This includes reading or extracting text/tables from PDFs, combining or merging multiple PDFs into one, splitting PDFs apart, rotating pages, adding watermarks, creating new PDFs, filling PDF forms, encrypting/decrypting PDFs, extracting images, and OCR on scanned PDFs to make them searchable. If the user mentions a .pdf file or

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.

This is your operations center. Read this on every session start.

To create a video from this capture, use the website-to-hyperframes skill.

This project uses AI agent skills for framework-specific patterns. Install them if not already present:

Always invoke the relevant skill before writing or modifying compositions. Skills encode framework-specific patterns (e.g., window.timelines registration, data- attribute semantics, shader-compatible CSS rules) that are NOT in generic web docs. Skipping them produces broken compositions.

Default to using Bun instead of Node.js.

Create video compositions, animations, title cards, overlays, captions, voiceovers, audio-reactive visuals, and scene transitions in HyperFrames HTML. Use when asked to build any HTML-based video content, add captions or subtitles synced to audio, generate text-to-speech narration, create audio-reactive animation (beat sync, glow, pulse driven by music), add animated text highlighting (marker swee

Capture a website and create a HyperFrames video from it. Use when: (1) a user provides a URL and wants a video, (2) someone says "capture this site", "turn this into a video", "make a promo from my site", (3) the user wants a social ad, product tour, or any video based on an existing website, (4) the user shares a link and asks for any kind of video content. Even if the user just pastes a URL — t

Translate an existing Remotion (React-based) video composition into a HyperFrames HTML composition. Use ONLY when the user explicitly asks to port, convert, migrate, translate, or rewrite a Remotion composition as HyperFrames (e.g. "port my Remotion project to HyperFrames"). Do NOT use when (a) authoring a NEW HyperFrames composition (even if A/B-testing a Remotion video); (b) Remotion is mentione

HyperFrames CLI dev loop — `npx hyperframes` for scaffolding (init), validation (lint, inspect), preview, render, and environment troubleshooting (doctor, browser, info, upgrade). Use when running any of these commands or troubleshooting the HyperFrames build/render environment. For asset preprocessing commands (`tts`, `transcribe`, `remove-background`), invoke the `hyperframes-media` skill instea

Web Animations API adapter patterns for HyperFrames. Use when authoring element.animate() motion, Animation currentTime seeking, document.getAnimations(), KeyframeEffect timing, fill modes, or native browser animations that must render deterministically in HyperFrames.

Anime.js adapter patterns for HyperFrames. Use when writing Anime.js animations or timelines inside HyperFrames compositions, registering animations on window.__hfAnime, making Anime.js seek-driven and deterministic, or translating Anime.js examples into render-safe HyperFrames HTML.

Install and wire registry blocks and components into HyperFrames compositions. Use when running hyperframes add, installing a block or component, wiring an installed item into index.html, or working with hyperframes.json. Covers the add command, install locations, block sub-composition wiring, component snippet merging, and registry discovery.

TypeGPU and raw WebGPU adapter patterns for HyperFrames. Use when creating GPU-rendered compositions with TypeGPU, raw WebGPU, WGSL fragment shaders, compute pipelines, liquid glass effects, particle systems, or any canvas layer driven by navigator.gpu that responds to HyperFrames hf-seek events.

Author a new HyperFrames registry block (caption style, VFX block, transition, lower third) or component (text effect, overlay, snippet) and ship it as an upstream PR to the hyperframes repo. Use ONLY when the user wants to CONTRIBUTE to the public catalog — for in-project caption/transition authoring use the `hyperframes` skill, for installing existing registry items use the `hyperframes-registry

Three.js and WebGL adapter patterns for HyperFrames. Use when creating deterministic Three.js scenes, WebGL canvas layers, AnimationMixer timelines, camera motion, shader-driven visuals, or canvas renders that respond to HyperFrames hf-seek events.

Tailwind CSS v4.2 browser-runtime patterns for HyperFrames compositions. Use when scaffolding or editing projects created with `hyperframes init --tailwind`, writing Tailwind utility classes in composition HTML, adding CSS-first Tailwind v4 theme tokens, debugging v3 vs v4 syntax, or deciding when to compile Tailwind to CSS instead of using the browser runtime.

Asset preprocessing for HyperFrames compositions — text-to-speech narration (Kokoro), audio/video transcription (Whisper), and background removal for transparent overlays (u2net). Use when generating voiceover from text, transcribing speech for captions, removing the background from a video or image to use as a transparent overlay, choosing a TTS voice or whisper model, or chaining these (TTS → tr

Lottie and dotLottie adapter patterns for HyperFrames. Use when embedding lottie-web JSON animations, .lottie files, @lottiefiles/dotlottie-web players, registering instances on window.__hfLottie, or making After Effects exports deterministic in HyperFrames.

GSAP animation reference for HyperFrames. Covers gsap.to(), from(), fromTo(), easing, stagger, defaults, timelines (gsap.timeline(), position parameter, labels, nesting, playback), and performance (transforms, will-change, quickTo). Use when writing GSAP animations in HyperFrames compositions.

CSS animation adapter patterns for HyperFrames. Use when authoring CSS keyframes, animation-delay based timing, animation-fill-mode, animation-play-state, or CSS-only motion that HyperFrames must seek deterministically during preview and rendering.