marsai

Main orchestrator for the 8-gate development cycle system. Loads tasks/subtasks from PM team output and executes through implementation → devops → SRE → unit testing → integration testing (write) → chaos testing (write) → review → validation gates (Gates 0-7), with state persistence and metrics collection. Gates 4-5 (integration/chaos) write and update test code per unit but only execute tests at end of cycle (deferred execution). Multi-tenant dual-mode is implemented during Gate 0 and verified at Gate 0.5G (no separate post-cycle step).

Gate 3 of development cycle - ensures unit test coverage meets threshold (85%+) for all acceptance criteria using TDD methodology.

Gate 5 of development cycle - ensures chaos tests exist using Toxiproxy to verify graceful degradation under connection loss, latency, and partitions.

Gate 1 of the development cycle. Creates/updates Docker configuration, docker-compose setup, and environment variables for local development and deployment readiness.

Gate 4 of development cycle - ensures integration tests pass for all external dependency interactions using real containers via testcontainers.

Gate 4 of development cycle - dispatches 7 specialized reviewers (code, business-logic, security, test, nil-safety, consequences, dead-code) in parallel for comprehensive code review feedback.

Gate 2 of the development cycle. VALIDATES that observability was correctly implemented by developers. Does not implement observability code - only validates it.

Creates comprehensive implementation plans with exact file paths, complete code examples, and verification steps for engineers with zero codebase context.

Socratic design refinement - transforms rough ideas into validated designs through structured questioning, alternative exploration, and incremental validation.

Generate Mermaid diagrams from context and open them in mermaid.live in the browser. Use when the user asks for a diagram, visualization, flowchart, sequence diagram, ER diagram, or any visual representation of code, architecture, or processes. Produces lightweight, shareable mermaid.live URLs that open in the browser for interactive editing.

Controlled plan execution with human review checkpoints - loads plan, executes in batches, pauses for feedback. Supports one-go (autonomous) or batch modes.

Autonomous two-phase codebase exploration - first discovers natural perspectives (layers, components, boundaries), then dispatches adaptive deep-dive explorers based on what was discovered. Synthesizes findings into actionable insights.

Send tasks to Gandalf (AI team member) via webhook and get responses back. Publish to Alfarrábio, send Slack notifications, ask for business context, and more.

Smart commit organization with atomic grouping, conventional commits, and trailer management

Proactive requirements gathering - systematically interviews the user to uncover ambiguities, preferences, and constraints BEFORE implementation begins.

Parallel lint fixing pattern - runs lint checks, groups issues into independent streams, and dispatches AI agents to fix all issues until the codebase is clean.

Comprehensive MarsAI-standards-aligned 44-dimension production readiness audit. Detects project stack, loads MarsAI standards via WebFetch, and runs in batches of 10 explorers appending incrementally to a single report file. Categories - Structure (pagination, errors, routes, bootstrap, runtime, core deps, naming, domain modeling, nil-safety, api-versioning, resource-leaks), Security (auth, IDOR, SQL, validation, secret-scanning, data-encryption, multi-tenant, rate-limiting, cors), Operations (telemetry, health, config, connections, logging, resilience, graceful-degradation), Quality (idempotency, docs, debt, testing, dependencies, performance, concurrency, migrations, linting, caching), Infrastructure (containers, hardening, cicd, async, makefile, license). Produces scored report (0-430, max 440 with multi-tenant) with severity ratings and standards cross-reference.

Generate Ops Update Guide from Git Diff. Produces internal Operations-facing update/migration guides based on git diff analysis. Supports STRICT_NO_TOUCH (default) and TEMP_CLONE_FOR_FRESH_REFS modes. Includes tag auto-detection and commit log analysis.

Create handoff documents capturing session state for seamless context-clear and resume

Four-phase debugging framework - root cause investigation, pattern analysis, hypothesis testing, implementation. Ensures understanding before attempting fixes.

RED-GREEN-REFACTOR implementation methodology - write failing test first, minimal implementation to pass, then refactor. Ensures tests verify behavior.

Agent testing methodology - run agents with test inputs, observe outputs, iterate until outputs are accurate and well-structured.

Test quality guard - prevents testing mock behavior, production pollution with test-only methods, and mocking without understanding dependencies.

Skill testing methodology - run scenarios without skill (RED), observe failures, write skill (GREEN), close loopholes (REFACTOR).

Isolated workspace creation - creates git worktrees with smart directory selection and safety verification for parallel feature development.

Mandatory orchestrator protocol - establishes ORCHESTRATOR principle (dispatch agents, don't operate directly) and skill discovery workflow for every conversation.

Generate beautiful, self-contained HTML pages that visually explain systems, code changes, plans, and data. Use when the user asks for a diagram, architecture overview, diff review, plan review, project recap, comparison table, or any visual explanation of technical concepts. Also use proactively when you are about to render a complex ASCII table (4+ rows or 3+ columns) — present it as a styled HTML page instead.

TDD for process documentation - write test cases (pressure scenarios), watch baseline fail, write skill, iterate until bulletproof against rationalization.

Development cycle state management — status reporting and cycle cancellation

Automated architectural code review against gold standard references. Compares diffs against the architecture template and reference examples, verifying structure, naming, architecture, events, duplication, responsibility, and ops.

Frontend development cycle orchestrator with 9 gates. Loads tasks from PM team output or backend handoff and executes through implementation → devops → accessibility → unit testing → visual testing → E2E testing → performance testing → review → validation.

Delivery Verification Gate — verifies that what was requested is actually delivered as reachable, integrated code. Not quality review (Gate 8), not test verification (Gate 9) — this gate answers: "Is every requirement from the original task actually functioning in the running application?" Applies to ANY task type: features, refactors, fixes, infrastructure, API endpoints, middleware, business logic, integrations.

Intercepts and audits dependency installations (pip, npm) before they execute. Validates package identity, checks for known vulnerabilities, flags suspicious signals (new package, single maintainer, recent name change), and enforces hash pinning in lockfiles. Acts as a supply-chain gate for every `install` command in a codebase.

Creates or audits Dockerfiles and Docker image configurations to achieve Docker Hub Health Score grade A. Enforces all evaluable security policies and supply chain best practices.

Development cycle feedback system - calculates assertiveness scores, analyzes prompt quality for all agents executed, aggregates cycle metrics, performs root cause analysis on failures, and generates improvement reports to docs/feedbacks/cycle-{date}/.

Gate 2 of frontend development cycle - ensures all components pass axe-core automated accessibility scans with zero WCAG 2.1 AA violations.

Gate 5 of frontend development cycle - ensures all user flows from product-designer have passing E2E tests with Playwright across browsers.

Gate 6 of frontend development cycle - ensures Core Web Vitals compliance, Lighthouse performance score > 90, and bundle size within budget.

Gate 4 of frontend development cycle - ensures all components have snapshot tests covering all states, viewports, and edge cases.

Mandatory skill for creating and maintaining Helm charts following V4-Company conventions. Enforces standardized chart structure, values organization, template patterns, security defaults, and dependency management.