Kind: skill

Use when implementing all features within a single page using outside-in TDD. Writes failing page tests first, then per-feature failing tests, implements until green. Uses Storybook page compositions as UI starting point if available. TDD Guard enforces red-green discipline.

Use when a sidecar manifest under ~/.skaile/sources/ needs its `requires:` graph filled in or refined. Scans asset bodies, manifest references, and code imports across the source; runs an LLM batch over the corpus to propose cross-asset requires-edges; writes proposals to a draft commit on a `deps-analysis-<timestamp>` branch for review. Trigger when the user says 'analyze deps for sidecar X', 'fill in the requires-graph', 'find missing dependencies in my sidecar', or asks how to extract cross-asset references automatically.

Use when you need to convert documents (PDF, DOCX, etc.), perform OCR, export images, transcribe audio, or extract structured data using the local docling CLI tool.

Use when you need to research topics or answer complex questions by querying Perplexity via the OpenRouter API.

Use after the datamodel is finalized and Storybook stories still use placeholder types (PostXL projects only). Replaces mocked types with schema-generated TypeScript interfaces from model.json and ensures the Storybook project compiles.

Use when features are approved but _concept/blueprint/datamodel/ is empty. Produces model.dbml (DBML), model.json (editor canvas), seed.json (test scenarios), and feature_map.json (model-to-feature cross-reference).

Use after completing an implementation step to verify and update Starlight documentation. Detects git-changed files, resolves which doc pages cover them via _sources frontmatter, checks accuracy, and rewrites stale sections. Run automatically at the end of implement-feature, scaffold, foundation, infrastructure, or any coding step.

Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction.

Use when you need to implement UnaUI (@una-ui/nuxt) in Nuxt 3/4 — N* component usage, color tokens, slot patterns, UnoCSS-driven theming, and UnaUI module configuration.

Designs and implements small, focused, agent-friendly CLI tools using uv and Typer. Use when you need to wrap a capability as a command-line interface instead of an MCP server, so that LLM agents can invoke it via shell commands.

This skill encodes Emil Kowalski's philosophy on UI polish, component design, animation decisions, and the invisible details that make software feel great.

[skaile-development] Monorepo-aware code quality audit for the skaile-dev codebase. Verifies build (lint + typecheck + build) and tests pass, then dispatches three parallel sub-agents for logic, security, and UI/UX findings. Three scopes: diff (staged or last-commit), package (one package deep), full (whole monorepo). Produces _devlog/reports/audit-<date>.json. Use before opening a PR or cutting a release.

Use when an implementation slice has its concept artifacts (feature.md + screens) frozen and needs a grill-me interview to surface unstated assumptions, technical constraints, and edge cases before plan-vertical writes the slice plan. Reads _concept/product-spec/features/<group>/<feature_slug>.md + _slice/impl/<id>/brainstorm.md (if standard/complex tier). Writes _slice/impl/<id>/align.md. Triggers on: 'align this slice', 'grill me on the implementation', 'lock down impl assumptions', 'pre-plan grill'.

Use when starting per-slice implementation work for a feature in a standard-app or complex-app tier project. Sparring partner on risks, unknowns, dependencies for THIS feature only. Reads _concept/_meta/scope.yaml + _concept/product-spec/features/<group>/<feature_slug>.md and writes _slice/impl/<slice_id>/brainstorm.md for impl-plan-align to consume. Triggers on: 'brainstorm the implementation of <feature>', 'risks before we plan this feature', 'pre-plan brainstorm for the slice'.

Understand an unfamiliar codebase. Map directory structure, identify entry points, trace data flow, locate where a feature is implemented. Use when the user asks "how does X work", "where is Y defined", or "what does this project do".

Set up and generate integration tests for any skaile-dev package. Covers API routes, DB operations, and cross-module flows. Knows the storage backends: SQLite + drizzle for forge apps, PostgreSQL + Prisma for platform/backend, temp-dir state for agent-framework. Scaffolds test DB isolation (in-memory SQLite / ephemeral test DB / temp workspaces), auth helpers, seed fixtures, then generates tests. Verifies tests run.

Use when you need to create a podcast script from the output of the knowledge-paper-research skill.

Use before e2e testing or after significant code changes to run a static audit. Launches three parallel sub-agents for logic errors, UI/UX issues, and security concerns, and checks _concept/ structure integrity.

Use when you need to convert markdown speaker dialogue and text into audio using the ElevenLabs API. Includes support for single voice TTS and multi-voice conversational dialogues.

Emit typed UI components into the chat stream using the Agent UI Protocol

Use when you need to search for programming library documentation or fetch up-to-date code examples via the Context7 REST API. Provides direct CLI access to Context7 without requiring the MCP server — search libraries by name and retrieve markdown documentation with code examples. Use when the user asks about library APIs, how to use a package, or needs current documentation for a specific library version.

Use when a pipeline checkpoint is reached (after scaffold, after each feature group, or before release) to evaluate code quality. Verifies build, then dispatches three parallel sub-agents for logic errors, security, and UI/UX concerns. Three scopes: scaffold / feature / full. Produces _implementation/eval-code.json.

Autonomous multi-agent skill for writing professional medical textbooks in child and adolescent psychiatry. Simulates a 5-agent team (Architect, Researcher, Pedagogue, Writer, Critic) to produce evidence-based, guideline-grounded content using a layered file architecture. Concept, research, scaffolds, and prose are stored in separate files. Triggers: "Write a book about...", "Start a book...", "/start_book", "/plan_chapter", "/write_chapter".

Use when starting per-feature concept work for a standard-app or complex-app — sparring partner that surfaces the user's mental model for THIS one feature (who uses it, what triggers it, the happy path, what's clearly out). Strictly open-ended — edge-case grilling is the next phase (concept-slice-align). Triggers on: 'brainstorm this feature', 'design a new feature', 'concept-slice start', 'feature kickoff'.

Use when concept-slice-scope-feature has completed and you need to commit THIS feature's permanent _concept/ artifacts — the feature spec, all required screen specs, and the per-feature mockup-walkthrough stub. The only writer of permanent _concept/ artifacts in the concept-slice cluster. Deletes _slice/concept/<id>/ on success. Triggers on: 'design this feature', 'commit slice artifacts', 'design-feature'.

[skaile-development] End-to-end work-item orchestrator for the Skaile platform. Drives any single work item — bug, feature, UI fix, chore, or issue — from 'just reported' to 'PR is open' in one flow: isolated worktree + branch, files the item at platform/issues/<ID>.md (status=testing, owner=current git user, bumps nextIds in categories.yaml), investigates, writes an uncommitted plan, dispatches a fresh agent to implement, dispatches a fresh agent to review, fixes valid review concerns, cleans up the plan, commits + pushes the branch, removes the worktree, opens a PR into main, and reports the PR link. Use when the user reports a platform bug, requests a small feature, asks for a UI fix or chore, and wants the whole cycle done in one shot.

Team notifications and messaging for skaile-dev. Supports free-form Mattermost messages plus structured templates for plans, breaking changes, releases, and devlog summaries.

[skaile-development] Scaffold a new dynamic web component for the Agent App Protocol. Generates COMPONENT.md, web component JS, agent-usage.md, and test harness in the components directory.

Use when all features are implemented and you need full end-to-end browser testing. Reads screen specs, features, and data model from _concept/, then uses agent-browser to test every user journey, take screenshots, and validate database records.

Integrated deep research skill that collects documents from multiple sources, stores them in organized folders, and synthesizes findings into a comprehensive research report with citations.

Maintains the human-readable _devlog for the skaile-dev monorepo. Writes short plain-language entries to _devlog/DEVLOG.md after every meaningful change. Generates detailed reports in _devlog/reports/ when architectural concepts, shared contracts, or core patterns change. Run after completing any implementation work.

Use when a slice has been recapped and refactored and is ready to land. Verifies all 3 predecessor handoffs (test, recap, refactor), inventories the working tree, decomposes into 1-N atomic commits with user approval, lands the commits, and deletes _slice/impl/<id>/ scratch on success. Does NOT replace impl-slice-git-prepare (project setup) or impl-slice-finish (branch closeout).

[skaile-development] Reviews the current Claude Code implementation session for the skaile-dev monorepo: reads the session JSONL to report token usage, cache efficiency, estimated cost, and workflow adherence against the skaile-development skill sequence. Outputs optimization tips and skillset improvement suggestions. Run at the end of any implementation session.

Use when starting a new concept pipeline and project identity, tier, and technology decisions have not been captured yet. Collects these through structured dialog and produces profile.yaml and decisions.yaml in _grounding/onboarding/.

Cross-document reference repair across the skaile-dev monorepo. Scans README ↔ CLAUDE.md ↔ docs/<pkg>/ ↔ DOMAIN.md ↔ monorepo CLAUDE.md and finds broken links, missing back-references, orphan Starlight pages, stale _sources frontmatter, and drift between the monorepo domain table and actual ai-assets/*/DOMAIN.md files. Shows a complete diff of proposed changes before applying — non-destructive.

Changelog management, semantic versioning, and git tagging for skaile-dev domains and packages. Three modes: status (show current version + unreleased changes), bump (update version + CHANGELOG.md), tag (create annotated git tag).

Use when writing new documentation, updating stale docs, auditing for gaps, or checking documentation status in the skaile-dev monorepo. Covers all five doc tiers: README.md, CLAUDE.md, Starlight docs, DOMAIN.md/SKILL.md, and _devlog.

Use when grounding decisions in real-world data — competitor analysis, audience research, design inspiration, behavioral patterns, color/font research. Research is a MODE that runs in parallel with other steps, not a sequential pipeline step.

Use after concept-grounding-onboard when the user has provided existing material in _seeds/. Scans and auto-classifies each file by content analysis, maps files to artifact slots, validates against schemas, and updates concept.yaml with seed statuses.

Use when a slice has passed the per-slice test gate and needs the mandatory recap step. Produces a 1-3 sentence 'what was built' summary, an ASCII diagram of the feature flow (mandatory), a Files-touched list, and an Outcome-vs-plan comparison. Skipping this step loses decision authority over multi-slice features.

Use when a slice has been recapped and you need a forced-simplification pass. Proposes 1-3 SMALLEST-IMPROVEMENT candidates that preserve behavior — only subtractions, simplifications, clarifications, never additions. Asks user to approve before any code edit. May exit with no edits if user declines or no candidate qualifies.

Use when an agent needs to read, modify, or inspect .xlsx / .xlsm / .xls workbooks. Wraps the Excel MCP stdio server (Java / Apache POI) exposing 26 tools across workbook lifecycle, range I/O, sheet management, row/column mutation, tables, named ranges, and read-only VBA module extraction. Every cell read surfaces type, value, and (if present) typed formula — so the agent can distinguish a stale cached value from a real one.

Search, read, and manage Outline wiki documents. Use when: (1) searching wiki for documentation, (2) reading wiki pages or articles, (3) listing wiki collections or documents, (4) creating or updating wiki content, (5) exporting documents as markdown. Works with any Outline wiki instance (self-hosted or cloud).

Build slide decks using Reveal.js in Skaile's brand design. Produces an index.html + skaile-theme.css that renders as a dark-themed, gradient-accented presentation with Plus Jakarta Sans / Inter / JetBrains Mono typography.

Use when you need to search the internet for current information, research topics, find news, or look up web content. Queries a local SearXNG instance with Google as the primary search engine and returns clean, structured markdown results.

Build slide decks using Slidev (sli.dev) in Skaile's brand design. Produces a slides.md + style.css that renders as a dark-themed, gradient-accented presentation with Plus Jakarta Sans / Inter / JetBrains Mono typography.

Use when a slice's implement step has finished and you need a per-slice usability gate before proceeding to recap. Runs manual checks + automated tests from plan.md ## Testing strategy, captures user usability observations, emits a Done/NeedsMoreWork/Blocked decision. NOT a project-wide regression suite — for that, use impl-quality/test-{unit,integration,e2e}.

[skaile-development] Evaluates resolved questions about the skaile-dev monorepo for FAQ-worthiness and curates entries. Broadened to all monorepo packages.

Scaffolds and implements GitAgent definitions (agent.yaml + SOUL.md + RULES.md). Use when you need to create a new AI agent identity with model configuration, delegation rules, and composable sub-agents. Supports domain agents (ai-assets), local project agents (.claude/agents, .omp/agents), and global agents.

Use when you need to browse, search, install, or deploy skills and agents from the ai-assets catalog. Wraps the `skaile` CLI for discovering what is available, resolving dependencies, and deploying assets to agent config directories.

Use after screens are approved to generate a 3-layer Storybook project: custom building-block components, full-page screen compositions, and clickable user journey flows. Framework-agnostic — resolves addon and story format from impl-architecture/profiles/. Delegates to 4 sub-skills in sequence.

Use when you need to implement or configure UnoCSS in Nuxt 3/4 projects — presets (wind4, icons, attributify, typography), uno.config.ts theming, dark mode, safelist, layers, and UnoCSS module integration.

Use when the project brief is approved but no visual brand exists. Discovers aesthetic direction through plain-language questions, extracts palettes from reference URLs, and writes identity.md + tokens.json + brandbook.html to _concept/discovery/brand/.

Write, edit, refactor, debug, and explain code in any language. Read files before modifying them. Propose minimal diffs. Enforce security best practices. Use when the user asks to write, fix, improve, or understand source code.

Set up and generate unit tests for any skaile-dev package (forge apps, agent-framework libraries, platform frontend/backend). Reads TEST_PLAN.md when present, otherwise discovers testable units from source. Scaffolds missing test infra (vitest.config.ts, test harness), then generates one test file per module with test cases mapped to CLAUDE.md Architecture. Verifies tests run before completing.

Use when features are approved and user wants to formalize behavioral rules, state machines, or entity lifecycle. Also when user says 'behavioral specs', 'state machine', 'formalize rules', 'allium specs'.

Use when features are approved and you need per-screen specifications. Produces grouped screen docs; registers back into feature frontmatter via feedback loop.

Use when screen specs are approved and building-block component stories are needed. Sub-skill 2/4: identifies custom components from specs, builds them using the project's component library, and creates their Storybook stories. Called by mockup-component-storybook-orchestrator.

Technical variant of the screens skill with component inventories. Use when screen specs exist and require precise component-level breakdowns. NOT in pipeline — experimental variant for testing purposes.

Use when screen specs exist and you need to identify shared UI patterns (data tables, forms, cards, navigation) across screens. Maps components to the tech stack's component library. Outputs to _concept/experience/screens/components/.

Use when you need to create a new skill domain — a named folder grouping related skills, agents, prompts, and tools under a shared contract. Scaffolds the full domain folder structure, writes a DOMAIN.md describing purpose and building blocks, and creates an empty <domain>-contract skill.

Use when stakeholders need a clickable Astro walkthrough of the application — built static site, Tailwind-styled, openable directly in a browser. Generates one HTML file per screen and per journey, plus a manifest.json that the mockup-feedback cluster reads. Best for standard-app tier.

Run or extend the Skaile platform e2e suite. Two modes: `run` executes the existing suite with pre-flight checks (stale-service guard for post-pull stale bundles, stale-deps guard for lockfile drift, seed sync, proxy slot health), failure-mode diagnosis, and auto-recovery (kill stale skaile-serve subprocesses, sync seed data, restart stuck proxy slots); `add` analyzes a git diff, proposes a test plan, waits for explicit user approval, lives-inspects the UI via chrome-devtools MCP, then writes new specs against the existing `platform/e2e/` harness. Use when the user says "run e2e tests", "fix e2e failures", "add e2e coverage for <feature>", "write e2e tests for my PR", or similar.

Use after features and techstack are approved to document system architecture. Produces architecture.md with system overview, backend structure, data flow, communication protocols, external integrations, and infrastructure.

Use when building-block components are ready and full-page screen compositions are needed. Sub-skill 3/4: builds AppShell and page stories from screen specs with all state variants and responsive viewports; writes manifest.json for the journeys sub-skill. Called by mockup-component-storybook-orchestrator.

The morning startup ritual for skaile-dev — opens with a cheeky "what did Peter do last night" investigation of the repo state, syncs the shell repo + submodules (reattaching any that landed detached at origin/main), reinstalls workspace deps, and builds the platform backend so frontend + backend are ready to start. Does NOT launch dev servers — Peter starts those himself. Use when Peter says "good morning", "/good-morning", "let's start the day", "fire up the platform", "boot me up", or any other morning kick-off phrase.

Use when the project brief exists and tech stack hasn't been chosen. Discovers available stacks from impl-architecture/profiles/, asks plain-language questions, recommends the best match, and writes stack.md.

Use when you need to extract metadata (title, authors, abstract) and references from scientific PDF papers or book chapters.

Use when you need to use when you need to implement advanced primevue 4 features in nuxt 3, including design tokens, forms, and custom theming.. Expert-level programming and pattern management.

Use when no Storybook project exists yet and one needs to be scaffolded for mockup work. Sub-skill 1/4: scaffolds a standalone Storybook project, installs dependencies, and applies brand tokens as CSS custom properties. Called by mockup-component-storybook-orchestrator.

Use when adding a new feature or modifying an existing feature in a live concept. Surgically adds the feature spec, cascades changes through downstream artifacts (journeys, tech stack, architecture, data model, screens), and optionally triggers implementation if the app is already built.

Use when you need to expert-level nuxt development. Expert-level programming and pattern management.

Use after scaffold and before feature implementation to apply the three foundational layers every app needs: brand tokens → CSS variables, authentication setup, and app shell layout. Also seeds initial data and configures Storybook with brand theme if present.

Use when the project uses the PostXL tech stack and you need to regenerate code or resolve merge conflicts after a schema change or custom action addition. Runs generators from postxl-schema.json, auto-resolves conflicts via a four-level cascade, and verifies the build.

[skaile-development] Code review for staged or committed changes in the skaile-dev monorepo. Checks quality, security, performance, scope, and repo-specific rules. Works locally without CI - designed for direct-to-main workflows.

Use when architecture.md defines custom_modules or processes beyond the standard stack. Sets up custom NestJS/backend modules, provider abstractions (real + in-memory), additional processes, and communication infrastructure (WebSocket, SSE).

Use after the data model is finalized and before feature implementation to generate database migration files. Reads model.dbml + model.json and stack.md and produces migration files for the target ORM (Prisma, Drizzle, Directus, raw SQL).

Git operations for the skaile-dev monorepo. Seven modes: commit (structured commit messages), branch (create/switch feature branches), worktree (parallel work in isolated checkouts), pr (open a pull request), finish (merge/PR/keep/discard branch), sync (two-way sync: pull + push shell repo and all submodules, print per-repo summary of commits pulled and pushed), deploy (merge main into deploy branch and push).

Use when a concept is complete and no project directory exists yet. Reads stack.md, uses the stack profile for scaffold commands and conventions, creates the directory structure, initializes git, and sets up _implementation/ tracking. Run before foundation and feature implementation.

Use after migrate to generate executable seed scripts from seed.json. Covers all seed scenarios (empty, single_user, populated, edge_cases); each is independently runnable against the target stack (Prisma, Drizzle, raw SQL, etc.).

Use when an implementation slice has its align.md (or, for mvp, its feature.md) ready and needs a vertical-decomposition plan. Reads _slice/impl/<id>/align.md + concept artifacts. Writes _slice/impl/<id>/plan.md containing one row per user-facing slice (UI + Logic + Data), testing strategy, and an anti-horizontal-nudge block. Resists the LLM default of horizontal layering. Triggers on: 'plan the slice', 'decompose into rows', 'write the per-slice implementation plan', 'plan-vertical for <feature>'.

Use before implementation begins to verify concept completeness and clarity. Independent adversarial review of _concept/ artifacts: checks every feature has acceptance criteria, screen specs, data model coverage, and a clear brief. Gate: pre-impl.

Monorepo-aware implementation orchestrator for the skaile-dev codebase. Reads the affected package CLAUDE.md files, identifies the tech stack, routes to the right prog-experts, produces a plan, executes with supervised dispatch, then triggers test, doc, and devlog on completion. Use for any non-trivial change to the skaile-dev monorepo.

Use when a superpowers plan exists and you want supervised subagent-driven implementation. Dispatches one subagent per task, enforces spec-compliance review before code-quality review, handles 4-status reports (DONE / DONE_WITH_CONCERNS / NEEDS_CONTEXT / BLOCKED), and manages escalation. Primary orchestrator in the impl-plan domain.

Use when the user is stuck on a bug and wants to hand off to a fresh agent (or themselves after /clear). Produces a self-contained markdown summary — bug description, attempts so far, current hypothesis, suggested next steps — pasteable into a new chat with no prior context.

Use when the user is stuck on a bug and wants the AI to autonomously verify whether a fix worked. Produces a self-runnable verification protocol (test commands + expected outputs + success criteria) the AI executes without user-as-test-loop.

Use after all feature groups pass eval-feature as the final gate before release. Grades the complete application against original brief goals on quality, originality, craft, functionality, performance, accessibility, and mobile. Gate: release.

Use when you need to search the web or find code examples using Exa's AI-powered search. Queries Exa's public MCP endpoint with JSON-RPC — no API key required for basic web search and code search.

Use before E2E testing to verify all features are complete enough to test. Checks each feature for concept doc, screen spec, data model entry, brand tokens, and tech stack; surfaces gaps with remediation commands.

Use when pushing proven project standards back to profiles, or syncing profile standards into a project. Triggered by 'sync standards', 'update profile conventions', or 'push standards to profile'.

[skaile-development] Debug a recently failed Skaile deployment on Jenkins. Defaults to the `skaile_platform` job; pass `target=store` to debug the `skaile_store` job instead. Reads the job over the local SSH tunnel (http://localhost:8090, anonymous read), finds the relevant build (last failed by default, or current/explicit), extracts the failure region from the console log, cross-references recent commits in skaile-dev around the build timestamp, and reports a structured summary with a fix hypothesis. Use when the user says "why did the deploy fail", "debug the jenkins failure", "what broke on jenkins", "the platform deploy is red", "the store deploy is red", "check the last platform-deploy", or otherwise asks about a Jenkins deployment failure.

Use when analyzing an existing codebase to extract conventions, patterns, and standards. Triggered when user says 'discover standards', 'analyze codebase conventions', or when starting implementation against an existing project.

Use before dispatching a skill to load applicable codebase standards. Called by orchestrator or as first step in standalone skill execution. Reads _concept/_standards/index.yml and returns matched standards.

Use when you need integration tests that verify API endpoints, data flow, and cross-feature interactions against a real database. Reads feature specs and data model to generate tests covering the full request-response cycle.

Use when ending an implementation branch after all per-slice work is committed. Presents four options: merge to main, create pull request, keep branch, or discard. Requires explicit confirmation for merge and discard. Refuses if any _slice/impl/<id>/ scratch dirs remain (those signal uncommitted slices).

Use when you need to generate long form podcast content from documents using a sophisticated multi-agent orchestration process.

Use when you need a comprehensive test plan derived from concept specs. Generates test scenarios per feature covering happy paths, error states, edge cases, and permissions, mapped to seed data scenarios.

Use when you need unit test files generated from feature specs. Reads existing source code patterns and feature requirements, then produces one test file per feature with test cases mapped to requirements.

Use when no git repo exists or no implementation branch exists before starting a supervised implementation run. Initializes git if needed, creates the implementation branch, and optionally sets up a git worktree (Claude Code / local mode only).

Use when implementing a single slice planned by impl-plan/plan-vertical. Reads _slice/impl/<slice_id>/plan.md, walks the vertical decomposition (UI + logic + data), writes failing tests first, implements with TDD Guard, persists per-slice progress to _slice/impl/<slice_id>/progress.json. Resumes interrupted runs from progress.json.

Use when a walkthrough site is ready and you need stakeholders to annotate it. Injects the annotation overlay so stakeholders can click elements and submit comments; produces _concept/_feedback/sessions/ for storage. First skill in the mockup-feedback cluster.

Use when you need to analyze a user request and find the appropriate prog-expert-* skill from the programming-* directories (e.g. programming-js, programming-python), or when you need to store new implementation knowledge and need to know which expert should learn it.

Use when patches for a feedback session are reviewed and ready to land. Applies approved section-anchored diffs to _concept/ files, appends devlog, writes applied/<sid>.json, and creates one git commit. Fourth and final skill in the mockup-feedback cluster.

Use when a triage file exists for a feedback session and you need to author diffs for each annotation. Produces patches/<sid>.json + patches/<sid>.review.md (LLM for change; templated for add/remove/question). Third skill in the mockup-feedback cluster.

Use when Storybook pages are built and clickable multi-screen journey stories are needed. Sub-skill 4/4: builds click-dummy journeys (hero, vital, hygiene) from stories.json, flowing through real page components inside AppShell. Called by mockup-component-storybook-orchestrator.

Use when building a multi-product meta-concept and the integration section is missing. Generates 3_integration/ covering inter-repo architecture, deployment topology, and shared contracts for the ecosystem.

Use after each feature group is implemented to verify the running app matches specs. Independent browser-based adversarial review: simulates user journeys, assumes something is broken. Gate: per-feature.

Use when a multi-product meta-concept needs a quality check. Audits for completeness, consistency, and accuracy — verifies all subsystems are documented, references are valid, maturity levels are honest, and no detail is duplicated from subsystem concepts.

Use when building a multi-product meta-concept and the subsystem index is missing. Generates 2_subsystems/ with maturity, audience, tech stack, and references to per-subsystem concepts for each product.

Use when starting a multi-product meta-concept and the discovery section does not exist yet. Generates discovery/ covering ecosystem brief, unified goals, and competitive positioning.

Search, read, and manage Outline wiki documents. Use when: (1) searching wiki for documentation, (2) reading wiki pages or articles, (3) listing wiki collections or documents, (4) creating or updating wiki content, (5) exporting documents as markdown. Works with any Outline wiki instance (self-hosted or cloud).

Use when the user has an existing project repository and wants to generate or bootstrap a _concept/ folder from it. Triggered by: 'reverse engineer this project', 'generate concept from existing code', 'I have a codebase, extract the concept', 'document this existing app', 'build concept from repo'.

Use when cross-references in _concept/ are broken or out of sync. Scans the entire concept folder, finds broken links, missing bidirectional references, and orphaned entities, then shows a diff before applying fixes.

Use when you need to set up, develop, or integrate Directus into your project, especially with Docker and Nuxt 3. Triggers include "setup directus with docker", "configure directus local development", "generate directus types", "integrate directus with nuxt", or "authenticate with directus sdk".

Use when stakeholders need a clickable static HTML walkthrough of the application — zero build, no JS framework, openable directly in a browser. Generates one HTML file per screen and per journey, plus a manifest.json that the mockup-feedback cluster reads to resolve clicks back to source artefacts. Best for simple-app tier.

Use when the user starts a new project and no _concept/_meta/scope.yaml exists yet, or when re-scoping (--tier= override). Picks one of mvp / simple-app / standard-app / complex-app from a one-sentence project description and writes _concept/_meta/scope.yaml. First action in the skaileup pipeline; gates which flow runs next.

Use when starting or resuming the full concept pipeline for a new product. Runs Discovery → Experience → Blueprint with checkpoint approvals, PLANS.md tracking, and auto-review mode; dispatches sub-skills for each step.

Use when you need to create, configure, or manage GitAgent-compatible agent definitions (agent.yaml, SOUL.md, RULES.md, SKILL.md). Expert-level programming and pattern management for the GitAgent open standard (spec v0.1.0).

Use when you need to create, edit, or debug Marimo reactive Python notebooks, including cell structure, reactivity rules, output display, and the Lint-Export-Assert test protocol. Expert-level programming and pattern management.

Compiles MUST/NEVER/CHECKLIST rules from skaile-development SKILL.md files into fast, deterministic Python validators. Generates a validator.py alongside each SKILL.md. Replaces slow LLM-based validation with sub-second structural checks. Run after editing any skill in ai-assets/skaile-development/skills/.

Use when integrating LLM agent sidecars (omp RPC) into a web frontend. Covers the Typed Action Protocol: SkillAction/ConsumerResponse bidirectional events, skill state machine, adapter layer, structured input/approval flows, API key resolution, and default model selection. Expert-level programming and pattern management.

Use when you need to work with omp (pi-coding-agent), including RPC mode integration, skill authoring, extension development, agent embedding, and CLI configuration. Expert-level programming and pattern management.

Use when all changes for a task are committed on a feature branch and you are ready to open a GitHub pull request for human review.

Use when you need to implement Python 3.12+ patterns, uv workspace monorepo management, async Python, decorator patterns, pytest/mock testing, ruff/mypy configuration, Rich CLI output, pydantic-settings config, and Protocol-based interface design. Expert-level programming and pattern management.

Read, write, create, and delete files within the project workspace. List directory trees. All operations are scoped to the active project workspace. Use when the user wants to open, save, browse, or manage project files.

Use when you need to implement pydantic-ai Agent API patterns including structured outputs with result_type, message history, OpenAI/Gemini model backends, async streaming with run_stream(), and multi-provider integration. Expert-level programming and pattern management.

[skaile-development] Use when building, modifying, or extending a PostXL-generated app inside skaile-dev — `platform/backend`, `platform/frontend`, and (in progress) `store/backend`. Covers schema authoring (`postxl-schema.json`, `schema/*.model.json`, `schema/*.enum.json`), the regenerate workflow (`bun run generate` → `pxl generate` + `tsr generate`), the three modes for code changes (schema edit / custom blocks / new module), `postxl-lock.json` and ejection semantics, the dual backend+frontend verify loop, the `pxl doctor`/`status`/`info` toolkit, and the `@postxl/ui-components` primitives. Activates whenever you see `postxl-schema.json`, `postxl-lock.json`, `generate.ts`, or `// @custom-start` markers, or when the user mentions PostXL, regenerate, eject, or custom block.

Use when you need to implement shadcn-vue (shadcn-nuxt) in Nuxt 3/4 — component registry via components.json, Tailwind CSS v4 with @tailwindcss/vite, class-variance-authority, tailwind-merge, and auto-imported shadcn components.

Use when you have completed significant work and need to post a structured progress update or completion summary to the Mattermost thread that initiated this session.

Use when you need to use when you need to implement advanced tiptap editors in nuxt 3, including collaboration, custom node views, and context menus.. Expert-level programming and pattern management.

Pre-release readiness gate for the skaile-dev monorepo. Verifies every package has README + CLAUDE.md with required sections, tests passing, build clean, typecheck clean, CHANGELOG present, and Starlight registration for packages with docs/. Produces a blocker/warning table and exits non-zero on any hard failure. Called by release as Phase 0.

Use when you need to implement TTS (text-to-speech) or STT (speech-to-text) integrations in Nuxt 3/Nitro applications, including Deepgram streaming STT via WebSocket, ElevenLabs TTS, browser MediaRecorder, and audio settings management. Expert-level programming and pattern management.

Generates a per-package test plan for any skaile-dev package. Reads CLAUDE.md (architecture, public API), the source tree, and existing tests; produces <package>/TEST_PLAN.md listing untested units, coverage gaps, integration seams, and recommended scenarios per layer (unit/integration/e2e). Used as the input for test-unit, test-integration, and test-e2e.

Given a scientific paper (PDF or Markdown), run a full structured-knowledge extraction and web-research pipeline. Produces one metadata file next to the paper and a dedicated <stem>_research/ folder containing four thematic research files plus one per-author profile file (prefixed author_). Use whenever you need to deeply understand a paper, prepare a research briefing, or enrich a paper's content with external context.

Use when you need to implement VueUse composables in Nuxt 3, including auto-import configuration, composable selection, conflict handling with Nuxt built-ins, and reactive browser/state/DOM utilities. Expert-level programming and pattern management.

Use when you need to implement a typst template from an image or pdf reference iteratively. Expert-level programming and pattern management.

[skaile-development] Umbrella quality-gate orchestrator for the skaile-dev monorepo. Runs typecheck → test (with coverage + ratchet when the mode requires it) → audit → doc-audit → ready in sequence, early-outing on the first hard failure. Produces a consolidated health snapshot that contributors look at before opening a PR and release uses as its pre-flight check. Supports quick (diff-scoped), package (one package deep), and full (whole monorepo, mirrors test-full.yml CI lane) modes.

Use when a feedback session JSON exists and annotations need to be routed to their target concept files. Resolves specRef.screen/feature/journey and produces triage/<sid>.json grouped by file. Deterministic — no LLM. Second skill in the mockup-feedback cluster.

Use when screen specs are approved and user wants interactive HTML mockups. Also when user says 'mockup', 'prototype', 'show me what it looks like'. Generates a linked multi-page prototype. Supports 3 stacks: Alpine.js+Shoelace, Vue 3+PrimeVue, Preact+HTM. Auto-selects stack template from tech-stack profile if stack.md exists.

Use when starting a new concept and no _concept/discovery/ exists, or when the user says 'I have an app idea', 'new project', 'start from scratch', or wants to redefine an existing brief.

Use when concept-slice-align has completed and you need to draw the IN/OUT line for THIS feature — reads align's edge-case list, forces an IN/OUT/DEFER decision on each item, and produces the final scope decision that concept-slice-design-feature honors. Triggers on: 'scope this feature', 'what's in vs out', 'lock the boundary'.

Use when concept-slice-brainstorm has completed (or as the entry point for simple-app) and you need to grill the user about THIS feature — surfaces edge cases, unstated rules, error states, role/permission gaps, and produces EARS-format acceptance criteria. Inverts the brainstorm: now the AI asks pointed questions, the user defends their assumptions. Triggers on: 'align this feature', 'grill me on edge cases', 'lock down acceptance criteria'.

Use when _concept/ needs a quality check or housekeeping pass. In audit mode: scans completeness, cross-reference integrity, golden principle compliance, and entropy; produces quality.json with score. In gardening mode: auto-fixes safe issues and reports what changed.

Use when the visual brand exists and you need to define communication tone, error message style, empty state messaging, micro-copy guidelines, and notification voice. Produces behavioral.md + copy_guidelines.md in _concept/discovery/brand/.

Use after project brief is approved to map user journeys. Reads the approved brief, goals, and optional research to define personas and story maps organized by stage (hero, vital, hygiene, backlog). Writes stories.json with EARS acceptance criteria. Required before features skill.

Use after user journeys are approved to plan features. Derives features from stories.json candidate hints and the project brief. Writes feature files organized in numbered groups. Required before screens and datamodel skills.

[skaile-development] Cross-session analysis of Claude Code session data for the skaile-dev monorepo. Reads a pre-computed digest (≤10KB) from the Python pipeline, triages improvement opportunities, reads implicated SKILL.md files, and proposes concrete diffs to reduce token waste and improve workflow adherence. Run after ./run.sh in _scripts/session-analysis/.

Use when concept is complete and you want to build the entire application end-to-end. Drives the full pipeline from scaffold through feature implementation to verified, deployable app; journey-first strategy (hero → vital → hygiene). Supports resume from any interrupted phase.

Test construction and execution for the skaile-dev monorepo. Two modes: 'run' executes the test suite for one or more packages and reports results; 'construct' generates new tests for recently implemented code. Knows the full test stack: Vitest 3.2.4 (agent-framework + forge/L4-project + forge/L4-assistant + _scripts), Vitest 4.1 (forge/L5-concept), Jest (platform backend), Vitest (platform frontend), Playwright (E2E), and how to run each via the Bun workspace. Coverage is collected under Bun with @vitest/coverage-istanbul (not v8) and ratcheted against the committed baseline via _scripts/check-coverage-ratchet.ts.

[skaile-development] Set up and generate end-to-end tests for skaile-dev packages: forge apps, platform/frontend, and the agent-framework CLI. Scaffolds Playwright for web apps (forge + platform) including config, global setup/teardown, sandbox, and fixtures. For CLI packages, generates shell-based end-to-end tests that invoke the bin and assert stdout/artifacts. Verifies tests run against a real dev server or real process.

Use when an agent needs to author, modify, review, render, or export PowerPoint (.pptx / .pptm) decks — create/open/close documents, add/duplicate/delete/reorder slides, edit text (with run/paragraph/shape scope + styling), insert images with picture effects, add/edit tables (incl. merge + per-cell borders), draw shapes (solid/gradient/pattern fills), update chart data in existing charts, render slides to PNG/JPG/SVG at low or high fidelity, and export to PPTX/PDF/HTML/PNG-batch/JPG-batch/SVG-batch/outline-text. Invoke via the `ppt-mcp:dev` Docker MCP server over stdio.

Use when an AI-asset repo author wants to ship a deterministic, author-curated asset inventory in `.skaile-source.yaml`. Walks the repo, builds the `assets:` block via `skaile source build-manifest`, reviews entries with the author (publisher mapping, requires-graph, file filter), computes hashes, and writes the result back. Trigger when the user says 'create a source manifest', 'lock down my asset versions', 'pre-pack my repo for the Catalog', or asks how to publish a repo to skaile.store without admin curation.

Create, review, or update a design spec / proposal for new features, architectural changes, or cross-package work in the skaile-dev monorepo. Use when work is too complex to jump straight into code — the spec captures the problem, design, alternatives, and approval status before implementation begins.

[skaile-development] Use when reasoning about whether and how to build an app idea on the Skaile/PostXL stack -- choosing between platform skills+flows, forge integration tiers, the agent runtime, or PostXL alone. Loads the four context packs (agent framework, ecosystem, platform, PostXL) on demand and routes the question to the relevant doc(s). Trigger when the user asks 'should we build X with Skaile?', 'where in the stack does this fit?', 'platform or standalone app?', 'PostXL or just NestJS?', or any architectural orientation question across the Skaile/PostXL surface.

Use when you need to design, build, or refine LLM agent skill systems with pipeline orchestration, artifact-based gates, cross-references, profiles, and UI integration. Expert-level skill architecture and pattern management.

Analyzes requirements, scaffolds directory structures, and implements new Agent skills. Use when you need to create a new agentic workflow or encapsulate custom tools into a reusable skill. Supports domain folders (ai-assets), local project skill folders (.claude/skills, .agents/skills), and global skill folders (~/.claude/skills).

Use when a user wants to refine a sidecar manifest under ~/.skaile/sources/ for a registered asset source. Walks the sidecar's auto-generated `assets:` block, interviews the user on publisher mapping, version, file filters, requires-graph, then verifies and commits. Trigger when the user says 'refine my sidecar', 'curate the manifest for source X', 'review sidecar assets', or asks how to clean up an auto-generated source manifest.

Visual verification of Skaile platform UI changes using browser automation. After implementing a UI feature, run this skill to systematically check that pages render correctly, navigation works, and key interactive elements are present. Uses agent-browser CLI and chrome-devtools MCP tools.

Cleanly kills the Skaile platform backend and every process in its spawn chain (port 3001 listener, nest start --watch, dotenvx, bun run dev, sh wrappers). Use when the user says "kill the backend", "stop the backend", "free port 3001", "kill bun run dev", "clean up stray backend processes", or wants a clean slate before restarting `bun run dev` in `platform/backend`.

Request a user name via input gate, then write it verbatim to workspace/test/name.txt. Test fixture - not for production.

Count files in workspace/test/ and write the count to a file. Optional node, used to exercise the skip path. Test fixture - not for production.

Read the name from test-ask-name and write a fixed-format greeting file. Test fixture - not for production.

Use when you need to interact with MCP (Model Context Protocol) servers, OpenAPI specs, or GraphQL endpoints via CLI. Converts API schemas into token-efficient CLI commands at runtime without code generation.

Use when discovering, researching, or installing agent skills from the open skills.sh ecosystem. Handles discovery via npx skills find, quality verification, and workspace integration via skaile source add / skaile install.