
TOON format knowledge and usage patterns for agent communication and memory persistence in plan-marshall marketplace
Project configuration wizard for planning system. Manages executor generation, health checks, build systems, and skill domains.
Two-track solution outline creation - Simple Track for localized changes, Complex Track for codebase-wide discovery
Base module providing reusable file operations patterns for workflow scripts
Python domain manifest for plan-marshall workflow integration
Script development standards covering implementation patterns, testing, and output contracts
Manage solution outline documents - standards, examples, validation, and deliverable extraction
Manage references.json files with field-level access and list management
Compose, read, and validate the per-plan execution manifest that drives Phase 5 verification and Phase 6 finalize step selection
Iterative request clarification until confidence threshold reached
Centralized architecture documentation for the plan-marshall bundle with visual diagrams
Unified plan lifecycle management - create, outline, execute, verify, and finalize plans
Language-agnostic testing methodology covering AAA pattern, test structure, organization, coverage, property-based testing, test doubles, and determinism
npm/npx build operations — TypeScript, Jest, ESLint, TAP parsing with workspace discovery, per-file JS coverage analysis, and automatic npm/npx routing
Shared input validation module for plan-marshall scripts — validates plan IDs, file paths, enums, and skill notation
LLM-based architectural analysis that transforms raw project data into meaningful structure
SonarQube/SonarCloud issue workflow - fetch issues, triage, and fix or suppress based on context
Domain-invariant recipe for deliberate wide-scope simplification campaigns across a scope x thoroughness cell, with a T4+ relation-graph pre-deliverable
CI provider abstraction with unified API for GitHub and GitLab operations (PR, issues, CI status)
Analyze and consolidate WebFetch domain permissions across projects with security research and validation
AsciiDoc formatting, validation, link verification, and template creation workflows
Diagnose and fix PR issues (build, reviews, Sonar) — thin wrapper around verification-feedback with producer=pr-state
Persist CI run artifacts (logs + manifest) under the plan directory for offline retrospectives
Foundational agent behavior rules covering user interaction, tool usage, research, dependency management, and document proliferation
Python/pyprojectx build operations — mypy type-checking, ruff linting, pytest with Cobertura coverage, and test-directory-based module discovery
Extension API for domain bundle discovery, module detection, and canonical command generation
Project-level infrastructure configuration for marshal.json
Init phase skill. Creates plan directory, request.md, references, and status. Complete initialization in a single agent call.
GitHub provider for PR review workflows — fetch comments, triage, and respond to review feedback via gh CLI
Build system module discovery consolidating Maven, Gradle, npm, and Python detection
Git commit workflow with conventional commits, artifact cleanup, and optional push
The single shared contract every untrusted-external-content ingestion surface loads — reader/orchestrator/writer isolation, the deterministic validator script as the containment boundary, and the output-schema discipline for candidate structs parsed from web pages, GitHub issue/PR/comment bodies, and Sonar issue messages
Complete plan execution with git workflow and PR management
Shared workflow steps and verification knowledge for plugin development outline, loaded by phase-3-outline skill
Plan-marshall-domain implementor of the ext-self-review-{domain} extension point. Surfaces deterministic candidates (regexes, user-facing strings, markdown sections, symmetric-pair functions, flag-guard pairs, contract sources, schema-bearing files) for pre-submission structural self-review.
Plugin development domain manifest with module discovery for plan-marshall workflow integration
Generic file I/O operations for plan directories
Domain-agnostic task planning from deliverables with skill resolution and optimization
Unified logging infrastructure for script execution, work progress, and decision tracking
Scans and reports complete marketplace inventory (bundles, agents, commands, skills, scripts)
Opt-in plan quality audit — analyzes artifacts, logs, metrics, chat, and invariants; compiles report and seeds lessons
Implement plugin tasks from plan with step iteration and progress tracking
Platform abstraction layer routing operations to Claude Code or OpenCode implementations
Universal script execution pattern via execute-script.py proxy
Recipe for enforcing CUI logging standards across all modules — migrate loggers, implement LogRecords, add test coverage
Diagnose and fix quality issues in marketplace components with automated safe fixes and prompted risky fixes
Manage request documents within plan directories with schema validation and template-based creation
Plan-marshall-domain implementor of the ext-self-review-{domain} extension point. Surfaces deterministic candidates (regexes, user-facing strings, markdown sections, symmetric-pair functions, flag-guard pairs, contract sources, schema-bearing files) for pre-submission structural self-review.
Provider management for external tool authentication — secure storage, interactive configuration, and REST client infrastructure
Diagnose plan artifacts (TASK-*.json) for unresolved lesson-ID references and other plan-level data integrity defects
Gradle build operations — Java/Kotlin builds with JaCoCo coverage, quality task detection, multi-project discovery, and OpenRewrite markers
GitLab provider for MR review workflows — fetch comments, triage, and respond to review feedback via glab CLI
Maven build profile classification and user workflow for unmatched profiles
Diagnose permission issues across settings files (read-only analysis)
Manage Architectural Decision Records (ADRs) with CRUD operations, automatic numbering, and AsciiDoc formatting
Domain-invariant recipe for converting a single lesson-learned into a slim, deterministic plan with surgical-style cascades
Manage Interface specifications with CRUD operations, automatic numbering, and AsciiDoc formatting
Write operations for fixing and managing Claude Code permissions - add, remove, consolidate, ensure, apply-fixes, executor migration, wildcard generation.
Create new marketplace components (agents, commands, skills, bundles) with proper structure and standards compliance
Content quality, tone analysis, organization standards, and review orchestration for technical documentation
Comprehensive maintenance skill for marketplace components - update components, manage knowledge, maintain READMEs, restructure, and apply orchestration compliance
Core JavaScript development standards covering ES modules, modern patterns, code quality, async programming, JSDoc documentation, and tooling
Architecture principles, skill patterns, and design guidance for building goal-based marketplace components
Verification mode that stops and analyzes on failures, workarounds, or resolution issues
Java domain extension with skill domains, module applicability, and workflow integration
Triage extension for requirements findings during plan-finalize phase
Reference library of narrative styles for technical documentation — tone, voice, and structural arcs per genre (engineering-narrative, future user-guide / spec-reference / runbook)
Test skill with cross-skill reference notation
Standards for linking specifications to implementation code and maintaining bidirectional traceability between documentation and source code
Authoring standards for SVG technical diagrams — uniform visual language, theme handling, AsciiDoc embedding, per-diagram-type patterns
JavaScript domain extension with skill domains, module applicability, and workflow integration
Documentation domain manifest for plan-marshall workflow integration
Requirements domain manifest for plan-marshall workflow integration
OCI container domain manifest for plan-marshall workflow integration
Comprehensive standards for creating and maintaining requirements and specification documents with SMART principles, proper structure, integrity, and traceability
Standards for setting up requirements and specification documentation in new projects with proper directory structure and initial documents
Skill without references directory
Test skill with table-format references
Fixture whose parent directory ends in -executor to trigger skill-naming-noun-suffix
Test skill with example code blocks that should NOT be detected as real references
Standards for creating and maintaining project planning documentation with task tracking, status indicators, and traceability to requirements
A test skill for README generation
A test skill with existing references
Use when writing, reviewing, or debugging Dockerfiles and Containerfiles — covers base image selection, multi-stage builds, version pinning, .dockerignore, multi-platform builds, OCI labels, certificate management, and Quarkus distroless health probes. Activate for any container image building task.
Triage extension for Python findings during plan-finalize phase
Triage extension for documentation findings during plan-finalize phase
Recipe for verifying documentation quality across project — validates AsciiDoc format, links, and documentation drift
Apply accumulated lessons learned to component documentation
Triage extension for JavaScript findings during plan-finalize phase
Use when writing, reviewing, or refactoring Python 3.10+ code — covers type annotations, data structures, error handling, resource management, async patterns, naming conventions, and imports. Activate for any Python production code task. Also use when working with pathlib, dataclass, pydantic, match statements, or structural pattern matching.
Use when writing, reviewing, or debugging Python tests — covers pytest framework, AAA pattern, fixtures, parametrization, isolation, mocking, assertions, and coverage configuration. Activate for any Python testing task.
Recipe for verifying and updating PlantUML diagrams to reflect current codebase state and regenerating PNG images
Triage extension for marketplace plugin findings during plan-finalize phase
Execute a single plan task with profile-based workflow selection (implementation, module_testing, verification)
Manage status.json files with phase tracking, metadata, and lifecycle operations
Unified JSONL storage for plan-scoped findings, phase-scoped Q-Gate findings, and component assessments
Create implementation tasks from deliverables using skill delegation
Shared Python modules consumed by other plan-marshall scripts via PYTHONPATH
Maven build operations — compile, test, verify with JaCoCo coverage, OpenRewrite markers, and multi-module profile management
Triage extension for Java findings during plan-finalize phase
Language-agnostic code quality principles covering SRP, CQS, complexity thresholds, refactoring triggers, error handling, and documentation standards
Triage extension for OCI container findings during plan-finalize phase
Run configuration handling for persistent command configuration storage
Domain-invariant recipe for refactoring code to comply with configured profile standards, package by package
Plan metrics collection and reporting for duration and token usage per phase
Manage lessons learned with global scope
Manage implementation tasks with sequential sub-steps within a plan
Execute phase skill for plan management. DUMB TASK RUNNER that executes tasks from TASK-*.json files sequentially.
Python/pyprojectx build operations — mypy type-checking, ruff linting, pytest with Cobertura coverage, and test-directory-based module discovery
Manage per-plan git worktrees under <project_root>/.claude/worktrees/
Deterministic candidate surfacing for pre-submission structural self-review (regexes, user-facing strings, markdown sections, symmetric-pair functions)
Foundational development practices covering user interaction, tool usage, research, dependency management, and document proliferation
CUI logging standards with CuiLogger, LogRecord patterns, and DSL-style LogMessages classes
CUI test library standards for test data generation, value object contracts, and JUL log testing
CUI HTTP client standards with HttpHandler, HttpResult pattern, and async-first adapters
Verify NiFi custom UI tabs via Chrome and update doc/guides screenshots and guides
CUI MockWebServer standards for HTTP client testing with JUnit 5 integration
CUI JavaScript domain manifest for plan-marshall workflow integration
Core CDI patterns including constructor injection, scopes, producers, events, observers, and interceptors
JavaDoc documentation standards including class, method, and code example patterns
Lombok patterns including @Delegate, @Builder, @UtilityClass for reducing boilerplate
Java code maintenance standards including prioritization, refactoring triggers, and compliance verification
JSpecify null safety annotations with @NullMarked, @Nullable, and package-level configuration
JavaScript unit testing standards covering Jest framework, DOM and web component testing, mocking patterns, async testing, and coverage configuration
JUnit 5 core testing patterns with AAA structure, test organization, and coverage standards
Finalize-phase wrapper that runs plugin-doctor against skills touched by the plan, reading modified_files from references.json and passing skill paths directly via --paths
Maven integration testing with Failsafe plugin, IT naming conventions, and profile configuration
Memory layer operations for persistent session storage
Quarkus-specific CDI standards with testing, native image support, and GraalVM reflection configuration
Core Java development standards for patterns, modern features, and performance optimization
ESLint flat config, Prettier, and Stylelint configuration, rule customization, and build integration standards for JavaScript projects
Finalize-phase wrapper that syncs marketplace bundles to the Claude plugin cache by delegating to the sync-plugin-cache skill
Weld Testing standards for CDI unit testing with @EnableAutoWeld, @AddBeanClasses, and auto-discovery patterns
Use when hardening container runtime configuration, scanning for vulnerabilities, securing the image supply chain, or auditing against OWASP Docker Top 10. Covers capability dropping, read-only filesystems, image signing, SBOMs, and Trivy/Cosign/Syft workflows.
CUI Java domain manifest for plan-marshall workflow integration
Build, deploy, and test NiFi E2E environment (Docker containers)
Analyze and consolidate WebFetch domain permissions across projects with security research and validation
Recipe skill that sweeps marketplace bundles for plugin architecture compliance
Domain-agnostic module testing task execution with two-tier skill loading
Synchronize marketplace permissions - generate wildcards, manage executor permissions, and migrate to executor pattern.
PR review response workflow - fetch comments, triage, and respond to review feedback (GitHub and GitLab)
JavaScript project structure, package.json configuration, dependency management, and Maven integration standards for consistent project setup and builds
Synchronize all marketplace bundles to the Claude plugin cache
Modern CSS standards covering native nesting, cascade layers, Container Queries, custom properties, responsive design, accessibility, and PostCSS/Stylelint tooling
Plan lifecycle operations - discovery, phase transitions, archiving, and routing
Verify workflow outputs using hybrid script + LLM assessment
Component evaluation storage with certainty/confidence assessments in JSONL persistence
Domain-agnostic implementation task execution with two-tier skill loading
Implement GitHub issues or standalone tasks with full verification
Verification-only task execution — runs commands without modifying files