prometheus-skill-pack

Tokio-native actor model pattern for Prometheus AGS projects. Implements actors as tokio tasks communicating via mpsc channels with a typed message enum, enabling safe concurrent state management without shared locks. Used in UAR session management, pk-librarian event broadcasting, and parking-lot scheduler design. Use when a component needs to own state exclusively while serving concurrent callers.

Isolated, cross-model adversarial review of KBD artifacts and change diffs. Dispatches a fresh-context LLM judge over an OpenAI-compatible REST gateway (openai-proxy or `liter-llm api`) with an explicit mandate to find problems — the model that produced an artifact or change is never the model that reviews it. Runs as a pipeline stage inside kbd-assess/analyze/plan (artifact mode) and kbd-execute's per-change QA gate (diff mode). Findings are severity-bucketed (CRITICAL/WARNING/SUGGESTION) and the judge's own report is screened by sycophancy-correction before it is surfaced.

Create, revise, package, and deploy agent-team definitions with staged questions and native exports for UAR, Codex, Claude Code, Copilot, Kimi Code, MiniMax CLI, OpenCode and DeepSeek. Use for team definition and catalog lifecycle; use agent-team-manage for active runtime task state.

Prepare and accept a durable handoff between agent roles or coding harnesses using task context, Git identity, evidence and memory references. Use when work must continue in another harness or agent; use agent-team-manage for ordinary same-owner task updates. Do not use for ordinary same-owner task updates (see agent-team-manage).

Manage an existing agent team's active task state: assign dependencies and owners, track evidence, cancel or reassign work, and reconcile KBD-linked completion. Use agent-team-creator for definition creation, versioned maintenance, native export, and UAR catalog deployment.

Discover configured models and choose explicit capability, strength and cost policies at team, role, skill and task levels. Use when selecting models or controlling an agent team budget; use agent-team-creator for role discovery. Unknown prices and capabilities remain unknown. Do not use for role selection (see agent-team-creator).

Instructions to make or update an app's UI so that it adapts to different Android devices including phones, tablets, foldables, laptops, desktop, TV, Auto and XR. It includes how to handle different window sizes, pointing devices (such as mouse) and text entry devices (such as keyboard) using the Compose MediaQuery API. It also covers multi-pane layouts using Navigation3 Scenes, adaptive UI components (such as buttons) with varying target sizes, and adaptive layouts (including navigation areas - nav rails and nav bars) using the Compose Grid and FlexBox APIs.

Use this skill to migrate your Jetpack Compose app to add adaptive edge-to-edge support and troubleshoot common issues. Use this skill to fix UI components (like buttons or lists) that are obscured by or overlapping with the navigation bar or status bar, fix IME insets, and fix system bar legibility.

Installs, configures, and manages ArgoCD as a multi-cloud GitOps control plane on GKE, with AKS and EKS registered as remote cluster destinations. Covers: fresh ArgoCD installation with --insecure mode behind Envoy Gateway, wildcard TLS certificate setup, cluster registration via argocd CLI, App-of-Apps root application creation, ArgoCD ApplicationSet authoring for cross-cluster fan-out delivery, ArgoCD project isolation per client/environment, RBAC configuration, and Dex OIDC SSO wiring. Use when setting up ArgoCD for the first time or adding remote clusters to an existing control plane.

Use this skill when creating or iteratively refining artifacts (logos, UI components, A2UI specifications, images, or content) using structured PMPO orchestration with explicit constraints, deterministic execution, and persistent artifact state.

Canonical async Rust patterns for Prometheus AGS projects. Covers tokio task spawning, Arc<RwLock<T>> vs parking_lot::Mutex selection, blocking guard prevention, broadcast channels, graceful shutdown, and structured concurrency. Use whenever writing async code in any Prometheus Fabric crate.

Axum 0.8 router, middleware, extractor, and state injection patterns for Prometheus AGS projects. Enforces the canonical Axum structure: typed state via Extension/State extractors, Tower middleware composition, structured error types, and Axum-native SSE for MCP servers. Use when building any Axum HTTP service, MCP server, or API gateway in the Prometheus stack.

Author, run, and maintain BDD integration tests using cucumber-js 13 with Gherkin, playwright-bdd for browser-driven scenarios, and tsx for TypeScript. Use when writing behavior tests, E2E tests, integration tests, feature files, or step definitions in any Node/TypeScript project.

Author, run, and maintain BDD integration tests in Rust using the cucumber 0.23 crate with async World, tokio + reqwest for HTTP scenarios, and thirtyfour for browser-driven scenarios. Use when writing behavior tests, integration tests, feature files, or step definitions for any Rust crate or workspace.

Codifies the create → run → triage → maintain workflow for BDD test suites. Includes outside-in scenario authoring, flake-budget enforcement wrapping cucumber's --retry-tag-filter primitive, an immutable-tests CI guard, and a visual-baseline refresh workflow with paper trail. Use when standing up a new BDD suite, growing an existing suite past 100 scenarios, or when flakiness starts eroding trust in CI.

DEPRECATED alias — use bdd-cucumber-js instead. This skill is retained as a redirect so downstream projects that reference "bdd-testing" by name continue to work.

Assemble a signed certification bundle from a cucumber test run — cucumber JSON report, MP4 videos (ffmpeg-remuxed from Playwright WebM), screenshot manifest, and a SHA-256 manifest keyed to the git commit. Two modes: local bundle under docs/certifications/<module>/<sha>/, or IPFS-pinned. Use when producing release evidence, reviewer-facing test proof, or audit trails.

Helps your project comply with accessibility standards and best practices.

Helps you build a color system and answer anything about color in your project. You can generate palettes, use semantic tokens, convert between formats, check contrast and more.

Combines all of the `better-*` skills into a single review across accessibility, layout, writing, typography, color and UI polish.

Helps with grouping, alignment, reading order, progressive disclosure and other details that make a good layout.

Focuses on type scale, spacing, sizing, variable fonts, OpenType features, wrapping, truncation and other details that make typography feel great across your product.

Polishes and improves the UI in your project. Covers concentric border radius, optical alignment, surface depth, contextual icons, hit areas and more.

Focuses on improving product copy in your project.

Renders a component you choose in every state and scenario on a temporary page and stress tests it.

CLEAN architecture patterns common to all languages in the Prometheus AGS stack. Defines the four-layer model (Domain → Application → Infrastructure → Interface), dependency inversion rules, trait/interface boundaries, and how the pattern maps to Rust crates, Flutter features, React feature slices, and Go packages. Apply across all languages to ensure consistent layering and testability.

Clone an existing Agent Skill and adapt it for a new domain. Preserves architecture while replacing domain-specific content.

Convert a branded HTML/HTMX artifact into a paginated, print-correct PDF via headless Chromium — with embedded fonts, a running header and page numbers, pagination discipline that prevents orphaned pages and split components, and a verification loop that proves the output before it ships.

Convert an HTMX + Alpine.js HTML artifact into a React TSX component ready for the scaffold-react-vite pipeline. Mechanical transforms run via a Node script; HTMX/Alpine constructs requiring judgment are surfaced as a sidecar markdown for review.

Convert a Markdown document into a self-contained branded HTMX artifact via the deterministic markdown-it pipeline with frontmatter support, semantic HTML wrapping, and brand-CSS injection.

Install, update, and manage AI coding agent skills across 20+ platforms using the cowork CLI. Covers Claude Code, Codex, OpenCode, Kimi Code, Zed, Cursor, Windsurf, GitHub Copilot, and more. Also manages prometheus-skill-pack updates, toolchain health checks, and disk-space reclamation via dsg delegation.

Generate a complete native Rust agent application with Supabase-style CLI, A2A/AG-UI/A2UI protocol support, React 19 assistant-ui chat frontend, liter-llm model routing, MCP client tools, and the Prometheus skills engine. One command scaffolds a runnable multi-protocol agent binary.

Create a new Agent Skill from scratch using PMPO orchestration. Generates a complete skill package with all required files.

10-stage deep research pipeline: Planner → Search → Retrieve → Collect → Verify → Resolve → Graph → Cite → Report → Export. Driven by a stage-contract driver that validates every stage's artifacts, checkpoints each boundary, and resumes. Produces persistent research packages (OKF-aligned knowledge assets) with labelled claims, a provenance sidecar, citations, confidence scores, knowledge graphs, and contradiction tracking. Integrates with surreal-memory, liter-llm, sycophancy-correction, and Feynman learning skills. Supersedes disposable report generation with structured knowledge infrastructure.

Operate timed usable deliveries with frozen delivery candidates, bounded work-ahead, child recovery and publication evidence. Use when running repeated delivery increments under KBD, a native goal, or standalone work. Do NOT use for initial architecture assessment; use kbd-assess.

Lightweight SVG logo creation for ideation. Mode-switching between LLM-suggested SVG (with strict parseability + XSS validation) and a deterministic Minijinja placeholder. Exports PNG raster set when `rsvg-convert` is available.

Anti-slop frontend skill for landing pages, portfolios, and redesigns. The agent reads the brief, infers the right design direction, and ships interfaces that do not look templated. Real design systems when applicable, audit-first on redesigns, strict pre-flight check.

The original v1 taste-skill, preserved for projects depending on its exact behavior. The current default is `design-taste-frontend` (v2 experimental), which is a substantial rewrite. Use this v1 install name only if you need exact backward compatibility.

Intelligent, safety-first disk space management for developer workstations. Scans and safely removes stale Rust target/, Node node_modules, Python __pycache__, Go module cache, Docker layers, Xcode DerivedData, and Homebrew caches using the dsg CLI. Defaults to dry-run; moves artifacts to system Trash, never rm.

Slash command /entity-audit — run full codebase audit against @prometheus-ags/prometheus-entity-management CLAUDE.md rules: component/store boundaries, hook I/O, registerSchema coverage, JSDoc on public hooks, and realtime/list patterns. Produces a severitized report using references/audit-checklist.md.

Build EntityFormSheet and EntityDetailSheet configurations from FieldDescriptor arrays: field types, enum options, readonly/create/edit flags, custom editControl/render, and wiring to useEntityCRUD buffers and actions.

Scaffold a full CRUD page (list, create, edit, detail, delete) using useEntityCRUD with EntityTable, EntityDetailSheet, and EntityFormSheet. Enforces Components → Hooks → Stores: page composes only; useXxxCRUD hook wraps library CRUD; API module holds fetch/mutations.

Register EntitySchema graphs with registerSchema: belongsTo, hasMany, manyToMany, listKeyPrefix alignment, invalidateTargetLists, globalListKeys, and verification that cascadeInvalidation matches list query keys.

Build EntityTable views with column helpers (textColumn, numberColumn, enumColumn, etc.), SortHeader, selectionColumn, and meta.entityMeta for filters; sync sorting and search with useEntityView via UseEntityViewResult.

Slash command /entity-gc — design application-level eviction for @prometheus-ags/prometheus-entity-management: removeEntity for stale entities, clearPatch for UI overlays, list refresh after bulk delete, route-based cleanup, and policies for long-lived sessions. Notes library has no automatic GC yet.

Slash command /entity-gql-hooks — produce typed useGQLEntity, useGQLList, useGQLMutation wrappers for concrete GraphQL documents; wire queryKey, getItems, getPagination, sideDescriptors, and invalidateLists for @prometheus-ags/prometheus-entity-management.

Slash command /entity-gql-setup — scaffold createGQLClient (GQLClientConfig), authentication headers, and EntityDescriptor sets from GraphQL SDL or introspection. Aligns paths and extractId with normalizeGQLResponse behavior in `@prometheus-ags/prometheus-entity-management`.

Slash command /entity-gql-subscription — connect GraphQL subscriptions via graphql-ws (or compatible) to either GQLClient.subscribe/useGQLSubscription with EntityDescriptors, or createGraphQLSubscriptionAdapter + RealtimeManager for coalesced ChangeSet delivery.

Generate complete CRUD screens for any entity type using @prometheus-ags/prometheus-entity-management hooks and UI components. Analyzes entity shape, produces column definitions (TanStack Table + entityMeta), FieldDescriptor-based forms, EntityDetailSheet / EntityFormSheet wiring, and registerSchema + cascade invalidation—all strictly following Components → Hooks → Stores → APIs data flow.

Static analysis pass to infer EntityType definitions, id fields, and relation hints from TypeScript, Prisma, GraphQL SDL, OpenAPI, and API routes—outputs entity_manifest JSON aligned with shared schemas.