marsai-default

Generate an Ops Update Guide from git diff between two refs

Generate beautiful, self-contained HTML pages that visually explain systems, code, and data

Create isolated git worktree with interactive setup

Create detailed implementation plan with bite-sized tasks

Interactive design refinement using Socratic method

Run comprehensive parallel code review with all 7 specialized reviewers

Organize and create atomic git commits with intelligent change grouping

Create a handoff document capturing current session state, with automatic context-clear and resume via Plan Mode

Generate Mermaid diagrams and open them in mermaid.live

Execute plan in batches with review checkpoints

Autonomous two-phase codebase exploration with adaptive agents

Proactive requirements gathering through structured user interview

Run lint checks and dispatch parallel agents to fix all issues

Transform a markdown file into a standalone, styled HTML page

Correctness Review: reviews domain correctness, business rules, edge cases, and requirements. Uses mental execution to trace code paths and analyzes full file context, not just changes. Runs in parallel with marsai:code-reviewer, marsai:security-reviewer, marsai:test-reviewer, marsai:nil-safety-reviewer, marsai:consequences-reviewer, and marsai:dead-code-reviewer for fast feedback.

Foundation Review: Reviews code quality, architecture, design patterns, algorithmic flow, and maintainability. Runs in parallel with marsai:business-logic-reviewer, marsai:security-reviewer, marsai:test-reviewer, marsai:nil-safety-reviewer, marsai:consequences-reviewer, and marsai:dead-code-reviewer for fast feedback.

Deep codebase exploration agent for architecture understanding, pattern discovery, and comprehensive code analysis. Deep codebase exploration agent for thorough analysis.

Ripple Effect Review: traces how code changes propagate through the codebase beyond the changed files. Walks caller chains, consumer contracts, shared state, and implicit dependencies to find breakage invisible in isolated review. Runs in parallel with marsai:code-reviewer, marsai:business-logic-reviewer, marsai:security-reviewer, marsai:test-reviewer, marsai:nil-safety-reviewer, and marsai:dead-code-reviewer for fast feedback.

Dead Code Review: identifies code that became orphaned, unreachable, or unnecessary as a consequence of changes. Walks the dependency graph outward from the diff to find abandoned helpers, unused types, orphaned modules, and zombie test infrastructure across three concentric rings: target files, first-derivative dependents, and transitive ripple effect. Runs in parallel with marsai:code-reviewer, marsai:business-logic-reviewer, marsai:security-reviewer, marsai:test-reviewer, marsai:nil-safety-reviewer, and marsai:consequences-reviewer for fast feedback.

Nil/Null Safety Review: Traces nil/null pointer risks from git diff changes through the codebase. Identifies missing guards, unsafe dereferences, panic paths, and API response consistency in Go and TypeScript. Runs in parallel with marsai:code-reviewer, marsai:business-logic-reviewer, marsai:security-reviewer, marsai:test-reviewer, marsai:consequences-reviewer, and marsai:dead-code-reviewer.

Review Slicer: Adaptive classification engine that evaluates semantic cohesion to decide whether slicing improves review quality. Sits between pre-analysis and reviewer dispatch. Classification-only — does NOT read source code.

Safety Review: Reviews vulnerabilities, authentication, input validation, and OWASP risks. Runs in parallel with marsai:code-reviewer, marsai:business-logic-reviewer, marsai:test-reviewer, marsai:nil-safety-reviewer, marsai:consequences-reviewer, and marsai:dead-code-reviewer for fast feedback.

Test Quality Review: Reviews test coverage, edge cases, test independence, assertion quality, and test anti-patterns across unit, integration, and E2E tests. Runs in parallel with marsai:code-reviewer, marsai:business-logic-reviewer, marsai:security-reviewer, marsai:nil-safety-reviewer, marsai:consequences-reviewer, and marsai:dead-code-reviewer for fast feedback.

Implementation Planning: Creates comprehensive plans for engineers with zero codebase context. Plans are executable by developers unfamiliar with the codebase, with bite-sized tasks (2-5 min each) and code review checkpoints.

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.

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.

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

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

2 hooks across 2 events