agents-united 0.5.0

package/registry/workflows/workflow-cleanup.md

@@ -0,0 +1,60 @@
+---
+name: "Code Hygiene & Refactoring Cleanup"
+description: "Systematic workflow for removing dead code, unused dependencies, formatting files, and normalizing code style."
+bundle: "software-engineering"
+estimatedDuration: "15-30m"
+---
+
+# Workflow: Code Hygiene & Refactoring Cleanup
+
+## Overview & Scope
+The Cleanup workflow streamlines codebase maintenance by identifying and eliminating orphaned code, unused npm packages, formatting inconsistencies, and stale comments across the project.
+
+## 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
+- Linter and formatter configurations (`.eslintrc`, `.prettierrc`)
+- Unused dependency scanner (`depcheck` / `knip`)
+- Repository file index & source directories
+
+## Phase 1: Context & Reconnaissance
+- Scan codebase for unreferenced export declarations, orphaned files, and dead code paths.
+- Audit `package.json` against actual import usages to find unused dependencies.
+- Check code formatting consistency across all source and test directories.
+
+## Phase 2: Execution & Orchestration
+- Safe removal of confirmed unused files, unused variables, and unreferenced functions.
+- Run automated code formatters (`prettier --write .`) and linter auto-fixes (`eslint --fix`).
+- Remove outdated or commented-out code blocks while preserving documentation comments.
+
+## Phase 3: Verification & Closure
+- Run full test suite and type-checker to ensure no functional code was inadvertently broken.
+- Verify clean git diff to confirm only intended refactor/cleanup edits were made.
+- Document total lines of code removed, dependencies pruned, and formatting changes applied.
+
+## 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 lint` | 0 lint errors and 0 warnings remaining post-cleanup |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm test && npm run typecheck` | 100% pass rate on test suite and static type check after code removal |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Unused dependencies and unreferenced exports verified with static analysis before removal.
+- **Validation Checkpoint 2**: Working tree formatted cleanly with zero style deviations.
+- **Automated Rollback Protocol**: Revert uncommitted file removals using `git checkout -- .` if cleanup causes test regressions.

package/registry/workflows/workflow-deploy-staging.md

@@ -0,0 +1,49 @@
+---
+name: "Staging Preview & Deployment Automation"
+description: "Workflow for automating container builds, staging preview deployments, environment sanity checks, and deployment verification gates."
+bundle: "devops-engineering"
+estimatedDuration: "10-20m"
+---
+
+# Workflow: Staging Preview & Deployment Automation
+
+## Overview & Scope
+The Staging Deployment workflow automates the creation of isolated staging environments, container image verification, and post-deployment health checks prior to production promotion.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Build & Image Verification]
+    P1 --> InputCheck{"Image Built & Tagged?"}
+    InputCheck -->|No| Abort1[Abort Deployment]
+    InputCheck -->|Yes| P2[Phase 2: Staging Deployment Rollout]
+    P2 --> Gate1{"Verification Gate: Health Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Trigger Automated Deployment Rollback]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Integration Audit & Sign-off]
+    P3 --> Done([Staging Deployment Verified])
+```
+
+## Required Tool Inputs & Context
+- Target container registry and deployment environment credentials
+- Health check HTTP endpoint (`/healthz` or `/api/health`)
+- Staging environment configuration parameters
+
+## Phase 1: Build & Image Verification
+- Build production container image using Docker multi-stage workflow.
+- Scan built container image for security vulnerabilities using vulnerability scanners.
+
+## Phase 2: Staging Deployment Rollout
+- Deploy container image to staging cluster or preview environment.
+- Verify environment variables and database migration status.
+
+## Phase 3: Integration Audit & Sign-off
+- Execute HTTP health check polling on staging URL.
+- Log deployment status, image SHA, and deployment duration.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Container built cleanly | `docker inspect <image>` | Image exists with non-root user context |
+| Phase 2 -> Phase 3 | Staging rollout completed | `curl -f https://staging.example.com/healthz` | Endpoint returns HTTP 200 OK |
+| Phase 3 -> Completion | Health verification passed | `agents doctor` | Deployment lockfile updated successfully |

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

@@ -0,0 +1,60 @@
+---
+name: "API & Interface Specification Design"
+description: "Workflow for designing clean code interfaces, TypeScript types/interfaces, OpenAPI/REST schemas, and module contracts."
+bundle: "system-architecture"
+estimatedDuration: "30-60m"
+---
+
+# Workflow: API & Interface Specification Design
+
+## Overview & Scope
+This workflow provides a methodical approach to designing software contracts, TypeScript interfaces, and schema definitions. It emphasizes type safety, clear abstraction boundaries, and backward compatibility.
+
+## 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
+- Domain model requirements and entity definitions
+- Interface guidelines and type convention standards
+- TypeScript compiler / Zod schema validator tools
+
+## Phase 1: Context & Reconnaissance
+- Identify core domain entities, value objects, and boundary interfaces.
+- Audit existing type definitions for duplication or naming inconsistencies.
+- Determine data validation rules, optional fields, and payload constraints.
+
+## Phase 2: Execution & Orchestration
+- Draft TypeScript interface definitions (`types.ts`) and export type signatures.
+- Implement validation schemas (e.g. Zod or JSON Schema) matching runtime payload requirements.
+- Add comprehensive TSDoc/JSDoc comments describing method parameters, return types, and potential errors.
+
+## Phase 3: Verification & Closure
+- Verify type compilation (`tsc --noEmit`) to confirm no circular type dependencies exist.
+- Validate schema serialization and deserialization against sample payload fixtures.
+- Export finalized type contracts for downstream consumption by backend/frontend engineers.
+
+## 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` | TypeScript compiler validates all new type interfaces without errors |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm test` | Schema validation unit tests pass cleanly against sample data |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Interfaces encapsulate domain logic cleanly with zero `any` types.
+- **Validation Checkpoint 2**: TSDoc documentation complete for all public interface methods and properties.
+- **Automated Rollback Protocol**: Revert interface modifications if circular dependencies or breaking type signature changes occur.

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

@@ -0,0 +1,60 @@
+---
+name: "Design-to-Engineering Handoff Specification"
+description: "Workflow for packaging visual designs, interaction specs, assets, and design token references into production-ready engineering specs."
+bundle: "product-design"
+estimatedDuration: "30-45m"
+---
+
+# Workflow: Design-to-Engineering Handoff Specification
+
+## Overview & Scope
+The Handoff workflow standardizes design specs for development. It packages redline specs, interaction behaviors, asset exports, token mappings, and edge-case specs into comprehensive developer handoffs.
+
+## 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
+- Finalized screen designs and component specs
+- Design token repository and component library mappings
+- Asset export rules (SVG optimization, image compression)
+
+## Phase 1: Context & Reconnaissance
+- Confirm screen designs are finalized and locked for implementation.
+- Audit design elements to ensure 100% map to existing design system tokens or documented new components.
+- Verify SVG graphics are clean and vectorized.
+
+## Phase 2: Execution & Orchestration
+- Attach redline specifications detailing layout margins, padding, and alignment.
+- Annotate dynamic component behaviors, error states, and micro-interactions.
+- Export optimized SVG/PNG assets and document data field requirements for backend APIs.
+
+## Phase 3: Verification & Closure
+- Conduct handoff walkthrough with engineering leads.
+- Address technical clarification questions and update handoff spec annotations.
+- Archive handoff specification package in project 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` | Doctor health check confirms handoff specification artifact structure |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm test` | Asset validation script confirms all exported SVGs are valid and optimized |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: 100% of visual elements mapped to design tokens or explicit component specs.
+- **Validation Checkpoint 2**: All graphic assets exported in optimized SVG format.
+- **Automated Rollback Protocol**: Update handoff spec package if engineers identify unannotated interaction behaviors.

package/registry/workflows/workflow-design-ops--plan-sprint.md

@@ -0,0 +1,60 @@
+---
+name: "Design Sprint & Capacity Planning"
+description: "Operational workflow for scoping design tasks, estimating design effort, allocating designer capacity, and planning design sprints."
+bundle: "product-design"
+estimatedDuration: "25-45m"
+---
+
+# Workflow: Design Sprint & Capacity Planning
+
+## Overview & Scope
+This workflow manages design team capacity and sprint execution. It scopes incoming requests, estimates design effort, allocates designer availability, and establishes clear sprint commitments.
+
+## 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 feature backlog and design request tickets
+- Designer availability & velocity history
+- Sprint goals and engineering milestone targets
+
+## Phase 1: Context & Reconnaissance
+- Collect incoming design requests and feature tickets for the upcoming sprint.
+- Calculate net available designer hours accounting for overhead, meetings, and PTO.
+- Review engineering sprint commitments to align design deliverables.
+
+## Phase 2: Execution & Orchestration
+- Break down design requests into specific tasks (research, wireframing, high-fi design, handoff).
+- Estimate effort story points for each design task based on complexity.
+- Assign tasks to designers matching capacity and expertise.
+
+## Phase 3: Verification & Closure
+- Review sprint plan with product management and engineering leads.
+- Commit sprint backlog items to design tracking board.
+- Publish Design Sprint Plan 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 verifies sprint plan document syntax |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Project build passes cleanly during sprint planning |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Total committed story points do not exceed calculated design team capacity.
+- **Validation Checkpoint 2**: Every sprint task has an explicit definition of done.
+- **Automated Rollback Protocol**: De-scope lower priority design tickets if allocated capacity is exceeded.

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

@@ -0,0 +1,60 @@
+---
+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"
+---
+
+# 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
+- 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
+- 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
+- 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

@@ -0,0 +1,60 @@
+---
+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"
+---
+
+# 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
+- 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
+- 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
+- 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

@@ -0,0 +1,60 @@
+---
+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"
+---
+
+# 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
+- 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
+- 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
+- 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

@@ -0,0 +1,60 @@
+---
+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"
+---
+
+# 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
+- 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
+- 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 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

@@ -0,0 +1,60 @@
+---
+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"
+---
+
+# 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
+- 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 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 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 |