pro-workflow

Captures developer corrections (style preferences, architectural constraints, bug fixes) into a local SQLite database with full-text search (FTS5) indexing. On every session start, learnings are automatically replayed to the AI agent, creating a compounding correction loop that reduces correction rate toward zero over 50+ sessions. Uses omitClaudeMd token optimization to minimize context overhead while maximizing retention of learned patterns.

Implements a three-tier command hierarchy (Command > Agent > Skill) that routes user intent through 8 specialized agents (Orchestrator, Context Engineer, Development Lifecycle agents, Quality & Review agents) to 24 modular skills. The Orchestrator manages a Research > Plan > Implement > Review workflow, coordinating parallel agent execution via a centralized event dispatcher. Each agent has role-specific token optimization and can be composed into agent teams for complex multi-phase tasks.

Defines 24 modular skills that encapsulate specific capabilities (git operations, context optimization, quality checks, etc.) and can be composed into workflows. Skills are organized into four categories: Workflow & Orchestration Skills (git commit, branch management), Quality & Memory Skills (test execution, correction capture), Context & Cost Management Skills (token budgeting, context compaction), and Security & Governance Skills (secret scanning, permission checks). Skills can be reused across different agents and commands, reducing code duplication and enabling consistent behavior.

Implements a structured four-phase workflow (Research > Plan > Implement > Review) that guides development from problem understanding to code review. Each phase is handled by specialized agents and skills, with explicit handoffs and context passing between phases. The Orchestrator agent manages phase transitions, ensuring that outputs from one phase become inputs to the next. Developers can skip phases or run them in parallel using worktrees, but the default workflow enforces a sequential, quality-focused approach.

Captures developer corrections (code changes, style feedback, architectural decisions) and stores them with semantic metadata (context, intent, affected code patterns). On subsequent sessions, similar corrections are automatically replayed using FTS5 semantic search. The system learns which corrections are most frequently applied and prioritizes them in context injection. Corrections can be manually reviewed, edited, or deleted before replay to ensure accuracy.

Integrates with git to automate commit operations, branch creation, and merge workflows. Agents can generate commit messages based on code changes, create feature branches with semantic naming, and manage branch lifecycle (creation, switching, deletion). Git hooks are used to enforce quality gates before commits. The system maintains a git history that can be queried to understand code evolution and correlate changes with corrections.

Manages session lifecycle with automatic context isolation and cleanup. Each session maintains its own context window, correction history, and worktree state. Sessions can be explicitly started, paused, resumed, or ended. On session end, temporary files and worktrees are cleaned up, and session metadata (duration, corrections applied, tokens used) is logged for analysis. Sessions can be resumed later with full context restoration.

Provides cost estimation for commands before execution, supporting multiple models (Claude 3.5 Sonnet, GPT-4, Gemini, etc.) with their respective pricing. Estimates include token count, model cost, and total cost across all agents in a workflow. Budget enforcement can be configured as warnings (alert but allow) or hard blocks (prevent execution). The system tracks cumulative costs per session and per project, enabling cost analysis and optimization.

Provides a /doctor command that validates the entire Pro Workflow installation and configuration. Checks include: git version and worktree support, Node.js version, required dependencies, config.json syntax and completeness, plugin manifest compatibility, database integrity, hook script syntax, and API key validity. Generates a detailed report with warnings, errors, and suggestions for fixing issues. Can be run before starting work to ensure the system is properly configured.

Provides a pluggable event-driven architecture that intercepts 24 system events (file writes, commits, context changes, permission checks) with 29 custom scripts. Hooks can perform AI-powered secret scanning, anti-pattern detection, token budget enforcement, and permission validation before actions execute. Hooks are organized into three categories: Tool Execution Hooks (pre/post command), Session & Context Hooks (lifecycle events), and Environment & Permission Hooks (security gates).

The Context Engineer agent audits token budgets before expensive operations and applies compaction strategies to keep context within limits. Implements omitClaudeMd optimization (removes markdown formatting from code blocks), context pruning (removes low-relevance historical messages), and split memory templates that separate long-term learnings from session-specific context. Provides /context and /cost commands to inspect token usage and simulate context overhead before executing commands.

Stores coding rules, architectural constraints, and style preferences in declarative .mdc (Markdown Config) files that are automatically injected into agent context at session start. Rules are organized by domain (naming conventions, error handling, testing patterns, security constraints) and can reference external templates or context mode files. The system supports rule inheritance and overrides, allowing team-wide rules to be customized per-project or per-developer.

Manages multiple git worktrees (isolated working directories) to enable parallel development streams without branch conflicts. Each worktree is associated with a specific agent or task, and the system automatically handles worktree creation, switching, and cleanup. Integrates with git hooks to enforce quality gates (linting, testing, secret scanning) before commits. Supports worktree-specific context and memory, allowing different agents to work on different features simultaneously without context pollution.

Exposes a CLI-like interface with 21 slash commands (e.g., /develop, /commit, /wrap-up, /doctor) that trigger specific agent workflows. Commands are organized into three categories: Development Commands (code generation, refactoring), Memory & Learning Commands (correction capture, history replay), and Context & Cost Commands (token budgeting, context inspection). Each command is mapped to a specific agent and skill combination, with built-in help, argument validation, and error handling.

Supports 32+ AI agents (Claude Code, Cursor, Gemini, etc.) through a unified plugin manifest system. Each agent has a plugin.json manifest that defines how Pro Workflow integrates with that agent's API and UI. Manifests specify command routing, context injection points, hook integration, and UI elements. The system abstracts away agent-specific differences, allowing the same workflow definition to run on multiple agents without modification.

Implements Quality & Review agents that enforce automated testing, linting, and code review gates before code is committed. Agents can run test suites, check code coverage, scan for security vulnerabilities, and generate review comments. Gates are configurable (can be warnings or hard blocks) and can be skipped with explicit override commands. Integrates with git hooks to prevent commits that fail quality gates unless explicitly approved.

Supports context mode files that dynamically inject different context based on the current task or agent role. Context modes can include different rule sets, code examples, architectural diagrams, or reference implementations depending on whether the agent is implementing, reviewing, or refactoring code. Modes are selected automatically based on the command or can be explicitly set by the developer. This allows the same codebase to be viewed through different lenses (implementation mode vs review mode) without changing the actual code.