agents-united 1.0.0 → 1.2.0

package/registry/workflows/workflow-api-contract-design.md

@@ -0,0 +1,48 @@
+---
+name: "API Contract & Schema Design"
+description: "Workflow for designing, validating, and versioning REST OpenAPI 3.1, GraphQL, and gRPC protobuf schema contracts with zero breaking changes."
+bundle: "backend-distributed-systems"
+estimatedDuration: "15-30m"
+---
+
+# Workflow: API Contract & Schema Design
+
+## Overview & Scope
+The API Contract Design workflow ensures all client-server and microservice communications have strictly typed, backward-compatible, and documented API schemas before implementation begins.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Domain Modeling & Entity Definition]
+    P1 --> InputCheck{"Entities & Types Modeled?"}
+    InputCheck -->|No| Abort1[Clarify Domain Schema]
+    InputCheck -->|Yes| P2[Phase 2: Schema Contract Generation]
+    P2 --> Gate1{"Verification Gate: Schema Valid & Compatible?"}
+    Gate1 -->|Fail| P2Fix[Resolve Schema Incompatibilities]
+    P2Fix --> P2
+    Gate1 -->|Pass| P3[Phase 3: Client SDK & Mock Generation]
+    P3 --> Done([API Contract Approved & Published])
+```
+
+## Required Tool Inputs & Context
+- Domain entity model and service requirements
+- Target API style (`REST OpenAPI`, `GraphQL`, `gRPC Protobuf`)
+- Backward compatibility requirements
+
+## Phase 1: Domain Modeling & Entity Definition
+- Map domain models to request/response payloads, error structures, and pagination patterns.
+- Enforce standard HTTP status code and error payload conventions (`RFC 7807`).
+
+## Phase 2: Schema Contract Generation
+- Author OpenAPI YAML, GraphQL SDL, or Protobuf `.proto` definition.
+- Run schema linting (`spectral` / `buf lint`) and breaking change detection (`buf breaking` / `oasdiff`).
+
+## Phase 3: Client SDK & Mock Generation
+- Generate typed client SDKs and mock server definitions (MSW / Prism) for parallel frontend development.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Domain entities specified | Entity mapping review | All mandatory fields and types declared |
+| Phase 2 -> Phase 3 | Schema authored | Schema linter & diff tool | 0 lint errors, 0 breaking changes detected |
+| Phase 3 -> Completion | SDK & mocks generated | Mock server validation | Client SDK compiles without type errors |

package/registry/workflows/workflow-app-store-release.md

@@ -0,0 +1,48 @@
+---
+name: "App Store & Google Play Release Preparation"
+description: "Workflow for auditing mobile application compliance, privacy policy disclosures, StoreKit/In-App Purchases, and app store submission assets."
+bundle: "mobile-development"
+estimatedDuration: "20-40m"
+---
+
+# Workflow: App Store & Google Play Release Preparation
+
+## Overview & Scope
+The App Store Release workflow audits mobile applications against Apple App Review Guidelines and Google Play Developer Policies prior to store submission, eliminating common rejection causes.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Privacy & Entitlements Audit]
+    P1 --> InputCheck{"Info.plist & Manifest Complete?"}
+    InputCheck -->|No| Abort1[Remediate Missing Descriptions]
+    InputCheck -->|Yes| P2[Phase 2: StoreKit & Permissions Verification]
+    P2 --> Gate1{"Verification Gate: Guidelines Compliant?"}
+    Gate1 -->|Fail| P2Fix[Apply Compliance Fixes]
+    P2Fix --> P2
+    Gate1 -->|Pass| P3[Phase 3: Metadata & Release Artifact Packaging]
+    P3 --> Done([App Store Submission Ready])
+```
+
+## Required Tool Inputs & Context
+- `Info.plist` (iOS) / `AndroidManifest.xml` (Android)
+- Privacy Policy URL and Terms of Service links
+- Screenshot assets for target screen sizes
+
+## Phase 1: Privacy & Entitlements Audit
+- Verify that every requested permission (Camera, Location, Notifications) includes a clear, user-facing purpose string.
+- Audit third-party SDK privacy manifests and data collection disclosures.
+
+## Phase 2: StoreKit & Permissions Verification
+- Verify In-App Purchase restore purchase functionality and clear pricing disclosures.
+- Verify account deletion capabilities for apps with user authentication.
+
+## Phase 3: Metadata & Release Artifact Packaging
+- Compile App Store Connect / Google Play metadata, release notes, and version increment commits.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Permission strings verified | Manifest & Info.plist audit | 100% of requested permissions have explanations |
+| Phase 2 -> Phase 3 | Store compliance verified | Guidelines checklist audit | Account deletion & purchase restore verified |
+| Phase 3 -> Completion | Metadata bundle signed off | Release notes & version audit | Clean submission package prepared |

package/registry/workflows/workflow-brainstorm.md

@@ -1,15 +1,60 @@
-# Workflow: Brainstorm
+---
+name: "Structured Option Generation & Brainstorming"
+description: "Workflow for generating creative technical solutions, evaluating design options, and applying SCAMPER/Lateral Thinking frameworks."
+bundle: "deep-research"
+estimatedDuration: "25-45m"
+---
 
-Multi-phase procedural workflow for Brainstorm.
+# Workflow: Structured Option Generation & Brainstorming
+
+## Overview & Scope
+This workflow drives structured technical innovation. It applies SCAMPER and Lateral Thinking frameworks to generate diverse solution options before narrowing down to optimal candidates.
+
+## 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
+- Problem context statement & hard project constraints
+- Brainstorming framework guides (SCAMPER, 6 Thinking Hats)
+- Option evaluation matrix template
 
 ## Phase 1: Context & Reconnaissance
-- Analyze the user request and existing codebase state.
-- Gather necessary inputs and verify environment readiness.
+- Review target problem statement and state non-negotiable constraints (tech stack, latency budget, timeline).
+- Set target idea volume goal (minimum 10 distinct solution concepts).
+- Prepare brainstorming workspace.
 
 ## Phase 2: Execution & Orchestration
-- Execute core steps with progressive verifications.
-- Delegate sub-tasks to specialized sub-agents.
+- Divergent Phase: Generate high-volume ideas using SCAMPER (Substitute, Combine, Adapt, Modify, Put to another use, Eliminate, Reverse).
+- Categorize generated ideas into architectural clusters.
+- Convergent Phase: Evaluate ideas against feasibility, impact, and project constraints.
 
 ## Phase 3: Verification & Closure
-- Run verification tests and linting.
-- Document outcome and present summary.
+- Select top 3 candidate options for detailed technical evaluation.
+- Document pros, cons, trade-offs, and risks for each top option.
+- Publish Technical Option Generation 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 | `node dist/cli.js doctor` | Doctor health check validates brainstorming document schema |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm test` | Validation test confirms presence of top candidate trade-off analyses |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Minimum of 10 distinct solution options generated during divergent phase.
+- **Validation Checkpoint 2**: Top candidate options evaluated against all hard project constraints.
+- **Automated Rollback Protocol**: Re-frame brainstorming prompt if generated concepts violate core constraints.

package/registry/workflows/workflow-build.md

@@ -1,15 +1,60 @@
-# Workflow: Build
+---
+name: "Production Build Verification"
+description: "Workflow for executing production build compilation, validating bundle output integrity, asset sizes, and target artifacts."
+bundle: "software-engineering"
+estimatedDuration: "15-30m"
+---
 
-Multi-phase procedural workflow for Build.
+# Workflow: Production Build Verification
+
+## Overview & Scope
+The Build workflow ensures project code compiles cleanly into production-ready build artifacts, validating bundle sizes, entry point executables, and asset integrity prior to deployment.
+
+## 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
+- Build script and bundling tool (`tsup` / `vite` / `webpack` / `esbuild`)
+- Target output directory (`dist/` or `build/`)
+- Maximum allowable bundle size thresholds
 
 ## Phase 1: Context & Reconnaissance
-- Analyze the user request and existing codebase state.
-- Gather necessary inputs and verify environment readiness.
+- Inspect build tool configuration files (`tsconfig.json`, `tsup.config.ts`, `vite.config.ts`).
+- Clean prior build artifacts and temporary files (`rimraf dist`).
+- Verify all required build dependencies and environment variables are present.
 
 ## Phase 2: Execution & Orchestration
-- Execute core steps with progressive verifications.
-- Delegate sub-tasks to specialized sub-agents.
+- Execute production compilation process via `npm run build`.
+- Monitor stdout/stderr streams for compilation warnings, deprecation notices, or missing exports.
+- Inspect generated output artifacts to confirm expected entry point scripts and source maps are emitted.
 
 ## Phase 3: Verification & Closure
-- Run verification tests and linting.
-- Document outcome and present summary.
+- Run post-build asset verification scripts to check bundle file sizes against thresholds.
+- Test executable CLI entry points or bundled modules in an isolated node process.
+- Publish build verification summary detailing artifact sizes, compilation time, and entry signatures.
+
+## 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` | Compilation completes with exit code 0 and zero fatal errors |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `node dist/cli.js --version` | Built CLI entry point executes cleanly without module resolution errors |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Output directory contains all expected JavaScript, type declaration (`.d.ts`), and map files.
+- **Validation Checkpoint 2**: Bundle size measurements fall within acceptable performance budget limits.
+- **Automated Rollback Protocol**: Clean corrupted `dist/` artifacts and revert build configuration changes if compilation fails.

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

@@ -1,15 +1,60 @@
-# Workflow: Business Panel
+---
+name: "Expert Business Evaluation Panel"
+description: "Panel workflow assembling business strategists, product managers, and financial analysts to evaluate product monetization, pricing, and business viability."
+bundle: "business-strategy"
+estimatedDuration: "45-75m"
+---
 
-Multi-phase procedural workflow for Business Panel.
+# Workflow: Expert Business Evaluation Panel
+
+## Overview & Scope
+The Business Panel workflow evaluates commercial viability. It convenes Business Strategists, Financial Analysts, and Product Managers to audit monetization models, pricing strategy, unit economics, and ROI.
+
+## 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
+- Business proposal or feature specification
+- Monetization model & pricing tier specs
+- Financial projections and market size data
 
 ## Phase 1: Context & Reconnaissance
-- Analyze the user request and existing codebase state.
-- Gather necessary inputs and verify environment readiness.
+- Gather business proposals, financial estimates, and target market analysis.
+- Establish evaluation dimensions (Monetization feasibility, Unit economics, Customer CAC/LTV, Competitive defensibility).
+- Distribute proposal to business panel personas.
 
 ## Phase 2: Execution & Orchestration
-- Execute core steps with progressive verifications.
-- Delegate sub-tasks to specialized sub-agents.
+- Conduct panel review session collecting structured evaluation from business expert personas.
+- Audit pricing tiers, margin expectations, and go-to-market assumptions.
+- Identify commercial risks and strategic opportunities.
 
 ## Phase 3: Verification & Closure
-- Run verification tests and linting.
-- Document outcome and present summary.
+- Synthesize panel feedback into Business Evaluation Verdict (Approved, Approved with Adjustments, Rejected).
+- Formulate actionable commercial recommendations and financial model updates.
+- Publish Business Panel Evaluation 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 | `node dist/cli.js doctor` | Doctor health check validates business panel report format |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm test` | Validation test suite confirms presence of financial metrics |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Monetization model and unit economics evaluated across all proposed pricing tiers.
+- **Validation Checkpoint 2**: Commercial risks cataloged with explicit mitigation recommendations.
+- **Automated Rollback Protocol**: Return proposal to draft state if panel issues commercial rejection verdict.

package/registry/workflows/workflow-cleanup.md

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

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

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

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