rpa

Execute one approved construction unit through the per-unit construction loop

Execute the global Build and Test stage after construction units are complete

Collect structured retrospective feedback as an experimental AI-DLC extension

Execute approved inception stages and write canonical AI-DLC artifacts

Generate experimental operations artifacts beyond the current upstream AI-DLC core

Initialize or resume the AI-DLC compatibility workflow and write the execution plan

You are tasked with creating git commits for the changes made during this session.

This document outlines the process for creating a handoff document to transfer work between sessions.

Create detailed implementation plans with thorough research and iteration

You are tasked with helping debug issues during manual testing or implementation. This command allows you to investigate problems by examining logs, database state, and git history without editing files. Think of this as a way to bootstrap a debugging session without using the primary window's context.

Enhance existing implementation plans by synthesizing user feedback and opinions

Enhance existing research documents by synthesizing user feedback and opinions

Implement technical plans from thoughts/shared/plans with verification

Iterate on existing implementation plans with thorough research and updates

Refactor monolithic/God-like code into focused, testable modules

Discover and index God-like modules for refactoring candidates

Document codebase as-is with thoughts directory for historical context

Resume work from handoff document with context analysis and validation

Scan codebase for technical debt and generate actionable paydown plan

Analyze technical debt trends over time from sweep reports

Create, update, and maintain test suites with coverage tracking

You are tasked with validating that an implementation plan was correctly executed, verifying all success criteria and identifying any deviations or issues.

Captures the complete API surface of a module before refactoring. Creates a baseline that refactor-validator uses to ensure no exports were removed or signatures changed. Critical for safe refactoring.

Detects architectural erosion: boundary violations, circular dependencies, god modules, and layer violations. Builds a lightweight module map and flags structural issues that lead to recurring technical debt.

Analyze code changes for potential bugs, trace logic flow across multiple files, or investigate suspicious behavior. Specializes in deep-dive analysis while maintaining concise summaries. Use for reviewing modifications, tracking errors, or validating changes don't introduce regressions.

Analyzes codebase implementation details. Call when you need to understand HOW specific components work. Traces data flow, identifies patterns, and explains technical workings with precise file:line references.

Locates files, directories, and components relevant to a feature or task. A "Super Grep/Glob/LS tool" - use when you need to find WHERE code lives without analyzing contents.

Finds similar implementations, usage examples, or existing patterns that can be modeled after. Returns concrete code examples with file locations. Like codebase-locator but also extracts relevant code snippets.

Detects hardcoded configuration values that should be externalized: file paths, URLs, API endpoints, environment-specific values, and potential credentials. Returns findings with recommendations for proper configuration management.

Maps all consumers of a module including re-export chains, CLI invocations, and file I/O dependencies. Critical for understanding refactoring impact and maintaining API compatibility.

Measures coupling between modules and identifies decoupling opportunities. Finds tight coupling, circular dependencies, inappropriate intimacy, and global state dependencies.

Parses coverage output from various backends (Istanbul, pytest-cov, go cover, tarpaulin). Generates trend reports and identifies coverage gaps.

Scans codebase for technical debt markers: TODO/FIXME comments, lint suppressions, complexity hot spots, and temporary code. Returns categorized findings with file:line references and suggested next steps.

Analyzes project dependency manifests for health indicators: missing lockfiles, outdated patterns, unused dependencies, and risky version specifications. Returns prioritized findings with verification commands.

Audits documentation for staleness and drift. Compares README, API docs, and docstrings against actual code. Identifies outdated examples, missing documentation, and inconsistencies.

Generates tests using multiple strategies: signature-based, implementation-based, characterization. Includes snapshot sanitization and type resolution.

Maps changed files to impacted tests and identifies missing tests. Works without coverage tools using import/usage heuristics.

Runs tests and analyzes results. Executes tests using appropriate framework, captures logs, and provides actionable insights. Use after code changes requiring validation, during debugging, or for test health reports.

Updates tests to match code changes. Non-destructive by default: renames, moves, signature changes are auto-fixed; assertion changes require approval.

Extracts high-value insights from thoughts documents. Deep dives into research docs, plans, and decisions to find actionable information. Filters aggressively to return only what matters now.

Discovers relevant documents in thoughts/ directory. Finds research, plans, tickets, and notes. Like codebase-locator but for the thoughts directory structure.

Generates AI-DLC-compatible unit planning artifacts from approved requirements, workflow planning, and application design artifacts.

Researches questions using web search. Finds accurate, relevant information from web sources. Use when you need current information, documentation, or answers not in the codebase.

Collects experimental retrospective observations from operations artifacts and links them back to canonical AI-DLC state.

Analyzes and summarizes file contents, particularly log files or verbose outputs. Extracts key information and provides concise summaries to reduce context usage. Perfect for reviewing test logs, error logs, or any large text output.

Scans codebase for God modules using language-agnostic weighted scoring. Ranks candidates by severity (size + surface + coupling + smells + hotspot). Distinguishes modules from scripts. Flags false positives ("big but cohesive"). Essential for /refactor and /refactor_candidates.

Generates experimental deployment, monitoring, and rollback artifacts from canonical AI-DLC state and construction outputs.

Executes parallel work streams in a git worktree. Reads issue analysis, spawns sub-agents for each work stream, coordinates their execution, and returns consolidated summary. Perfect for parallel execution of multi-part tasks.

Runs the global Build and Test stage using commands from the plugin overlay and reports structured pass/fail results.

Validates refactoring results by comparing API snapshots, checking behavior preservation, and verifying consumer compatibility. Runs after each refactoring phase.

Analyzes monolithic code for distinct responsibilities and proposes module decomposition. Identifies implicit domains, mixed abstractions, and separation opportunities. Outputs Mermaid diagrams for visualization.

Validates AI-DLC work against the active compatibility rule set, enabled extensions, and the plugin-local overlay.

Analyzes test infrastructure: framework detection, convention discovery, coverage backend identification. Produces Test Harness Manifest for deterministic subsequent runs.

Analyzes dependencies to determine what to mock vs import. Classifies code as pure/impure, identifies side effects, generates mock scaffolding strategy.

3 hooks across 2 events