requirements-framework

Plugin requirements-framework from marketplace requirements-framework in HarmAalbers/claude-requirements-framework. Commands read from the repo's manifest — 4 days ago.

Skills (21)

• brainstorming

  Use when facing any creative work - creating features, building components, adding functionality, or modifying behavior, before any implementation begins

• dispatching-parallel-agents

  Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

• executing-plans

  Use when there is a written implementation plan to execute in a separate session with review checkpoints

• finishing-a-development-branch

  Use when implementation is complete, all tests pass, and it is time to decide how to integrate the work into the main branch

• receiving-code-review

  Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear, technically questionable, or comes from multiple reviewers

• refactor-orchestration

  Use when starting a multi-layer top-down refactor that's too large for one session. Produces a validated plan and a copy-paste orchestrator prompt that dispatches small chunks to the refactor-executor agent (Haiku) and escalates contradictions to the refactor-investigator agent (Sonnet) plus the use

• requesting-code-review

  Use when completing tasks, implementing major features, or before merging to verify work meets requirements

• requirements-framework-builder

  This skill should be used when the user asks to "extend requirements framework", "add new requirement type", "create custom strategy", "add custom calculator", "modify framework architecture", "create requirement plugin", or wants to build new requirement strategies. Also triggers on questions about

• requirements-framework-development

  This skill should be used when the user asks to "develop requirements framework", "fix requirements framework bug", "rebuild the plugin bundle", "update framework code", "test framework changes", or needs help with the framework development workflow including the hooks/ → bundle build, live-reload t

• requirements-framework-status

  This skill should be used when the user asks to "requirements framework status", "show requirements project context", "what's the state of requirements framework", "requirements framework overview", or wants a comprehensive status report of the requirements framework implementation and current state

• requirements-framework-usage

  This skill should be used when the user asks about "using requirements framework", "how to configure requirements", "add requirement checklist", "customize requirements", "requirements not working", "bypass requirements", "satisfy requirements", or needs help with the requirements framework CLI (req

• session-learning

  This skill should be used when the user asks about "session learning", "learn from session", "improve future sessions", "session reflection", "session metrics", "session analysis", "/session-reflect", "req learning", "learning updates", "rollback learning", or wants to understand how Claude Code can

• subagent-driven-development

  Use when executing implementation plans with independent tasks in the current session

• systematic-debugging

  Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes

• test-driven-development

  Use when implementing any feature or bugfix, before writing implementation code

• using-git-worktrees

  Use when starting feature work that needs isolation from current workspace, or before executing implementation plans in a separate branch

• using-requirements-framework

  Use when starting any conversation to establish skill discovery and invocation practices

• verification-before-completion

  Use when about to claim work is complete, fixed, or passing, before committing, creating PRs, or moving to the next task

• workflow-index

  Use this skill at the start of any non-trivial work in a project that uses the requirements-framework. It maps the current phase to the single next command to run. Triggers on "what next", "where am I", "/req", or when the user is uncertain what workflow to use.

• writing-plans

  Use when there is a spec or requirements for a multi-step task, before touching code

• writing-skills

  Use when creating new skills, editing existing skills, or verifying skills work before deployment

Slash commands (15)

• /requirements-framework:arch-review

  Multi-perspective team-based architecture review with agent debate and commit planning

• /requirements-framework:codex-review

  AI-powered code review using OpenAI Codex

• /requirements-framework:commit-checks

  Auto-fix code quality issues - comment cleanup and import organization

• /requirements-framework:deep-review

  Cross-validated team-based code review with agent debate

• /requirements-framework:execute-plan

  Execute implementation plan with batch checkpoints and review

• /requirements-framework:pre-commit

  Quick code review before committing (code + error handling)

• /requirements-framework:refactor-orchestrate

  Multi-layer top-down refactor workflow. Produces a validated plan and an orchestrator-prompt that runs in a fresh claude session, dispatching Haiku executor chunks and escalating contradictions to a Sonnet investigator.

• /requirements-framework:req-init

  Scaffold .claude/requirements.local.yaml for strict-mode compliance

• /requirements-framework:req-optout

  Mark the project inert under strict mode via the .rf-optout sentinel

• /requirements-framework:req-pause

  Pause the framework's blocking gates for this session only (auto-resumes at session end)

• /requirements-framework:req-resume

  Resume the framework's blocking gates for this session (undo /req-pause)

• /requirements-framework:req

  Workflow conductor — derives the current requirements-framework phase and dispatches to the matching skill/command. Run with no arguments to be guided, or pass an explicit phase. The default phases are design, plan, validate, build, review, ship (these are the default phases; a project may configure

• /requirements-framework:session-reflect

  Review current session and suggest improvements for future sessions

• /requirements-framework:v3-review

  SDK fan-out code review (V3) — structured-output review workers + aggregator, rendered as an ADR-013 report. Additive opt-in alternative to /deep-review (see ADR-018).

• /requirements-framework:write-plan

  Create detailed implementation plan from requirements or spec

Subagents (25)

• adr-guardian

  Use this agent when: (1) Planning code changes to validate plans against existing Architecture Decision Records, (2) Reviewing code to ensure compliance with ADRs, (3) A new architectural pattern, tool choice, or code organization decision needs to be documented, (4) Updating existing ADRs when requ

• appsec-auditor

  Use this agent to audit code for application security vulnerabilities aligned with OWASP Top 10. Specialized for .NET Core + Angular + Python + Azure platforms. Checks for injection flaws (SQL, command, template, LDAP, path traversal, XXE, SSRF), authentication/authorization gaps (missing [Authorize

• backward-compatibility-checker

  Detect breaking changes in schemas, APIs, and contracts that break existing tests. Use this agent when modifying Pydantic models, database schemas, or API contracts to ensure changes don't break existing code.\n\nExamples:\n<example>\nContext: User modified a Pydantic model.\nuser: \"I renamed a fie

• code-reviewer

  Use this agent to review code before committing for adherence to project guidelines, style guides, and best practices. This agent should be used proactively after writing or modifying code, especially before committing changes. It will check for style violations, potential issues, and ensure code fo

• codex-arch-reviewer

  Orchestrates OpenAI Codex CLI for architecture-focused plan and code review. Uses `codex exec` non-interactively to analyze branch changes through an architectural lens: coupling/cohesion, module dependencies, API surface design, scalability, separation of concerns. Skips silently when Codex CLI is

• codex-review-agent

  Orchestrates OpenAI Codex code review workflow. Use this agent for AI-powered code review using OpenAI's Codex CLI for advanced static analysis.\n\nExamples:\n<example>\nContext: User wants an external AI code review.\nuser: \"Run a Codex review on my changes\"\nassistant: \"I'll use the codex-revie

• comment-analyzer

  Use this agent to check comment accuracy before committing. This includes verifying that comments accurately reflect the code they describe, identifying comment rot or technical debt, and ensuring documentation completeness.\n\n<example>\nContext: User has added documentation.\nuser: \"I've added do

• comment-cleaner

  Use this agent to automatically remove useless comments from staged files. Detects and removes comments that just repeat the code, TODOs without context, commented-out code blocks, and obvious docstrings. Auto-fixes issues by editing files directly.\n\nExamples:\n<example>\nContext: User wants to cl

• commit-planner

  Use this agent after a plan has been created and validated by adr-guardian. Creates an atomic commit strategy by analyzing the plan structure, identifying logical commit boundaries, and appending the commit sequence to the plan file. Ensures each commit is independently reviewable and follows depend

• compliance-auditor

  Use this agent to audit code for regulatory compliance with GDPR/AVG (Dutch privacy law), audit trail requirements, PII handling, legal professional privilege (verschoningsrecht), and NOvA (Netherlands Bar Association) requirements. Specialized for Dutch law firm SaaS platforms handling privileged a

• frontend-reviewer

  Use this agent to review React/frontend code for best practices, accessibility, performance, and project-specific checklist compliance. Triggers when changes include .tsx, .jsx, .css, .scss, or .ts files with React imports. The agent loads project-configurable checklists from .claude/requirements.ya

• import-organizer

  Use this agent to automatically organize imports in staged Python files. Moves imports to the top of the file and groups them by stdlib, third-party, and local. Auto-fixes issues by editing files directly.\n\nExamples:\n<example>\nContext: User wants imports organized.\nuser: \"Organize the imports

• refactor-advisor

  Use this agent when reviewing a plan to identify preparatory refactoring opportunities in the existing codebase. Analyzes the planned change and the code it will touch, then identifies structural improvements that would make the planned change easier, simpler, or more natural to implement. Follows M

• refactor-analyzer

  Retrospective writer for refactor orchestration runs. Reads the session transcript, git log, and learnings ledger; produces a structured retrospective report; appends new observations to the learnings ledger; proposes template/agent edits when an observation hits rule-of-three (count=3). Mostly read

• refactor-executor

  Mechanical chunk executor for refactor orchestration. Reads ONLY the referenced plan section, writes or edits the named files, verifies with ruff and an import smoke. Does NOT redesign, does NOT read ADRs, does NOT ask questions. Use when a refactor plan is frozen and you need a specific chunk imple

• refactor-investigator

  Read-only diagnostician for refactor orchestration. Diagnoses contradictions between a frozen plan and current code / library / framework reality. Returns root cause + 2-3 solution paths with trade-offs. Does NOT change any code. Use when a refactor-executor reports a complex issue that suggests the

• sentry-triage

  Checks Sentry for unresolved production errors/warnings in the code a plan is about to change. Reads the project's `sentry: {org, project}` block from the requirements.yaml cascade, derives the touched files from the plan (or branch diff), and searches Sentry via MCP for unresolved issues referencin

• session-analyzer

  Analyzes session metrics to identify patterns, friction points, and improvement opportunities. This agent reviews tool usage, requirement satisfaction, errors, and workflows to suggest improvements to memories, skills, and commands for future sessions.\n\nExamples:\n<example>\nContext: User wants to

• silent-failure-hunter

  Use this agent to check error handling before committing code that involves try-catch blocks, error callbacks, fallback logic, or any code that could potentially suppress errors. This agent should be invoked proactively after completing a logical chunk of work that involves error handling.\n\n<examp

• solid-reviewer

  Use this agent when reviewing a plan to validate SOLID design principles. Checks for Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion violations with Python-specific guidance. Scales strictness proportionally to plan size. This is a BLOCKING ag

• tdd-validator

  Use this agent when reviewing a plan to validate TDD readiness. Checks that the plan includes a testing strategy section, identifies test types per feature/component, and describes a TDD sequence (tests written first). This is a BLOCKING agent - plans should not proceed without TDD elements.\n\nExam

• tenant-isolation-auditor

  Use this agent to audit code for multi-tenant data leakage vulnerabilities. Specialized for .NET Core + EF Core + Angular + Azure platforms serving multiple tenants. Checks for missing tenant filters on DB queries, shared caches without tenant-scoped keys, global query filter bypasses, cross-tenant

• test-analyzer

  Use this agent to review test coverage quality and completeness before committing. This agent should be invoked when tests have been added or modified to ensure they adequately cover functionality and edge cases.\n\n<example>\nContext: User has written new tests.\nuser: \"I've created the tests. Can

• tool-validator

  Execute linting and type-checking tools on staged changes to catch CI errors locally. Use this agent to run pyright, ruff, eslint, and other CI tools before committing to catch errors early.\n\nExamples:\n<example>\nContext: User wants to check if their code will pass CI.\nuser: \"Run the linters be

• type-design-analyzer

  Use this agent to analyze type design before committing new types. Specifically use it when introducing a new type to ensure it follows best practices for encapsulation and invariant expression, or when refactoring existing types. The agent provides ratings on encapsulation, invariant expression, us

Hooks (13)

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/check-requirements.py

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/auto-satisfy-skills.py

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/clear-single-use.py

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/handle-plan-exit.py

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/handle-plan-enter.py

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/hooks/handle-session-start.py

• Stop

  ${CLAUDE_PLUGIN_ROOT}/hooks/handle-stop.py

• Stop

  ${CLAUDE_PLUGIN_ROOT}/hooks/langfuse-trace.py

• SessionEnd

  ${CLAUDE_PLUGIN_ROOT}/hooks/handle-session-end.py

• UserPromptSubmit

  ${CLAUDE_PLUGIN_ROOT}/hooks/handle-prompt-submit.py

• SubagentStart

  ${CLAUDE_PLUGIN_ROOT}/hooks/handle-subagent-start.py

• PostToolUseFailure

  ${CLAUDE_PLUGIN_ROOT}/hooks/handle-tool-failure.py

• PreCompact

  ${CLAUDE_PLUGIN_ROOT}/hooks/handle-pre-compact.py