agents-united 0.5.0

package/registry/workflows/workflow-seo-audit-pipeline.md

@@ -0,0 +1,47 @@
+---
+name: "Technical SEO Audit & Programmatic Deployment Workflow"
+description: "Comprehensive SEO audit, schema validation, sitemap generation, and programmatic page deployment."
+bundle: "seo-content-marketing"
+estimatedDuration: "30-60m"
+---
+
+# Workflow: Technical SEO Audit & Programmatic Deployment
+
+## Overview & Scope
+This workflow coordinates full-site technical SEO audits, Core Web Vitals checks, schema JSON-LD generation, and programmatic landing page deployments.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start SEO Pipeline]) --> P1[Phase 1: Crawl & Indexing Audit]
+    P1 --> InputCheck{"Robots.txt & Canonical Directives Valid?"}
+    InputCheck -->|No| Abort1[Abort & Fix Directive Errors]
+    InputCheck -->|Yes| P2[Phase 2: Schema & Content Optimization]
+    P2 --> Gate1{"Verification Gate: Schema.org Validation Pass?"}
+    Gate1 -->|Fail| P2Fix[Remediate Missing Schema Fields]
+    P2Fix --> P2
+    Gate1 -->|Pass| P3[Phase 3: Sitemap Generation & Verification]
+    P3 --> Gate2{"Indexability Gate: Zero Crawl Errors Reported?"}
+    Gate2 -->|Fail| P3Retry[Inspect Broken Links and 404s]
+    P3Retry --> P3
+    Gate2 -->|Pass| Done([SEO Pipeline Verified & Live])
+```
+
+## Phase 1: Crawl & Indexing Audit
+- Inspect `robots.txt`, meta robots tags, and canonical headers.
+- Audit page load performance and Core Web Vitals scores.
+
+## Phase 2: Schema & Content Optimization
+- Inject structured JSON-LD schemas (`SoftwareApplication`, `FAQPage`, `BreadcrumbList`).
+- Verify keyword placement in titles, H1/H2 tags, and meta descriptions.
+
+## Phase 3: Sitemap Generation & Verification
+- Compile and validate XML sitemaps.
+- Submit sitemap ping to search engine consoles.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Crawl checks pass | `node dist/cli.js doctor` | 0 robots.txt or canonical errors |
+| Phase 2 -> Phase 3 | Schema injected | `npm test` | JSON-LD schema syntax validates cleanly |
+| Phase 3 -> Completion | Sitemap verified | `node dist/cli.js doctor` | Sitemaps compiled with valid XML |

package/registry/workflows/workflow-seo-content-pipeline.md

@@ -0,0 +1,65 @@
+---
+name: "Programmatic SEO & Content Generation Pipeline"
+description: "End-to-end workflow for programmatic keyword research, schema markup architecture, automated SEO content drafting, and crawl validation."
+bundle: "seo-content-marketing"
+estimatedDuration: "45-90m"
+---
+
+# Workflow: Programmatic SEO & Content Generation Pipeline
+
+## Overview & Scope
+The Programmatic SEO & Content Pipeline workflow automates the research, generation, optimization, and technical validation of high-volume programmatic SEO landing pages and editorial content. It orchestrates keyword intent clustering, Schema.org JSON-LD structured data injection, automated internal linking graphs, and static HTML crawl validation.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Keyword Reconnaissance]
+    P1 --> InputCheck{"Keyword Dataset & Schema Spec Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Seed Dataset]
+    InputCheck -->|Yes| P2[Phase 2: Programmatic Execution & Content Generation]
+    P2 --> Gate1{"Verification Gate: Schema & Link Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification, SEO Validation & Deployment]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Meta / Schema Errors]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- Seed keyword dataset & search intent taxonomy (informational, commercial, transactional)
+- Target database / programmatic CMS data source (CSV, JSON, SQL records)
+- Schema.org structured data templates (Article, FAQPage, BreadcrumbList, Product, Organization)
+- Editorial tone and style guide parameters
+
+## Phase 1: Context & Keyword Reconnaissance
+- Extract and cluster programmatic search queries based on volume, keyword difficulty, and intent.
+- Define URL routing and taxonomy rules (e.g., `/solutions/:use-case-for-:industry`).
+- Select and configure Schema.org JSON-LD types matching the target page template.
+- Establish internal linking hierarchy between parent hub pages and child programmatic spoke pages.
+
+## Phase 2: Programmatic Execution & Content Generation
+- Hydrate content templates dynamically with structured data variables, unique headings, and custom body copy.
+- Generate semantic heading structures (H1 through H3) with target keyword integration and natural language density.
+- Inject validated Schema.org JSON-LD script blocks into the page header.
+- Construct contextual internal links using dynamic anchor text across related programmatic pages.
+
+## Phase 3: Verification, SEO Validation & Deployment
+- Execute Schema.org structured data validator against generated pages to guarantee 0 syntax errors or missing required fields.
+- Audit page meta tags (title tag <= 60 chars, meta description <= 160 chars, canonical URL, OpenGraph tags).
+- Run automated readability scanner (Flesch-Kincaid) and ensure keyword density falls within the 1-2% range.
+- Build static pages and generate updated XML sitemap with canonical URL entries.
+
+## 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` | SEO test suite validates Schema.org JSON-LD syntax and internal link graph integrity |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Static site generator builds programmatic pages and XML sitemap without errors |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: 100% of programmatic pages pass Schema.org JSON-LD validation with zero syntax errors or missing required fields.
+- **Validation Checkpoint 2**: Internal link graph verification confirms zero broken links and valid canonical tags on every generated page.
+- **Validation Checkpoint 3**: Readability and keyword density checks verify content quality without keyword stuffing.
+- **Automated Rollback Protocol**: Halt XML sitemap publishing and revert CMS template generation if Schema.org validation fails or duplicate URL canonicalization conflicts are detected.

package/registry/workflows/workflow-serverless-gpu-deploy.md

@@ -0,0 +1,52 @@
+---
+name: "Serverless GPU Deployment Workflow"
+description: "Deploying and stress-testing serverless GPU workers on Modal, Replicate, and RunPod with cold-start benchmarks and cost safety limits."
+bundle: "ai-ml-engineering"
+estimatedDuration: "15-30m"
+---
+
+# Workflow: Serverless GPU Deployment
+
+## Overview & Scope
+This workflow coordinates packaging model weights, configuring GPU container environments, setting timeout and spend guardrails, and deploying serverless inference endpoints.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Deployment]) --> P1[Phase 1: Environment & Spend Guardrails]
+    P1 --> InputCheck{"GPU Quota & Budget Alerts Active?"}
+    InputCheck -->|No| Abort1[Abort & Configure Budget Controls]
+    InputCheck -->|Yes| P2[Phase 2: Container Build & Weight Hydration]
+    P2 --> Gate1{"Verification Gate: Local/Staging GPU Smoke Test Pass?"}
+    Gate1 -->|Fail| P2Debug[Debug CUDA / PyTorch Dependencies]
+    P2Debug --> P2
+    Gate1 -->|Pass| P3[Phase 3: Endpoint Deployment & Cold-Start Benchmarking]
+    P3 --> Gate2{"Latency Gate: Cold-start < 10s & TTFT < 500ms?"}
+    Gate2 -->|Fail| CacheOptimize[Optimize Layer Caching / Model Quantization]
+    CacheOptimize --> P2
+    Gate2 -->|Pass| Done([Serverless GPU Endpoint Live])
+```
+
+## Phase 1: Environment & Spend Guardrails
+- Define maximum execution timeout (`timeout=300s`) and idle scaledown window (`scaledown_window=60s`).
+- Verify API credentials and ensure no secrets are hard-coded in source files.
+
+## Phase 2: Container Build & Weight Hydration
+- Build container image with pinned CUDA/torch layers.
+- Mount network storage volume or pre-bake model weights into layer cache.
+
+## Phase 3: Endpoint Deployment & Cold-Start Benchmarking
+- Deploy serverless function to Modal / RunPod / Replicate.
+- Run concurrent smoke-test invocations measuring cold-start latency, memory usage, and auto-scaling behavior.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Guardrails verified | `node dist/cli.js doctor` | Budget alert and credentials verified |
+| Phase 2 -> Phase 3 | Container built | `npm test` | Smoke test inference returns 200 OK |
+| Phase 3 -> Completion | Metrics validated | `node dist/cli.js doctor` | Endpoint scales from 0 to N and returns cleanly |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Validate timeout parameters and scale-to-zero settings in deployment manifest.
+- **Validation Checkpoint 2**: Test health check endpoint under 10 concurrent requests.
+- **Automated Rollback Protocol**: If cold-start latency exceeds 30s or error rate exceeds 1%, immediately tear down active endpoint, route traffic to standby API endpoint, and rollback container image tag.

package/registry/workflows/workflow-spec-panel.md

@@ -0,0 +1,60 @@
+---
+name: "Multi-Perspective Specification Review Panel"
+description: "Panel workflow assembling architecture, security, and domain experts to evaluate complex technical specifications."
+bundle: "system-architecture"
+estimatedDuration: "45-75m"
+---
+
+# Workflow: Multi-Perspective Specification Review Panel
+
+## Overview & Scope
+The Spec Panel workflow convenes diverse expert perspectives (Architecture, Security, Engineering Ops, Business) to conduct rigorous multi-dimensional reviews of critical system specifications.
+
+## 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
+- Technical specification or architecture proposal document
+- Review evaluation matrix (scalability, security, maintainability, UX)
+- Panel reviewer persona profiles
+
+## Phase 1: Context & Reconnaissance
+- Load specification document and extract key architectural assumptions.
+- Assemble evaluation matrix covering system scalability, threat model, implementation risk, and operational cost.
+- Distribute specification to panel personas for pre-review analysis.
+
+## Phase 2: Execution & Orchestration
+- Convene panel evaluation session to collect independent feedback across reviewer personas.
+- Record consensus points, technical disagreements, and identified design gaps.
+- Formulate required modifications and actionable revision requirements.
+
+## Phase 3: Verification & Closure
+- Synthesize panel feedback into formal Review Verdict (Approved, Approved with Revisions, Rejected).
+- Assign ownership and due dates for all required spec revision items.
+- Publish Panel Review Summary report to 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 specification document integrity |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run typecheck` | All code snippets within specification compile cleanly |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: All 4 review dimensions evaluated with documented panel comments.
+- **Validation Checkpoint 2**: Verdict explicitly supported by documented panel findings.
+- **Automated Rollback Protocol**: Return specification document to draft status if panel issues a Rejection verdict.

package/registry/workflows/workflow-spec.md

@@ -0,0 +1,44 @@
+---
+name: "Technical Specification & Backlog Breakdown"
+description: "Procedural workflow for generating PRD specs from notes or grilling results and breaking them down into actionable backlog tickets."
+bundle: "software-engineering"
+estimatedDuration: "15-30m"
+---
+
+# Workflow: Technical Specification & Backlog Breakdown
+
+## Overview & Scope
+The Technical Specification & Backlog Breakdown workflow turns high-level requirements into formal technical specifications (`to-spec`) and decomposes them into atomic, executable task tickets (`to-tickets`).
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: PRD & Spec Drafting]
+    P1 --> Gate1{"Spec Draft Complete & Validated?"}
+    Gate1 -->|No| P1
+    Gate1 -->|Yes| P2[Phase 2: Ticket Decomposition]
+    P2 --> P3[Phase 3: Backlog Registration]
+    P3 --> Done([Workflow Complete])
+```
+
+## Required Tool Inputs & Context
+- Feature requirements, grilling notes, or ADR reference.
+- Output directory for specs (`docs/specs/`).
+
+## Phase 1: PRD & Spec Drafting
+- Run `to-spec` skill to outline goals, architecture, data structures, and acceptance criteria.
+- Store artifact in `docs/specs/<feature-name>.md`.
+
+## Phase 2: Ticket Decomposition
+- Run `to-tickets` skill on the generated specification file.
+- Break down implementation steps into atomic tasks with explicit verification steps.
+
+## Phase 3: Backlog Registration
+- Output tickets in requested target format (GitHub issues, Linear, or markdown task list).
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Notes collected | `docs/specs/*.md` exists | Spec file created with required sections |
+| Phase 2 -> Phase 3 | Spec analyzed | Task list checklist | All spec requirements covered by tickets |
+| Phase 3 -> Completion | Breakdown finished | Ticket validation | Tasks are self-contained with criteria |

package/registry/workflows/workflow-test.md

@@ -0,0 +1,60 @@
+---
+name: "Test Suite Execution & Coverage Verification"
+description: "Systematic workflow for running unit, integration, and e2e test suites, analyzing coverage gaps, and fixing failing tests."
+bundle: "software-engineering"
+estimatedDuration: "15-30m"
+---
+
+# Workflow: Test Suite Execution & Coverage Verification
+
+## Overview & Scope
+This workflow provides a structured approach for executing test suites across multiple tiers (unit, integration, e2e), evaluating code coverage metrics, and systematically isolating and repairing test failures.
+
+## 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
+- Test framework runner configuration (`vitest` / `jest`)
+- Coverage threshold targets (e.g. >= 80% line coverage)
+- Target test paths or suite filter expressions
+
+## Phase 1: Context & Reconnaissance
+- Identify project test environment configuration and existing coverage baselines.
+- Inspect test directory layout and locate relevant test setup files.
+- Verify test runner dependencies and clean cached test results if required.
+
+## Phase 2: Execution & Orchestration
+- Run targeted unit test files for modified components to get fast feedback.
+- Execute integration and end-to-end test suites across affected modules.
+- Analyze test output logs, stack traces, and coverage reports to pinpoint failures and untested code branches.
+
+## Phase 3: Verification & Closure
+- Re-run full test suite with coverage collection enabled.
+- Verify that code coverage metrics satisfy configured threshold requirements.
+- Generate test execution report summarizing test counts, duration, and coverage metrics.
+
+## 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` | All tests pass without skipped test regressions |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run test:coverage` | Statement and line coverage meet or exceed configured target percentage |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Test runner executes cleanly with zero unhandled promise rejections.
+- **Validation Checkpoint 2**: Coverage report confirms all new code paths have corresponding unit test coverage.
+- **Automated Rollback Protocol**: Revert test file modifications via `git checkout -- tests/` if invalid mock setups break test isolation.

package/registry/workflows/workflow-troubleshoot.md

@@ -0,0 +1,60 @@
+---
+name: "Root Cause Diagnosis & Troubleshooting"
+description: "Systematic troubleshooting workflow for diagnosing bugs, analyzing error logs, isolating root causes, and implementing verified fixes."
+bundle: "security-operations"
+estimatedDuration: "30-60m"
+---
+
+# Workflow: Root Cause Diagnosis & Troubleshooting
+
+## Overview & Scope
+The Troubleshoot workflow provides a scientific approach to bug fixing. It guides engineers through reproducing bugs, inspecting stack traces, isolating root causes, applying patches, and adding regression tests.
+
+## 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
+- Bug report description & error stack trace
+- System log files & telemetry data
+- Debugger & testing tools
+
+## Phase 1: Context & Reconnaissance
+- Analyze error stack trace and log files to isolate failing module and function.
+- Construct minimal reproducible test case that reliably triggers the failure.
+- Formulate root cause hypotheses based on code inspection.
+
+## Phase 2: Execution & Orchestration
+- Validate root cause hypothesis by tracing variable state and execution flow.
+- Implement targeted code fix addressing root cause without side effects.
+- Verify that minimal reproduction test case transitions from failing to passing.
+
+## Phase 3: Verification & Closure
+- Run full project regression test suite to ensure fix introduces zero side effects.
+- Document Root Cause Analysis (RCA) report detailing cause, fix, and preventive measures.
+- Commit bug fix patch with dedicated regression unit test.
+
+## 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` | Reproduction test passes cleanly post-fix |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run typecheck` | Type checker confirms patch introduces no type errors |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Bug reliably reproduced in isolation before applying fix.
+- **Validation Checkpoint 2**: Full regression test suite passes cleanly with zero broken tests.
+- **Automated Rollback Protocol**: Revert patch edits using `git checkout` if regression tests reveal unexpected side effects.

package/registry/workflows/workflow-ui-design--color-palette.md

@@ -0,0 +1,60 @@
+---
+name: "Color System & Palette Design"
+description: "Workflow for defining accessible, semantic color systems, design tokens, contrast ratios, and dark mode variants."
+bundle: "product-design"
+estimatedDuration: "30-45m"
+---
+
+# Workflow: Color System & Palette Design
+
+## Overview & Scope
+This workflow defines accessible, scalable color systems. It governs the generation of color scales, semantic token mappings, contrast ratio auditing against WCAG 2.1 AA, and dark mode palette generation.
+
+## 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
+- Brand style guide and core brand colors
+- WCAG 2.1 contrast ratio standards (4.5:1 text, 3:1 UI controls)
+- Design token repository file (`tokens.json` / CSS variables)
+
+## Phase 1: Context & Reconnaissance
+- Audit existing color usage across UI components and brand guidelines.
+- Identify primary, secondary, neutral, and functional feedback colors (success, warning, error, info).
+- Set target accessibility contrast ratios for light and dark themes.
+
+## Phase 2: Execution & Orchestration
+- Generate 10-step color shade scales (50 through 900) using perceptual color spaces (OKLCH / HSL).
+- Map raw color scale values to semantic tokens (`bg-primary`, `text-body`, `border-muted`).
+- Construct dark mode color palette variants ensuring consistent contrast ratios.
+
+## Phase 3: Verification & Closure
+- Run automated contrast ratio checks on all text/background token combinations.
+- Export finalized color tokens to CSS custom properties and JSON token manifests.
+- Document color usage guidelines and accessibility compliance 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` | Automated contrast check suite passes for 100% of color token pairs |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Token compilation script builds valid CSS/JSON outputs |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: All text/background combinations satisfy WCAG 2.1 AA >= 4.5:1 contrast requirement.
+- **Validation Checkpoint 2**: Light and dark mode token mappings complete and validated.
+- **Automated Rollback Protocol**: Adjust color lightness values automatically if contrast validation fails.

package/registry/workflows/workflow-ui-design--design-screen.md

@@ -0,0 +1,60 @@
+---
+name: "Screen Visual Design & Layout"
+description: "Workflow for designing high-fidelity screen UI layouts, typography hierarchy, visual assets, and component assembly."
+bundle: "product-design"
+estimatedDuration: "45-90m"
+---
+
+# Workflow: Screen Visual Design & Layout
+
+## Overview & Scope
+The Design Screen workflow structures visual UI creation. It guides designers through layout grid setup, visual hierarchy construction, component composition, and responsive screen specs.
+
+## 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 story & screen wireframe requirements
+- Design system component library & token definitions
+- Target viewport dimension specifications (Mobile, Tablet, Desktop)
+
+## Phase 1: Context & Reconnaissance
+- Review screen user goals, required UI components, and primary user call-to-actions.
+- Select layout grid system (4px/8px baseline grid) and viewport container limits.
+- Audit required design system components for availability.
+
+## Phase 2: Execution & Orchestration
+- Assemble layout framework, placing header, sidebar, main content, and footer containers.
+- Populate layout with design system components, applying semantic color and typography tokens.
+- Establish visual hierarchy using contrast, spacing, and typographic weight scales.
+
+## Phase 3: Verification & Closure
+- Conduct optical alignment check and verify spacing grid adherence across all elements.
+- Export screen mockups and redline specs for developer handoff.
+- Log new component requirements if custom elements were created during design.
+
+## 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` | Visual layout test suite confirms 0 grid alignment violations |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Design assets compile cleanly into build pipeline |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Layout adheres strictly to 8px spatial grid system.
+- **Validation Checkpoint 2**: 100% of UI components utilized exist in design system library or are flagged as new component specs.
+- **Automated Rollback Protocol**: Re-align component layout frames to grid if spatial audit flags alignment errors.

package/registry/workflows/workflow-ui-design--responsive-audit.md

@@ -0,0 +1,60 @@
+---
+name: "Responsive Breakpoint UI Audit"
+description: "Comprehensive audit workflow for verifying UI layout reflow, touch targets, and typography readability across mobile, tablet, and desktop viewports."
+bundle: "product-design"
+estimatedDuration: "30-45m"
+---
+
+# Workflow: Responsive Breakpoint UI Audit
+
+## Overview & Scope
+This workflow systematically audits UI responsiveness across screen sizes. It checks layout reflow, touch target dimensions, font readability, and container query behavior from mobile up to desktop.
+
+## 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
+- Screen design mockups or live page URLs
+- Target viewport breakpoint specs (375px, 768px, 1280px, 1920px)
+- Touch target & accessibility standards (>= 44x44px)
+
+## Phase 1: Context & Reconnaissance
+- Set up testing viewports for target device dimensions (Mobile Small, Mobile Large, Tablet, Desktop).
+- Define breakpoint reflow rules (navigation bar to hamburger menu, multi-column to single-column).
+- Prepare responsive inspection checklist.
+
+## Phase 2: Execution & Orchestration
+- Inspect layout reflow at each breakpoint for text wrapping, image scaling, and horizontal overflow.
+- Verify interactive control dimensions meet minimum 44x44px touch target guidelines on mobile viewports.
+- Test container queries and fluid typography scaling across fluid viewport transitions.
+
+## Phase 3: Verification & Closure
+- Document visual overflow bugs, layout clipping, or touch target violations.
+- Generate responsive remediation ticket list with specific breakpoint fix instructions.
+- Publish Responsive Audit Matrix report.
+
+## 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` | Responsive audit suite confirms 0 horizontal scroll overflow on mobile |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | CSS media queries and breakpoint utility classes compile cleanly |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Zero horizontal layout overflow across all tested viewports.
+- **Validation Checkpoint 2**: 100% of interactive controls meet minimum touch target size criteria on touch viewports.
+- **Automated Rollback Protocol**: Apply responsive container layout patches to fix broken breakpoint reflows.

package/registry/workflows/workflow-ui-design--type-system.md

@@ -0,0 +1,60 @@
+---
+name: "Typography System Specification"
+description: "Workflow for defining typographic scales, font families, line heights, font weights, and responsive text sizing."
+bundle: "product-design"
+estimatedDuration: "20-40m"
+---
+
+# Workflow: Typography System Specification
+
+## Overview & Scope
+The Type System workflow establishes a mathematical typography hierarchy. It defines font stacks, modular scale ratios, line heights, letter spacing, and responsive text utility classes.
+
+## 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
+- Brand typography guidelines & licensed font files
+- Modular scale ratio selection (e.g. Major Third 1.25)
+- Target CSS font stack and fallbacks
+
+## Phase 1: Context & Reconnaissance
+- Audit existing typographic usage to identify needed scale steps (headings, body, caption, code).
+- Select modular scale ratio matching design aesthetic.
+- Verify web font formats (WOFF2) and fallback system font stacks.
+
+## Phase 2: Execution & Orchestration
+- Calculate font size steps (xs: 12px, sm: 14px, base: 16px, lg: 20px, xl: 25px, 2xl: 31px, etc.).
+- Assign relative line-height values (1.2 for headings, 1.5 for body text) to eliminate line collisions.
+- Define typography tokens (`font-heading`, `text-body-md`, `font-weight-semibold`).
+
+## Phase 3: Verification & Closure
+- Test typography rendering across viewports and browsers for legibility.
+- Export typography tokens to CSS variables and Tailwind configuration.
+- Publish Typographic Style Spec 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 | `npm test` | Typography scale test verifies mathematical consistency of font steps |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Typography CSS classes compile without syntax errors |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: All font size steps generated according to selected modular scale ratio.
+- **Validation Checkpoint 2**: Every font step includes explicit line-height and letter-spacing specifications.
+- **Automated Rollback Protocol**: Recalculate font step sizes if container constraints cause text wrapping defects.