ghe

Configure GitHub Elements plugin for this project

Spawn a background Claude agent in a new Terminal window (macOS only)

Use this agent when CI failures are detected or when automated issue creation is needed. Creates GitHub issues from CI/CD failures. Parses failure logs, extracts relevant details, and creates properly labeled issues linked to the appropriate epic. Examples: <example>Context: CI workflow failed. user: "Create an issue for the CI failure" assistant: "I'll use ci-issue-opener to create a properly formatted issue"</example>

Use this agent when creating DEV threads, resuming DEV work, posting DEV checkpoints, or transitioning DEV to TEST. Manages DEV thread lifecycle for code-heavy development work. Handles thread creation, claiming, checkpointing, and transition to TEST. Examples: <example>Context: Starting new development work. user: "Create a new DEV thread for the authentication feature" assistant: "I'll use dev-thread-manager to create and initialize the DEV thread"</example> <example>Context: DEV work complete, ready for testing. user: "DEV is done, transition to TEST" assistant: "I'll use dev-thread-manager to close DEV and prepare for TEST"</example>

Use this agent when checking for workflow violations during maintenance cycles, when violations are suspected, or for periodic audits. Detects and reports workflow violations in GitHub Elements. Scans for phase order violations, scope violations, and missing checkpoints. Uses progressive enforcement (warn first, block on repeat). Examples: <example>Context: Maintenance cycle. user: "Check for workflow violations" assistant: "I'll use enforcement agent to scan for violations"</example>

Use this agent when managing issues, coordinating threads, running maintenance cycles, or enforcing workflow rules in GitHub Elements. Central orchestrator that manages DEV/TEST/REVIEW thread lifecycle, spawns specialized agents for maintenance, and reports issues to main Claude. Trigger when user mentions "orchestrate", "maintain github elements", "run maintenance cycle", "coordinate threads", "enforce rules". Examples: <example>Context: User wants to start maintenance cycle. user: "Run a maintenance cycle on the github elements" assistant: "I'll use the github-elements-orchestrator to coordinate maintenance across all active threads"</example>

Use this agent when memory needs syncing after checkpoints, thread claims, or thread closures. Synchronizes GitHub Elements with SERENA memory bank. Updates activeContext.md, progress.md, techContext.md based on thread lifecycle events. Examples: <example>Context: Thread just closed. user: "Sync the memory bank after closing DEV" assistant: "I'll use memory-sync to update SERENA"</example>

Use this agent when validating phase transitions in GitHub Elements workflow. Ensures DEV to TEST to REVIEW order is maintained, checks prerequisites before transitions, and blocks invalid transitions. Use before any phase transition, when validating workflow state, or checking if transition is allowed. Examples: <example>Context: DEV wants to transition to TEST. user: "Can we transition from DEV to TEST?" assistant: "I'll use phase-gate to validate the transition"</example> <example>Context: Checking workflow state. user: "Is the workflow in a valid state?" assistant: "I'll use phase-gate to audit the current state"</example>

Use this agent when PRs are opened or updated and need validation against GitHub Elements workflow rules. Checks for linked issues, correct phase, required reviews, and CI status. Examples: <example>Context: New PR opened. user: "Check if this PR meets requirements" assistant: "I'll use pr-checker to validate the PR"</example>

This reference covers epic phases, branch management, and epic lifecycle.

This reference covers epic creation, wave creation, epic phase transitions, and epic completion protocols.

This reference covers multi-issue coordination, concurrent agent spawning, workload balancing, priority queue algorithm, conflict prevention, autonomous dispatch loop, and progress monitoring.

This reference covers Athena's requirements output format, domain detection, and domain-specific patterns (mathematical, game mechanics, financial/legal, distributed systems, security, UI/UX, API, data sources, assets).

All GitHub issue/PR comments MUST include an avatar banner for visual identity. The `post_with_avatar.py` module provides functions to format and post comments with proper avatars.

**ALL reports MUST be posted to BOTH locations:**

The GHE safeguards system provides comprehensive error prevention and recovery functions. All agents MUST use these safeguards before performing critical operations.

Complete reference for all GHE Python scripts. Use these instead of embedding inline code.

This reference covers WAVE-based development, wave lifecycle, wave completion notifications, and wave tracking.

Use this agent when you need status reports and metrics for GitHub Elements workflow. Provides thread status, phase distribution, cycle times, and violation counts. Use for status requests, maintenance summaries, or periodic reports. Examples: <example>Context: Need workflow status. user: "Give me a status report" assistant: "I'll use reporter to generate a comprehensive status report"</example>

Use this agent when claiming REVIEW threads, evaluating code, triaging bug reports, or handling external reviews. Manages REVIEW thread lifecycle, bug reports, and external reviews. Handles thread claiming, code review, coverage estimation, final verdict (PASS/FAIL), bug report triage, and reproduction attempts. Responsible for ALL quality evaluation - TEST only runs existing tests. Examples: <example>Context: TEST complete, ready for review. user: "Claim the REVIEW thread and evaluate the code" assistant: "I'll use review-thread-manager to claim and begin evaluation"</example> <example>Context: Bug reported in GitHub issues. user: "Triage this bug report" assistant: "I'll use review-thread-manager to attempt reproduction and validate"</example> <example>Context: External review posted. user: "Handle this external code review" assistant: "I'll use review-thread-manager to evaluate and respond"</example>

Use this agent when claiming TEST threads, running tests, fixing simple bugs, or transitioning TEST to REVIEW. Manages TEST thread lifecycle for running tests and fixing bugs. Handles thread claiming, test execution, bug fixes (simple only), and transition to REVIEW or demotion to DEV. Examples: <example>Context: TEST thread ready after DEV. user: "Claim the TEST thread and run the tests" assistant: "I'll use test-thread-manager to claim and execute tests"</example> <example>Context: Tests passing, ready for review. user: "All tests pass, move to REVIEW" assistant: "I'll use test-thread-manager to transition to REVIEW"</example>

This skill should be used when updating the project CHANGELOG, tracking requirement changes, recording design decisions, or documenting version history. Uses git-diff to detect and categorize changes to both code and requirements. Trigger on "changelog", "version history", "what changed", or after significant commits.

POST a progress checkpoint to the CURRENTLY ACTIVE thread. Saves work state without changing phases. Requires an already-claimed in-progress thread. USE THIS SKILL WHEN: - User says "post a checkpoint" or "save my progress" - User says "update the issue" or "record current state" - User says "checkpoint" or "save checkpoint" - User completed a milestone and wants to record it - User encountered a blocker and wants to document it - User is about to take a break and wants to save state - Meaningful state change occurred during work PRECONDITION: User must already have an active (claimed, in-progress) thread. DO NOT USE THIS SKILL WHEN: - User wants to SEE status (use ghe-status) - User wants to START work on new issue (use ghe-claim) - User wants to FINISH current phase and MOVE to next (use ghe-transition) - User wants reports (use ghe-report) - No active thread exists (must claim first) EXAMPLES: <example> Context: User working on DEV wants to save progress user: "Post a checkpoint" assistant: "I'll use ghe-checkpoint to post your current progress to the active thread" </example> <example> Context: User completed a milestone user: "Save my progress, I finished the authentication module" assistant: "I'll use ghe-checkpoint to record this milestone" </example> <example> Context: User taking a break user: "I need to stop for now, save my work" assistant: "I'll use ghe-checkpoint to save your current state before you go" </example>

CLAIM a specific GitHub issue to START working on it. Requires an issue number. Performs validation, atomic claim, posts claim comment, and sets up worktree. USE THIS SKILL WHEN: - User says "claim issue #N" or "claim #N" - User says "start working on issue #N" or "take issue #N" - User says "I'll work on #N" or "pick up #N" - User wants to BEGIN work on a specific issue number - User selected an issue from available work and wants to claim it REQUIRED: An issue number must be specified or identifiable from context. DO NOT USE THIS SKILL WHEN: - User just wants to SEE status (use ghe-status) - User is ALREADY working and wants to post update (use ghe-checkpoint) - User wants to CHANGE phases (use ghe-transition) - User wants reports (use ghe-report) - No specific issue number is mentioned EXAMPLES: <example> Context: User wants to start work on a specific issue user: "Claim issue #201" assistant: "I'll use ghe-claim to claim issue #201 with the full protocol" </example> <example> Context: User picks from available work user: "I'll take issue #205" assistant: "I'll use ghe-claim to claim issue #205" </example> <example> Context: User wants to start on specific feature user: "Start working on #312" assistant: "I'll use ghe-claim to claim and set up issue #312" </example>

Reference material for Athena when writing requirements. NOT a template - Athena writes requirements freely based on the domain. This skill provides guidance patterns that may be useful, not constraints to follow.

Generate DETAILED reports with metrics, health checks, or epic-specific analysis. More comprehensive than quick status overview. USE THIS SKILL WHEN: - User asks for "metrics" or "statistics" or "performance report" - User asks for "health check" or "workflow health" or "compliance check" - User asks for "epic report" or "epic status for X" - User asks for "detailed report" or "comprehensive report" - User asks "how are we performing" or "what's our throughput" - User asks about "cycle times" or "demotion rates" - User wants analysis, not just current state REPORT TYPES: - metrics: Throughput, cycle times, first-pass rates, demotion rates - health: Compliance status, stale threads, violation history, memory bank status - epic: Single epic details with thread history, progress, decisions DO NOT USE THIS SKILL WHEN: - User just wants QUICK status overview (use ghe-status) - User wants to CLAIM an issue (use ghe-claim) - User wants to POST a checkpoint (use ghe-checkpoint) - User wants to TRANSITION phases (use ghe-transition) KEY DIFFERENCE FROM ghe-status: - ghe-status = quick overview, current state, what's active - ghe-report = detailed analysis, metrics, trends, health assessment EXAMPLES: <example> Context: User wants performance metrics user: "Show me the workflow metrics" assistant: "I'll use ghe-report with type 'metrics' for detailed performance analysis" </example> <example> Context: User wants to check workflow compliance user: "Run a health check on the workflow" assistant: "I'll use ghe-report with type 'health' to assess workflow compliance" </example> <example> Context: User wants details on specific epic user: "Give me a report on the jwt-auth epic" assistant: "I'll use ghe-report with type 'epic' for jwt-auth" </example> <example> Context: User asks about performance trends user: "What's our first-pass review rate?" assistant: "I'll use ghe-report with type 'metrics' to get performance statistics" </example>

This skill should be used when creating, updating, linking, or versioning requirements for GitHub Elements threads. Use when user mentions requirements, specs, REQ files, or when starting feature development. Provides the requirements folder structure, versioning system, and SERENA backup protocols.

READ-ONLY quick overview of GitHub Elements workflow state. Shows active threads, phase distribution, and workflow health at a glance. USE THIS SKILL WHEN: - User asks "what's the status" or "show me the status" - User asks "what threads are active" or "what am I working on" - User asks "show me the workflow state" or "what's happening" - User wants a quick overview before starting work - Starting a session and need context DO NOT USE THIS SKILL WHEN: - User wants to CLAIM an issue (use ghe-claim) - User wants to POST a checkpoint (use ghe-checkpoint) - User wants to TRANSITION phases (use ghe-transition) - User wants DETAILED metrics/health reports (use ghe-report) EXAMPLES: <example> Context: User starting a session wants to see current state user: "What's the github elements status?" assistant: "I'll use ghe-status to show you the current workflow state" </example> <example> Context: User wants to know what work is available user: "Show me what threads are active" assistant: "I'll use ghe-status to display active and available threads" </example> <example> Context: Quick check before doing work user: "What am I currently working on?" assistant: "I'll use ghe-status to find your in-progress threads" </example>

Use this skill when the user expresses ANY intent related to issue/thread management: - Switching issues: "let's work on X", "switch to #Y", "go to the auth issue" - Checking status: "what are we working on?", "current issue?", "status?" - Background work: "what's in background?", "any features ready?", "check progress" - Starting development: "implement X", "add feature", "fix bug Y", "build a..." - Joining reviews: "let me see the review", "check that feature", "join #X" - Pausing/resuming: "pause this", "come back later", "resume #X" - Stopping transcription: "stop tracking", "don't record this", "private mode" - Resuming last session: "what were we working on?", "resume last issue", "continue where we left off" - Any natural expression of wanting to change focus or check work status This skill interprets natural language - users should NOT memorize commands. For the full GHE workflow protocol, see skill: github-elements-tracking

CHANGE phases in the GitHub Elements workflow. Closes current thread and opens next phase thread. This is a PHASE CHANGE operation, not just saving progress. USE THIS SKILL WHEN: - User says "transition to TEST" or "move to REVIEW" - User says "I'm done with DEV, start TEST" or "DEV complete" - User says "advance to next phase" or "close this phase" - User says "demote to DEV" (from TEST or REVIEW) - User says "tests pass, ready for review" - User says "merge this" (after REVIEW PASS) - User explicitly wants to END current phase and BEGIN next DO NOT USE THIS SKILL WHEN: - User just wants to SEE status (use ghe-status) - User wants to START work on new issue (use ghe-claim) - User wants to SAVE progress but CONTINUE working (use ghe-checkpoint) - User wants reports (use ghe-report) - User is not ready to END current phase IMPORTANT: This CLOSES current thread and OPENS next thread. Use ghe-checkpoint if you just want to save progress without changing phases. EXAMPLES: <example> Context: DEV work complete, ready for testing user: "I'm done with DEV, transition to TEST" assistant: "I'll use ghe-transition to close DEV and open TEST thread" </example> <example> Context: All tests pass, ready for review user: "Tests pass, move to REVIEW" assistant: "I'll use ghe-transition to close TEST and open REVIEW thread" </example> <example> Context: Structural issues found in TEST user: "This needs structural changes, demote to DEV" assistant: "I'll use ghe-transition to demote from TEST back to DEV" </example> <example> Context: REVIEW passed, ready to merge user: "REVIEW passed, merge it" assistant: "I'll use ghe-transition to complete the workflow and merge" </example>

This skill should be used when writing Claude Code plugin hooks or debugging the "operation was aborted" error. Teaches the critical "immediate response" pattern that prevents Claude Code's internal timeout from aborting hooks. Essential knowledge for plugin developers creating PreToolUse, PostToolUse, UserPromptSubmit, Stop, or SessionStart hooks.

5 hooks across 5 events