ma-agents 2.13.4 → 2.15.0

package/_bmad/bmm/workflows/generate-project-context/steps/step-03-complete.md

@@ -0,0 +1,278 @@
+# Step 3: Context Completion & Finalization
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER generate content without user input
+- ✅ ALWAYS treat this as collaborative completion between technical peers
+- 📋 YOU ARE A FACILITATOR, not a content generator
+- 💬 FOCUS on finalizing a lean, LLM-optimized project context
+- 🎯 ENSURE all critical rules are captured and actionable
+- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show your analysis before taking any action
+- 📝 Review and optimize content for LLM context efficiency
+- 📖 Update frontmatter with completion status
+- 🚫 NO MORE STEPS - this is the final step
+
+## CONTEXT BOUNDARIES:
+
+- All rule categories from step-2 are complete
+- Technology stack and versions are documented
+- Focus on final review, optimization, and completion
+- Ensure the context file is ready for AI agent consumption
+
+## YOUR TASK:
+
+Complete the project context file, optimize it for LLM efficiency, and provide guidance for usage and maintenance.
+
+## COMPLETION SEQUENCE:
+
+### 1. Review Complete Context File
+
+Read the entire project context file and analyze:
+
+**Content Analysis:**
+
+- Total length and readability for LLMs
+- Clarity and specificity of rules
+- Coverage of all critical areas
+- Actionability of each rule
+
+**Structure Analysis:**
+
+- Logical organization of sections
+- Consistency of formatting
+- Absence of redundant or obvious information
+- Optimization for quick scanning
+
+### 2. Optimize for LLM Context
+
+Ensure the file is lean and efficient:
+
+**Content Optimization:**
+
+- Remove any redundant rules or obvious information
+- Combine related rules into concise bullet points
+- Use specific, actionable language
+- Ensure each rule provides unique value
+
+**Formatting Optimization:**
+
+- Use consistent markdown formatting
+- Implement clear section hierarchy
+- Ensure scannability with strategic use of bolding
+- Maintain readability while maximizing information density
+
+### 3. Final Content Structure
+
+Ensure the final structure follows this optimized format:
+
+```markdown
+# Project Context for AI Agents
+
+_This file contains critical rules and patterns that AI agents must follow when implementing code in this project. Focus on unobvious details that agents might otherwise miss._
+
+---
+
+## Technology Stack & Versions
+
+{{concise_technology_list}}
+
+## Critical Implementation Rules
+
+### Language-Specific Rules
+
+{{specific_language_rules}}
+
+### Framework-Specific Rules
+
+{{framework_patterns}}
+
+### Testing Rules
+
+{{testing_requirements}}
+
+### Code Quality & Style Rules
+
+{{style_and_quality_patterns}}
+
+### Development Workflow Rules
+
+{{workflow_patterns}}
+
+### Critical Don't-Miss Rules
+
+{{anti_patterns_and_edge_cases}}
+
+---
+
+## Usage Guidelines
+
+**For AI Agents:**
+
+- Read this file before implementing any code
+- Follow ALL rules exactly as documented
+- When in doubt, prefer the more restrictive option
+- Update this file if new patterns emerge
+
+**For Humans:**
+
+- Keep this file lean and focused on agent needs
+- Update when technology stack changes
+- Review quarterly for outdated rules
+- Remove rules that become obvious over time
+
+Last Updated: {{date}}
+```
+
+### 4. Present Completion Summary
+
+Based on user skill level, present the completion:
+
+**Expert Mode:**
+"Project context complete. Optimized for LLM consumption with {{rule_count}} critical rules across {{section_count}} sections.
+
+File saved to: `{output_folder}/project-context.md`
+
+Ready for AI agent integration."
+
+**Intermediate Mode:**
+"Your project context is complete and optimized for AI agents!
+
+**What we created:**
+
+- {{rule_count}} critical implementation rules
+- Technology stack with exact versions
+- Framework-specific patterns and conventions
+- Testing and quality guidelines
+- Workflow and anti-pattern rules
+
+**Key benefits:**
+
+- AI agents will implement consistently with your standards
+- Reduced context switching and implementation errors
+- Clear guidance for unobvious project requirements
+
+**Next steps:**
+
+- AI agents should read this file before implementing
+- Update as your project evolves
+- Review periodically for optimization"
+
+**Beginner Mode:**
+"Excellent! Your project context guide is ready! 🎉
+
+**What this does:**
+Think of this as a 'rules of the road' guide for AI agents working on your project. It ensures they all follow the same patterns and avoid common mistakes.
+
+**What's included:**
+
+- Exact technology versions to use
+- Critical coding rules they might miss
+- Testing and quality standards
+- Workflow patterns to follow
+
+**How AI agents use it:**
+They read this file before writing any code, ensuring everything they create follows your project's standards perfectly.
+
+Your project context is saved and ready to help agents implement consistently!"
+
+### 5. Final File Updates
+
+Update the project context file with completion information:
+
+**Frontmatter Update:**
+
+```yaml
+---
+project_name: '{{project_name}}'
+user_name: '{{user_name}}'
+date: '{{date}}'
+sections_completed:
+  ['technology_stack', 'language_rules', 'framework_rules', 'testing_rules', 'quality_rules', 'workflow_rules', 'anti_patterns']
+status: 'complete'
+rule_count: { { total_rules } }
+optimized_for_llm: true
+---
+```
+
+**Add Usage Section:**
+Append the usage guidelines from step 3 to complete the document.
+
+### 6. Completion Validation
+
+Final checks before completion:
+
+**Content Validation:**
+✅ All critical technology versions documented
+✅ Language-specific rules are specific and actionable
+✅ Framework rules cover project conventions
+✅ Testing rules ensure consistency
+✅ Code quality rules maintain standards
+✅ Workflow rules prevent conflicts
+✅ Anti-pattern rules prevent common mistakes
+
+**Format Validation:**
+✅ Content is lean and optimized for LLMs
+✅ Structure is logical and scannable
+✅ No redundant or obvious information
+✅ Consistent formatting throughout
+
+### 7. Completion Message
+
+Present final completion to user:
+
+"✅ **Project Context Generation Complete!**
+
+Your optimized project context file is ready at:
+`{output_folder}/project-context.md`
+
+**📊 Context Summary:**
+
+- {{rule_count}} critical rules for AI agents
+- {{section_count}} comprehensive sections
+- Optimized for LLM context efficiency
+- Ready for immediate agent integration
+
+**🎯 Key Benefits:**
+
+- Consistent implementation across all AI agents
+- Reduced common mistakes and edge cases
+- Clear guidance for project-specific patterns
+- Minimal LLM context usage
+
+**📋 Next Steps:**
+
+1. AI agents will automatically read this file when implementing
+2. Update this file when your technology stack or patterns evolve
+3. Review quarterly to optimize and remove outdated rules
+
+Your project context will help ensure high-quality, consistent implementation across all development work. Great work capturing your project's critical implementation requirements!"
+
+## SUCCESS METRICS:
+
+✅ Complete project context file with all critical rules
+✅ Content optimized for LLM context efficiency
+✅ All technology versions and patterns documented
+✅ File structure is logical and scannable
+✅ Usage guidelines included for agents and humans
+✅ Frontmatter properly updated with completion status
+✅ User provided with clear next steps and benefits
+
+## FAILURE MODES:
+
+❌ Final content is too verbose for LLM consumption
+❌ Missing critical implementation rules or patterns
+❌ Not optimizing content for agent readability
+❌ Not providing clear usage guidelines
+❌ Frontmatter not properly updated
+❌ Not validating file completion before ending
+
+## WORKFLOW COMPLETE:
+
+This is the final step of the Generate Project Context workflow. The user now has a comprehensive, optimized project context file that will ensure consistent, high-quality implementation across all AI agents working on the project.
+
+The project context file serves as the critical "rules of the road" that agents need to implement code consistently with the project's standards and patterns.

package/_bmad/bmm/workflows/generate-project-context/workflow.md

@@ -0,0 +1,49 @@
+---
+name: generate-project-context
+description: 'Create project-context.md with AI rules. Use when the user says "generate project context" or "create project context"'
+---
+
+# Generate Project Context Workflow
+
+**Goal:** Create a concise, optimized `project-context.md` file containing critical rules, patterns, and guidelines that AI agents must follow when implementing code. This file focuses on unobvious details that LLMs need to be reminded of.
+
+**Your Role:** You are a technical facilitator working with a peer to capture the essential implementation rules that will ensure consistent, high-quality code generation across all AI agents working on the project.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **micro-file architecture** for disciplined execution:
+
+- Each step is a self-contained file with embedded rules
+- Sequential progression with user control at each step
+- Document state tracked in frontmatter
+- Focus on lean, LLM-optimized content generation
+- You NEVER proceed to a step file if the current step file indicates the user must approve and indicate continuation.
+
+---
+
+## INITIALIZATION
+
+### Configuration Loading
+
+Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
+
+- `project_name`, `output_folder`, `user_name`
+- `communication_language`, `document_output_language`, `user_skill_level`
+- `date` as system-generated current datetime
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Paths
+
+- `installed_path` = `{project-root}/_bmad/bmm/workflows/generate-project-context`
+- `template_path` = `{installed_path}/project-context-template.md`
+- `output_file` = `{output_folder}/project-context.md`
+
+---
+
+## EXECUTION
+
+Load and execute `{project-root}/_bmad/bmm/workflows/generate-project-context/steps/step-01-discover.md` to begin the workflow.
+
+**Note:** Input document discovery and initialization protocols are handled in step-01-discover.md.

package/_bmad/bmm/workflows/mil498/bmad-mil-generate-ocd.md

@@ -0,0 +1,17 @@
+# bmad-mil-generate-ocd.md
+# Generate Operational Concept Description (OCD)
+
+This workflow generates a MIL-STD-498 OCD document to describe the system from a user's perspective.
+
+## Instructions
+1.  **Load Template**: Read the OCD template from `{project-root}/_bmad/bmm/templates/mil498/OCD.md`.
+2.  **Gather Context**:
+    - Load the **PRD** for user needs and business goals.
+    - Load the **Architecture** for system context.
+    - Load **UX Designs** for user workflows and interactions.
+3.  **Map Concept**:
+    - **Section 3 (Current system or situation)**: Describe the problem being solved (from PRD).
+    - **Section 4 (Nature of proposed changes)**: Overview of the solution.
+    - **Section 5 (Operational concept)**: Describe user roles, operational scenarios, and key workflows (from UX/Stories).
+4.  **Clarity**: Ensure the document is written in a way that is easily understood by system users and stakeholders.
+5.  **Output**: Save the generated document to the `{output_folder}/planning-artifacts/` as `OCD.md`.

package/_bmad/bmm/workflows/mil498/bmad-mil-generate-sdd.md

@@ -0,0 +1,18 @@
+# bmad-mil-generate-sdd.md
+# Generate Software Design Description (SDD)
+
+This workflow generates a MIL-STD-498 SDD document (using the SSDD template) based on the system design and implementation details.
+
+## Instructions
+1.  **Load Template**: Read the SSDD template from `{project-root}/_bmad/bmm/templates/mil498/SSDD.md`.
+2.  **Gather Context**:
+    - Load the **Architecture** document for high-level design and component structure.
+    - Load **UX Designs** for detailed user interface design.
+    - Load **Epics and Stories** to understand detailed behavior and logic.
+    - Load the **PRD** for design constraints.
+3.  **Map Design**:
+    - **Section 3 (CSCI-wide design decisions)**: Describe the architectural patterns and technology stack.
+    - **Section 4 (CSCI architectural design)**: Define components, their interfaces, and data flow.
+    - **Section 5 (CSCI detailed design)**: Map Stories to detailed logic and internal data structures.
+4.  **Consistency**: Ensure the design matches the requirements specified in the SRS.
+5.  **Output**: Save the generated document to the `{output_folder}/planning-artifacts/` as `SDD.md`.

package/_bmad/bmm/workflows/mil498/bmad-mil-generate-sdp.md

@@ -0,0 +1,17 @@
+# bmad-mil-generate-sdp.md
+# Generate Software Development Plan (SDP)
+
+This workflow generates a MIL-STD-498 SDP document to outline the development approach and project management artifacts.
+
+## Instructions
+1.  **Load Template**: Read the SDP template from `{project-root}/_bmad/bmm/templates/mil498/SDP.md`.
+2.  **Gather Context**:
+    - Load the **Product Brief** for project vision and objectives.
+    - Load the **PRD** for scope and constraints.
+    - Identify any **Planning Documents** or schedules.
+3.  **Map Plan**:
+    - **Section 3 (Project organization and resources)**: Define roles and resources based on the Product Brief.
+    - **Section 4 (Software development process)**: Describe the BMAD-METHOD lifecycle used.
+    - **Section 5 (Software development activities)**: Detail the tasks, schedules, and milestones.
+4.  **Consistency**: Ensure the plan reflects the actual development methodology being followed.
+5.  **Output**: Save the generated document to the `{output_folder}/planning-artifacts/` as `SDP.md`.

package/_bmad/bmm/workflows/mil498/bmad-mil-generate-srs.md

@@ -0,0 +1,19 @@
+# bmad-mil-generate-srs.md
+# Generate Software Requirements Specification (SRS)
+
+This workflow generates a MIL-STD-498 SRS document by extracting requirements from BMAD-METHOD records.
+
+## Instructions
+1.  **Load Template**: Read the SRS template from `{project-root}/_bmad/bmm/templates/mil498/SRS.md`.
+2.  **Gather Context**:
+    - Load the **PRD** to identify functional and non-functional requirements.
+    - Load the **Architecture** document to understand system boundaries and external interfaces.
+    - Load **UX Designs** to define user interface requirements.
+    - Load **Epics** to group related requirements into capabilities (Section 3.2).
+3.  **Map Requirements**:
+    - **Section 3.1 (States and Modes)**: Identify any operational modes from the PRD/Architecture.
+    - **Section 3.2 (CSCI Capability Requirements)**: Map Epics and leur related requirements to this section.
+    - **Section 3.3 (External Interface Requirements)**: Map Architecture interface definitions here.
+    - **Section 3.10 (Computer Resource Requirements)**: Extract hardware/software constraints from the Architecture document.
+4.  **Traceability**: Ensure each requirement has a unique CID and is traced to the original PRD entry.
+5.  **Output**: Save the generated document to the `{output_folder}/planning-artifacts/` as `SRS.md`.

package/_bmad/bmm/workflows/mil498/bmad-mil-generate-sss.md

@@ -0,0 +1,16 @@
+# bmad-mil-generate-sss.md
+# Generate System/Subsystem Specification (SSS)
+
+This workflow generates a MIL-STD-498 SSS document for high-level system requirements.
+
+## Instructions
+1.  **Load Template**: Read the SSS template from `{project-root}/_bmad/bmm/templates/mil498/SSS.md`.
+2.  **Gather Context**:
+    - Load the **Product Brief** for high-level system identification and goals.
+    - Load the **PRD** for primary system requirements.
+3.  **Map Requirements**:
+    - **Section 3.2 (System capability requirements)**: Map high-level PRD features to system capabilities.
+    - **Section 3.3 (System external interface requirements)**: Map top-level interfaces.
+    - **Section 3.4 (System internal interface requirements)**: Map interfaces between major subsystems.
+4.  **High-Level Focus**: Keep requirements at the system/subsystem level, avoiding low-level software details.
+5.  **Output**: Save the generated document to the `{output_folder}/planning-artifacts/` as `SSS.md`.

package/_bmad/bmm/workflows/mil498/bmad-mil-generate-std.md

@@ -0,0 +1,17 @@
+# bmad-mil-generate-std.md
+# Generate Software Test Description (STD)
+
+This workflow generates a MIL-STD-498 STD document to define the test cases and procedures for software qualification.
+
+## Instructions
+1.  **Load Template**: Read the STD template from `{project-root}/_bmad/bmm/templates/mil498/STD.md`.
+2.  **Gather Context**:
+    - Load the **Architecture** for test environment details.
+    - Load **Epics and Stories** to identify test objectives and acceptance criteria.
+    - Load the **SRS** to link test cases to requirements (Traceability).
+3.  **Map Tests**:
+    - **Section 3 (Test preparations)**: Describe hardware/software needed for testing (from Architecture).
+    - **Section 4 (Test descriptions)**: Map Story acceptance criteria to specific test cases and procedures.
+    - **Section 5 (Requirements traceability)**: Link each test case to one or more SRS requirements.
+4.  **Verification**: Ensure all requirements in the SRS have at least one test case.
+5.  **Output**: Save the generated document to the `{output_folder}/planning-artifacts/` as `STD.md`.

package/_bmad/bmm/workflows/qa-generate-e2e-tests/checklist.md

@@ -0,0 +1,33 @@
+# Quinn Automate - Validation Checklist
+
+## Test Generation
+
+- [ ] API tests generated (if applicable)
+- [ ] E2E tests generated (if UI exists)
+- [ ] Tests use standard test framework APIs
+- [ ] Tests cover happy path
+- [ ] Tests cover 1-2 critical error cases
+
+## Test Quality
+
+- [ ] All generated tests run successfully
+- [ ] Tests use proper locators (semantic, accessible)
+- [ ] Tests have clear descriptions
+- [ ] No hardcoded waits or sleeps
+- [ ] Tests are independent (no order dependency)
+
+## Output
+
+- [ ] Test summary created
+- [ ] Tests saved to appropriate directories
+- [ ] Summary includes coverage metrics
+
+## Validation
+
+Run the tests using your project's test command.
+
+**Expected**: All tests pass ✅
+
+---
+
+**Need more comprehensive testing?** Install [Test Architect (TEA)](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/) for advanced workflows.

package/_bmad/bmm/workflows/qa-generate-e2e-tests/instructions.md

@@ -0,0 +1,110 @@
+# Quinn QA - Automate
+
+**Goal**: Generate automated API and E2E tests for implemented code.
+
+**Scope**: This workflow generates tests ONLY. It does **not** perform code review or story validation (use Code Review `CR` for that).
+
+## Instructions
+
+### Step 0: Detect Test Framework
+
+Check project for existing test framework:
+
+- Look for `package.json` dependencies (playwright, jest, vitest, cypress, etc.)
+- Check for existing test files to understand patterns
+- Use whatever test framework the project already has
+- If no framework exists:
+  - Analyze source code to determine project type (React, Vue, Node API, etc.)
+  - Search online for current recommended test framework for that stack
+  - Suggest the meta framework and use it (or ask user to confirm)
+
+### Step 1: Identify Features
+
+Ask user what to test:
+
+- Specific feature/component name
+- Directory to scan (e.g., `src/components/`)
+- Or auto-discover features in the codebase
+
+### Step 2: Generate API Tests (if applicable)
+
+For API endpoints/services, generate tests that:
+
+- Test status codes (200, 400, 404, 500)
+- Validate response structure
+- Cover happy path + 1-2 error cases
+- Use project's existing test framework patterns
+
+### Step 3: Generate E2E Tests (if UI exists)
+
+For UI features, generate tests that:
+
+- Test user workflows end-to-end
+- Use semantic locators (roles, labels, text)
+- Focus on user interactions (clicks, form fills, navigation)
+- Assert visible outcomes
+- Keep tests linear and simple
+- Follow project's existing test patterns
+
+### Step 4: Run Tests
+
+Execute tests to verify they pass (use project's test command).
+
+If failures occur, fix them immediately.
+
+### Step 5: Create Summary
+
+Output markdown summary:
+
+```markdown
+# Test Automation Summary
+
+## Generated Tests
+
+### API Tests
+- [x] tests/api/endpoint.spec.ts - Endpoint validation
+
+### E2E Tests
+- [x] tests/e2e/feature.spec.ts - User workflow
+
+## Coverage
+- API endpoints: 5/10 covered
+- UI features: 3/8 covered
+
+## Next Steps
+- Run tests in CI
+- Add more edge cases as needed
+```
+
+## Keep It Simple
+
+**Do:**
+
+- Use standard test framework APIs
+- Focus on happy path + critical errors
+- Write readable, maintainable tests
+- Run tests to verify they pass
+
+**Avoid:**
+
+- Complex fixture composition
+- Over-engineering
+- Unnecessary abstractions
+
+**For Advanced Features:**
+
+If the project needs:
+
+- Risk-based test strategy
+- Test design planning
+- Quality gates and NFR assessment
+- Comprehensive coverage analysis
+- Advanced testing patterns and utilities
+
+→ **Install Test Architect (TEA) module**: <https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/>
+
+## Output
+
+Save summary to: `{implementation_artifacts}/tests/test-summary.md`
+
+**Done!** Tests generated and verified.

package/_bmad/bmm/workflows/qa-generate-e2e-tests/workflow.yaml

@@ -0,0 +1,42 @@
+name: qa-generate-e2e-tests
+description: 'Generate end to end automated tests for existing features. Use when the user says "create qa automated tests for [feature]"'
+
+# Critical variables from config
+config_source: "{project-root}/_bmad/bmm/config.yaml"
+implementation_artifacts: "{config_source}:implementation_artifacts"
+user_name: "{config_source}:user_name"
+communication_language: "{config_source}:communication_language"
+document_output_language: "{config_source}:document_output_language"
+date: system-generated
+
+# Workflow components
+installed_path: "{project-root}/_bmad/bmm/workflows/qa-generate-e2e-tests"
+instructions: "{installed_path}/instructions.md"
+validation: "{installed_path}/checklist.md"
+template: false
+
+# Variables and inputs
+test_dir: "{project-root}/tests" # Root test directory
+source_dir: "{project-root}" # Source code directory
+
+# Output configuration
+default_output_file: "{implementation_artifacts}/tests/test-summary.md"
+
+# Required tools
+required_tools:
+  - read_file # Read source code and existing tests
+  - write_file # Create test files
+  - create_directory # Create test directories
+  - list_files # Discover features
+  - search_repo # Find patterns
+  - glob # Find files
+
+tags:
+  - qa
+  - automation
+  - testing
+
+execution_hints:
+  interactive: false
+  autonomous: true
+  iterative: false

package/_bmad/bmm/workflows/sre/check-deployment-status.md

@@ -0,0 +1,23 @@
+# workflow-check-deployment-status.md
+# Deployment Status Check Workflow
+
+This workflow guides the agent through checking the status of a specific deployment in a Kubernetes cluster.
+
+## Parameters
+- `{namespace}`: The namespace of the deployment (default: `default`)
+- `{deployment_name}`: The name of the deployment to check
+
+## Instructions
+1.  **Identify Resource**: Determine the `{deployment_name}` and `{namespace}` from user input or context.
+2.  **Run Diagnostics**:
+    -   `kubectl get deployment {deployment_name} -n {namespace}`
+    -   `kubectl describe deployment {deployment_name} -n {namespace}`
+3.  **Check Pods**:
+    -   `kubectl get pods -l app={deployment_name} -n {namespace}`
+    -   Identify any pods that are NOT in `Running` state.
+4.  **Analyze Events**:
+    -   Look at the `Events` section of the `describe` output for error messages (e.g., `ImagePullBackOff`, `CrashLoopBackOff`).
+5.  **Report**:
+    -   Summarize the current status.
+    -   Highlight any issues found.
+    -   Suggest next steps (e.g., "Check logs", "Check resource limits").

package/_bmad/bmm/workflows/sre/check-secrets.md

@@ -0,0 +1,14 @@
+# workflow-check-secrets.md
+# Secret Debugging Workflow
+
+This workflow helps identify and resolve problems related to Kubernetes Secrets.
+
+## Instructions
+1.  **Check Visibility**: `kubectl get secret -n {namespace}`
+2.  **Verify Mounting**:
+    -   Check if the deployment actually mounts the secret.
+    -   `kubectl get deployment {deployment_name} -o yaml | grep secret`
+3.  **Check Permissions**: Verify ServiceAccount has permissions to read the secret (RBAC).
+4.  **Content Verification**: (Safety first!) Offer to check if keys exist WITHOUT displaying sensitive values unless explicitly requested.
+    -   `kubectl get secret {name} -n {namespace} -o jsonpath='{.data}'`
+5.  **Common Errors**: Look for "Secret not found" or "Authorization" errors in pod events.

package/_bmad/bmm/workflows/sre/check-system-status.md

@@ -0,0 +1,18 @@
+# workflow-check-system-status.md
+# Overall System Status Workflow
+
+This workflow provides a high-level overview of the health of the container runtime and orchestration environment.
+
+## Instructions
+1.  **Detect Runtime**: Check if reachable:
+    -   `kubectl cluster-info` (Kubernetes)
+    -   `docker info` (Docker)
+    -   `podman info` (Podman)
+2.  **Resource Overview**:
+    -   **K8s**: `kubectl get nodes`, `kubectl get pods -A | grep -v Running`
+    -   **Docker**: `docker ps`, `docker stats --no-stream`
+    -   **Podman**: `podman ps`, `podman stats --no-stream`
+3.  **Cross-Platform Diagnostics**:
+    -   Check for resource exhaustion (High CPU/Memory).
+    -   Verify network connectivity between key services.
+4.  **Summary Table**: Present a status table of all detected environments.