agents-united 1.0.0 → 1.2.0

package/registry/workflows/workflow-design-ops--setup-workflow.md

@@ -1,15 +1,60 @@
-# Workflow: Design Ops  Setup Workflow
+---
+name: "Design Tooling & Workflow Pipeline Setup"
+description: "Workflow for configuring design tooling pipelines, version control rules, asset sync scripts, and team workspace environments."
+bundle: "product-design"
+estimatedDuration: "30-60m"
+---
 
-Multi-phase procedural workflow for Design Ops  Setup Workflow.
+# Workflow: Design Tooling & Workflow Pipeline Setup
+
+## Overview & Scope
+The Setup Workflow provisions design infrastructure. It configures design tool integrations, token sync automation webhooks, asset export scripts, and team workspace governance rules.
+
+## 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
+- Design tool API credentials (Figma API token, repository tokens)
+- Project workspace template files
+- CI/CD workflow definitions
 
 ## Phase 1: Context & Reconnaissance
-- Analyze the user request and existing codebase state.
-- Gather necessary inputs and verify environment readiness.
+- Audit existing design tooling setup and identifying automation friction points.
+- Inspect repository access permissions and webhook configuration settings.
+- Prepare automated sync scripts for tokens and assets.
 
 ## Phase 2: Execution & Orchestration
-- Execute core steps with progressive verifications.
-- Delegate sub-tasks to specialized sub-agents.
+- Configure automated webhook triggers for design token synchronization on file updates.
+- Set up linter rules for design file naming conventions and component organization.
+- Establish design file branching and approval workflow rules.
 
 ## Phase 3: Verification & Closure
-- Run verification tests and linting.
-- Document outcome and present summary.
+- Execute test run of automated asset sync pipeline.
+- Verify workspace permissions and access controls across team member roles.
+- Publish Design Workflow Documentation.
+
+## 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` | Pipeline integration test suite confirms webhook payload processing |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Workflow setup scripts compile without errors |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Automated webhook triggers successfully on token repository changes.
+- **Validation Checkpoint 2**: Design token repository synchronizes automatically without manual intervention.
+- **Automated Rollback Protocol**: Revert webhook credentials and API configurations if sync verification tests fail.

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

@@ -1,15 +1,60 @@
-# Workflow: Design Orchestrate
+---
+name: "Multi-Agent Design Orchestration"
+description: "Master orchestration workflow coordinating UI designers, UX strategists, interaction designers, and design system leads on end-to-end design initiatives."
+bundle: "product-design"
+estimatedDuration: "60-120m"
+---
 
-Multi-phase procedural workflow for Design Orchestrate.
+# Workflow: Multi-Agent Design Orchestration
+
+## Overview & Scope
+The Design Orchestrate workflow manages multi-agent design pipelines. It decomposes large product epics, delegating sub-tasks to UX Strategist, UI Designer, Interaction Designer, and Design Systems subagents.
+
+## 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
+- Product epic specification document
+- Design subagent manifest definitions
+- Design system token and component specs
 
 ## Phase 1: Context & Reconnaissance
-- Analyze the user request and existing codebase state.
-- Gather necessary inputs and verify environment readiness.
+- Deconstruct epic into domain-specific subagent assignments (UX Strategy -> Visual Design -> Micro-Interactions -> Tokens).
+- Establish subagent input/output file contracts and state passing conventions.
+- Verify subagent environment readiness.
 
 ## Phase 2: Execution & Orchestration
-- Execute core steps with progressive verifications.
-- Delegate sub-tasks to specialized sub-agents.
+- Dispatch UX Strategist subagent to frame problems and define wireframe flows.
+- Dispatch UI Designer and Interaction Designer subagents to author screen visuals and motion specs.
+- Dispatch Design Systems Lead subagent to verify token alignment and component reuse.
 
 ## Phase 3: Verification & Closure
-- Run verification tests and linting.
-- Document outcome and present summary.
+- Synthesize subagent deliverables into a unified Master Design Specification.
+- Run end-to-end completeness and consistency verification checks.
+- Publish Design Orchestration Summary.
+
+## 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` | Orchestration test suite confirms all subagent deliverables meet quality gates |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Master design documentation builds cleanly |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: All delegated subagent tasks completed without missing output artifacts.
+- **Validation Checkpoint 2**: Unified design spec complies 100% with design system token rules.
+- **Automated Rollback Protocol**: Re-invoke specific failed subagent with adjusted parameters if deliverable fails quality bar.

package/registry/workflows/workflow-design-systems--audit-system.md

@@ -1,15 +1,60 @@
-# Workflow: Design Systems  Audit System
+---
+name: "Design System & Component Drift Audit"
+description: "Workflow for auditing codebase UI components against design system standards, detecting hardcoded styles, and cataloging component drift."
+bundle: "product-design"
+estimatedDuration: "30-60m"
+---
 
-Multi-phase procedural workflow for Design Systems  Audit System.
+# Workflow: Design System & Component Drift Audit
+
+## Overview & Scope
+This workflow monitors design system adoption and component drift. It scans the codebase for hardcoded hex colors, arbitrary spacing, duplicate component implementations, and detached styles.
+
+## 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
+- Component library codebase & design token definitions
+- AST / static analysis scanning scripts
+- Design system adoption target metrics
 
 ## Phase 1: Context & Reconnaissance
-- Analyze the user request and existing codebase state.
-- Gather necessary inputs and verify environment readiness.
+- Configure static analysis rules to search for inline styles, raw CSS hex colors, and hardcoded pixel values.
+- Scan codebase UI components to list custom component implementations.
+- Establish design system adoption baseline score.
 
 ## Phase 2: Execution & Orchestration
-- Execute core steps with progressive verifications.
-- Delegate sub-tasks to specialized sub-agents.
+- Categorize drift violations by severity (e.g. Critical: raw color usage, Major: custom button rewrite, Minor: arbitrary padding).
+- Calculate adoption metrics per module/page.
+- Identify candidate components for design system consolidation.
 
 ## Phase 3: Verification & Closure
-- Run verification tests and linting.
-- Document outcome and present summary.
+- Generate Design System Drift Report with exact file paths and line numbers.
+- Create refactoring tickets to migrate custom components to design system tokens.
+- Publish Design Debt Dashboard.
+
+## 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` | Drift audit script completes scan across 100% of codebase UI files |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run typecheck` | Static type checking passes cleanly post-scan |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: 100% of codebase UI components scanned for style violations.
+- **Validation Checkpoint 2**: Every detected drift instance cataloged with file path, line number, and remediation guidance.
+- **Automated Rollback Protocol**: Adjust audit script parameters if false positive scans exceed acceptable noise threshold.

package/registry/workflows/workflow-design-systems--create-component.md

@@ -1,15 +1,60 @@
-# Workflow: Design Systems  Create Component
+---
+name: "Design System Component Authoring"
+description: "End-to-end workflow for designing, building, documenting, and testing a reusable design system component."
+bundle: "product-design"
+estimatedDuration: "45-90m"
+---
 
-Multi-phase procedural workflow for Design Systems  Create Component.
+# Workflow: Design System Component Authoring
+
+## Overview & Scope
+The Create Component workflow governs the authoring of production-ready design system components. It enforces token integration, accessibility compliance, state coverage, and Storybook documentation.
+
+## 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
+- Component API specification and visual designs
+- Design token library (`tokens.json`)
+- Storybook / component testing framework (`vitest` / `axe-core`)
 
 ## Phase 1: Context & Reconnaissance
-- Analyze the user request and existing codebase state.
-- Gather necessary inputs and verify environment readiness.
+- Review component API design, props, variants, and keyboard interaction specs.
+- Verify design tokens needed for component styling are available.
+- Select component template structure in design system workspace.
 
 ## Phase 2: Execution & Orchestration
-- Execute core steps with progressive verifications.
-- Delegate sub-tasks to specialized sub-agents.
+- Implement component TSX code, applying semantic design tokens for styling.
+- Implement keyboard navigation and ARIA accessibility attributes matching target design pattern.
+- Author unit tests, accessibility tests (`axe-core`), and Storybook story files.
 
 ## Phase 3: Verification & Closure
-- Run verification tests and linting.
-- Document outcome and present summary.
+- Run automated unit test suite and visual regression tests across all component variants.
+- Verify Storybook stories render cleanly without console warnings.
+- Export component package for distribution.
+
+## 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` | 100% of component unit tests and automated accessibility scans pass |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Component builds cleanly and exports type definitions (`.d.ts`) |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Zero accessibility violations detected by `axe-core` scanner.
+- **Validation Checkpoint 2**: Storybook stories exist for all component variants, sizes, and states.
+- **Automated Rollback Protocol**: Revert component code modifications if visual regression or accessibility tests fail.

package/registry/workflows/workflow-design-systems--tokenize.md

@@ -1,15 +1,60 @@
-# Workflow: Design Systems  Tokenize
+---
+name: "Design Token Extraction & Transformation"
+description: "Workflow for defining, transforming, and distributing design tokens across CSS, Tailwind, TypeScript, and JSON platforms."
+bundle: "product-design"
+estimatedDuration: "20-40m"
+---
 
-Multi-phase procedural workflow for Design Systems  Tokenize.
+# Workflow: Design Token Extraction & Transformation
+
+## Overview & Scope
+This workflow automates design token pipeline management. It ingests source tokens, transforms them across platform formats (CSS custom properties, Tailwind, TS types, iOS/Android formats), and validates output files.
+
+## 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
+- Source design token JSON / Figma Tokens file
+- Token transformation tool (`Style Dictionary`)
+- Target platform format configurations
 
 ## Phase 1: Context & Reconnaissance
-- Analyze the user request and existing codebase state.
-- Gather necessary inputs and verify environment readiness.
+- Inspect raw token source files for valid DTCG (Design Tokens Community Group) schema compliance.
+- Check token naming conventions (category-type-item-variant-state).
+- Verify output build configuration rules.
 
 ## Phase 2: Execution & Orchestration
-- Execute core steps with progressive verifications.
-- Delegate sub-tasks to specialized sub-agents.
+- Execute transformation build scripts using Style Dictionary.
+- Generate platform-specific outputs: CSS custom properties (`tokens.css`), JS/TS constants (`tokens.ts`), Tailwind config extension.
+- Validate that generated token values contain no unresolved references or `undefined` properties.
 
 ## Phase 3: Verification & Closure
-- Run verification tests and linting.
-- Document outcome and present summary.
+- Run token integration tests against sample UI components.
+- Publish updated design token package.
+- Document token release notes detailing added, changed, or deprecated tokens.
+
+## 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 build` | Style Dictionary compilation builds with exit code 0 |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm test` | Token validation suite confirms zero undefined token values |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Style Dictionary transformation executes without warnings or errors.
+- **Validation Checkpoint 2**: Generated CSS/TS token files pass syntax validation.
+- **Automated Rollback Protocol**: Restore previous token package version if transform scripts fail.

package/registry/workflows/workflow-diagnose.md

@@ -0,0 +1,45 @@
+---
+name: "Evidence-Driven Bug Diagnosis"
+description: "Procedural workflow for isolating software bugs, gathering empirical evidence, and formulating root-cause remediation plans."
+bundle: "software-engineering"
+estimatedDuration: "15-45m"
+---
+
+# Workflow: Evidence-Driven Bug Diagnosis
+
+## Overview & Scope
+The Evidence-Driven Bug Diagnosis workflow guides orchestrators and developers through evidence gathering, symptom reproduction, and root-cause isolation without resorting to blind trial-and-error edits.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Log & Traceback Collection]
+    P1 --> P2[Phase 2: Reproduction & Hypothesis Isolation]
+    P2 --> Gate1{"Root Cause Verified with Evidence?"}
+    Gate1 -->|No| P2
+    Gate1 -->|Yes| P3[Phase 3: Remediation Plan]
+    P3 --> Done([Workflow Complete])
+```
+
+## Required Tool Inputs & Context
+- Stack trace, error log output, or reproduction context.
+- Access to project codebase and test framework.
+
+## Phase 1: Log & Traceback Collection
+- Run `diagnosing-bugs` skill to parse error tracebacks and locate fault sites.
+- Inspect surrounding source files and recent commit history.
+
+## Phase 2: Reproduction & Hypothesis Isolation
+- Formulate testable hypotheses for defect cause.
+- Author minimal reproduction test case demonstrating 100% reliable failure.
+
+## Phase 3: Remediation Plan
+- Document verified root cause mechanism.
+- Hand off minimal failing test and root cause summary to `workflow-implement.md`.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Traceback logged | File & line isolated | Target crash site identified |
+| Phase 2 -> Phase 3 | Hypotheses tested | Reproduction test | Test fails with exact reported error |
+| Phase 3 -> Completion | Root cause proven | Plan documented | Remediate plan ready for implementation |

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

@@ -1,15 +1,60 @@
-# Workflow: Estimate
+---
+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"
+---
 
-Multi-phase procedural workflow for Estimate.
+# 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
-- Analyze the user request and existing codebase state.
-- Gather necessary inputs and verify environment readiness.
+- 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
-- Execute core steps with progressive verifications.
-- Delegate sub-tasks to specialized sub-agents.
+- 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
-- Run verification tests and linting.
-- Document outcome and present summary.
+- 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.