agents-united 0.5.0

package/registry/workflows/workflow-e2e-testing.md

@@ -0,0 +1,49 @@
+---
+name: "End-to-End Browser Test Automation"
+description: "Workflow for authoring and running Playwright browser test specs, capturing failure traces/videos, and validating critical user journeys."
+bundle: "qa-automation"
+estimatedDuration: "15-30m"
+---
+
+# Workflow: End-to-End Browser Test Automation
+
+## Overview & Scope
+The E2E Testing workflow executes automated browser journeys across desktop and mobile viewports, verifying critical business flows (signup, checkout, data mutation) with video/trace capture.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Test Scenario & Page Object Scaffolding]
+    P1 --> InputCheck{"User Journey Defined?"}
+    InputCheck -->|No| Abort1[Clarify Acceptance Criteria]
+    InputCheck -->|Yes| P2[Phase 2: Playwright Spec Implementation]
+    P2 --> Gate1{"Verification Gate: Test Suite Passes 100%?"}
+    Gate1 -->|Fail| P2Debug[Inspect Trace Viewer & Fix Assertions]
+    P2Debug --> P2
+    Gate1 -->|Pass| P3[Phase 3: Multi-Browser Matrix & CI Report]
+    P3 --> Done([E2E Test Suite Certified])
+```
+
+## Required Tool Inputs & Context
+- Target user flow description and test credentials
+- Playwright configuration and preview URL
+- Expected UI states and assertions
+
+## Phase 1: Test Scenario & Page Object Scaffolding
+- Map user story steps into Page Object Model methods.
+- Set up isolated test database fixtures and authentication storage states.
+
+## Phase 2: Playwright Spec Implementation
+- Author test assertions utilizing user-facing locators (`getByRole`, `getByLabel`).
+- Execute test run locally via `npx playwright test`.
+
+## Phase 3: Multi-Browser Matrix & CI Report
+- Run tests against Chromium, Firefox, and WebKit matrix.
+- Generate HTML test report and verify trace artifacts on any retried tests.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Page Objects structured | POM code review | Selectors utilize role/label locators |
+| Phase 2 -> Phase 3 | Local tests passing | `npx playwright test` | 100% test scenarios pass with exit code 0 |
+| Phase 3 -> Completion | Multi-browser matrix verified | CI test runner execution | Zero test flakes or unhandled exceptions |

package/registry/workflows/workflow-email-drip-sequence.md

@@ -0,0 +1,65 @@
+---
+name: "Automated Email Drip Sequence & Lifecycle Nurturing"
+description: "Workflow for architecting automated email nurture sequences, behavioral trigger rules, deliverability testing, and churn prevention playbooks."
+bundle: "lifecycle-email-marketing"
+estimatedDuration: "30-60m"
+---
+
+# Workflow: Automated Email Drip Sequence & Lifecycle Nurturing
+
+## Overview & Scope
+The Email Drip Sequence workflow creates lifecycle email automation campaigns. It designs onboarding welcome drips, behavioral re-engagement triggers, trial-to-paid conversion sequences, and churn prevention playbooks while enforcing deliverability and compliance standards.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Audience Segmentation & Trigger Mapping]
+    P1 --> InputCheck{"User Segments & Event Triggers Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Segment Definitions]
+    InputCheck -->|Yes| P2[Phase 2: Email Copywriting & Template Staging]
+    P2 --> Gate1{"Verification Gate: Deliverability & HTML Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Deliverability Testing & Workflow Activation]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Rendering / Spam Score Issues]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- Lifecycle stage definitions (New User, Active Free, Trial Expiring, Inactive At-Risk, Churned)
+- Behavioral event triggers (User Signed Up, Feature Unused after 7 Days, Trial Day 11, Churn Risk Score > 70)
+- Responsive email HTML templates and merge tag syntax specification
+- Deliverability configuration (SPF, DKIM, DMARC, List-Unsubscribe headers)
+
+## Phase 1: Audience Segmentation & Trigger Mapping
+- Map lifecycle trigger rules and delay cadences (Day 0: Welcome, Day 2: Key Feature Tutorial, Day 5: Case Study, Day 10: Upgrade Offer).
+- Define audience inclusion and exclusion filters (e.g., exclude paying customers from upgrade drips).
+- Configure frequency capping rules to prevent subscriber email fatigue.
+- Set primary conversion goals per sequence (Activation, Upgrade, Feature Adoption, Re-activation).
+
+## Phase 2: Email Copywriting & Template Staging
+- Draft compelling subject lines, preview text, and body copy using proven copywriting frameworks (PAS, AIDA).
+- Build responsive HTML/CSS email templates with dynamic merge tags (`first_name`, `company_name`, `usage_stat`).
+- Implement plain-text email fallbacks and one-click unsubscribe links compliant with CAN-SPAM and GDPR.
+- Configure A/B split testing for subject lines and CTA button copy.
+
+## Phase 3: Deliverability Testing & Workflow Activation
+- Audit authentication records (SPF, DKIM, DMARC) and run automated spam score analysis (SpamAssassin score < 2.0).
+- Perform cross-client rendering test across mobile, desktop, web clients, and Dark Mode.
+- Verify webhook bounce handling and unsubscribe event processing.
+- Deploy automated drip sequences into live marketing automation engine.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `npm test` | Email template validator confirms responsive HTML layout, merge tag syntax, and link tracking |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Automation sequence configuration and email templates compile without errors |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Email spam test produces zero deliverability warnings and passes SPF/DKIM verification.
+- **Validation Checkpoint 2**: HTML templates render correctly across 100% of tested client configurations including dark mode.
+- **Validation Checkpoint 3**: Unsubscribe links and physical mailing address headers are present in all message templates.
+- **Automated Rollback Protocol**: Immediately pause active drip automation and suppress affected recipient segments if bounce rate exceeds 2.5% or spam complaint rate exceeds 0.08% during initial sequence sends.

package/registry/workflows/workflow-estimate.md

@@ -0,0 +1,60 @@
+---
+name: "Technical Estimation & Complexity Analysis"
+description: "Structured workflow for estimating engineering effort, breaking down tasks, assigning complexity scores, and identifying risks."
+bundle: "system-architecture"
+estimatedDuration: "20-40m"
+---
+
+# Workflow: Technical Estimation & Complexity Analysis
+
+## Overview & Scope
+The Estimate workflow standardizes task breakdown and effort estimation. It leverages story points, complexity scoring, risk identification, and confidence intervals to produce reliable project estimates.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- Feature spec or architecture design document
+- Task breakdown structure (WBS) template
+- Historical velocity and estimation baseline metrics
+
+## Phase 1: Context & Reconnaissance
+- Deconstruct overall feature or epic into granular, atomic engineering tasks.
+- Identify technical dependencies across frontend, backend, infrastructure, and QA domains.
+- Flag high-uncertainty areas requiring spikes or research.
+
+## Phase 2: Execution & Orchestration
+- Assign Fibonacci story point scores (1, 2, 3, 5, 8, 13) to each decomposed task.
+- Assess technical risk factors (low, medium, high) and assign confidence ratings.
+- Calculate total duration range (best-case, worst-case, expected) including buffer for risks.
+
+## Phase 3: Verification & Closure
+- Review task estimates with engineering leads to ensure consensus.
+- Document estimation assumptions, risk mitigations, and prerequisite dependencies.
+- Publish technical estimation matrix to project management repository.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `node dist/cli.js doctor` | Project tasks properly formatted with explicit acceptance criteria |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Verification build runs cleanly without broken task dependencies |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Every task item has assigned story points, risk rating, and explicit owner role.
+- **Validation Checkpoint 2**: Summed estimate includes explicit contingency buffer for identified risks.
+- **Automated Rollback Protocol**: Re-scope and re-estimate feature breakdown if total duration exceeds iteration budget capacity.

package/registry/workflows/workflow-explain.md

@@ -0,0 +1,60 @@
+---
+name: "Architectural Explanation & Technical Walkthrough"
+description: "Workflow for explaining complex codebase architectures, technical concepts, design patterns, and code implementations clearly."
+bundle: "deep-research"
+estimatedDuration: "20-40m"
+---
+
+# Workflow: Architectural Explanation & Technical Walkthrough
+
+## Overview & Scope
+The Explain workflow creates clear technical explanations. It structures walkthroughs using progressive disclosure (High-level summary -> Diagram -> Code inspection -> Edge cases) tailored to audience experience.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- Target codebase files or technical concept
+- Target audience experience profile (Beginner, Intermediate, Senior Engineer)
+- Explanation document template
+
+## Phase 1: Context & Reconnaissance
+- Analyze target code module to understand core mechanisms and data flows.
+- Identify key concepts requiring explanation and potential points of confusion.
+- Determine appropriate depth level based on audience profile.
+
+## Phase 2: Execution & Orchestration
+- Construct high-level summary overview of the component or architecture.
+- Draw system interaction diagram illustrating data flow between modules.
+- Provide step-by-step code walkthrough with line-by-line commentary.
+
+## Phase 3: Verification & Closure
+- Review explanation for clarity, technical accuracy, and tone.
+- Add FAQ section covering common edge cases and troubleshooting tips.
+- Publish Technical Explanation Document.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `node dist/cli.js doctor` | Doctor health check confirms explanation document structure |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run typecheck` | Code snippets inside explanation compile cleanly |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Explanation tailored appropriately to target audience technical level.
+- **Validation Checkpoint 2**: Code commentary verified against actual implementation logic.
+- **Automated Rollback Protocol**: Clarify ambiguous sections if peer review identifies inaccurate commentary.

package/registry/workflows/workflow-frontend-audit.md

@@ -0,0 +1,49 @@
+---
+name: "Frontend Performance & Accessibility Audit"
+description: "Workflow for measuring Core Web Vitals (LCP, INP, CLS), client bundle sizes, WCAG accessibility, and responsive layout fidelity."
+bundle: "frontend-engineering"
+estimatedDuration: "15-30m"
+---
+
+# Workflow: Frontend Performance & Accessibility Audit
+
+## Overview & Scope
+The Frontend Audit workflow evaluates web applications against Core Web Vitals thresholds (Largest Contentful Paint, Interaction to Next Paint, Cumulative Layout Shift), accessibility standards, and JavaScript bundle sizes.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Bundle & Asset Size Analysis]
+    P1 --> InputCheck{"Bundle Analysis Complete?"}
+    InputCheck -->|No| Abort1[Generate Bundle Stats]
+    InputCheck -->|Yes| P2[Phase 2: Core Web Vitals & Runtime Profiling]
+    P2 --> Gate1{"Verification Gate: CWV Within Targets?"}
+    Gate1 -->|Fail| P2Opt[Apply Code Splitting & Asset Optimizations]
+    P2Opt --> P2
+    Gate1 -->|Pass| P3[Phase 3: Accessibility & Screen Reader Audit]
+    P3 --> Done([Frontend Audit Signed Off])
+```
+
+## Required Tool Inputs & Context
+- Production build bundle stats or Lighthouse test runner
+- Target performance budgets (e.g. initial JS < 150KB gzip)
+- Web application URL or local preview server
+
+## Phase 1: Bundle & Asset Size Analysis
+- Analyze Webpack / Vite / Next.js bundle visualizer output.
+- Identify duplicate dependencies or un-tree-shaken libraries.
+
+## Phase 2: Core Web Vitals & Runtime Profiling
+- Measure Largest Contentful Paint (LCP < 2.5s), Cumulative Layout Shift (CLS < 0.1), and Interaction to Next Paint (INP < 200ms).
+- Apply lazy loading, dynamic imports, and font optimization.
+
+## Phase 3: Accessibility & Screen Reader Audit
+- Run automated axe-core / Lighthouse a11y audit to verify WCAG 2.1 AA compliance.
+- Confirm keyboard tab navigation and modal focus trapping.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Bundle analysis complete | Bundle size measurement | Main bundle under 150KB gzipped |
+| Phase 2 -> Phase 3 | Performance metrics gathered | Lighthouse / Web Vitals audit | Performance score >= 90 |
+| Phase 3 -> Completion | Accessibility verified | A11y axe-core scan | 0 critical/serious accessibility violations |

package/registry/workflows/workflow-git.md

@@ -0,0 +1,60 @@
+---
+name: "Git Version Control & Branch Strategy"
+description: "Workflow for managing git feature branches, atomic commit formatting, rebase workflow, PR preparation, and merge readiness."
+bundle: "software-engineering"
+estimatedDuration: "10-20m"
+---
+
+# Workflow: Git Version Control & Branch Strategy
+
+## Overview & Scope
+The Git workflow establishes best practices for version control operations. It covers branch creation, atomic Conventional Commits, interactive rebasing, merge conflict resolution, and pull request preparation.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- Git CLI tool
+- Conventional Commit naming convention guidelines
+- Target base branch (`main` / `dev`)
+
+## Phase 1: Context & Reconnaissance
+- Inspect `git status` to verify current working directory state.
+- Fetch latest remote branches (`git fetch origin`) and check rebase status against base branch.
+- Review pending uncommitted changes and organize them into logical, atomic change sets.
+
+## Phase 2: Execution & Orchestration
+- Stage changes incrementally (`git add -p`) and craft conventional commit messages (`feat:`, `fix:`, `docs:`).
+- Perform interactive rebase onto target base branch (`git rebase origin/main`) to maintain linear history.
+- Resolve any merge conflicts cleanly, running tests after each resolved conflict.
+
+## Phase 3: Verification & Closure
+- Verify git commit history hygiene (no fixup commits, clean messages).
+- Push feature branch to remote origin (`git push -u origin feature-branch`).
+- Prepare PR description linking related issues, summarizing changes, and listing verification commands.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `git status` | Working tree is clean with no unstaged changes or untracked files |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `git log -n 5 --oneline` | Commit history is linear and messages adhere to Conventional Commits |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Branch rebased onto current remote base branch without remaining conflict markers.
+- **Validation Checkpoint 2**: Remote feature branch synchronized and PR ready for review.
+- **Automated Rollback Protocol**: Use `git rebase --abort` to cancel rebase if conflicts become unmanageable, returning to pre-rebase state.

package/registry/workflows/workflow-grill.md

@@ -0,0 +1,51 @@
+---
+name: "Socratic Alignment & Domain Grilling"
+description: "Interactive orchestration workflow for Socratic requirements grilling, ubiquitous language definition in CONTEXT.md, and ADR creation."
+bundle: "software-engineering"
+estimatedDuration: "15-30m"
+---
+
+# Workflow: Socratic Alignment & Domain Grilling
+
+## Overview & Scope
+The Socratic Alignment & Domain Grilling workflow aligns developers and orchestrators on problem scope, edge cases, and non-goals. It invokes the `grill-with-docs`, `grill-me`, and `domain-modeling` skills to build a shared vocabulary in `CONTEXT.md` and record decisions in ADRs (`docs/adr/`).
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Socratic Alignment Interview]
+    P1 --> Gate1{"User Intent & Scope Explicit?"}
+    Gate1 -->|No| P1
+    Gate1 -->|Yes| P2[Phase 2: Ubiquitous Language & CONTEXT.md Sync]
+    P2 --> P3[Phase 3: ADR Generation & Hand-off]
+    P3 --> Done([Workflow Complete])
+```
+
+## Required Tool Inputs & Context
+- Project root with `CONTEXT.md` (or authorization to create `CONTEXT.md`).
+- Feature request or architectural proposal details.
+
+## Phase 1: Socratic Alignment Interview
+- Execute `/grill-with-docs` or `/grill-me` skill runbook.
+- Interrogate assumptions, data flows, edge cases, failure states, and performance constraints.
+- Collect explicit user decisions on every trade-off.
+
+## Phase 2: Ubiquitous Language & CONTEXT.md Sync
+- Extract candidate domain terms from the interview.
+- Update `CONTEXT.md` with definitions for new domain entities and rules.
+
+## Phase 3: ADR Generation & Hand-off
+- Document chosen architectural strategy in `docs/adr/ADR-XXXX-<title>.md`.
+- Summarize agreed scope and hand off to technical specification (`workflow-spec.md`) or implementation (`workflow-implement.md`).
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Grilling questions answered | User approval | All ambiguities resolved |
+| Phase 2 -> Phase 3 | Terms extracted | `CONTEXT.md` check | `CONTEXT.md` contains defined terms |
+| Phase 3 -> Completion | ADR formatted | `docs/adr/*.md` exists | ADR saved cleanly |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: All questions answered before drafting ADR.
+- **Validation Checkpoint 2**: `CONTEXT.md` contains valid domain definitions.
+- **Rollback Protocol**: Revert draft ADR files if grilling reveals invalid assumptions.

package/registry/workflows/workflow-implement.md

@@ -0,0 +1,61 @@
+---
+name: "Implement Feature or Fix"
+description: "End-to-end procedural workflow for code implementation, refactoring, and feature execution with TDD validation and regression checks."
+bundle: "software-engineering"
+estimatedDuration: "30-60m"
+---
+
+# Workflow: Implement Feature or Fix
+
+## Overview & Scope
+The Implement workflow guides developers and autonomous agents through a rigorous implementation process. It enforces Test-Driven Development (TDD) principles, incremental code modifications, and strict phase verification gates to ensure code quality and zero regressions.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- Target file paths & module interfaces
+- Feature requirements or issue specification document
+- Test suite execution command (`npm test`)
+- Linter & static type-checker (`npm run typecheck`, `npm run lint`)
+
+## Phase 1: Context & Reconnaissance
+- Analyze the feature specification or issue report to understand functional goals and constraints.
+- Inspect existing codebase state, git branch status, and relevant module dependencies.
+- Identify target test files and code components that will be affected by the implementation.
+
+## Phase 2: Execution & Orchestration
+- Write red unit tests covering expected new functionality or bug reproduction.
+- Implement minimum viable code changes required to transition tests from failing to passing (green state).
+- Refactor implementation for readability, performance, and style consistency while maintaining passing tests.
+
+## Phase 3: Verification & Closure
+- Run the full project test suite to verify no regressions were introduced in existing functionality.
+- Execute static type checking (`tsc --noEmit`) and linter checks to ensure compliance with codebase standards.
+- Summarize implementation details, updated files, and test results for reviewer handoff.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `npm run typecheck` | 0 type errors across all project files |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm test` | 100% of unit and integration tests passing cleanly |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Red-Green-Refactor test cycle verified before staging changes.
+- **Validation Checkpoint 2**: Static type checking and linting pass without errors or warnings.
+- **Automated Rollback Protocol**: Execute `git checkout -- .` or `git reset --hard HEAD` to revert incomplete or failing edits if verification fails.

package/registry/workflows/workflow-incident-triage.md

@@ -0,0 +1,49 @@
+---
+name: "Production Incident Response & Triage"
+description: "Workflow for responding to production alerts, triaging telemetry metrics, executing runbooks, and publishing blameless post-mortems."
+bundle: "sysops-sre"
+estimatedDuration: "15-45m"
+---
+
+# Workflow: Production Incident Response & Triage
+
+## Overview & Scope
+The Incident Response workflow guides SRE and SysOps engineers through structured triage, root-cause investigation, emergency mitigation, and post-mortem reporting during production incidents.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Alert Triggered]) --> P1[Phase 1: Severity Classification & Telemetry Triage]
+    P1 --> TriageCheck{"Severity Level Determined?"}
+    TriageCheck -->|P1 Critical| P2[Phase 2: Emergency Mitigation & Rerouting]
+    TriageCheck -->|P2/P3 Degraded| P2
+    P2 --> Gate1{"Verification Gate: Service Restored?"}
+    Gate1 -->|No| Escalation[Escalate & Execute DR Failover]
+    Escalation --> P2
+    Gate1 -->|Yes| P3[Phase 3: Post-Mortem & Preventative Action]
+    P3 --> Done([Incident Resolved & Documented])
+```
+
+## Required Tool Inputs & Context
+- Triggering alert payload or error metric log trace
+- System architecture diagram and service dependencies
+- Prometheus / Grafana telemetry metrics and incident runbook
+
+## Phase 1: Severity Classification & Telemetry Triage
+- Correlate triggering alert with RED metrics (Rate, Errors, Duration).
+- Classify incident severity (P1 Critical Outage, P2 High Impact, P3 Moderate Degraded State).
+
+## Phase 2: Emergency Mitigation & Rerouting
+- Execute runbook mitigation steps (pod scaling, traffic drain, service restart, cache flush).
+- Monitor p99 latency and error rates to confirm service stabilization.
+
+## Phase 3: Post-Mortem & Preventative Action
+- Draft Blameless Post-Mortem covering timeline, root cause, impact metrics, and action items.
+- File preventative engineering tickets to prevent incident recurrence.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Incident severity classified | Log analysis & alert payload audit | Impacted microservices identified |
+| Phase 2 -> Phase 3 | Mitigation steps applied | Telemetry HTTP 5xx error rate audit | Error rate drops below 0.1% SLO threshold |
+| Phase 3 -> Completion | Service health verified | Post-mortem markdown audit | Post-mortem document includes action items and owner assignments |

package/registry/workflows/workflow-interaction-design--design-interaction.md

@@ -0,0 +1,60 @@
+---
+name: "Micro-Interaction & Transition Design"
+description: "Workflow for designing component state transitions, micro-animations, timing curves, and interactive UI behavior specs."
+bundle: "product-design"
+estimatedDuration: "30-45m"
+---
+
+# Workflow: Micro-Interaction & Transition Design
+
+## Overview & Scope
+This workflow defines micro-interactions and UI motion specs. It standardizes transition durations, easing curves, visual feedback states, and accessibility fallbacks for motion sensitivities.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- UI component visual designs
+- Design system motion guidelines (durations, easing curves)
+- Accessibility reduced motion specification (`prefers-reduced-motion`)
+
+## Phase 1: Context & Reconnaissance
+- Identify interactive UI triggers (hover, active press, toggle, modal open, page transition).
+- Review target motion principles (expressive vs functional animation).
+- Establish duration thresholds (150ms micro-interactions, 300ms layout transitions).
+
+## Phase 2: Execution & Orchestration
+- Define animation properties (scale, opacity, transform, background-color).
+- Select cubic-bezier easing curves (ease-in-out, standard spring curves).
+- Design reduced-motion alternatives for users with motion sensitivity settings.
+
+## Phase 3: Verification & Closure
+- Verify motion performance (60fps hardware acceleration, GPU-promoted layers).
+- Document interaction spec with timing values and CSS/Framer Motion code snippets.
+- Export interaction tokens (`duration-fast`, `ease-out-back`).
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `npm test` | Interaction suite verifies prefers-reduced-motion fallbacks for all motion specs |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Motion animation CSS/JS tokens build cleanly |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: All transition durations fall within standard 100ms-300ms usability window.
+- **Validation Checkpoint 2**: Explicit reduced-motion fallback defined for every animated component.
+- **Automated Rollback Protocol**: Simplify animation curves and remove heavy transforms if frame rate drops below 60fps.

package/registry/workflows/workflow-interaction-design--error-flow.md

@@ -0,0 +1,60 @@
+---
+name: "Error UX & Fault Recovery Flow Design"
+description: "Workflow for mapping error states, validation feedback, network failure fallbacks, and user recovery paths across UI components."
+bundle: "product-design"
+estimatedDuration: "30-45m"
+---
+
+# Workflow: Error UX & Fault Recovery Flow Design
+
+## Overview & Scope
+The Error Flow workflow ensures resilient UI design during system failures. It maps validation errors, network offline states, API exceptions, and user recovery mechanisms with clear human-centric UX.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- User interaction flows & form specifications
+- API error payload schemas and HTTP status codes
+- Error copy guidelines
+
+## Phase 1: Context & Reconnaissance
+- Enumerate all potential failure modes (field validation failure, session timeout, network offline, 500 server error).
+- Audit existing error message copy for clarity and tone.
+- Define focus management strategy when error state triggers.
+
+## Phase 2: Execution & Orchestration
+- Design inline error messages, toast alerts, empty state illustrations, and modal error dialogs.
+- Map explicit recovery paths for the user (Retry CTA, Re-authenticate link, Customer support fallback).
+- Draft clear, empathetic error copy explaining what happened and how to fix it.
+
+## Phase 3: Verification & Closure
+- Review error flows against accessibility guidelines (ARIA live regions `aria-live="polite"`).
+- Verify focus is placed on broken form inputs or alert headers upon error submission.
+- Publish Error UX Specification Matrix.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `npm test` | Error flow tests verify accessibility ARIA live attributes on error containers |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run typecheck` | Error payload interfaces compile cleanly |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Every failure mode has an explicit UI design and recovery CTA.
+- **Validation Checkpoint 2**: Zero technical error jargon in user-facing message copy.
+- **Automated Rollback Protocol**: Revise error messages and recovery paths if usability checks reveal confusing copy.