
Persist CI run artifacts (logs + manifest) under the plan directory for offline retrospectives
Agentfile context-hygiene rubric — objective criteria classifying every CLAUDE.md/AGENTS.md section as always-on-justified, demotable-to-skill, or inert/deletable, plus the always-on line budget and directory-tree anti-pattern; the shared source of truth for the recipe and the plugin-doctor backstop rules
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.
Manage Architectural Decision Records (ADRs) with CRUD operations, automatic numbering, and AsciiDoc formatting
Diagnose and fix PR issues (build, reviews, Sonar) — thin wrapper around verification-feedback with producer=pr-state
ESLint flat config, Prettier, and Stylelint configuration, rule customization, and build integration standards for JavaScript projects
Use when running or interpreting the Python arch-gate — the import-linter-based architectural-fitness-function check that runs as a per-deliverable read-only structural-boundary gate and emits arch-constraint findings. A thin pointer to the central arch-gate model in plan-marshall:manage-architecture; carries only the Python/import-linter binding.
Use when writing, reviewing, or debugging Dockerfiles and Containerfiles — covers base image selection, multi-stage builds, version pinning, .dockerignore (including excluding secrets from the build context), multi-platform builds, OCI labels, certificate management, secrets management (never embedding secrets in image layers, BuildKit build-time secrets, runtime secret injection), and Quarkus distroless health probes. Activate for any container image building or build-context hardening task.
Architecture principles, skill patterns, and design guidance for building goal-based marketplace components
JavaScript project structure, package.json configuration, dependency management, and Maven integration standards for consistent project setup and builds
Domain-invariant cognitive sweep recipe that classifies every CLAUDE.md/AGENTS.md section against the shared ref-agentfile-hygiene rubric and emits one remediation deliverable per offending section
Modern CSS standards covering native nesting, cascade layers, Container Queries, custom properties, responsive design, accessibility, and PostCSS/Stylelint tooling
JavaScript domain extension with skill domains, module applicability, and workflow integration
Use when reviewing or hardening JavaScript security — DOM trust boundaries, XSS sinks (innerHTML/outerHTML/insertAdjacentHTML), safe text rendering, sanitization (DOMPurify), and Trusted Types. The focused JavaScript security surface resolved via skills_by_profile.security; a thin pointer that delegates cross-cutting foundations upward to plan-marshall:persona-security-expert.
JavaScript unit testing standards covering Jest framework, DOM and web component testing, mocking patterns, async testing, and coverage configuration
Quarkus-specific CDI standards with testing, native image support, GraalVM reflection configuration, and inbound REST input validation
Java code maintenance standards including prioritization, refactoring triggers, and compliance verification
JavaDoc documentation standards including class, method, and code example patterns
Lombok patterns including @Delegate, @Builder, @Value, @Data, @UtilityClass for reducing boilerplate
Use when running or interpreting the JavaScript arch-gate — the dependency-cruiser-based architectural-fitness-function check that runs as a per-deliverable read-only structural-boundary gate and emits arch-constraint findings. A thin pointer to the central arch-gate model in plan-marshall:manage-architecture; carries only the JavaScript/dependency-cruiser binding.
Recipe for enforcing CUI logging standards across all modules — migrate loggers, implement LogRecords, add test coverage
Use when running or interpreting the Java arch-gate — the ArchUnit-based architectural-fitness-function check that runs as a per-deliverable read-only structural-boundary gate and emits arch-constraint findings. A thin pointer to the central arch-gate model in plan-marshall:manage-architecture; carries only the Java/ArchUnit binding.
Python domain manifest for plan-marshall workflow integration
Use when reviewing or hardening Java application security — inbound input validation at trust boundaries, secure logging, secrets handling, startup configuration validation, and security anti-patterns. The focused Java security surface resolved via skills_by_profile.security; a thin pointer that delegates cross-cutting foundations upward to plan-marshall:persona-security-expert.
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. Cross-references the cross-cutting foundations in plan-marshall:persona-security-expert.
Use when reviewing or hardening Python security — injection sinks (subprocess, eval/exec, unsafe deserialization, SQL), path-traversal prevention, and untrusted-input handling at stdlib boundaries. The focused Python security surface resolved via skills_by_profile.security; a thin pointer that delegates cross-cutting foundations upward to plan-marshall:persona-security-expert.
JUnit 5 core testing patterns with AAA structure, test organization, and coverage standards
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, or when hardening untrusted input (secure subprocess, deserialization, eval, and SQL injection sinks).
Recipe for verifying and updating PlantUML diagrams to reflect current codebase state and regenerating PNG images
Java domain extension with skill domains, module applicability, and workflow integration
Recipe for verifying and fixing alignment of ASCII box diagrams across .md skill source and .adoc documentation, one deliverable per offending file
Maven integration testing with Failsafe plugin, IT naming conventions, and profile configuration
Code-review persona that composes other personas as evaluation lenses
Domain-invariant recipe for deliberate wide-scope simplification campaigns across a scope x thoroughness cell, with a T4+ relation-graph pre-deliverable
On-demand code-review recipe that runs a diff-aware structural/quality review over the current footprint and emits lint-issue findings into the triage pipeline
Recipe for verifying documentation quality across project — validates AsciiDoc format, links, and documentation drift
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
Manage references.json files with field-level access and list management
Triage extension for Java findings during plan-finalize phase
Generic file I/O operations for plan directories
Write operations for fixing and managing host-platform permissions - add, remove, consolidate, ensure, apply-fixes, executor migration, wildcard generation.
Shared input validation module for plan-marshall scripts — validates plan IDs, file paths, enums, and skill notation
Use when writing, reviewing, or debugging Python tests — covers pytest framework, AAA pattern, fixtures, parametrization, isolation, mocking, assertions, coverage configuration, and property-based / adversarial testing (Hypothesis). Activate for any Python testing task.
Language-agnostic testing methodology covering AAA pattern, test structure, organization, coverage, property-based testing, test doubles, determinism, constructed-argv assertion at the lowest subprocess primitive, and real-resolver E2E testing for path-resolver/create side effects
Manage Architectural Decision Records (ADRs) with CRUD operations, progressive-disclosure metadata, scan-by-tag/affects, automatic numbering, and AsciiDoc formatting
Git commit workflow with conventional commits, artifact cleanup, optional push, and consolidated branch/worktree verbs (force-push, branch-sync-state parity, worktree lifecycle)
Platform abstraction layer routing operations to Claude Code or OpenCode implementations
CUI MockWebServer standards for HTTP testing with JUnit 5 — @MockResponseConfig setup, request verification, HTTPS/TLS testing, @ModuleDispatcher routing, timeout/resilience testing, and generator-driven adversarial attack-database testing (path/header/query)
Execute a single plan task with profile-based workflow selection (implementation, module_testing, verification)
AsciiDoc formatting, validation, link verification, and template creation workflows
CUI logging standards with CuiLogger, LogRecord patterns, and DSL-style LogMessages classes
CUI HTTP standards for de.cuioss:cui-http — HttpHandler client configuration, HttpResult error handling, async adapters with ETag caching and resilient retry, custom content converters, SSL/TLS context, HTTP status classification, and inbound HTTP security input-sanitization (de.cuioss.http.security validation pipelines)
Shared Python modules consumed by other plan-marshall scripts via PYTHONPATH
Domain-invariant recipe for converting a single lesson-learned into a slim, deterministic plan with surgical-style cascades
CUI test library standards for test data generation, value object contracts, and JUL log testing
Unified logging infrastructure for script execution, work progress, and decision tracking across the plan, global, and main-anchored orchestrator stores
Base module providing reusable file operations patterns and parameterized store-root resolution (plans, orchestrator) for workflow scripts
Test skill with cross-skill reference notation
Skill without references directory
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
A test skill for README generation
A test skill with existing references
Audit persona that composes other personas as evaluation lenses across a wide scope
Content quality, tone analysis, organization standards, and review orchestration for technical documentation
Maven build operations — compile, test, verify with JaCoCo coverage and multi-module profile management
Compose, read, and validate the per-plan execution manifest that drives Phase 5 verification and Phase 6 finalize step selection
Two-lane solution outline creation - light lane for bounded localized changes, deep lane for codebase-wide discovery
Execute phase skill for plan management. Manifest-driven task runner that executes tasks from TASK-*.json files sequentially and runs the per-deliverable plus end-of-phase verification sweep from manifest.phase_5.verification_steps.
Manage implementation tasks with sequential sub-steps within a plan
Analyze and consolidate WebFetch domain permissions across projects with security research and validation
Core JavaScript development standards covering ES modules, modern patterns, web component patterns (Lit), DOM trust boundaries / XSS prevention, code quality, async programming, JSDoc documentation, and tooling
CUI JavaScript domain manifest for plan-marshall workflow integration
Plugin development domain manifest with module discovery for plan-marshall workflow integration
Manage Interface specifications with CRUD operations, automatic numbering, and AsciiDoc formatting
Authoring standards for ASCII box diagrams in skill and doc source — box-drawing conventions, right-border alignment, and a deterministic check/fix validator over fenced/literal code blocks in .md and .adoc files
Micro-lane recipe for a pre-diagnosed surgical fix — composes a deterministic surgical outline for a root-cause-known change bounded to a single module
Maven build profile classification and user workflow for unmatched profiles
SonarQube/SonarCloud provider - two pure verbs (fetch_findings files new-code issues to the ledger, post_responses transmits triaged dismissals) via the REST client
Scans and reports complete marketplace inventory (bundles, agents, commands, skills, scripts)
Script development standards covering implementation patterns, testing, and output contracts
Comprehensive maintenance skill for marketplace components - update components, manage knowledge, maintain READMEs, restructure, and apply orchestration compliance
Domain-agnostic task planning from deliverables with skill resolution and optimization
Apply accumulated lessons learned to component documentation
Diagnose plan artifacts (TASK-*.json) for unresolved lesson-ID references and other plan-level data integrity defects
Extension API for domain bundle discovery, module detection, and canonical command generation
Diagnose and fix quality issues in marketplace components with automated safe fixes and prompted risky fixes
Foundational agent behavior rules covering user interaction, tool usage, research, dependency management, and document proliferation
Language-agnostic code quality principles covering SRP, CQS, complexity thresholds, refactoring triggers, error handling, and documentation standards
Reference library of narrative styles for technical documentation — tone, voice, and structural arc for the engineering-narrative, reference-spec, and tutorial-walkthrough styles
Standards for setting up requirements and specification documentation in new projects with proper directory structure and initial documents
Provider management for external tool authentication — secure storage, interactive configuration, and REST client infrastructure
Remediation recipe for the exit_code=2 / argparse_rejection defect class — invented or paraphrased manage-* subcommands and flags that do not exist in the script's argparse choices
On-demand security-audit recipe that runs the shared five-stage audit engine over the current footprint and emits findings into the triage pipeline
Verification mode that stops and analyzes on failures, workarounds, or resolution issues
Standards for linking specifications to implementation code and maintaining bidirectional traceability between documentation and source code
Use when reviewing or hardening the security of marketplace meta-project components — the Python script surface (subprocess, path traversal, environment trust, unvalidated config-key handling) and the markdown trust surface (new external-content ingestion that bypasses the untrusted-ingestion boundary, trust-boundary erosion, prompt-injection-susceptible prose). The plan-marshall-plugin-dev security surface resolved via skills_by_profile.security; owns the two marketplace-specific surfaces and delegates cross-cutting foundations upward to plan-marshall:persona-security-expert.
Comprehensive standards for creating and maintaining requirements and specification documents with SMART principles, proper structure, integrity, and traceability
LLM-based architectural analysis that transforms raw project data into meaningful structure
Operator control surface for the marshalld build server — enrol/drop a project in the machine-global registry (the opt-in enable signal and anti-laundering wall), manage the daemon lifecycle (start, stop, drain, status, install, upgrade) version-pinned to the verified bundle copy, and inspect the daemon's per-project interaction-audit log (read-only)
Cross-session coordination primitives — the unified file-based merge mutex fronted by a FIFO admission queue for fair merge ordering, and the build-queue concurrency limiter, on one shared, TOCTOU-safe read-modify-write + plan-liveness core
Triage extension for OCI container findings during plan-finalize phase
Gradle build operations — Java/Kotlin builds with JaCoCo coverage, quality task detection, and multi-project discovery
The tiny build-consumption client for the marshalld build server — submit a build job, bounded long-poll for its result, ping the daemon identity, and preflight registry-plus-liveness in one call; consumption only, never provisioning or enrolment
Project-level infrastructure configuration for marshal.json
Resumable epic-orchestration skill - decomposes epics into workstreams and staged plans, emits ready-to-run /plan-marshall commands, tracks plan lifecycles, analyzes landings, owns the append-only inbox channel executing plans write their structured messages to, and reconciles the persisted orchestrator ledger; orchestrates, never implements
Manage request documents within plan directories with schema validation and template-based creation
--- lane: class: adversarial cost_size: L name: automatic-review description: CI automated review — drives the pr-comment findings pipeline for the configured review bots user-invocable: true mode: workflow allowed-tools: Read, Bash, Skill order: 30 requires: [ci-complete] mutates_source: true default_on: true presets: - standard - full implements: - plan-marshall:extension-api/standards/ext-point-execution-context-workflow - plan-marshall:extension-api/standards/ext-point-finalize-s
Manage status.json files with phase tracking, metadata, and lifecycle operations for plans, plus the lean kind=orchestrator status store for orchestrator epics
npm/npx build operations — TypeScript, Jest, ESLint, TAP parsing with workspace discovery, per-file JS coverage analysis, and automatic npm/npx routing
Pure platform-agnostic terminal-title composition consumed by platform-runtime via PYTHONPATH — plan-scoped pm:{phase} bodies and orchestrator Orchestrator-{SlugName} bodies
Unified plan lifecycle management - create, outline, execute, verify, and finalize plans
Complete plan execution with git workflow and PR management
Foundational agent behavior rules covering user interaction, tool usage, research, dependency management, and document proliferation
Run configuration handling for persistent command configuration storage
Python/pyprojectx build operations — mypy type-checking, ruff linting, pytest with Cobertura coverage, and test-directory-based module discovery
Init phase skill. Creates plan directory, request.md, references, and status, runs the Tier 1 recipe-match routing tier (registry-wide recipe scoring + request-aspect classification) ahead of planning-lane routing. Runs inline in the orchestrator context to complete initialization.
Opt-in plan quality audit — analyzes artifacts, logs, metrics, chat, and invariants; compiles report and seeds lessons
Triage extension for JavaScript findings during plan-finalize phase
Language-agnostic code quality principles covering SRP, CQS, complexity thresholds, refactoring triggers, error handling, and documentation standards
Manage solution outline documents - standards, examples, validation, and deliverable extraction
Domain-owned OpenRewrite log-line finding parser for the java-cui domain — parses the
Domain-owned OpenRewrite marker detection for the java-cui domain — scans Java/Kotlin sources for cui-rewrite TODO markers, categorizes them by recipe, and fails the gate on any detected marker
GitLab provider for MR review workflows — fetch comments, triage, and respond to review feedback via glab CLI
CUI Java domain manifest for plan-marshall workflow integration
GitHub provider for PR review workflows — three pure verbs (fetch_findings files comments to the ledger, post_responses transmits triaged dispositions, bot_completion reports a review bot's completion state) via gh CLI
Triage extension for marketplace plugin findings during plan-finalize phase
Project configuration wizard for planning system. Manages executor generation, health checks, executor/config staleness signaling, build systems, skill domains, and the upgrade verb for one-flow post-change reconciliation.
Epic-orchestration persona — the work identity for decomposing epics into workstreams and plans, tracking plan lifecycles, analyzing landings, and reconciling the persisted orchestrator ledger; orchestrates, never implements
Triage extension for requirements findings during plan-finalize phase
Triage extension for Python findings during plan-finalize phase
Universal script execution pattern via execute-script.py proxy
Triage extension for documentation findings during plan-finalize phase
Unified JSONL storage for plan-scoped findings, phase-scoped Q-Gate findings, and component assessments
Centralized architecture documentation for the plan-marshall bundle with visual diagrams
CI provider abstraction with unified API for GitHub and GitLab operations (PR, issues, CI status, repo merge-queue)
Build system module discovery consolidating Maven, Gradle, npm, and Python detection
The single append-only change-ledger — one worktree_sha-stamped substrate for kind=build, kind=change, and kind=job entries — plus the first-class worktree-sha freshness API
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, keep markers, producer-consumer pairs, source-of-truth duplicates, same-document normative directives, description-vs-body frontmatter, lone-unguarded-boundary calls, stale count-prose, near-identical-hunk touched claims, advertised-form help strings, same-document ordinal references) for pre-submission structural self-review.
OCI container domain manifest for plan-marshall workflow integration
Implement plugin tasks from plan with step iteration and progress tracking
Create implementation tasks from deliverables using skill delegation
Core Java development standards for patterns, modern features, and performance optimization. Inbound input validation at trust boundaries is owned by pm-dev-java:java-security
Documentation domain manifest for plan-marshall workflow integration
Create new marketplace components (agents, commands, skills, bundles) with proper structure and standards compliance
Test skill with table-format references
Authoring standards for SVG technical diagrams — uniform visual language, theme handling, AsciiDoc embedding, per-diagram-type patterns
Standards for creating and maintaining project planning documentation with task tracking, status indicators, and traceability to requirements
Manage lessons learned with global scope
Core CDI patterns including constructor injection, scopes, producers, events, observers, and interceptors
JSpecify null safety annotations with @NullMarked, @Nullable, and package-level configuration
Request clarification toward a confidence threshold via a single bounded operator escalation
Language-agnostic testing methodology covering AAA pattern, test structure, organization, coverage, property-based testing, test doubles, determinism, constructed-argv assertion at the lowest subprocess primitive, and real-resolver E2E testing for path-resolver/create side effects
Shared workflow steps and verification knowledge for plugin development outline, loaded by phase-3-outline skill
Requirements domain manifest for plan-marshall workflow integration
Security-expert persona — the work identity for security review and hardening, and the central authoritative home for cross-cutting security knowledge (OWASP Top 10, STRIDE, secrets, secure logging, trust boundaries, authn/authz, secure design)
Domain-invariant recipe for refactoring code to comply with configured profile standards, package by package
Documentation persona — the work identity for authoring and maintaining project documentation
Integration-testing persona — the work identity for cross-component and end-to-end test authoring
Production-code implementation persona — the work identity for building and modifying production code
TOON format knowledge and usage patterns for agent communication and memory persistence in plan-marshall marketplace
Plan metrics collection and reporting for duration and token usage per phase
Resolve a persona's composition DAG into a flat, deduped skills[] for dispatch
Diagnose permission issues across settings files (read-only analysis)
Manage per-plan git worktrees under <project_root>/.claude/worktrees/
Foundational development practices covering user interaction, tool usage, research, dependency management, and document proliferation
Deterministic candidate surfacing for pre-submission structural self-review (regexes, user-facing strings, markdown sections, symmetric-pair functions)
Python/pyprojectx build operations — mypy type-checking, ruff linting, pytest with Cobertura coverage, and test-directory-based module discovery
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
Build, deploy, and test NiFi E2E environment (Docker containers)
Memory layer operations for persistent session storage
Verify NiFi custom UI tabs via Chrome and update doc/guides screenshots and guides
Finalize-phase wrapper that syncs marketplace bundles to the Claude plugin cache by delegating to the sync-plugin-cache skill
Synchronize marketplace permissions - generate wildcards, manage executor permissions, and migrate to executor pattern.
Plan lifecycle operations - discovery, phase transitions, archiving, and routing
Recipe skill that sweeps marketplace bundles for plugin architecture compliance
Synchronize all marketplace bundles to the Claude plugin cache
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
Analyze and consolidate WebFetch domain permissions across projects with security research and validation
Domain-agnostic module testing task execution with two-tier skill loading
PR review response workflow - fetch comments, triage, and respond to review feedback (GitHub and GitLab)