diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
index d74c9e4..84b0e5c 100644
--- a/.claude-plugin/marketplace.json
+++ b/.claude-plugin/marketplace.json
@@ -11,7 +11,7 @@
   "plugins": [
     {
       "name": "plugin-dev",
-      "description": "Comprehensive toolkit for developing Claude Code plugins. Includes 7 expert skills covering hooks, MCP integration, commands, agents, and best practices. AI-assisted plugin creation and validation.",
+      "description": "Comprehensive toolkit for developing Claude Code plugins. Includes 8 expert skills covering hooks, MCP integration, commands, agents, marketplaces, and best practices. AI-assisted plugin creation and validation.",
       "version": "0.1.0",
       "author": {
         "name": "Daisy Hollman",
diff --git a/CLAUDE.md b/CLAUDE.md
index 385871b..ba1c25b 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Overview
 
-This repository is a **plugin marketplace** containing the **plugin-dev** plugin - a comprehensive toolkit for developing Claude Code plugins. It provides 7 specialized skills, 3 agents, and 1 guided workflow command for building high-quality plugins.
+This repository is a **plugin marketplace** containing the **plugin-dev** plugin - a comprehensive toolkit for developing Claude Code plugins. It provides 8 specialized skills, 3 agents, and 2 guided workflow commands for building high-quality plugins and marketplaces.
 
 ## Quick Reference
 
@@ -22,7 +22,7 @@ plugin-dev/                      # Marketplace root
 │       │   └── plugin.json      # Plugin manifest
 │       ├── commands/            # Slash commands
 │       ├── agents/              # Autonomous agents
-│       └── skills/              # 7 specialized skills
+│       └── skills/              # 8 specialized skills
 └── .github/workflows/           # CI/CD workflows
 ```
 
@@ -46,7 +46,7 @@ Each skill follows progressive disclosure:
 - `examples/` - Complete working examples and templates for copy-paste
 - `scripts/` - Utility scripts (executable without loading into context)
 
-**The 7 Skills:**
+**The 8 Skills:**
 
 1. `hook-development` - Event-driven automation with prompt-based hooks
 2. `mcp-integration` - Model Context Protocol server configuration
@@ -55,8 +55,9 @@ Each skill follows progressive disclosure:
 5. `command-development` - Slash commands with frontmatter
 6. `agent-development` - Autonomous agents with AI-assisted generation
 7. `skill-development` - Creating skills with progressive disclosure
+8. `marketplace-structure` - Plugin marketplace creation and distribution
 
-**Note:** `mcp-integration`, `plugin-structure`, and `skill-development` have no utility scripts—they provide documentation and examples only.
+**Note:** `mcp-integration`, `plugin-structure`, `skill-development`, and `marketplace-structure` have no utility scripts—they provide documentation and examples only.
 
 ### Writing Style
 
@@ -174,7 +175,9 @@ Hooks defined in `hooks/hooks.json`:
 
 ## Workflow
 
-The `/plugin-dev:create-plugin` command provides an 8-phase guided workflow:
+### `/plugin-dev:create-plugin`
+
+An 8-phase guided workflow for plugin creation:
 
 1. Discovery - Understand requirements
 2. Component Planning - Determine needed components
@@ -183,13 +186,26 @@ The `/plugin-dev:create-plugin` command provides an 8-phase guided workflow:
 5. Component Implementation - Build each component
 6. Validation - Run validators
 7. Testing - Verify in Claude Code
-8. Documentation - Finalize README
+8. Documentation - Finalize README and marketplace publishing
+
+### `/plugin-dev:create-marketplace`
+
+An 8-phase guided workflow for marketplace creation:
+
+1. Discovery - Understand marketplace purpose
+2. Plugin Planning - Determine plugins to include
+3. Metadata Design - Configure marketplace metadata
+4. Structure Creation - Create directory and manifest
+5. Plugin Entry Configuration - Configure each plugin entry
+6. Distribution Setup - Configure team settings or community guidelines
+7. Validation - Run marketplace validators
+8. Testing & Finalization - Test installation and finalize
 
 ## Validation Agents
 
 Use these agents proactively after creating components:
 
-- **plugin-validator**: Validates entire plugin structure
+- **plugin-validator**: Validates entire plugin structure and marketplace.json
 - **skill-reviewer**: Reviews skill quality and triggering
 - **agent-creator**: Generates new agents from descriptions
 
diff --git a/plugins/plugin-dev/.claude-plugin/plugin.json b/plugins/plugin-dev/.claude-plugin/plugin.json
index 325de12..19ce3e2 100644
--- a/plugins/plugin-dev/.claude-plugin/plugin.json
+++ b/plugins/plugin-dev/.claude-plugin/plugin.json
@@ -1,7 +1,7 @@
 {
   "name": "plugin-dev",
   "version": "0.1.0",
-  "description": "Comprehensive toolkit for developing Claude Code plugins. Includes 7 expert skills covering hooks, MCP integration, commands, agents, and best practices. AI-assisted plugin creation and validation.",
+  "description": "Comprehensive toolkit for developing Claude Code plugins. Includes 8 expert skills covering hooks, MCP integration, commands, agents, marketplaces, and best practices. AI-assisted plugin creation and validation.",
   "author": {
     "name": "Daisy Hollman",
     "email": "daisy@anthropic.com"
diff --git a/plugins/plugin-dev/agents/plugin-validator.md b/plugins/plugin-dev/agents/plugin-validator.md
index 60aff6d..1e75846 100644
--- a/plugins/plugin-dev/agents/plugin-validator.md
+++ b/plugins/plugin-dev/agents/plugin-validator.md
@@ -1,6 +1,6 @@
 ---
 name: plugin-validator
-description: Use this agent when the user asks to "validate my plugin", "check plugin structure", "verify plugin is correct", "validate plugin.json", "check plugin files", or mentions plugin validation. Also trigger proactively after user creates or modifies plugin components. Examples:
+description: Use this agent when the user asks to "validate my plugin", "check plugin structure", "verify plugin is correct", "validate plugin.json", "check plugin files", "validate marketplace", "check marketplace.json", "verify marketplace structure", or mentions plugin or marketplace validation. Also trigger proactively after user creates or modifies plugin or marketplace components. Examples:
 
 <example>
 Context: User finished creating a new plugin
@@ -31,22 +31,42 @@ Manifest modified, validate to ensure correctness.
 assistant: "I'll use the plugin-validator agent to check the manifest."
 </example>
 
+<example>
+Context: User created or modified a marketplace
+user: "I've set up a marketplace.json for my plugins"
+assistant: "Let me validate the marketplace structure."
+<commentary>
+Marketplace created, validate schema and plugin entries.
+</commentary>
+assistant: "I'll use the plugin-validator agent to check the marketplace."
+</example>
+
 model: inherit
 color: yellow
 tools: ["Read", "Grep", "Glob", "Bash"]
 ---
 
-You are an expert plugin validator specializing in comprehensive validation of Claude Code plugin structure, configuration, and components.
+You are an expert plugin and marketplace validator specializing in comprehensive validation of Claude Code plugin structure, configuration, components, and plugin marketplaces.
 
 **Your Core Responsibilities:**
+
 1. Validate plugin structure and organization
 2. Check plugin.json manifest for correctness
 3. Validate all component files (commands, agents, skills, hooks)
 4. Verify naming conventions and file organization
-5. Check for common issues and anti-patterns
-6. Provide specific, actionable recommendations
+5. Validate marketplace.json schema and plugin entries
+6. Check for common issues and anti-patterns
+7. Provide specific, actionable recommendations
+
+## Detection: Plugin vs. Marketplace
 
-**Validation Process:**
+First, determine what type of validation is needed:
+
+- **Marketplace**: `.claude-plugin/marketplace.json` exists at repository root
+- **Plugin**: `.claude-plugin/plugin.json` exists (may be inside a marketplace's `plugins/` directory)
+- **Both**: Repository is a marketplace containing plugins (validate both)
+
+**Plugin Validation Process:**
 
 1. **Locate Plugin Root**:
    - Check for `.claude-plugin/plugin.json`
@@ -133,15 +153,66 @@ You are an expert plugin validator specializing in comprehensive validation of C
     - Hooks don't have obvious security issues
     - No secrets in example files
 
+**Marketplace Validation Process:**
+
+When `.claude-plugin/marketplace.json` is detected, perform marketplace-specific validation:
+
+1. **Validate Marketplace Schema**:
+   - Check JSON syntax
+   - Verify required fields:
+     - `name`: kebab-case string, 3-50 characters
+     - `owner`: object with at least `name` field
+     - `plugins`: non-empty array
+   - Validate optional `metadata` object:
+     - `description`: string
+     - `version`: semver format
+     - `pluginRoot`: valid relative path
+
+2. **Validate Plugin Entries**:
+   - For each entry in `plugins` array:
+     - `name` is required, kebab-case, unique within marketplace
+     - `source` is required (string or object)
+   - Check source types:
+     - String: relative path starting with `./` or `../`
+     - Object with `source: "github"`: has `repo` field
+     - Object with `source: "url"`: has `url` field
+   - Validate optional fields:
+     - `version`: semver format if present
+     - `license`: valid SPDX identifier if present
+
+3. **Check for Duplicate Names**:
+   - No duplicate plugin names in `plugins` array
+   - Report all duplicates if found
+
+4. **Validate Relative Source Paths**:
+   - For plugins with relative path sources:
+     - Check that the path exists
+     - If `strict: true` (default), verify `.claude-plugin/plugin.json` exists
+     - If `strict: false`, verify plugin directory exists
+   - Consider `metadata.pluginRoot` as base path
+
+5. **Cross-Validate Local Plugins**:
+   - For each relative path plugin:
+     - Run plugin validation on the referenced directory
+     - Report issues found in local plugins
+
+6. **Marketplace Best Practices**:
+   - Check all entries have `version` specified
+   - Check all entries have `description` specified
+   - Verify README.md documents the marketplace
+   - Suggest CHANGELOG.md for version tracking
+
 **Quality Standards:**
+
 - All validation errors include file path and specific issue
 - Warnings distinguished from errors
 - Provide fix suggestions for each issue
 - Include positive findings for well-structured components
 - Categorize by severity (critical/major/minor)
 
-**Output Format:**
+**Output Format for Plugin Validation:**
 
+```markdown
 ## Plugin Validation Report
 
 ### Plugin: [name]
@@ -180,14 +251,61 @@ Location: [path]
 ### Overall Assessment
 
 [PASS/FAIL] - [Reasoning]
+```
+
+**Output Format for Marketplace Validation:**
+
+```markdown
+## Marketplace Validation Report
+
+### Marketplace: [name]
+
+Location: [path]
+
+### Summary
+
+[Overall assessment - pass/fail with key stats]
+
+### Critical Issues ([count])
+
+- `file/path` - [Issue] - [Fix]
+
+### Warnings ([count])
+
+- `file/path` - [Issue] - [Recommendation]
+
+### Plugin Entries ([count])
+
+| Name | Source Type | Version | Status |
+|------|-------------|---------|--------|
+| [name] | [relative/github/url] | [version] | [valid/issues] |
+
+### Local Plugin Validation
+
+[For each relative path plugin, include summary of plugin validation]
+
+### Positive Findings
+
+- [What's done well]
+
+### Recommendations
+
+1. [Priority recommendation]
+2. [Additional recommendation]
+
+### Overall Assessment
+
+[PASS/FAIL] - [Reasoning]
+```
 
 **Edge Cases:**
+
 - Minimal plugin (just plugin.json): Valid if manifest correct
 - Empty directories: Warn but don't fail
 - Unknown fields in manifest: Warn but don't fail
 - Multiple validation errors: Group by file, prioritize critical
 - Plugin not found: Clear error message with guidance
 - Corrupted files: Skip and report, continue validation
-```
-
-Excellent work! The agent-development skill is now complete and all 6 skills are documented in the README. Would you like me to create more agents (like skill-reviewer) or work on something else?
+- Marketplace with only external plugins: Valid if schema correct
+- Marketplace with strict:false entries: Don't require plugin.json in those directories
+- Circular marketplace references: Detect and report
diff --git a/plugins/plugin-dev/commands/create-marketplace.md b/plugins/plugin-dev/commands/create-marketplace.md
new file mode 100644
index 0000000..6b69d6d
--- /dev/null
+++ b/plugins/plugin-dev/commands/create-marketplace.md
@@ -0,0 +1,420 @@
+---
+description: Guided end-to-end marketplace creation workflow with plugin organization and validation
+argument-hint: Optional marketplace description
+allowed-tools: ["Read", "Write", "Grep", "Glob", "Bash", "TodoWrite", "AskUserQuestion", "Skill", "Task"]
+---
+
+# Marketplace Creation Workflow
+
+Guide the user through creating a complete plugin marketplace from initial concept to validated, distributable collection. Follow a systematic approach: understand requirements, plan plugins, configure structure, add entries, validate, and prepare for distribution.
+
+## Core Principles
+
+- **Ask clarifying questions**: Identify all ambiguities about marketplace purpose, plugins, distribution strategy. Ask specific questions rather than making assumptions. Wait for user answers before proceeding.
+- **Load marketplace-structure skill**: Use the Skill tool to load the marketplace-structure skill for schema and pattern guidance
+- **Use plugin-validator agent**: Leverage the plugin-validator agent for comprehensive marketplace validation
+- **Follow best practices**: Apply patterns from this repository's own marketplace.json
+- **Use TodoWrite**: Track all progress throughout all phases
+
+**Initial request:** $ARGUMENTS
+
+---
+
+## Phase 1: Discovery
+
+**Goal**: Understand what marketplace needs to be created and its purpose
+
+**Actions**:
+
+1. Create todo list with all 8 phases
+2. If marketplace purpose is clear from arguments:
+   - Summarize understanding
+   - Identify marketplace type (team internal, community, single-plugin, multi-plugin)
+3. If marketplace purpose is unclear, ask user:
+   - What plugins will this marketplace contain?
+   - Who is the target audience? (team, community, public)
+   - Will plugins be local (in same repo) or external (GitHub, git URLs)?
+   - Single maintainer or community contributions?
+4. Summarize understanding and confirm with user before proceeding
+
+**Output**: Clear statement of marketplace purpose and distribution strategy
+
+---
+
+## Phase 2: Plugin Planning
+
+**Goal**: Determine which plugins to include and their sources
+
+**MUST load marketplace-structure skill** using Skill tool before this phase.
+
+**Actions**:
+
+1. Load marketplace-structure skill for schema guidance
+2. List plugins to include in marketplace:
+   - For each plugin: name, source type, brief description
+3. Categorize by source type:
+   - **Local (relative path)**: Plugins maintained in same repository
+   - **GitHub**: External plugins on GitHub
+   - **Git URL**: External plugins on GitLab, Bitbucket, or self-hosted
+4. Present plugin plan to user as table:
+
+   ```text
+   | Plugin Name      | Source Type | Description            |
+   |------------------|-------------|------------------------|
+   | code-formatter   | local       | Code formatting tools  |
+   | security-scanner | github      | Security analysis      |
+   | legacy-tool      | git-url     | Legacy utility         |
+   ```
+
+5. For each local plugin, determine:
+   - Does it already exist? (will validate)
+   - Need to create it? (redirect to /plugin-dev:create-plugin)
+6. Get user confirmation or adjustments
+
+**Output**: Confirmed list of plugins with sources
+
+---
+
+## Phase 3: Metadata Design
+
+**Goal**: Define marketplace metadata and owner information
+
+**Actions**:
+
+1. Determine marketplace name:
+   - Must be kebab-case (lowercase, hyphens)
+   - Should be descriptive of purpose
+   - Examples: `team-tools`, `security-plugins`, `awesome-claude-plugins`
+
+2. Gather owner information:
+   - Ask user: "Who maintains this marketplace?"
+   - Required: name
+   - Optional: email, url
+
+3. Define optional metadata:
+   - description: Brief marketplace description
+   - version: Initial version (recommend 1.0.0 or 0.1.0)
+   - pluginRoot: Base path for relative sources (default: none)
+
+4. Present configuration summary:
+
+   ```json
+   {
+     "name": "team-tools",
+     "owner": {
+       "name": "Platform Team",
+       "email": "platform@company.com"
+     },
+     "metadata": {
+       "description": "Internal development tools",
+       "version": "1.0.0"
+     }
+   }
+   ```
+
+5. Get user confirmation
+
+**Output**: Confirmed marketplace metadata
+
+---
+
+## Phase 4: Structure Creation
+
+**Goal**: Create marketplace directory structure and manifest
+
+**Actions**:
+
+1. Determine marketplace location:
+   - Ask user: "Where should I create the marketplace?"
+   - Offer options: current directory, new directory, custom path
+
+2. Create directory structure using bash:
+
+   ```bash
+   mkdir -p marketplace-name/.claude-plugin
+   mkdir -p marketplace-name/plugins  # if local plugins
+   ```
+
+3. Create marketplace.json manifest using Write tool:
+
+   ```json
+   {
+     "name": "marketplace-name",
+     "owner": {
+       "name": "[from Phase 3]"
+     },
+     "metadata": {
+       "description": "[from Phase 3]",
+       "version": "[from Phase 3]"
+     },
+     "plugins": []
+   }
+   ```
+
+4. Create README.md template with:
+   - Marketplace description
+   - Installation instructions
+   - Available plugins table (to be filled in Phase 5)
+   - Contributing guidelines (if community)
+
+5. Initialize git repo if creating new directory
+
+**Output**: Marketplace directory structure created
+
+---
+
+## Phase 5: Plugin Entry Configuration
+
+**Goal**: Configure each plugin entry with appropriate metadata
+
+**Actions**:
+
+1. For each plugin in the plan (from Phase 2):
+
+   **For local plugins**:
+
+   - If plugin exists:
+     - Read its plugin.json to get metadata
+     - Create entry with relative source path
+   - If plugin doesn't exist:
+     - Ask: "Plugin 'X' doesn't exist. Create it now or add placeholder?"
+     - If create: Use Task tool to run /plugin-dev:create-plugin
+     - If placeholder: Create entry with TODO comment in README
+
+   **For GitHub plugins**:
+
+   - Create entry with github source object
+   - Prompt for version, description if not known
+   - Consider strict: false if plugin lacks plugin.json
+
+   **For git URL plugins**:
+
+   - Create entry with url source object
+   - Prompt for version, description if not known
+
+2. For each entry, configure optional fields:
+   - version (recommend always including)
+   - description (recommend always including)
+   - category (if marketplace uses categories)
+   - tags (for discoverability)
+
+3. Update marketplace.json with all plugin entries
+
+4. Update README.md with plugin table:
+
+   | Plugin | Description | Version |
+   |--------|-------------|---------|
+   | X      | Does Y      | 1.0.0   |
+
+**Output**: All plugin entries configured in marketplace.json
+
+---
+
+## Phase 6: Distribution Setup
+
+**Goal**: Configure distribution strategy based on target audience
+
+**Actions**:
+
+1. **For team/internal marketplaces**:
+   - Provide team settings configuration:
+
+     ```json
+     {
+       "extraKnownMarketplaces": {
+         "marketplace-name": {
+           "source": {
+             "source": "github",
+             "repo": "org/marketplace-repo"
+           }
+         }
+       }
+     }
+     ```
+
+   - Document which plugins should be in `enabledPlugins`
+   - Add to README: How team members install
+
+2. **For community/public marketplaces**:
+   - Create CONTRIBUTING.md with:
+     - Plugin submission guidelines
+     - Review process
+     - Quality requirements
+   - Create CI workflow for validation (optional):
+     - JSON syntax check
+     - Required field validation
+     - Duplicate name detection
+
+3. **For all marketplaces**:
+   - Document installation command in README:
+
+     ```bash
+     /plugin marketplace add owner/repo
+     ```
+
+   - List individual plugin installation:
+
+     ```bash
+     /plugin install plugin-name@marketplace-name
+     ```
+
+**Output**: Distribution documentation complete
+
+---
+
+## Phase 7: Validation
+
+**Goal**: Ensure marketplace meets quality standards
+
+**Actions**:
+
+1. **Run plugin-validator agent**:
+   - Use plugin-validator agent to validate marketplace
+   - Check: schema, required fields, plugin entries, source paths
+
+2. **Fix critical issues**:
+   - Address any critical errors from validation
+   - Fix warnings that indicate real problems
+
+3. **Validate local plugins** (if any):
+   - For each local plugin, run plugin validation
+   - Fix any issues found
+
+4. **Check best practices**:
+   - All entries have version
+   - All entries have description
+   - README documents all plugins
+   - Owner information complete
+
+5. **Present validation report**:
+   - Summary of marketplace validation
+   - Summary of each local plugin validation
+   - Overall quality assessment
+
+6. **Ask user**: "Validation complete. Would you like me to fix any issues, or proceed to testing?"
+
+**Output**: Marketplace validated and ready for testing
+
+---
+
+## Phase 8: Testing & Finalization
+
+**Goal**: Test marketplace installation and finalize
+
+**Actions**:
+
+1. **Test locally**:
+   - Show user how to test:
+
+     ```bash
+     /plugin marketplace add ./path/to/marketplace
+     ```
+
+   - List marketplace:
+
+     ```bash
+     /plugin marketplace list
+     ```
+
+   - Install test plugin:
+
+     ```bash
+     /plugin install plugin-name@marketplace-name
+     ```
+
+2. **Verification checklist**:
+   - [ ] Marketplace adds successfully
+   - [ ] All plugins appear in `/plugin` browser
+   - [ ] Local plugins install correctly
+   - [ ] External plugins accessible (if public)
+
+3. **Create summary**:
+   - Mark all todos complete
+   - List what was created:
+     - Marketplace name and purpose
+     - Number of plugins configured
+     - Distribution strategy
+     - Key files created
+   - Next steps:
+     - Push to GitHub/git hosting
+     - Share with team
+     - Add to project settings
+
+4. **Suggest improvements** (optional):
+   - Additional plugins to consider
+   - CI/CD integration opportunities
+   - Version management strategies
+
+**Output**: Complete, validated marketplace ready for distribution
+
+---
+
+## Important Notes
+
+### Throughout All Phases
+
+- **Use TodoWrite** to track progress at every phase
+- **Load marketplace-structure skill** for schema reference
+- **Use plugin-validator agent** for validation
+- **Ask for user confirmation** at key decision points
+- **Follow this repository's marketplace.json** as reference
+- **Apply best practices**:
+  - kebab-case names
+  - Complete owner information
+  - Version all entries
+  - Document all plugins in README
+  - ${CLAUDE_PLUGIN_ROOT} for local plugin paths
+
+### Key Decision Points (Wait for User)
+
+1. After Phase 1: Confirm marketplace purpose
+2. After Phase 2: Approve plugin plan
+3. After Phase 3: Confirm metadata
+4. After Phase 5: Proceed to distribution setup
+5. After Phase 7: Fix issues or proceed
+
+### Skills to Load
+
+- **Phase 2+**: marketplace-structure (for schema and patterns)
+- **Phase 5**: plugin-structure (if creating local plugins)
+
+### Quality Standards
+
+Every marketplace must meet these standards:
+
+- ✅ Valid JSON syntax
+- ✅ All required fields present (name, owner, plugins)
+- ✅ Plugin entries have name and source
+- ✅ No duplicate plugin names
+- ✅ Local source paths exist
+- ✅ README documents marketplace and plugins
+- ✅ Validated with plugin-validator agent
+
+---
+
+## Example Workflow
+
+### User Request
+
+"Create a marketplace for our team's internal tools"
+
+### Phase 1: Discovery
+
+- Understand: Internal team distribution
+- Confirm: Team-only plugins, GitHub hosting
+
+### Phase 2: Plugin Planning
+
+- 3 plugins: linter-config (local), security-scanner (local), docs-generator (github)
+
+### Phase 3: Metadata
+
+- name: team-tools
+- owner: Platform Team
+- version: 1.0.0
+
+### Phase 4-8: Structure, Entries, Distribution, Validation, Testing
+
+---
+
+Begin with Phase 1: Discovery.
diff --git a/plugins/plugin-dev/commands/create-plugin.md b/plugins/plugin-dev/commands/create-plugin.md
index 25576bd..d06ee3d 100644
--- a/plugins/plugin-dev/commands/create-plugin.md
+++ b/plugins/plugin-dev/commands/create-plugin.md
@@ -316,30 +316,61 @@ Guide the user through creating a complete, high-quality Claude Code plugin from
 **Goal**: Ensure plugin is well-documented and ready for distribution
 
 **Actions**:
+
 1. **Verify README completeness**:
    - Check README has: overview, features, installation, prerequisites, usage
    - For MCP plugins: Document required environment variables
    - For hook plugins: Explain hook activation
    - For settings: Provide configuration templates
 
-2. **Add marketplace entry** (if publishing):
-   - Show user how to add to marketplace.json
-   - Help draft marketplace description
-   - Suggest category and tags
-
-3. **Create summary**:
+2. **Ask about marketplace publishing**:
+   - Ask user: "Would you like to publish this plugin to a marketplace?"
+   - If yes, proceed with marketplace integration
+   - If no, skip to step 4
+
+3. **Marketplace integration** (if publishing):
+   - Load marketplace-structure skill using Skill tool
+   - Determine target marketplace:
+     - Ask: "Which marketplace? (existing marketplace path, create new, or skip)"
+   - If existing marketplace:
+     - Read marketplace.json
+     - Draft plugin entry:
+
+       ```json
+       {
+         "name": "[plugin-name]",
+         "source": "[relative-path-or-github]",
+         "description": "[from plugin.json]",
+         "version": "[from plugin.json]",
+         "category": "[suggest based on plugin type]"
+       }
+       ```
+
+     - Show diff of marketplace.json before/after addition
+     - Ask user to confirm entry
+     - Update marketplace.json with new plugin entry
+     - Update marketplace metadata.version (bump patch version)
+   - If create new marketplace:
+     - Suggest using `/plugin-dev:create-marketplace` command
+     - Or create minimal marketplace.json with this plugin as first entry
+   - Validate marketplace after update using plugin-validator agent
+
+4. **Create summary**:
    - Mark all todos complete
    - List what was created:
      - Plugin name and purpose
      - Components created (X skills, Y commands, Z agents, etc.)
      - Key files and their purposes
      - Total file count and structure
+   - If added to marketplace:
+     - Marketplace name and location
+     - Plugin entry details
    - Next steps:
      - Testing recommendations
-     - Publishing to marketplace (if desired)
+     - Publishing to marketplace (if not done)
      - Iteration based on usage
 
-4. **Suggest improvements** (optional):
+5. **Suggest improvements** (optional):
    - Additional components that could enhance plugin
    - Integration opportunities
    - Testing strategies
@@ -379,6 +410,7 @@ Guide the user through creating a complete, high-quality Claude Code plugin from
 - **Phase 2**: plugin-structure
 - **Phase 5**: skill-development, command-development, agent-development, hook-development, mcp-integration, plugin-settings (as needed)
 - **Phase 6**: (agents will use skills automatically)
+- **Phase 8**: marketplace-structure (if publishing to marketplace)
 
 ### Quality Standards
 
diff --git a/plugins/plugin-dev/skills/marketplace-structure/SKILL.md b/plugins/plugin-dev/skills/marketplace-structure/SKILL.md
new file mode 100644
index 0000000..899c206
--- /dev/null
+++ b/plugins/plugin-dev/skills/marketplace-structure/SKILL.md
@@ -0,0 +1,271 @@
+---
+name: marketplace-structure
+description: This skill should be used when the user asks to "create a marketplace", "set up marketplace.json", "organize multiple plugins", "distribute plugins", "host plugins", "marketplace schema", "plugin marketplace structure", "multi-plugin organization", or needs guidance on plugin marketplace creation, marketplace manifest configuration, or plugin distribution strategies.
+---
+
+# Marketplace Structure
+
+A plugin marketplace is a catalog of available plugins that enables centralized discovery, version management, and distribution. This skill covers creating and maintaining marketplaces for team or community plugin distribution.
+
+## Overview
+
+Marketplaces provide:
+
+- **Centralized discovery** - Browse plugins from multiple sources in one place
+- **Version management** - Track and update plugin versions automatically
+- **Team distribution** - Share required plugins across an organization
+- **Flexible sources** - Support for relative paths, GitHub repos, and git URLs
+
+### When to Create a Marketplace vs. a Plugin
+
+| Create a Plugin | Create a Marketplace |
+|----------------|---------------------|
+| Single-purpose extension | Collection of related plugins |
+| Used directly by end users | Distributes multiple plugins |
+| One team or individual maintains it | Curates plugins from various sources |
+| Installed via `/plugin install` | Added via `/plugin marketplace add` |
+
+## Directory Structure
+
+Place `marketplace.json` in the `.claude-plugin/` directory at the repository root:
+
+```text
+marketplace-repo/
+├── .claude-plugin/
+│   └── marketplace.json      # Required: Marketplace manifest
+├── plugins/                  # Optional: Local plugin directories
+│   ├── plugin-one/
+│   │   └── .claude-plugin/
+│   │       └── plugin.json
+│   └── plugin-two/
+│       └── .claude-plugin/
+│           └── plugin.json
+└── README.md                 # Recommended: Marketplace documentation
+```
+
+## Marketplace Schema
+
+The `marketplace.json` manifest defines the marketplace and its available plugins.
+
+### Required Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `name` | string | Marketplace identifier (kebab-case, no spaces) |
+| `owner` | object | Marketplace maintainer information |
+| `plugins` | array | List of available plugin entries |
+
+### Owner Object
+
+```json
+{
+  "owner": {
+    "name": "Team Name",
+    "email": "team@example.com",
+    "url": "https://github.com/team"
+  }
+}
+```
+
+### Optional Metadata
+
+```json
+{
+  "metadata": {
+    "description": "Brief marketplace description",
+    "version": "1.0.0",
+    "pluginRoot": "./plugins"
+  }
+}
+```
+
+The `pluginRoot` field sets the base path for relative plugin sources.
+
+## Plugin Entry Format
+
+Each plugin in the `plugins` array requires:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `name` | string | Plugin identifier (kebab-case, unique within marketplace) |
+| `source` | string or object | Where to fetch the plugin |
+
+### Optional Plugin Fields
+
+Standard metadata fields:
+
+- `description` - Brief plugin description
+- `version` - Plugin version (semver)
+- `author` - Author information object
+- `homepage` - Documentation URL
+- `repository` - Source code URL
+- `license` - SPDX license identifier
+- `keywords` - Tags for discovery
+- `category` - Plugin category
+- `tags` - Additional searchability tags
+
+Component configuration fields:
+
+- `commands` - Custom paths to command files or directories
+- `agents` - Custom paths to agent files
+- `hooks` - Hooks configuration or path to hooks file
+- `mcpServers` - MCP server configurations
+
+For complete field reference, see `references/schema-reference.md`.
+
+## Plugin Sources
+
+### Relative Paths
+
+For plugins within the same repository:
+
+```json
+{
+  "name": "my-plugin",
+  "source": "./plugins/my-plugin"
+}
+```
+
+### GitHub Repositories
+
+```json
+{
+  "name": "github-plugin",
+  "source": {
+    "source": "github",
+    "repo": "owner/plugin-repo"
+  }
+}
+```
+
+### Git URLs
+
+For GitLab, Bitbucket, or self-hosted git:
+
+```json
+{
+  "name": "git-plugin",
+  "source": {
+    "source": "url",
+    "url": "https://gitlab.com/team/plugin.git"
+  }
+}
+```
+
+## Strict vs. Non-Strict Mode
+
+The `strict` field controls whether plugins must have their own `plugin.json`:
+
+| Mode | Behavior |
+|------|----------|
+| `strict: true` (default) | Plugin must include `plugin.json`; marketplace entry supplements it |
+| `strict: false` | `plugin.json` optional; marketplace entry serves as complete manifest |
+
+Use `strict: false` when:
+
+- Curating external plugins without modifying their source
+- Providing all metadata in the marketplace entry
+- Plugin directories contain only commands/agents/skills without manifest
+
+```json
+{
+  "name": "external-plugin",
+  "source": {
+    "source": "github",
+    "repo": "external/plugin"
+  },
+  "description": "Complete metadata here",
+  "version": "2.0.0",
+  "strict": false
+}
+```
+
+## Best Practices
+
+### Organization
+
+- **One theme per marketplace** - Group related plugins (e.g., "frontend-tools", "security-plugins")
+- **Clear naming** - Use descriptive kebab-case names for both marketplace and plugins
+- **Version all entries** - Include `version` for every plugin entry
+- **Document each plugin** - Provide `description` for discoverability
+
+### Versioning
+
+- Use semantic versioning (X.Y.Z) for marketplace `metadata.version`
+- Update marketplace version when adding, removing, or updating plugins
+- Consider a CHANGELOG.md for tracking changes
+
+### Distribution
+
+- **GitHub hosting** - Simplest distribution via `/plugin marketplace add owner/repo`
+- **Team settings** - Configure `extraKnownMarketplaces` in `.claude/settings.json`
+- **Local testing** - Add with `/plugin marketplace add ./path` during development
+
+For detailed distribution patterns, see `references/distribution-patterns.md`.
+
+### Validation
+
+Validate marketplace structure before publishing:
+
+```bash
+# Check JSON syntax
+jq . .claude-plugin/marketplace.json
+
+# Verify required fields
+jq 'has("name") and has("owner") and has("plugins")' .claude-plugin/marketplace.json
+```
+
+Use the `plugin-validator` agent with marketplace support for comprehensive validation.
+
+## Complete Example
+
+```json
+{
+  "name": "team-tools",
+  "owner": {
+    "name": "DevTools Team",
+    "email": "devtools@company.com",
+    "url": "https://github.com/company"
+  },
+  "metadata": {
+    "description": "Internal development tools for the engineering team",
+    "version": "1.0.0"
+  },
+  "plugins": [
+    {
+      "name": "code-formatter",
+      "source": "./plugins/formatter",
+      "description": "Automatic code formatting on save",
+      "version": "2.1.0"
+    },
+    {
+      "name": "security-scanner",
+      "source": {
+        "source": "github",
+        "repo": "company/security-plugin"
+      },
+      "description": "Security vulnerability detection",
+      "version": "1.5.0",
+      "category": "security"
+    }
+  ]
+}
+```
+
+## Additional Resources
+
+- `references/schema-reference.md` - Complete field reference for marketplace.json
+- `references/distribution-patterns.md` - Hosting and team distribution strategies
+- `examples/minimal-marketplace.md` - Single plugin marketplace template
+- `examples/team-marketplace.md` - Internal company marketplace template
+- `examples/community-marketplace.md` - Public multi-plugin marketplace template
+
+## Related Skills
+
+- **plugin-structure** - For individual plugin `plugin.json` details
+- **plugin-validator** agent - For validating marketplace structure
+- **`/plugin-dev:create-marketplace`** - Guided marketplace creation workflow
+
+## Working Example
+
+This repository (`plugin-dev`) is itself a marketplace. Examine `.claude-plugin/marketplace.json` at the repository root for a real-world example of marketplace structure and plugin organization.
diff --git a/plugins/plugin-dev/skills/marketplace-structure/examples/community-marketplace.md b/plugins/plugin-dev/skills/marketplace-structure/examples/community-marketplace.md
new file mode 100644
index 0000000..4a660e3
--- /dev/null
+++ b/plugins/plugin-dev/skills/marketplace-structure/examples/community-marketplace.md
@@ -0,0 +1,215 @@
+# Community Marketplace Example
+
+A public multi-plugin marketplace curating plugins from various authors.
+
+## Use Case
+
+- Curate best-of-breed plugins for a domain
+- Community-driven plugin discovery
+- Mix of local and external plugin sources
+
+## Directory Structure
+
+```text
+awesome-claude-plugins/
+├── .claude-plugin/
+│   └── marketplace.json
+├── plugins/
+│   └── featured-plugin/          # Locally maintained plugin
+│       └── .claude-plugin/
+│           └── plugin.json
+├── CONTRIBUTING.md
+├── README.md
+└── .github/
+    └── workflows/
+        └── validate.yml          # CI validation
+```
+
+## marketplace.json
+
+```json
+{
+  "name": "awesome-claude-plugins",
+  "owner": {
+    "name": "Community Maintainers",
+    "url": "https://github.com/awesome-claude-plugins"
+  },
+  "metadata": {
+    "description": "Curated collection of high-quality Claude Code plugins",
+    "version": "1.3.0"
+  },
+  "plugins": [
+    {
+      "name": "code-reviewer",
+      "source": {
+        "source": "github",
+        "repo": "author1/code-reviewer-plugin"
+      },
+      "description": "AI-powered code review assistant",
+      "version": "2.0.0",
+      "category": "development",
+      "tags": ["review", "quality"],
+      "author": {
+        "name": "Author One",
+        "url": "https://github.com/author1"
+      }
+    },
+    {
+      "name": "test-generator",
+      "source": {
+        "source": "github",
+        "repo": "author2/test-generator"
+      },
+      "description": "Automatic test case generation",
+      "version": "1.5.0",
+      "category": "testing",
+      "tags": ["testing", "automation"],
+      "author": {
+        "name": "Author Two"
+      }
+    },
+    {
+      "name": "doc-writer",
+      "source": {
+        "source": "github",
+        "repo": "docs-team/doc-writer"
+      },
+      "description": "Documentation generation and maintenance",
+      "version": "3.1.0",
+      "category": "documentation",
+      "tags": ["docs", "markdown"]
+    },
+    {
+      "name": "featured-plugin",
+      "source": "./plugins/featured-plugin",
+      "description": "Marketplace's featured community plugin",
+      "version": "1.0.0",
+      "category": "productivity"
+    },
+    {
+      "name": "legacy-tool",
+      "source": {
+        "source": "github",
+        "repo": "legacy/tool-plugin"
+      },
+      "description": "Legacy tool without plugin.json",
+      "version": "0.9.0",
+      "category": "utilities",
+      "strict": false,
+      "commands": "./commands/"
+    }
+  ]
+}
+```
+
+## README.md Template
+
+```markdown
+# Awesome Claude Plugins
+
+A curated collection of high-quality Claude Code plugins.
+
+## Installation
+
+```bash
+/plugin marketplace add awesome-claude-plugins/awesome-claude-plugins
+```
+
+## Available Plugins
+
+| Plugin | Description | Category |
+|--------|-------------|----------|
+| code-reviewer | AI-powered code review | Development |
+| test-generator | Automatic test generation | Testing |
+| doc-writer | Documentation generation | Documentation |
+| featured-plugin | Community featured plugin | Productivity |
+
+## Contributing
+
+See `CONTRIBUTING.md` for submission guidelines.
+
+## License
+
+MIT
+```
+
+## CONTRIBUTING.md Template
+
+```markdown
+# Contributing
+
+## Submitting a Plugin
+
+1. Fork this repository
+2. Add your plugin entry to `marketplace.json`
+3. Ensure your plugin:
+   - Has a valid `plugin.json` (or use `strict: false`)
+   - Includes description and version
+   - Is publicly accessible
+4. Submit a PR with:
+   - Plugin entry in `marketplace.json`
+   - Brief description of what the plugin does
+
+## Plugin Requirements
+
+- [ ] Public GitHub repository
+- [ ] Valid plugin structure
+- [ ] No security vulnerabilities
+- [ ] Clear documentation
+
+## Review Process
+
+1. Automated validation runs on PR
+2. Maintainer reviews plugin quality
+3. Community feedback period (1 week)
+4. Merge and marketplace update
+```
+
+## CI Validation Workflow
+
+`.github/workflows/validate.yml`:
+
+```yaml
+name: Validate Marketplace
+
+on:
+  pull_request:
+    paths:
+      - '.claude-plugin/marketplace.json'
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Validate JSON syntax
+        run: jq . .claude-plugin/marketplace.json
+
+      - name: Check required fields
+        run: |
+          jq -e 'has("name") and has("owner") and has("plugins")' \
+            .claude-plugin/marketplace.json
+
+      - name: Check no duplicate plugin names
+        run: |
+          DUPES=$(jq '[.plugins[].name] | group_by(.) | map(select(length > 1)) | length' \
+            .claude-plugin/marketplace.json)
+          if [ "$DUPES" -gt 0 ]; then
+            echo "Duplicate plugin names found"
+            exit 1
+          fi
+```
+
+## Installation
+
+```bash
+# Add marketplace
+/plugin marketplace add awesome-claude-plugins/awesome-claude-plugins
+
+# Browse available plugins
+/plugin
+
+# Install specific plugin
+/plugin install code-reviewer@awesome-claude-plugins
+```
diff --git a/plugins/plugin-dev/skills/marketplace-structure/examples/minimal-marketplace.md b/plugins/plugin-dev/skills/marketplace-structure/examples/minimal-marketplace.md
new file mode 100644
index 0000000..0bf9719
--- /dev/null
+++ b/plugins/plugin-dev/skills/marketplace-structure/examples/minimal-marketplace.md
@@ -0,0 +1,83 @@
+# Minimal Marketplace Example
+
+A single-plugin marketplace with only required fields.
+
+## Use Case
+
+- Quick setup for distributing one plugin
+- Minimal configuration overhead
+- Local development and testing
+
+## Directory Structure
+
+```text
+my-marketplace/
+├── .claude-plugin/
+│   └── marketplace.json
+└── plugins/
+    └── my-plugin/
+        └── .claude-plugin/
+            └── plugin.json
+```
+
+## marketplace.json
+
+```json
+{
+  "name": "my-marketplace",
+  "owner": {
+    "name": "Your Name"
+  },
+  "plugins": [
+    {
+      "name": "my-plugin",
+      "source": "./plugins/my-plugin"
+    }
+  ]
+}
+```
+
+## Plugin's plugin.json
+
+The plugin must have its own manifest since `strict: true` is the default:
+
+```json
+{
+  "name": "my-plugin",
+  "version": "1.0.0",
+  "description": "A simple plugin"
+}
+```
+
+## Installation
+
+```bash
+# Local testing
+/plugin marketplace add ./my-marketplace
+
+# After publishing to GitHub
+/plugin marketplace add your-username/my-marketplace
+```
+
+## Extending to Multiple Plugins
+
+Add more plugins to the array:
+
+```json
+{
+  "name": "my-marketplace",
+  "owner": {
+    "name": "Your Name"
+  },
+  "plugins": [
+    {
+      "name": "plugin-one",
+      "source": "./plugins/plugin-one"
+    },
+    {
+      "name": "plugin-two",
+      "source": "./plugins/plugin-two"
+    }
+  ]
+}
+```
diff --git a/plugins/plugin-dev/skills/marketplace-structure/examples/team-marketplace.md b/plugins/plugin-dev/skills/marketplace-structure/examples/team-marketplace.md
new file mode 100644
index 0000000..f0b63b3
--- /dev/null
+++ b/plugins/plugin-dev/skills/marketplace-structure/examples/team-marketplace.md
@@ -0,0 +1,135 @@
+# Team Marketplace Example
+
+An internal company marketplace with team settings integration.
+
+## Use Case
+
+- Distribute approved plugins across engineering team
+- Auto-install required plugins for projects
+- Mix of internal and curated external plugins
+
+## Directory Structure
+
+```text
+company-plugins/
+├── .claude-plugin/
+│   └── marketplace.json
+├── plugins/
+│   ├── code-standards/
+│   │   ├── .claude-plugin/
+│   │   │   └── plugin.json
+│   │   ├── commands/
+│   │   └── hooks/
+│   └── security-scanner/
+│       ├── .claude-plugin/
+│       │   └── plugin.json
+│       └── agents/
+└── README.md
+```
+
+## marketplace.json
+
+```json
+{
+  "name": "company-plugins",
+  "owner": {
+    "name": "Platform Team",
+    "email": "platform@company.com",
+    "url": "https://github.com/company"
+  },
+  "metadata": {
+    "description": "Official plugins for Company engineering teams",
+    "version": "2.0.0",
+    "pluginRoot": "./plugins"
+  },
+  "plugins": [
+    {
+      "name": "code-standards",
+      "source": "./code-standards",
+      "description": "Enforces company coding standards",
+      "version": "1.5.0",
+      "category": "quality"
+    },
+    {
+      "name": "security-scanner",
+      "source": "./security-scanner",
+      "description": "Security vulnerability detection",
+      "version": "2.1.0",
+      "category": "security"
+    },
+    {
+      "name": "approved-formatter",
+      "source": {
+        "source": "github",
+        "repo": "company/code-formatter"
+      },
+      "description": "Company-approved code formatter",
+      "version": "3.0.0"
+    }
+  ]
+}
+```
+
+## Team Settings Integration
+
+Add to project's `.claude/settings.json`:
+
+```json
+{
+  "extraKnownMarketplaces": {
+    "company-plugins": {
+      "source": {
+        "source": "github",
+        "repo": "company/claude-plugins"
+      }
+    }
+  },
+  "enabledPlugins": [
+    "code-standards@company-plugins",
+    "security-scanner@company-plugins"
+  ]
+}
+```
+
+## Project-Specific Settings
+
+For projects requiring specific plugins, commit `.claude/settings.json`:
+
+```json
+{
+  "extraKnownMarketplaces": {
+    "company-plugins": {
+      "source": {
+        "source": "github",
+        "repo": "company/claude-plugins"
+      }
+    }
+  },
+  "enabledPlugins": [
+    "code-standards@company-plugins"
+  ]
+}
+```
+
+When developers trust the project folder, these plugins install automatically.
+
+## Adding New Plugins to the Marketplace
+
+1. Create plugin in `plugins/` directory
+2. Add entry to `marketplace.json`
+3. Bump marketplace `metadata.version`
+4. Create PR for review
+5. After merge, team can run `/plugin marketplace update company-plugins`
+
+## Installation for New Team Members
+
+```bash
+# One-time marketplace setup
+/plugin marketplace add company/claude-plugins
+
+# Install all required plugins
+/plugin install code-standards@company-plugins
+/plugin install security-scanner@company-plugins
+```
+
+Or let project settings auto-install by trusting the project folder.
diff --git a/plugins/plugin-dev/skills/marketplace-structure/references/distribution-patterns.md b/plugins/plugin-dev/skills/marketplace-structure/references/distribution-patterns.md
new file mode 100644
index 0000000..ff24b18
--- /dev/null
+++ b/plugins/plugin-dev/skills/marketplace-structure/references/distribution-patterns.md
@@ -0,0 +1,330 @@
+# Distribution Patterns
+
+Strategies for hosting, distributing, and managing plugin marketplaces.
+
+## Hosting Options
+
+### GitHub Hosting (Recommended)
+
+The simplest distribution method with built-in version control:
+
+```text
+my-marketplace/
+├── .claude-plugin/
+│   └── marketplace.json
+├── plugins/
+│   └── ... (optional local plugins)
+└── README.md
+```
+
+**Installation:**
+
+```bash
+/plugin marketplace add owner/repo
+```
+
+**Benefits:**
+
+- Free hosting for public repositories
+- Built-in issue tracking and collaboration
+- Automatic version history
+- Pull request workflow for plugin additions
+- GitHub Actions for validation
+
+### GitLab / Other Git Services
+
+Any git hosting service works:
+
+```bash
+/plugin marketplace add https://gitlab.com/company/plugins.git
+```
+
+**Use when:**
+
+- Organization uses GitLab, Bitbucket, or self-hosted git
+- Need private repository hosting
+- Integration with existing CI/CD pipelines
+
+### Local Development
+
+Test marketplaces locally before publishing:
+
+```bash
+# Add local directory
+/plugin marketplace add ./my-marketplace
+
+# Add direct path to marketplace.json
+/plugin marketplace add ./path/to/marketplace.json
+```
+
+## Team Distribution Patterns
+
+### Pattern 1: Shared Repository Settings
+
+Configure team marketplaces in `.claude/settings.json` (project or organization level):
+
+```json
+{
+  "extraKnownMarketplaces": {
+    "team-tools": {
+      "source": {
+        "source": "github",
+        "repo": "company/claude-plugins"
+      }
+    },
+    "project-plugins": {
+      "source": {
+        "source": "git",
+        "url": "https://git.company.com/project-plugins.git"
+      }
+    }
+  }
+}
+```
+
+When team members trust the repository folder, Claude Code automatically installs these marketplaces.
+
+### Pattern 2: Enabled Plugins List
+
+Pre-configure required plugins for a project:
+
+```json
+{
+  "extraKnownMarketplaces": {
+    "team-tools": {
+      "source": {
+        "source": "github",
+        "repo": "company/plugins"
+      }
+    }
+  },
+  "enabledPlugins": [
+    "security-scanner@team-tools",
+    "code-formatter@team-tools"
+  ]
+}
+```
+
+### Pattern 3: Monorepo Marketplace
+
+For organizations with many plugins in one repository:
+
+```text
+org-plugins/
+├── .claude-plugin/
+│   └── marketplace.json
+└── plugins/
+    ├── security-scanner/
+    ├── code-formatter/
+    ├── test-runner/
+    └── deployment-tools/
+```
+
+```json
+{
+  "name": "org-plugins",
+  "metadata": {
+    "pluginRoot": "./plugins"
+  },
+  "plugins": [
+    { "name": "security-scanner", "source": "./security-scanner" },
+    { "name": "code-formatter", "source": "./code-formatter" },
+    { "name": "test-runner", "source": "./test-runner" },
+    { "name": "deployment-tools", "source": "./deployment-tools" }
+  ]
+}
+```
+
+### Pattern 4: Curated External Plugins
+
+Marketplace that curates plugins from various sources:
+
+```json
+{
+  "name": "curated-tools",
+  "plugins": [
+    {
+      "name": "plugin-a",
+      "source": { "source": "github", "repo": "author1/plugin-a" }
+    },
+    {
+      "name": "plugin-b",
+      "source": { "source": "github", "repo": "author2/plugin-b" }
+    },
+    {
+      "name": "internal-tool",
+      "source": "./plugins/internal-tool"
+    }
+  ]
+}
+```
+
+## Version Management
+
+### Marketplace Versioning
+
+Track marketplace changes with semantic versioning:
+
+```json
+{
+  "metadata": {
+    "version": "2.1.0"
+  }
+}
+```
+
+| Change Type | Version Bump | Examples |
+|-------------|--------------|----------|
+| Breaking | Major (X.0.0) | Remove plugins, major restructuring |
+| Feature | Minor (X.Y.0) | Add new plugins, new categories |
+| Fix | Patch (X.Y.Z) | Update versions, fix metadata |
+
+### Plugin Version Tracking
+
+Always include version in plugin entries:
+
+```json
+{
+  "name": "my-plugin",
+  "version": "1.2.3",
+  "source": "./plugins/my-plugin"
+}
+```
+
+### Update Workflow
+
+```bash
+# Refresh marketplace metadata
+/plugin marketplace update marketplace-name
+
+# Check for plugin updates
+/plugin marketplace list
+```
+
+## Multi-Environment Distribution
+
+### Development vs. Production
+
+Maintain separate marketplaces for environments:
+
+```text
+plugins-repo/
+├── .claude-plugin/
+│   └── marketplace.json           # Stable plugins
+├── staging/
+│   └── .claude-plugin/
+│       └── marketplace.json       # Pre-release testing
+└── plugins/
+```
+
+### Feature Branches
+
+Use git branches for experimental plugins:
+
+```bash
+# Add marketplace from specific branch
+/plugin marketplace add owner/repo#feature-branch
+```
+
+## Security Considerations
+
+### Access Control
+
+- **Public marketplaces**: Anyone can install plugins
+- **Private repositories**: Only authorized users can access
+- **Team settings**: Control which marketplaces are auto-installed
+
+### Plugin Verification
+
+Before adding external plugins to your marketplace:
+
+1. Review source code for security issues
+2. Check for hardcoded credentials
+3. Verify hook commands are safe
+4. Test in isolated environment
+
+### Secure Distribution Checklist
+
+- [ ] Use HTTPS for all git URLs
+- [ ] MCP servers use HTTPS/WSS, not HTTP/WS
+- [ ] No credentials in marketplace.json
+- [ ] External plugins reviewed before curation
+- [ ] Private repositories for sensitive tools
+
+## Marketplace Management Commands
+
+### List Marketplaces
+
+```bash
+/plugin marketplace list
+```
+
+### Update Marketplace
+
+```bash
+/plugin marketplace update marketplace-name
+```
+
+### Remove Marketplace
+
+```bash
+/plugin marketplace remove marketplace-name
+```
+
+**Note:** Removing a marketplace uninstalls all plugins from it.
+
+### Install Plugins
+
+```bash
+# Install from specific marketplace
+/plugin install plugin-name@marketplace-name
+
+# Browse available plugins
+/plugin
+```
+
+## Troubleshooting
+
+### Marketplace Not Loading
+
+1. Verify URL/path is accessible
+2. Check `.claude-plugin/marketplace.json` exists at correct path
+3. Validate JSON syntax
+4. Confirm access permissions (for private repos)
+
+### Plugin Installation Fails
+
+1. Verify plugin source URL is accessible
+2. Check plugin directory contains required files
+3. For GitHub sources, ensure repository is public or you have access
+4. Test plugin sources manually by cloning
+
+### Validation Commands
+
+```bash
+# Validate JSON syntax
+jq . .claude-plugin/marketplace.json
+
+# Check required fields
+jq 'has("name") and has("owner") and has("plugins")' \
+  .claude-plugin/marketplace.json
+
+# Validate in Claude Code
+claude plugin validate .
+```
+
+## Migration Patterns
+
+### From Single Plugin to Marketplace
+
+1. Create `.claude-plugin/marketplace.json`
+2. Move plugin to `plugins/` subdirectory
+3. Add plugin entry with relative source
+4. Update installation instructions
+
+### Consolidating Multiple Plugins
+
+1. Create new marketplace repository
+2. Add each plugin as entry (relative or external source)
+3. Test installation of all plugins
+4. Migrate users to marketplace-based installation
diff --git a/plugins/plugin-dev/skills/marketplace-structure/references/schema-reference.md b/plugins/plugin-dev/skills/marketplace-structure/references/schema-reference.md
new file mode 100644
index 0000000..68e608f
--- /dev/null
+++ b/plugins/plugin-dev/skills/marketplace-structure/references/schema-reference.md
@@ -0,0 +1,262 @@
+# Marketplace Schema Reference
+
+Complete field reference for `marketplace.json` and plugin entries.
+
+## Marketplace Root Fields
+
+### Required Fields
+
+| Field | Type | Constraints | Description |
+|-------|------|-------------|-------------|
+| `name` | string | kebab-case, 3-50 chars | Unique marketplace identifier |
+| `owner` | object | See Owner Object | Marketplace maintainer information |
+| `plugins` | array | At least 1 entry | List of available plugins |
+
+### Optional Metadata Object
+
+```json
+{
+  "metadata": {
+    "description": "string",
+    "version": "string",
+    "pluginRoot": "string"
+  }
+}
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `description` | string | Brief marketplace description (1-200 chars) |
+| `version` | string | Marketplace version (semver X.Y.Z recommended) |
+| `pluginRoot` | string | Base path for relative plugin sources |
+
+## Owner Object
+
+### Required Owner Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `name` | string | Maintainer name (person or organization) |
+
+### Optional Owner Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `email` | string | Contact email address |
+| `url` | string | Maintainer homepage or profile URL |
+
+### Example
+
+```json
+{
+  "owner": {
+    "name": "DevTools Team",
+    "email": "devtools@company.com",
+    "url": "https://github.com/company"
+  }
+}
+```
+
+## Plugin Entry Fields
+
+### Required Plugin Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `name` | string | Plugin identifier (kebab-case, unique within marketplace) |
+| `source` | string or object | Where to fetch the plugin (see Source Types) |
+
+### Optional Standard Metadata
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `description` | string | Brief plugin description |
+| `version` | string | Plugin version (semver X.Y.Z) |
+| `author` | object | Plugin author (same format as owner) |
+| `homepage` | string | Plugin documentation URL |
+| `repository` | string | Source code repository URL |
+| `license` | string | SPDX license identifier (MIT, Apache-2.0, etc.) |
+| `keywords` | array | String tags for discovery |
+| `category` | string | Plugin category (productivity, security, etc.) |
+| `tags` | array | Additional searchability tags |
+
+### Marketplace-Specific Fields
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `strict` | boolean | `true` | Require `plugin.json` in plugin folder |
+
+### Component Configuration Fields
+
+These fields override or supplement plugin component paths:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `commands` | string or array | Custom paths to command files or directories |
+| `agents` | string or array | Custom paths to agent files |
+| `hooks` | string or object | Hooks configuration or path to hooks file |
+| `mcpServers` | string or object | MCP server configurations or path |
+
+## Source Types
+
+### Relative Path (String)
+
+For plugins in the same repository:
+
+```json
+{
+  "source": "./plugins/my-plugin"
+}
+```
+
+Paths are relative to:
+
+1. `metadata.pluginRoot` if specified
+2. Repository root otherwise
+
+### GitHub Repository (Object)
+
+```json
+{
+  "source": {
+    "source": "github",
+    "repo": "owner/repo-name"
+  }
+}
+```
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `source` | string | Yes | Must be `"github"` |
+| `repo` | string | Yes | GitHub repository in `owner/repo` format |
+
+### Git URL (Object)
+
+For GitLab, Bitbucket, or self-hosted git repositories:
+
+```json
+{
+  "source": {
+    "source": "url",
+    "url": "https://gitlab.com/team/plugin.git"
+  }
+}
+```
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `source` | string | Yes | Must be `"url"` |
+| `url` | string | Yes | Full git clone URL |
+
+## Complete Plugin Entry Example
+
+Advanced plugin entry with all optional fields:
+
+```json
+{
+  "name": "enterprise-tools",
+  "source": {
+    "source": "github",
+    "repo": "company/enterprise-plugin"
+  },
+  "description": "Enterprise workflow automation tools",
+  "version": "2.1.0",
+  "author": {
+    "name": "Enterprise Team",
+    "email": "enterprise@company.com"
+  },
+  "homepage": "https://docs.company.com/plugins/enterprise-tools",
+  "repository": "https://github.com/company/enterprise-plugin",
+  "license": "MIT",
+  "keywords": ["enterprise", "workflow", "automation"],
+  "category": "productivity",
+  "tags": ["enterprise", "automation"],
+  "commands": [
+    "./commands/core/",
+    "./commands/enterprise/"
+  ],
+  "agents": [
+    "./agents/security-reviewer.md",
+    "./agents/compliance-checker.md"
+  ],
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/scripts/validate.sh"
+          }
+        ]
+      }
+    ]
+  },
+  "mcpServers": {
+    "enterprise-db": {
+      "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",
+      "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"]
+    }
+  },
+  "strict": false
+}
+```
+
+## Strict Mode Details
+
+### strict: true (Default)
+
+- Plugin directory must contain `.claude-plugin/plugin.json`
+- Marketplace entry fields supplement plugin manifest values
+- Plugin manifest takes precedence for conflicting fields
+
+### strict: false
+
+- `plugin.json` is optional in plugin directory
+- Marketplace entry serves as complete plugin manifest if no `plugin.json` exists
+- Useful for curating external plugins or lightweight plugin directories
+
+### When to Use strict: false
+
+| Scenario | Reasoning |
+|----------|-----------|
+| External plugins | Cannot modify external source to add plugin.json |
+| Minimal plugins | Plugin has only commands/agents without needing manifest |
+| Complete metadata in entry | All plugin info provided in marketplace entry |
+| Legacy plugins | Older plugins without manifest file |
+
+## Validation Rules
+
+### Marketplace Level
+
+- `name` must be kebab-case (lowercase letters, numbers, hyphens)
+- `name` must be 3-50 characters
+- `owner.name` is required
+- `plugins` array must have at least one entry
+- No duplicate plugin names in `plugins` array
+
+### Plugin Entry Level
+
+- `name` must be kebab-case
+- `name` must be unique within the marketplace
+- `source` must be valid (string path or recognized source object)
+- `version` should follow semver if provided
+- `license` should be valid SPDX identifier if provided
+
+### Source Validation
+
+- Relative paths: Must start with `./` or `../`
+- GitHub sources: `repo` must be `owner/repo` format
+- URL sources: Must be valid git URL
+
+## Schema Relationship
+
+Plugin entries build on the plugin manifest schema:
+
+```text
+plugin.json schema (all fields optional in marketplace entry)
+    + marketplace-specific fields (source, strict, category, tags)
+    = marketplace plugin entry
+```
+
+This means any field valid in `plugin.json` can also be used in a marketplace entry.