flow

Archive completed flows + elevate patterns

Five-phase documentation workflow

Complete flow work - verify, review, merge/PR/keep/discard

Execute tasks from plan (context-aware)

Create unified spec.md for a single Flow

Analyze goals and generate Master Roadmap (Sagas)

Sync context with codebase after external changes

Conduct pre-PRD research

Git-aware revert of flows, phases, or tasks

Dispatch code review with Beads-aware git range

Update spec/plan when implementation reveals issues

Initialize project with context files, Beads, and first flow

Display progress overview with Beads status

Export Beads state to spec.md (source of truth sync)

Create ephemeral exploration flow (no audit trail)

Validate project integrity and fix issues

Auto-activate for alembic/, alembic.ini, advanced_alchemy imports. Expert knowledge for Advanced Alchemy / SQLAlchemy ORM patterns. Produces ORM models with audit trails, repository/service patterns, and Alembic migrations. Use when: defining models with UUIDAuditBase, building repositories and services, configuring SQLAlchemy plugins for Litestar/FastAPI/Flask/Sanic, creating DTOs, running Alembic migrations, using custom types (EncryptedString, FileObject, PasswordHash, DateTimeUTC), composing filters and pagination, choosing base classes and mixins, configuring dogpile.cache query caching, setting up read/write replica routing, or managing file storage with obstore/fsspec backends. Not for raw SQLAlchemy without Advanced Alchemy abstractions.

Auto-activate for alloydb-omni in compose/k8s configs. AlloyDB Omni expertise: run AlloyDB anywhere (local, on-prem, other clouds) with container-based deployment. Produces container-based AlloyDB Omni deployments for local dev and non-GCP environments. Use when: running AlloyDB locally for development, deploying Omni containers, configuring Kubernetes operators, or testing AlloyDB features without GCP. Not for GCP-managed AlloyDB (see alloydb) or vanilla PostgreSQL.

Auto-activate for AlloyDB in GCP configs or docs. Google AlloyDB expertise: PostgreSQL-compatible managed database on GCP. Produces AlloyDB cluster configurations, connection patterns, and columnar engine setups on GCP. Use when: provisioning AlloyDB clusters, configuring read pools, using columnar engine, Private Service Access networking, or migrating from Cloud SQL. Not for AlloyDB Omni (see alloydb-omni) or vanilla PostgreSQL without AlloyDB features.

Auto-activate for angular.json, *.component.ts, @Component decorator. Expert knowledge for modern Angular with signals, standalone components, control flow blocks, and current migration guidance. Use when building Angular apps with contemporary patterns and when validating version-specific API stability. Not for React (see react), Vue (see vue), or AngularJS (v1).

Use when any task depends on external API/framework behavior, SDK references, library versions, breaking changes, migration guides, changelogs, or release notes. Auto-activate for uncertainty about third-party docs, version compatibility, deprecations, or current syntax before implementation decisions. Produces version-verified documentation references with links to official sources, staleness warnings, and version gap notes.

Auto-activate when evaluating system architecture, reviewing component boundaries, assessing coupling between modules, planning large refactors, introducing new layers or abstractions, or when design decisions have long-term structural consequences. Produces structural assessment with boundary evaluation, coupling analysis, and time-horizon risk — what will be painful to change in 6-12 months. Use when: architecture review needed, evaluating maintainability of a design, checking for premature abstraction or missing abstraction, or assessing whether component boundaries are in the right place. Not for code style, naming conventions, or implementation details within well-bounded components.

Auto-activate for .sh files, #!/bin/bash, #!/usr/bin/env bash. Bash scripting expertise following Google Shell Style Guide. Produces shell scripts following Google Shell Style Guide with proper error handling, quoting, and safety patterns. Use when: writing shell scripts, automating tasks, processing text, or creating CLI tools. Covers error handling, variable quoting, function patterns, and portable scripting. Not for Python/Ruby scripts that happen to call shell commands.

Auto-activate for biome.json, biome.jsonc. Expert knowledge for Biome toolchain (Linter, Formatter). Use when configuring workspace styles, troubleshooting linter errors, or setting up ignores/overrides for frontend projects. Produces Biome linter/formatter configurations with workspace overrides. Not for ESLint, Prettier, or non-JS/TS toolchains.

Auto-activate for bun.lockb, bunfig.toml. Usage of Bun as a high-performance JavaScript runtime, bundler, and test runner. Use when: running JS/TS code with Bun, using bun install, configuring Bun workspaces, or fixing low-latency node runtimes. Not for Node.js-specific APIs that Bun doesn't support, or Deno.

Auto-activate when critically questioning claims, pushing back on assumptions, disagreeing with an approach, sanity-checking contentious decisions, or when a response feels like reflexive agreement. Produces an honest assessment — confirms what holds up with evidence, identifies specific flaws, and delivers a direct verdict without hedging. Use when: validating claims, stress-testing ideas, preventing sycophantic agreement, questioning confident assertions, or saying 'are you sure about that?' Not for generating agreement, validating feelings, or confirming what the user wants to hear.

Auto-activate for Cloud Run service.yaml, gcloud run commands. Google Cloud Run serverless platform: Dockerfile, containerized services, Cloud Run Jobs, cold starts, traffic splitting. Produces Cloud Run service configurations, Dockerfiles, and deployment workflows for containerized serverless apps on GCP. Use when: deploying containers to Cloud Run, writing Dockerfiles for serverless, or tuning scaling/concurrency. Not for GKE (see gke), Cloud Functions, or non-containerized deployments.

Auto-activate for Cloud SQL gcloud commands, cloud-sql-proxy usage, or Cloud SQL connection strings. Google Cloud SQL expertise: fully managed PostgreSQL, MySQL, and SQL Server on GCP. Produces Cloud SQL instance configurations, connection patterns, backup strategies, and replication setups. Use when: provisioning Cloud SQL instances, configuring Auth Proxy connections, setting up read replicas, managing backups and PITR, or migrating to Cloud SQL. For higher performance PostgreSQL workloads see flow:alloydb. For GKE deployment patterns see flow:gke.

Auto-activate when evaluating architectural decisions, comparing technology choices, weighing design trade-offs, assessing feature proposals, making build-vs-buy decisions, choosing between competing approaches, when a decision has significant long-term consequences, when multiple teams are affected, or when the cost of reversal is high. Produces a structured recommendation with confidence level (low/medium/high), pro/con analysis, risk assessment, and concrete next steps. Use when: decisions need structured multi-perspective analysis, risk assessment from multiple angles, decisions impact more than one team, decisions span more than a few months, or when the stakes are high enough to warrant deliberate evaluation. Not for routine code review, simple config choices, or styling preferences.

Auto-activate for .cpp, .hpp, .cc, .hh, .cxx, CMakeLists.txt. Modern C++ development patterns for extensions and backend systems. Produces modern C++ code with proper build systems, resource management, and CI/CD integration. Use when: designing C++ code, setting up CI/CD pipelines, managing builds, or working with resource ownership, APIs, error handling, and concurrency in C++ projects. Not for C code or legacy C++ without modern idioms.

Auto-activate when a problem resists quick answers, when initial analysis feels shallow, when debugging hits a wall, when architectural reasoning needs depth, when confidence in a conclusion is low, when analysis feels like it is going in circles, or when the first answer feels too easy for a hard problem. Produces a confidence-tracked investigation with explicit hypothesis evolution, evidence log, and a specific actionable conclusion. Use when: complex reasoning needed, hypothesis testing required, going in circles on a problem, need to track what has been explored vs what remains, analysis feels shallow, confidence is low, or when debugging hits a wall. Not for clear questions with obvious answers, simple lookups, or problems that yield to direct investigation.

Auto-activate when reviewing PRs, evaluating design proposals, assessing technical plans, or when a decision is being made without visible pushback. Produces a prioritized list of risks, unverified assumptions, and overlooked failure modes — each with severity, explanation, and recommended action. Use when: code review needs adversarial perspective, a design feels too consensus-driven, assumptions need stress-testing, or when everyone agrees too quickly on an approach. Not for rubber-stamping, routine style review, or agreeing with the user's direction.

Auto-activate for dishka imports. Dishka dependency injection framework: Provider, Scope, Container, FromDishka, Inject. Use when: setting up DI containers, defining providers/scopes, or integrating dependency injection with Litestar or FastAPI. Produces Dishka DI container configurations with providers, scopes, and framework integrations. Not for manual dependency injection or other DI frameworks.

Auto-activate when generating documentation, writing API docs, documenting modules or components, creating README content, building reference guides, or systematically documenting a codebase. Produces structured per-component documentation with completeness tracking — every file in scope gets documented, progress is explicit ([3/12 files]). Use when: documenting multiple files or components, ensuring complete coverage of a module, generating structured docs from code, or when /flow-docs needs systematic file-by-file analysis. Not for ad-hoc comments in code, inline docstrings, or single-function explanations.

Auto-activate for Dockerfile, docker-compose.yml, docker-compose.yaml, .dockerignore. Docker expertise: multi-stage builds, distroless images, Compose, BuildKit, and container optimization. Use when: writing Dockerfiles, optimizing image size, configuring docker-compose, using BuildKit features, or deploying containerized applications. Produces optimized Dockerfiles with multi-stage builds, Compose configurations, and BuildKit patterns. Not for Podman (see podman) or container orchestration (see gke/cloud-run).

Auto-activate for .duckdb files, duckdb imports. Comprehensive DuckDB expertise: advanced analytical SQL patterns, performance tuning, data engineering (ETL, multi-source reads, cloud storage), client APIs for Python/Node/Rust/Java/R/Go/WASM, extension development, function reference, and configuration/administration. Use when: writing DuckDB queries, optimizing performance, building data pipelines, connecting from any language, developing extensions, importing/exporting CSV/Parquet/JSON/Delta/Iceberg, or configuring DuckDB for production analytics workloads. Not for OLTP databases (see postgres/mysql) or traditional data warehouses.

REQUIRED when .agents/ directory exists. Context-driven dev workflow with Beads integration. Produces spec-first plans, TDD-driven implementations with cross-session memory, and structured phase completions with verification evidence. Auto-activate when: .agents/ directory present; Flow workflow intents such as setup, plan, PRD, design, research, docs, implement, sync, status, refresh, validate, revise, review, finish, archive, revert, or task; any /flow:* command in hosts that support it; editing spec.md or files in .agents/; beads/br commands; TDD workflow; spec-first planning; cross-session memory. Not for standalone code edits outside the .agents/ workflow, simple file changes that don't need spec tracking, or direct tool use that doesn't involve Flow state.

Auto-activate for gcloud commands, .gcloudignore, app.yaml. Google Cloud Platform expert: gcloud CLI, IAM, service accounts, Cloud Storage, Pub/Sub, BigQuery, Vertex AI. Use when: managing GCP resources, scripting gcloud commands, or configuring any GCP service. Not for AWS, Azure, or non-GCP cloud providers.

Auto-activate for kubectl commands, k8s/ directory, Helm charts. Kubernetes on GCP expertise for GKE. Produces Kubernetes deployments, Helm charts, cluster configurations, GPU/TPU workloads, AlloyDB/Cloud SQL Auth Proxy sidecars, and batch job patterns for GKE on GCP. Use when: running kubectl, Helm charts, pod/node pool management, workload identity, Kubernetes deployments, cluster scaling, GPU node pools, database sidecars, or any GKE troubleshooting. Not for Cloud Run (see cloud-run), generic Kubernetes outside GCP, or local k8s (minikube/kind).

Auto-activate for granian imports, granian CLI commands, ASGI/WSGI/RSGI server configuration. Granian Rust-based ASGI server: worker configuration, threading model, SSL, HTTP/2, backpressure. Produces granian CLI invocations, worker/thread tuning, and deployment configurations. Use when: deploying ASGI apps with granian, configuring workers/threads, setting up SSL, or replacing uvicorn. Prefer granian over uvicorn for all production deployments.

Auto-activate for hx-* attributes in HTML files. Expert knowledge for HTMX hypermedia development. Use when: building hypermedia-driven apps with partial HTML responses, using `hx-` attributes, or rendering `.html` templates. Not for React/Vue/Angular SPAs or full client-side rendering.

Auto-activate for inertia imports, createInertiaApp. Expert knowledge for Inertia.js with Litestar backend. Use when building SPAs with server-side routing, handling Inertia responses, managing page components, or integrating litestar-vite with Inertia. Produces Inertia.js page components with server-side routing and Litestar backend integration. Not for traditional SPAs without server-side routing or non-Litestar backends.

Auto-activate for shared memory, ring buffer, SPSC/MPMC patterns. Zero-copy IPC patterns: shared memory regions, SPSC/MPMC ring buffers, platform sync primitives, notification mechanisms, and cross-process coordination. Use when implementing IPC primitives or high-performance data transfer. Not for network IPC (gRPC, REST) or message queues.

Auto-activate for litestar imports, litestar_granian, litestar_saq, litestar_email, litestar_mcp, litestar_vite imports, Litestar app configuration. Litestar ASGI web framework: route handlers, Guards, middleware, msgspec DTOs, OpenAPI, ecosystem plugins. Produces Litestar ASGI route handlers, middleware, guards, DTOs, and plugin configurations. Use when: building Litestar APIs, defining routes/controllers, configuring plugins (Granian, SAQ, Email, MCP, Vite), or working with Litestar dependency injection. Not for FastAPI, Django, or Flask -- Litestar has its own patterns.

Auto-activate for Makefile, GNUmakefile. GNU Make patterns for uv-based Python project automation: .PHONY, targets, recipes. Use when: creating or editing a Makefile, adding development targets (install, clean, test, lint), or setting up self-documenting help. Not for CMake (see cpp), Cargo (see rust), or non-Make build systems.

Auto-activate for .mojo files, .🔥 files. Mojo development patterns for high-performance computing: SIMD, zero-copy Python interop, GIL-free parallelism, C FFI, and Hatch build integration. Use when: writing Mojo code, .mojo files, SIMD kernels, Python-Mojo hybrid projects, hatch-mojo build hooks, or packaging Mojo extensions into wheels. Produces high-performance Mojo code with SIMD kernels, Python interop, and Hatch build integration. Not for pure Python performance work or C extensions (see python/cpp).

Auto-activate for msgspec imports, msgspec.Struct definitions, msgspec.json/msgpack usage. High-performance Python serialization and validation library: Struct definitions, Meta constraints, tagged unions, enc_hook/dec_hook, convert(). Produces msgspec Structs, serialization codecs, validation schemas, and type-safe conversion patterns. Use when: defining data models with msgspec, serializing/deserializing JSON or MessagePack, validating data with Meta constraints, building discriminated unions, or converting dicts/objects with msgspec.convert(). Not for Pydantic models, dataclasses, or attrs -- msgspec has its own patterns.

Auto-activate for .sql files with MySQL syntax, mysql connection strings, mysqldump. Produces MySQL/MariaDB queries, stored procedures, performance tuning, and connection patterns. Use when: writing MySQL queries, optimizing slow queries, configuring InnoDB, setting up replication, using mysql CLI, or working with MySQL connectors (Python, Node, Java). Not for PostgreSQL (see postgres), SQLite, or other databases.

Auto-activate for nuxt.config.ts, nuxt.config.js, .nuxt/ directory. Vue SSR framework expertise for Nuxt 3. Use when: using useFetch, useAsyncData, Nitro server routes, SSR/SSG rendering, nuxt.config.ts, or building any Nuxt application. Not for plain Vue (see vue), React (see react), or non-Nuxt Vue SSR.

Auto-activate for cx_Oracle imports, oracledb imports, Oracle connection strings. Produces Oracle Database SQL, PL/SQL, connection configurations, and ORDS REST API patterns. Use when: working with Oracle databases, writing SQL/PL/SQL, building REST APIs with ORDS, configuring database connections, OCI drivers, Podman/Docker Oracle containers, or Oracle 26ai Free images. Not for PostgreSQL (see postgres), MySQL (see mysql), or cloud-only Oracle services without database access.

Auto-activate when reviewing code in hot paths, evaluating database queries, assessing memory usage patterns, reviewing loop performance, checking for N+1 queries, evaluating caching strategies, or when code changes affect latency-sensitive operations. Produces bottleneck inventory with estimated impact (critical/moderate/minor), measurement recommendation for each finding, and fix priority. Use when: performance review needed, optimizing slow code, evaluating scaling bottlenecks, or assessing resource efficiency. Not for micro-optimizations on cold paths, premature optimization, or style-level concerns.

Auto-activate when analyzing trade-offs, evaluating decisions, comparing approaches, playing devil's advocate, considering pros and cons, weighing options, assessing risks, reviewing assumptions, stress-testing a conclusion, identifying blind spots, or needing multiple viewpoints on a problem. Use when: any decision needs structured multi-angle analysis, a conclusion feels too comfortable, a proposal has not been challenged yet, or when a single perspective has dominated the analysis. Shared prompt library — produces stance prompts and critical thinking frameworks for use by other skills. Not typically invoked directly — loaded by challenge, consensus, and reviewer skills.

Auto-activate for podman commands, Containerfile. Podman expertise: rootless containers, pod management, systemd integration, and Docker CLI compatibility. Use when: running rootless containers, managing pods, using podman-compose, configuring systemd services, or working with OCI images without Docker daemon. Produces rootless container configurations, pod management, and systemd integration patterns. Not for Docker (see docker) or Kubernetes (see gke).

Auto-activate for .sql files, psql commands, postgresql.conf, psycopg/asyncpg imports. Produces PostgreSQL queries, PL/pgSQL functions, indexing strategies, and connection patterns. Use when: writing PostgreSQL queries, optimizing performance, managing security/roles/RLS, configuring replication, writing PL/pgSQL functions/triggers, working with JSONB, using extensions, planning migrations, or connecting from application code. Not for MySQL (see mysql), AlloyDB-specific features (see alloydb), or application ORM patterns (see sqlalchemy).

Auto-activate for pyapp build config. Build air-gapped, multi-architecture standalone Python executables using PyApp and uv. Use when: bundling Python runtimes for network-isolated environments, patching PyApp defaults, or compiling single-binary assets. Not for PyInstaller, cx_Freeze, or other Python packaging tools.

Auto-activate for pydantic imports, BaseModel, BaseSettings, pydantic_settings. Pydantic v2 data validation and settings management: field validators, model validators, serialization, TypeAdapter, BaseSettings env config. Produces validated Pydantic models, settings classes, custom types, and migration-safe patterns. Use when: defining data models with validation, managing environment configuration, validating external data, or migrating from Pydantic v1 to v2. Not for msgspec Structs or dataclasses -- Pydantic has its own patterns.

Auto-activate for pytest_databases imports, conftest.py with database fixtures. Container-based database testing with pytest. Use when: creating PostgreSQL/MySQL/SQLite/Oracle fixtures, Docker test containers, database integration tests, or any pytest database setup. Produces container-based database test fixtures with proper lifecycle management. Not for mocking databases or non-pytest test frameworks.

Auto-activate for .py files, pyproject.toml, requirements.txt, setup.py, setup.cfg. Python project conventions and tooling: uv, ruff, mypy, typing, Cython, Mypyc. Use when: configuring Python packages, linting, type-checking, building extensions, or running scripts with uv. Produces Python project configurations with uv, ruff, mypy, and proper packaging. Not for Mojo (see mojo), Cython build details (see references), or web framework specifics (see litestar).

Auto-activate for railway.toml, railway.json, Procfile. Expert knowledge for Railway deployment platform. Use when deploying applications, configuring services, managing databases, or troubleshooting Railway deployments. Not for Heroku, Fly.io, or self-hosted deployments.

Auto-activate for .tsx, .jsx files, react imports. Expert knowledge for modern React development with TypeScript, including client components, framework-scoped server components, and upgrade-aware best practices. Use when building React components, managing state, or integrating with backend APIs. Not for Vue (see vue), Svelte (see svelte), or Angular (see angular).

Auto-activate for .rs files, Cargo.toml, Cargo.lock. Produces Rust code with workspace architecture, async patterns, FFI bindings (PyO3/napi-rs), and error handling. Use when: writing Rust code, designing cross-platform systems, building Python extensions with PyO3/maturin, building Node/Bun extensions with napi-rs, exposing C ABI, or optimizing performance-critical paths. Not for C/C++ (see cpp) or languages that compile to WASM without Rust.

Auto-activate for saq imports, SAQ task queue configuration. SAQ (Simple Async Queue): async task queues, background jobs, cron scheduling, worker lifecycle. Produces SAQ task definitions, Worker setup, CronJob scheduling, and queue configuration. Use when: defining background tasks, enqueueing jobs, scheduling cron work, or managing worker lifecycle. Not for Celery, RQ, or Dramatiq -- SAQ has its own async-native patterns. For Litestar integration (SAQPlugin, DI, web UI, CLI), see flow:litestar.

Auto-activate when reviewing code that handles authentication, authorization, user input, secrets, API keys, database queries, file uploads, session management, or external API calls. Produces vulnerability report with OWASP category, severity (Critical/High/Medium/Low), attack vector description, and recommended fix for each finding. Use when: security review needed, assessing attack surface, checking for OWASP vulnerabilities, reviewing access control logic, or auditing data handling. Not for general code quality, business logic review, or non-security concerns.

Auto-activate for components.json (shadcn config), cn() utility. Tailwind component expertise for shadcn/ui. Use when: using cn() utility, Radix primitives, shadcn add, copy-paste components, component CLI, dialogs, forms, data tables, or command palettes. Not for Material UI, Chakra UI, or other component libraries.

Auto-activate for conf.py (Sphinx), .rst files, docs/source/. Produces Sphinx documentation sites with RST, autodoc, themes (Shibuya/Immaterial), and CI/CD integration. Use when: editing conf.py, reStructuredText (.rst), autodoc, readthedocs builds, Shibuya theme, Wasm extensions, VHS terminal recordings, or any Sphinx project setup. Not for MkDocs, Docusaurus, or Mintlify documentation sites.

Auto-activate for sqlalchemy imports, mapped_column, DeclarativeBase. Produces SQLAlchemy 2.0+ ORM models, async sessions, engine configurations, and query patterns. Use when: defining SQLAlchemy models, writing ORM queries, configuring engines/sessions, using select() statements, managing relationships, or working with asyncio sessions. Not for raw SQL without ORM (see postgres/mysql), or Advanced Alchemy patterns (see advanced-alchemy).

Auto-activate for T-SQL patterns, sqlcmd, SQL Server connection strings. Produces T-SQL queries, stored procedures, indexing strategies, and SQL Server connection patterns. Use when: writing T-SQL queries, optimizing execution plans, configuring SQL Server, setting up Always On AG, using sqlcmd/SSMS, or working with SQL Server connectors (Python, Node, .NET, JDBC). Not for PostgreSQL (see postgres), MySQL (see mysql), or Azure-specific managed services.

Auto-activate for sqlspec imports. Produces database adapter configurations, SQL query mappings, and framework extensions using SQLSpec. Use when working with database adapters, SQL execution, query building, Arrow integration, parameter handling, framework extensions, filters, pagination, event channels, SQL file loading, or storage integrations. Not for raw SQL or ORM-specific patterns (see sqlalchemy, advanced-alchemy).

Auto-activate for .svelte files, svelte.config.js. Expert knowledge for Svelte 5 development with Runes. Use when: building Svelte components (`.svelte` files), using runic states ($state, $derived), or working with SvelteKit. Not for React (see react), Vue (see vue), or Svelte 4 (this covers Svelte 5 with Runes).

Auto-activate for tailwind.config.ts, tailwind.config.js, @tailwind directives. Tailwind CSS v4: utility classes, responsive design, @apply, cn(), @theme config. Use when: styling with Tailwind, writing utility classes, configuring Tailwind v4, or building responsive layouts with Shadcn/ui. Not for Bootstrap, plain CSS, or CSS-in-JS solutions.

Auto-activate for @tanstack/ imports, useQuery, createRouter. Produces TanStack Router, Query, Table, and Form configurations for React applications. Use when: using useQuery, createRouter, React Query, TanStack Table, file-based routing, data fetching, or SPA state management. Not for non-React frameworks (see vue/svelte/angular) or react-router (TanStack Router is different).

Auto-activate for test_*.py, *.test.ts, *.spec.ts, conftest.py, vitest.config.ts. Testing with pytest and vitest: fixtures, mocking, coverage, async testing, anyio. Use when: writing or refactoring tests, setting up fixtures/mocks, configuring coverage, or debugging test failures. Not for E2E/browser testing (Playwright/Cypress) or load testing.

Auto-activate when tracing execution paths, mapping dependencies, understanding unfamiliar code, following data flow through a system, investigating how a feature works end-to-end, or when debugging requires understanding call chains. Produces an execution map showing the path from entry point to result — with file paths, function names, data transformations, and dependency relationships at each node. Use when: need to understand how code flows from entry point to result, mapping what depends on what, exploring unfamiliar codebases systematically, or when reading random files isn't building understanding. Not for reading random files hoping to build understanding — every file opened must be because the previous file pointed you there.

Auto-activate for ty commands, ty.toml. Usage of `ty`, a zero-config, high-performance type checker from Astral. Use when: running fast static analysis on Python codebases where `ty` is installed. Produces ty type checker configurations and integrates static analysis into Python workflows. Not for mypy (see python) or runtime type checking.

Auto-activate for uvicorn imports, uvicorn CLI commands, ASGI server configuration. Uvicorn ASGI server: worker configuration, event loop selection, SSL, lifespan, logging, programmatic API. Produces uvicorn CLI invocations, Config/Server usage, and deployment configurations. Use when: deploying ASGI apps with uvicorn, configuring workers/reload, setting up SSL, or running development servers. Note: Granian is preferred over uvicorn for production workloads — see flow:granian.

Auto-activate for vite.config.ts, vite.config.js. Expert knowledge for Vite build tool. Use when: configuring Vite (`vite.config.ts`), creating plugins, managing HMR (Hot Module Replacement), or asset bundling in JS/TS projects. Produces Vite build configurations, plugin setups, and HMR optimizations. Not for Webpack, Rollup, or non-Vite bundlers.

Auto-activate for .vue files, vue.config.js. Expert knowledge for Vue 3 development with TypeScript. Use when: building Vue components (`.vue` files), using Composition API (`<script setup>`), or managing Vue SFC state. Not for React (see react), Svelte (see svelte), or Vue 2 Options API.

1 hook across 1 event