Add command layer and navigation UX for v0.6

2026-09-14 20:06:57 +08:00 · 2026-03-06 14:42:26 -05:00
parent 1e8ff6247c
commit 6f1911ca7f
28 changed files with 2083 additions and 7 deletions
@@ -2,6 +2,8 @@

 ## Project Structure & Module Organization
 - `skills/<skill-name>/SKILL.md` holds each skill. Skill folders use lowercase kebab-case names (e.g., `skills/user-story/SKILL.md`).
+- `commands/<command-name>.md` holds reusable orchestration commands that chain local skills.
+- `catalog/` holds generated indexes for fast browsing (`skills-by-type.md`, `commands.md`, and YAML indexes).
 - `research/` contains reference essays that inform skills.
 - `docs/` contains usage guides, including `docs/Using PM Skills with Codex.md`.
 - `app/` contains the Streamlit (beta) playground (`app/main.py`) and setup docs (`app/STREAMLIT_INTERFACE.md`).
@@ -12,6 +14,8 @@ This is a Markdown-first repository with no build system or automated tests.
 - `rg --files` lists all files quickly.
 - `rg "SKILL.md"` finds skill definitions.
 - `rg "skill-name"` verifies references before submitting.
+- `./scripts/find-a-command.sh --list-all` lists available workflow commands.
+- `./scripts/test-library.sh` validates skills + commands and regenerates catalogs.
 - `streamlit run app/main.py` launches the Streamlit (beta) skill playground.

 ## Coding Style & Naming Conventions
@@ -23,6 +27,16 @@ This is a Markdown-first repository with no build system or automated tests.
 - Use fenced code blocks with language tags for commands or templates.
 - Keep language concise and opinionated; avoid filler.

+### Interactive Skills
+**What:** Multi-turn conversational flows that gather context through sequential questioning and offer intelligent next-step recommendations.
+
+**Characteristics:**
+- Asks questions one at a time (or in small batches)
+- Uses answers to inform subsequent questions
+- Offers **enumerated, context-aware recommendations** for next steps
+- Allows user to select by number ("1", "2 & 4") or provide custom input
+- Adapts based on user choices
+
 ## Testing Guidelines
 No automated tests exist. Validate changes by:
 - Ensuring linked skill paths resolve (e.g., `skills/prd-development/SKILL.md`).
@@ -1,8 +1,69 @@
 # Product Manager Skills — Development Roadmap

-**Last Updated:** 2026-02-10
-**Status:** Phase 1 COMPLETE ✅ | Phase 2 COMPLETE ✅ | Phase 3 COMPLETE ✅ | Phase 4 COMPLETE ✅ | Phase 5 COMPLETE ✅ | Phase 6 COMPLETE ✅ | Phase 7 COMPLETE ✅ | Phase 8 IN PROGRESS 🚧
-**Version:** v0.4 (Released February 10, 2026)
+**Last Updated:** 2026-03-06
+**Status:** Phase 1 COMPLETE ✅ | Phase 2 COMPLETE ✅ | Phase 3 COMPLETE ✅ | Phase 4 COMPLETE ✅ | Phase 5 COMPLETE ✅ | Phase 6 COMPLETE ✅ | Phase 7 PLANNED ⏳
+**Version:** v0.6 (Released March 6, 2026)
+
+---
+
+## v0.6 Navigation + Commands Program (Phased)
+
+Goal: make this repo as easy to navigate and run as possible at 60+ skills, without introducing plugins.
+
+### Phase 1: Operating Model (Complete)
+- [x] Keep current architecture: `skills/<skill-name>/SKILL.md` remains the core library.
+- [x] Preserve local skill subtypes: `component`, `interactive`, `workflow`.
+- [x] Add command architecture as orchestration wrappers over existing skills.
+
+Exit criteria:
+- A `commands/` directory exists with command definitions that reference existing skills.
+
+### Phase 2: Navigation System (Complete)
+- [x] Add generated catalog artifacts for skills and commands.
+- [x] Add quick browse pages (`catalog/skills-by-type.md`, `catalog/commands.md`).
+- [x] Add command discovery script (`scripts/find-a-command.sh`).
+
+Exit criteria:
+- Users can browse by type and search skills/commands from the terminal.
+
+### Phase 3: Fast Onboarding (Complete)
+- [x] Add a single-entry quick-start guide (`START_HERE.md`).
+- [x] Add copy/paste "do this now" usage paths.
+- [x] Wire quick-start into the root README.
+
+Exit criteria:
+- A new user can run a skill or command in under 60 seconds.
+
+### Phase 4: Commands v1 (Complete)
+- [x] Create high-value commands for common PM outcomes (`discover`, `strategy`, `write-prd`, `plan-roadmap`, `prioritize`, `leadership-transition`).
+- [x] Ensure each command includes invocation guidance, workflow checkpoints, and next steps.
+- [x] Ensure each command references only local skills.
+
+Exit criteria:
+- Command files pass metadata/reference validation.
+
+### Phase 5: Tooling + Validation (Complete)
+- [x] Add command metadata validator (`scripts/check-command-metadata.py`).
+- [x] Add command-enabled launcher (`scripts/run-pm.sh`) for skill/command execution scaffolding.
+- [x] Add library-level test runner (`scripts/test-library.sh`) and catalog generator (`scripts/generate-catalog.py`).
+
+Exit criteria:
+- One command can validate skills + commands + generated catalogs.
+
+### Phase 6: Documentation Consolidation (Complete)
+- [x] Add README quick-start section for skills + commands.
+- [x] Extend platform-specific docs with command-first examples.
+- [x] Publish v0.6 release note after docs sweep.
+
+Exit criteria:
+- README + primary usage docs present one consistent flow.
+
+### Phase 7: Streamlit Command Mode (Planned)
+- [ ] Add command browsing/execution mode to Streamlit beta.
+- [ ] Show command step progress and per-step outputs.
+
+Exit criteria:
+- Streamlit users can run either a skill or a command intentionally.

 ---

@@ -1,6 +1,14 @@
 <a id="pmskills"></a>
 # Product Manager Skills

+![GitHub stars](https://img.shields.io/github/stars/deanpeters/Product-Manager-Skills?style=flat-square)
+[![License: CC BY-NC-SA 4.0](https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey?style=flat-square)](https://github.com/deanpeters/Product-Manager-Skills/blob/main/LICENSE)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen?style=flat-square)](https://github.com/deanpeters/Product-Manager-Skills/blob/main/CONTRIBUTING.md)
+[![Version](https://img.shields.io/badge/version-v0.6-blue?style=flat-square)](https://github.com/deanpeters/Product-Manager-Skills)
+![Skills](https://img.shields.io/badge/skills-46-informational?style=flat-square)
+![Commands](https://img.shields.io/badge/commands-6-informational?style=flat-square)
+![Streamlit Beta](https://img.shields.io/badge/streamlit-beta-orange?style=flat-square)
+
 ```text
 ╔════════════════════════════════════════════════════════════════════╗
 ║                                                                    ║
@@ -11,10 +19,10 @@
 ║   ██║     ██║ ╚═╝ ██║    ███████║██║  ██╗██║███████╗███████╗███████║
 ║   ╚═╝     ╚═╝     ╚═╝    ╚══════╝╚═╝  ╚═╝╚═╝╚══════╝╚══════╝╚══════╝
 ║                                                                    ║
-║   46 battle-tested frameworks for AI agents                        ║
-║   Claude Code • Cowork • Codex • ChatGPT • Gemini                  ║
+║   46 battle-tested skills + 6 command workflows                    ║
+║   Claude Code • Cursor • Codex  • n8n • OpenClaw • and more ...    ║
 ║                                                                    ║
-║   v0.5 • Feb 27, 2026 • CC BY-NC-SA 4.0                            ║
+║   v0.6 • Mar 6, 2026 • CC BY-NC-SA 4.0                             ║
 ╚════════════════════════════════════════════════════════════════════╝
 ```

@@ -26,6 +34,21 @@ Frame problems, hunt opportunities, scaffold validation experiments, and kill ba

 ## 📣 Updates & Announcements

+### Mar 6, 2026 — v0.6 Navigation + Commands
+
+We added a command layer and fast navigation system while keeping skills as the source of truth.
+
+What shipped:
+- `START_HERE.md` for 60-second onboarding
+- `commands/` directory with reusable multi-skill workflows
+- `catalog/` generated indexes for quick browsing
+- New helper scripts: `run-pm.sh`, `find-a-command.sh`, `test-library.sh`, and `generate-catalog.py`
+- Command validation with `scripts/check-command-metadata.py`
+
+Release note draft: [`docs/announcements/2026-03-06-v0-6-navigation-commands.md`](docs/announcements/2026-03-06-v0-6-navigation-commands.md)
+
+---
+
 ### Feb 27, 2026 — v0.5 Streamlit (beta) Playground

 We launched a new **Streamlit (beta)** interface for local skill test-driving.
@@ -100,7 +123,7 @@ Still rewriting PM prompts and getting generic AI output? I built a reusable PM

 ## 🎯 What This Is

-**46 ready-to-use PM frameworks** that teach AI agents how to do product management work professionally—without you having to explain your process every time.
+**46 ready-to-use PM skills + reusable command workflows** that teach AI agents how to do product management work professionally—without you having to explain your process every time.

 Instead of saying *"Write a PRD"* and hoping for the best, the agent already knows:
 - ✅ How to structure a PRD
@@ -115,6 +138,41 @@ Instead of saying *"Write a PRD"* and hoping for the best, the agent already kno

 ---

+## ⚡ Start in 60 Seconds
+
+New here? Start with [`START_HERE.md`](START_HERE.md).
+
+```bash
+# Run a skill (artifact/analysis)
+./scripts/run-pm.sh skill prioritization-advisor "We have 12 requests and one sprint"
+
+# Run a command (multi-skill workflow)
+./scripts/run-pm.sh command discover "Reduce onboarding drop-off for self-serve users"
+```
+
+Need discovery first?
+
+```bash
+./scripts/find-a-skill.sh --keyword onboarding
+./scripts/find-a-command.sh --keyword roadmap
+```
+
+---
+
+## Why The Command Layer Helps
+
+Commands make using skills easier without replacing skills.
+
+- Skills stay deep and pedagogic: they are still the source of truth for frameworks and quality.
+- Commands remove stitching work: one command chains the right skills in the right order.
+- You start faster: less "which skill should I run first?" and fewer manual handoffs.
+- Outputs are more consistent: commands enforce checkpoints, then defer to skill-level rigor.
+- Teams onboard quicker: new users can run `/discover` or `/write-prd` and learn the skill system while shipping.
+
+In short: **skills provide expertise; commands provide momentum.**
+
+---
+
 ## 🧪 Streamlit (beta)

 Want a quick local test-drive before using skills in your agent workflow?
@@ -154,8 +212,12 @@ Some skills include a `scripts/` folder with deterministic helpers for calculati
 - `scripts/add-a-skill.sh` - Content-first, AI-assisted generation from notes/frameworks.
 - `scripts/build-a-skill.sh` - Guided "build-a-bear" wizard that prompts section-by-section.
 - `scripts/find-a-skill.sh` - Search skills by name/type/keyword with ranked results.
+- `scripts/find-a-command.sh` - Search commands by name/keyword/used skills.
+- `scripts/run-pm.sh` - Fast runner for either a skill or a command.
 - `scripts/test-a-skill.sh` - Run strict conformance checks and optional smoke checks.
+- `scripts/test-library.sh` - Validate skills, commands, and regenerate catalogs.
 - `scripts/zip-a-skill.sh` - Build upload-ready `.zip` files by skill, type, or all skills.
+- `scripts/generate-catalog.py` - Regenerate skill/command navigation indexes.

 **What it does:**
 1. Analyzes your content and suggests skill types
@@ -174,9 +236,18 @@ Some skills include a `scripts/` folder with deterministic helpers for calculati
 # Find a skill
 ./scripts/find-a-skill.sh --keyword pricing --type interactive

+# Find a command
+./scripts/find-a-command.sh --keyword roadmap
+
+# Run a command workflow
+./scripts/run-pm.sh command write-prd "Mobile onboarding redesign"
+
 # Test one skill
 ./scripts/test-a-skill.sh --skill finance-based-pricing-advisor --smoke

+# Test full library surface
+./scripts/test-library.sh
+
 # Build Claude upload zip for one skill
 ./scripts/zip-a-skill.sh --skill finance-based-pricing-advisor

@@ -367,6 +438,18 @@ Detailed concept notes live in [`PLANS.md`](PLANS.md#future-skill-candidates).

 **Confused by setup options?** Start here: [PM Skills Rule-of-Thumb Guide](docs/PM%20Skills%20Rule-of-Thumb%20Guide.md).

+### Fastest Path (Local Repo)
+
+```bash
+# Skill mode
+./scripts/run-pm.sh skill user-story "Checkout improvements for returning customers"
+
+# Command mode
+./scripts/run-pm.sh command plan-roadmap "Q3-Q4 roadmap for enterprise reporting"
+```
+
+Command definitions live in [`commands/`](commands/README.md), and generated browse indexes live in [`catalog/`](catalog/README.md).
+
 ### With Claude Desktop or Claude.ai

 1. Open a conversation with Claude
@@ -402,6 +485,9 @@ Use GitHub app connections (formerly connectors), Custom GPT Knowledge uploads,
 - **[Using PM Skills with Claude](docs/Using%20PM%20Skills%20with%20Claude.md)** — Claude Code usage plus GitHub ZIP upload steps for Claude Desktop/Web.
 - **[Using PM Skills with Codex](docs/Using%20PM%20Skills%20with%20Codex.md)** — Local workspace usage plus GitHub-connected Codex on ChatGPT.
 - **[Using PM Skills with ChatGPT](docs/Using%20PM%20Skills%20with%20ChatGPT.md)** — GitHub app connection, Custom GPT Knowledge setup, and Project-based usage.
+- **[Start Here](START_HERE.md)** — One-page "do this now" onboarding for skills and commands.
+- **[Commands](commands/README.md)** — Command format, command list, validation, and discovery.
+- **[Catalog Artifacts](catalog/README.md)** — Generated skill/command indexes for fast navigation.
 - **[PM Skills Rule-of-Thumb Guide](docs/PM%20Skills%20Rule-of-Thumb%20Guide.md)** — Non-technical setup choices (local repo vs ZIP vs app connections) in plain English.
 - **[Marketplace Strategy](MARKETPLACE_STRATEGY.md)** — PM-friendly strategy for distributing skills in marketplaces.
 - **[Marketplace Submission Runbook](docs/Marketplace%20Submission%20Runbook.md)** — Step-by-step submission workflow for non-technical teams.
@@ -556,6 +642,14 @@ See [LICENSE](LICENSE) for full details.

 ---

+**v0.6 — March 6, 2026**
+
+Highlights in this release:
+- Added `commands/` with reusable workflow wrappers over local skills (`discover`, `strategy`, `write-prd`, `plan-roadmap`, `prioritize`, `leadership-transition`)
+- Added `START_HERE.md` for 60-second onboarding
+- Added generated `catalog/` artifacts for fast skill and command navigation
+- Added tooling for discovery/validation/execution: `find-a-command.sh`, `run-pm.sh`, `check-command-metadata.py`, `test-library.sh`, `generate-catalog.py`
+
 **v0.5 — February 27, 2026**

 Highlights in this release:
@@ -0,0 +1,56 @@
+# Start Here
+
+Pick one path and run it immediately.
+
+## 1) I Need An Artifact
+
+Use a component skill.
+
+```bash
+./scripts/run-pm.sh skill user-story "Write stories for a new account settings page"
+```
+
+Other strong starts:
+- `positioning-statement`
+- `problem-statement`
+- `press-release`
+
+## 2) I Need Help Deciding
+
+Use an interactive skill.
+
+```bash
+./scripts/run-pm.sh skill prioritization-advisor "We have 12 requests and one sprint"
+```
+
+Other strong starts:
+- `feature-investment-advisor`
+- `finance-based-pricing-advisor`
+- `business-health-diagnostic`
+
+## 3) I Need End-To-End Guidance
+
+Use a workflow skill or command.
+
+```bash
+./scripts/run-pm.sh command discover "Reduce onboarding drop-off for self-serve users"
+```
+
+Other command starts:
+- `strategy`
+- `write-prd`
+- `plan-roadmap`
+
+## Find The Right Capability Fast
+
+```bash
+./scripts/find-a-skill.sh --keyword onboarding
+./scripts/find-a-command.sh --keyword roadmap
+./scripts/find-a-command.sh --list-all
+```
+
+## Validate The Library
+
+```bash
+./scripts/test-library.sh
+```
@@ -105,6 +105,16 @@ Navigation is state-based (`st.session_state.view`). The `nav()` helper handles
 - Phase radio selector lets users jump to any phase
 - Each phase: enter context → Run → output → Re-run or Continue to next phase

+**Multi-Turn interactions**
+**What:** Multi-turn conversational flows that gather context through sequential questioning and offer intelligent next-step recommendations.
+**Characteristics:**
+- Asks questions one at a time (or in small batches)
+- Uses answers to inform subsequent questions
+- Offers **enumerated, context-aware recommendations** for next steps
+- Allows user to select by number ("1", "2 & 4") or provide custom input
+- Adapts based on user choices
+
+
 ### System Prompt

 Each session uses the full `SKILL.md` body as the system prompt, with a short facilitation addendum for interactive skills:
@@ -0,0 +1,14 @@
+# Catalog Artifacts
+
+These files are generated navigation indexes for skills and commands.
+
+- `skills-index.yaml` - machine-readable skill metadata index
+- `commands-index.yaml` - machine-readable command metadata index
+- `skills-by-type.md` - human-readable browse view by skill type
+- `commands.md` - human-readable command catalog
+
+Regenerate any time skills or commands change:
+
+```bash
+python3 scripts/generate-catalog.py
+```
@@ -0,0 +1,92 @@
+generated_from: commands/*.md
+count: 6
+commands:
+- name: discover
+  description: Run a structured discovery flow from problem framing through opportunity
+    mapping and validation planning.
+  argument_hint: <problem, opportunity, or feature area>
+  uses:
+  - discovery-process
+  - problem-framing-canvas
+  - discovery-interview-prep
+  - opportunity-solution-tree
+  - pol-probe-advisor
+  outputs:
+  - Discovery plan
+  - Prioritized assumptions
+  - Validation experiment backlog
+  path: commands/discover.md
+- name: leadership-transition
+  description: Guide PM to Director to VP/CPO transition planning with role-fit diagnostics
+    and onboarding guidance.
+  argument_hint: <current role, target role, and transition scenario>
+  uses:
+  - altitude-horizon-framework
+  - director-readiness-advisor
+  - vp-cpo-readiness-advisor
+  - executive-onboarding-playbook
+  outputs:
+  - Transition diagnosis
+  - Role-readiness plan
+  - 30-60-90 leadership actions
+  path: commands/leadership-transition.md
+- name: plan-roadmap
+  description: Turn strategy and validated opportunities into a sequenced roadmap
+    with clear tradeoffs.
+  argument_hint: <time horizon, goals, and candidate initiatives>
+  uses:
+  - roadmap-planning
+  - epic-hypothesis
+  - prioritization-advisor
+  - user-story-mapping
+  - epic-breakdown-advisor
+  outputs:
+  - Prioritized roadmap
+  - Epic hypotheses
+  - Release slices and sequencing rationale
+  path: commands/plan-roadmap.md
+- name: prioritize
+  description: Select what to work on next using the right prioritization method for
+    your context.
+  argument_hint: <candidate initiatives, constraints, and decision context>
+  uses:
+  - prioritization-advisor
+  - feature-investment-advisor
+  - acquisition-channel-advisor
+  - finance-based-pricing-advisor
+  - recommendation-canvas
+  outputs:
+  - Ranked options
+  - Decision rationale
+  - Explicit tradeoffs and follow-up actions
+  path: commands/prioritize.md
+- name: strategy
+  description: Build product strategy from positioning through opportunity and roadmap
+    decisions.
+  argument_hint: <product, market, and strategic question>
+  uses:
+  - product-strategy-session
+  - positioning-workshop
+  - problem-statement
+  - opportunity-solution-tree
+  - roadmap-planning
+  outputs:
+  - Strategy narrative
+  - Core strategic choices
+  - Sequenced roadmap direction
+  path: commands/strategy.md
+- name: write-prd
+  description: Create a decision-ready PRD by chaining problem framing, requirements
+    definition, and story scaffolding.
+  argument_hint: <feature, initiative, or product change>
+  uses:
+  - prd-development
+  - problem-statement
+  - proto-persona
+  - user-story
+  - user-story-splitting
+  outputs:
+  - Structured PRD
+  - Core personas and requirements
+  - Initial implementation-ready stories
+  path: commands/write-prd.md
@@ -0,0 +1,98 @@
+# Commands Catalog
+
+Generated by `scripts/generate-catalog.py`. Do not edit manually.
+
+## /discover
+
+- Description: Run a structured discovery flow from problem framing through opportunity mapping and validation planning.
+- Argument hint: `<problem, opportunity, or feature area>`
+- Path: `commands/discover.md`
+- Uses:
+  - `discovery-process`
+  - `problem-framing-canvas`
+  - `discovery-interview-prep`
+  - `opportunity-solution-tree`
+  - `pol-probe-advisor`
+- Outputs:
+  - Discovery plan
+  - Prioritized assumptions
+  - Validation experiment backlog
+
+## /leadership-transition
+
+- Description: Guide PM to Director to VP/CPO transition planning with role-fit diagnostics and onboarding guidance.
+- Argument hint: `<current role, target role, and transition scenario>`
+- Path: `commands/leadership-transition.md`
+- Uses:
+  - `altitude-horizon-framework`
+  - `director-readiness-advisor`
+  - `vp-cpo-readiness-advisor`
+  - `executive-onboarding-playbook`
+- Outputs:
+  - Transition diagnosis
+  - Role-readiness plan
+  - 30-60-90 leadership actions
+
+## /plan-roadmap
+
+- Description: Turn strategy and validated opportunities into a sequenced roadmap with clear tradeoffs.
+- Argument hint: `<time horizon, goals, and candidate initiatives>`
+- Path: `commands/plan-roadmap.md`
+- Uses:
+  - `roadmap-planning`
+  - `epic-hypothesis`
+  - `prioritization-advisor`
+  - `user-story-mapping`
+  - `epic-breakdown-advisor`
+- Outputs:
+  - Prioritized roadmap
+  - Epic hypotheses
+  - Release slices and sequencing rationale
+
+## /prioritize
+
+- Description: Select what to work on next using the right prioritization method for your context.
+- Argument hint: `<candidate initiatives, constraints, and decision context>`
+- Path: `commands/prioritize.md`
+- Uses:
+  - `prioritization-advisor`
+  - `feature-investment-advisor`
+  - `acquisition-channel-advisor`
+  - `finance-based-pricing-advisor`
+  - `recommendation-canvas`
+- Outputs:
+  - Ranked options
+  - Decision rationale
+  - Explicit tradeoffs and follow-up actions
+
+## /strategy
+
+- Description: Build product strategy from positioning through opportunity and roadmap decisions.
+- Argument hint: `<product, market, and strategic question>`
+- Path: `commands/strategy.md`
+- Uses:
+  - `product-strategy-session`
+  - `positioning-workshop`
+  - `problem-statement`
+  - `opportunity-solution-tree`
+  - `roadmap-planning`
+- Outputs:
+  - Strategy narrative
+  - Core strategic choices
+  - Sequenced roadmap direction
+
+## /write-prd
+
+- Description: Create a decision-ready PRD by chaining problem framing, requirements definition, and story scaffolding.
+- Argument hint: `<feature, initiative, or product change>`
+- Path: `commands/write-prd.md`
+- Uses:
+  - `prd-development`
+  - `problem-statement`
+  - `proto-persona`
+  - `user-story`
+  - `user-story-splitting`
+- Outputs:
+  - Structured PRD
+  - Core personas and requirements
+  - Initial implementation-ready stories
@@ -0,0 +1,104 @@
+# Skills By Type
+
+Generated by `scripts/generate-catalog.py`. Do not edit manually.
+
+## Component (20)
+
+- `altitude-horizon-framework` - The core mental model for the PM-to-Director transition: altitude (scope) and horizon (time), the waiter-to-operator shift, four transition zones, named failure modes, and the Cascading Context Map.
+  - `skills/altitude-horizon-framework/SKILL.md`
+- `company-research` - Create a comprehensive company profile that extracts executive insights, product strategy, transformation initiatives, and organizational dynamics from publicly available sources. Use this to understa
+  - `skills/company-research/SKILL.md`
+- `customer-journey-map` - Create a comprehensive customer journey map that visualizes how customers interact with your brand across all stages—from awareness to loyalty—documenting their actions, touchpoints, emotions, KPI
+  - `skills/customer-journey-map/SKILL.md`
+- `eol-message` - Craft a clear, empathetic End-of-Life (EOL) message that communicates product or feature discontinuation, explains the rationale, addresses customer impact, provides transition support, and positions
+  - `skills/eol-message/SKILL.md`
+- `epic-hypothesis` - Frame epics as testable hypotheses using an if/then structure that articulates the action or solution, the target beneficiary, the expected outcome, and how you'll validate success. Use this to manage
+  - `skills/epic-hypothesis/SKILL.md`
+- `finance-metrics-quickref` - Fast lookup table for 32+ SaaS finance metrics with formulas, benchmarks, and when to use each. Includes red flags and decision frameworks.
+  - `skills/finance-metrics-quickref/SKILL.md`
+- `jobs-to-be-done` - Systematically explore what customers are trying to accomplish (functional, social, emotional jobs), the pains they experience, and the gains they seek. Use this framework to uncover unmet needs, vali
+  - `skills/jobs-to-be-done/SKILL.md`
+- `pestel-analysis` - Conduct a systematic analysis of macro-environmental factors—Political, Economic, Social, Technological, Environmental, and Legal—that could impact your product or project. Use this to identify ex
+  - `skills/pestel-analysis/SKILL.md`
+- `pol-probe` - Define a Proof of Life (PoL) probe—a lightweight validation artifact that surfaces harsh truths before expensive development. Use it to test hypotheses with minimal investment.
+  - `skills/pol-probe/SKILL.md`
+- `positioning-statement` - Create a Geoffrey Moore-style positioning statement that clearly articulates who your product serves, what need it addresses, how it's categorized, what benefit it delivers, and how it differs from al
+  - `skills/positioning-statement/SKILL.md`
+- `press-release` - Create a visionary press release following Amazon's "Working Backwards" methodology to define and communicate a product or feature before building it. Use this to align stakeholders on the customer va
+  - `skills/press-release/SKILL.md`
+- `problem-statement` - Articulate a problem from the user's perspective using an empathy-driven framework that captures who they are, what they're trying to do, what's blocking them, why, and how it makes them feel. Use thi
+  - `skills/problem-statement/SKILL.md`
+- `proto-persona` - Create an initial, assumption-based persona profile that synthesizes available user research, market data, and stakeholder knowledge into a working hypothesis about your target user. Use this to align
+  - `skills/proto-persona/SKILL.md`
+- `recommendation-canvas` - Evaluate and propose AI product solutions using a structured canvas that assesses business outcomes, customer outcomes, problem framing, solution hypotheses, positioning, risks, and value justificatio
+  - `skills/recommendation-canvas/SKILL.md`
+- `saas-economics-efficiency-metrics` - Evaluate unit economics and capital efficiency for SaaS. Covers CAC, LTV, payback, margins, burn rate, Rule of 40, and magic number.
+  - `skills/saas-economics-efficiency-metrics/SKILL.md`
+- `saas-revenue-growth-metrics` - Calculate and interpret revenue, retention, and growth metrics for SaaS products. Covers revenue, ARPU/ARPA, MRR/ARR, churn, NRR, expansion, and cohort analysis.
+  - `skills/saas-revenue-growth-metrics/SKILL.md`
+- `storyboard` - Create a 6-frame visual narrative that tells the story of a user's journey from problem to solution, using the classic storytelling arc to build empathy, illustrate value, and make abstract product co
+  - `skills/storyboard/SKILL.md`
+- `user-story` - Create clear, concise user stories that combine Mike Cohn's user story format with Gherkin-style acceptance criteria. Use this to translate user needs into actionable development work that focuses on
+  - `skills/user-story/SKILL.md`
+- `user-story-mapping` - Visualize the user journey by creating a hierarchical map that breaks down high-level activities into steps and tasks, organized left-to-right as a narrative flow. Use this to build shared understandi
+  - `skills/user-story-mapping/SKILL.md`
+- `user-story-splitting` - Break down large user stories, epics, or features into smaller, independently deliverable stories using systematic splitting patterns. Use this to make work more manageable, reduce risk, enable faster
+  - `skills/user-story-splitting/SKILL.md`
+
+## Interactive (20)
+
+- `acquisition-channel-advisor` - Evaluate acquisition channels using unit economics, customer quality, and scalability. Recommends scale/test/kill decisions.
+  - `skills/acquisition-channel-advisor/SKILL.md`
+- `ai-shaped-readiness-advisor` - Assess whether your product work is AI-first or AI-shaped. Score 5 competencies and recommend the next capability to build.
+  - `skills/ai-shaped-readiness-advisor/SKILL.md`
+- `business-health-diagnostic` - Diagnose SaaS business health using key metrics, identify red flags, and prioritize actions. Analyzes growth, retention, efficiency, and capital health.
+  - `skills/business-health-diagnostic/SKILL.md`
+- `context-engineering-advisor` - Diagnose context stuffing vs. context engineering. Assess practices, define boundaries, and advise on memory architecture, retrieval, and the Research→Plan→Reset→Implement cycle.
+  - `skills/context-engineering-advisor/SKILL.md`
+- `customer-journey-mapping-workshop` - Guide product managers through creating a customer journey map by asking adaptive questions about the actor (persona), scenario/goal, journey phases, actions/emotions, and opportunities for improvemen
+  - `skills/customer-journey-mapping-workshop/SKILL.md`
+- `director-readiness-advisor` - Coaches PMs and new Directors through the transition from individual contributor to organizational leader across four situations: preparing, interviewing, newly landed, or recalibrating.
+  - `skills/director-readiness-advisor/SKILL.md`
+- `discovery-interview-prep` - Guide product managers through preparing for customer discovery interviews by asking adaptive questions about research goals, customer segments, constraints, and methodologies. Use this to design effe
+  - `skills/discovery-interview-prep/SKILL.md`
+- `epic-breakdown-advisor` - Break down epics into user stories using Richard Lawrence's Humanizing Work methodology—a flowchart-driven approach that applies 9 splitting patterns sequentially.
+  - `skills/epic-breakdown-advisor/SKILL.md`
+- `feature-investment-advisor` - Guide PMs through evaluating feature investments using revenue impact, cost structure, ROI, and strategic value. Delivers build/don't build recommendations.
+  - `skills/feature-investment-advisor/SKILL.md`
+- `finance-based-pricing-advisor` - Evaluate pricing changes using financial impact analysis - ARPU/ARPA, conversion, churn risk, NRR, and payback. Recommends go/no-go on pricing decisions.
+  - `skills/finance-based-pricing-advisor/SKILL.md`
+- `lean-ux-canvas` - Guide product managers through Jeff Gothelf's Lean UX Canvas v2—a one-page tool that frames work around a business problem, exposes assumptions, and ensures learning every sprint.
+  - `skills/lean-ux-canvas/SKILL.md`
+- `opportunity-solution-tree` - Guide product managers through creating an Opportunity Solution Tree (OST) by extracting target outcomes from stakeholder requests, generating opportunity options (problems to solve), mapping potentia
+  - `skills/opportunity-solution-tree/SKILL.md`
+- `pol-probe-advisor` - Select the right Proof of Life (PoL) probe based on hypothesis, risk, and resources. Use this to match the validation method to the real learning goal, not tooling comfort.
+  - `skills/pol-probe-advisor/SKILL.md`
+- `positioning-workshop` - Guide product managers through discovering and articulating product positioning by asking adaptive questions about target customers, unmet needs, product category, benefits, and competitive differenti
+  - `skills/positioning-workshop/SKILL.md`
+- `prioritization-advisor` - Guide product managers in choosing the right prioritization framework by asking adaptive questions about product stage, team context, decision-making needs, and stakeholder dynamics. Use this to avoid
+  - `skills/prioritization-advisor/SKILL.md`
+- `problem-framing-canvas` - Guide PMs through MITRE's Problem Framing Canvas with structured questions across Look Inward, Look Outward, and Reframe to produce a clear, bias-resistant problem statement.
+  - `skills/problem-framing-canvas/SKILL.md`
+- `tam-sam-som-calculator` - Guide product managers through calculating Total Addressable Market (TAM), Serviceable Available Market (SAM), and Serviceable Obtainable Market (SOM) for a product idea by asking adaptive, contextual
+  - `skills/tam-sam-som-calculator/SKILL.md`
+- `user-story-mapping-workshop` - Guide product managers through creating a user story map by asking adaptive questions about the system, users, workflow, and priorities—then generating a two-dimensional map with backbone (activitie
+  - `skills/user-story-mapping-workshop/SKILL.md`
+- `vp-cpo-readiness-advisor` - Coaches Directors and executives through the transition to VP or CPO across four situations: preparing, interviewing, newly landed, or recalibrating at executive level.
+  - `skills/vp-cpo-readiness-advisor/SKILL.md`
+- `workshop-facilitation` - Facilitate workshop sessions in a multi-turn, one-step flow with numbered recommendations at decision points and quick-select options for regular questions.
+  - `skills/workshop-facilitation/SKILL.md`
+
+## Workflow (6)
+
+- `discovery-process` - Guide product managers through a complete discovery cycle—from initial problem hypothesis to validated solution—by orchestrating problem framing, customer interviews, synthesis, and experimentatio
+  - `skills/discovery-process/SKILL.md`
+- `executive-onboarding-playbook` - A 30-60-90 day playbook for VP and CPO leaders entering a new role: diagnose before acting, surface unwritten strategy, assess people, and build the body of evidence that informs all decisions.
+  - `skills/executive-onboarding-playbook/SKILL.md`
+- `prd-development` - Guide product managers through structured PRD (Product Requirements Document) creation by orchestrating problem framing, user research synthesis, solution definition, and success criteria into a cohes
+  - `skills/prd-development/SKILL.md`
+- `product-strategy-session` - Guide product managers through a comprehensive product strategy session by orchestrating positioning, problem framing, customer discovery, and roadmap planning skills into a cohesive end-to-end proces
+  - `skills/product-strategy-session/SKILL.md`
+- `roadmap-planning` - Guide product managers through strategic roadmap planning by orchestrating prioritization, epic definition, stakeholder alignment, and release sequencing skills into a structured process. Use this to
+  - `skills/roadmap-planning/SKILL.md`
+- `skill-authoring-workflow` - Turn raw PM content into a compliant, publish-ready skill by choosing build/add paths, running conformance checks, and updating docs before commit.
+  - `skills/skill-authoring-workflow/SKILL.md`
@@ -0,0 +1,270 @@
+generated_from: skills/*/SKILL.md
+count: 46
+skills:
+- name: acquisition-channel-advisor
+  description: Evaluate acquisition channels using unit economics, customer quality,
+    and scalability. Recommends scale/test/kill decisions.
+  type: interactive
+  path: skills/acquisition-channel-advisor/SKILL.md
+- name: ai-shaped-readiness-advisor
+  description: Assess whether your product work is AI-first or AI-shaped. Score 5
+    competencies and recommend the next capability to build.
+  type: interactive
+  path: skills/ai-shaped-readiness-advisor/SKILL.md
+- name: altitude-horizon-framework
+  description: 'The core mental model for the PM-to-Director transition: altitude
+    (scope) and horizon (time), the waiter-to-operator shift, four transition zones,
+    named failure modes, and the Cascading Context Map.'
+  type: component
+  path: skills/altitude-horizon-framework/SKILL.md
+- name: business-health-diagnostic
+  description: Diagnose SaaS business health using key metrics, identify red flags,
+    and prioritize actions. Analyzes growth, retention, efficiency, and capital health.
+  type: interactive
+  path: skills/business-health-diagnostic/SKILL.md
+- name: company-research
+  description: Create a comprehensive company profile that extracts executive insights,
+    product strategy, transformation initiatives, and organizational dynamics from
+    publicly available sources. Use this to understa
+  type: component
+  path: skills/company-research/SKILL.md
+- name: context-engineering-advisor
+  description: "Diagnose context stuffing vs. context engineering. Assess practices,\
+    \ define boundaries, and advise on memory architecture, retrieval, and the Research\u2192\
+    Plan\u2192Reset\u2192Implement cycle."
+  type: interactive
+  path: skills/context-engineering-advisor/SKILL.md
+- name: customer-journey-map
+  description: "Create a comprehensive customer journey map that visualizes how customers\
+    \ interact with your brand across all stages\u2014from awareness to loyalty\u2014\
+    documenting their actions, touchpoints, emotions, KPI"
+  type: component
+  path: skills/customer-journey-map/SKILL.md
+- name: customer-journey-mapping-workshop
+  description: Guide product managers through creating a customer journey map by asking
+    adaptive questions about the actor (persona), scenario/goal, journey phases, actions/emotions,
+    and opportunities for improvemen
+  type: interactive
+  path: skills/customer-journey-mapping-workshop/SKILL.md
+- name: director-readiness-advisor
+  description: 'Coaches PMs and new Directors through the transition from individual
+    contributor to organizational leader across four situations: preparing, interviewing,
+    newly landed, or recalibrating.'
+  type: interactive
+  path: skills/director-readiness-advisor/SKILL.md
+- name: discovery-interview-prep
+  description: Guide product managers through preparing for customer discovery interviews
+    by asking adaptive questions about research goals, customer segments, constraints,
+    and methodologies. Use this to design effe
+  type: interactive
+  path: skills/discovery-interview-prep/SKILL.md
+- name: discovery-process
+  description: "Guide product managers through a complete discovery cycle\u2014from\
+    \ initial problem hypothesis to validated solution\u2014by orchestrating problem\
+    \ framing, customer interviews, synthesis, and experimentatio"
+  type: workflow
+  path: skills/discovery-process/SKILL.md
+- name: eol-message
+  description: Craft a clear, empathetic End-of-Life (EOL) message that communicates
+    product or feature discontinuation, explains the rationale, addresses customer
+    impact, provides transition support, and positions
+  type: component
+  path: skills/eol-message/SKILL.md
+- name: epic-breakdown-advisor
+  description: "Break down epics into user stories using Richard Lawrence's Humanizing\
+    \ Work methodology\u2014a flowchart-driven approach that applies 9 splitting patterns\
+    \ sequentially."
+  type: interactive
+  path: skills/epic-breakdown-advisor/SKILL.md
+- name: epic-hypothesis
+  description: Frame epics as testable hypotheses using an if/then structure that
+    articulates the action or solution, the target beneficiary, the expected outcome,
+    and how you'll validate success. Use this to manage
+  type: component
+  path: skills/epic-hypothesis/SKILL.md
+- name: executive-onboarding-playbook
+  description: 'A 30-60-90 day playbook for VP and CPO leaders entering a new role:
+    diagnose before acting, surface unwritten strategy, assess people, and build the
+    body of evidence that informs all decisions.'
+  type: workflow
+  path: skills/executive-onboarding-playbook/SKILL.md
+- name: feature-investment-advisor
+  description: Guide PMs through evaluating feature investments using revenue impact,
+    cost structure, ROI, and strategic value. Delivers build/don't build recommendations.
+  type: interactive
+  path: skills/feature-investment-advisor/SKILL.md
+- name: finance-based-pricing-advisor
+  description: Evaluate pricing changes using financial impact analysis - ARPU/ARPA,
+    conversion, churn risk, NRR, and payback. Recommends go/no-go on pricing decisions.
+  type: interactive
+  path: skills/finance-based-pricing-advisor/SKILL.md
+- name: finance-metrics-quickref
+  description: Fast lookup table for 32+ SaaS finance metrics with formulas, benchmarks,
+    and when to use each. Includes red flags and decision frameworks.
+  type: component
+  path: skills/finance-metrics-quickref/SKILL.md
+- name: jobs-to-be-done
+  description: Systematically explore what customers are trying to accomplish (functional,
+    social, emotional jobs), the pains they experience, and the gains they seek. Use
+    this framework to uncover unmet needs, vali
+  type: component
+  path: skills/jobs-to-be-done/SKILL.md
+- name: lean-ux-canvas
+  description: "Guide product managers through Jeff Gothelf's Lean UX Canvas v2\u2014\
+    a one-page tool that frames work around a business problem, exposes assumptions,\
+    \ and ensures learning every sprint."
+  type: interactive
+  path: skills/lean-ux-canvas/SKILL.md
+- name: opportunity-solution-tree
+  description: Guide product managers through creating an Opportunity Solution Tree
+    (OST) by extracting target outcomes from stakeholder requests, generating opportunity
+    options (problems to solve), mapping potentia
+  type: interactive
+  path: skills/opportunity-solution-tree/SKILL.md
+- name: pestel-analysis
+  description: "Conduct a systematic analysis of macro-environmental factors\u2014\
+    Political, Economic, Social, Technological, Environmental, and Legal\u2014that\
+    \ could impact your product or project. Use this to identify ex"
+  type: component
+  path: skills/pestel-analysis/SKILL.md
+- name: pol-probe
+  description: "Define a Proof of Life (PoL) probe\u2014a lightweight validation artifact\
+    \ that surfaces harsh truths before expensive development. Use it to test hypotheses\
+    \ with minimal investment."
+  type: component
+  path: skills/pol-probe/SKILL.md
+- name: pol-probe-advisor
+  description: Select the right Proof of Life (PoL) probe based on hypothesis, risk,
+    and resources. Use this to match the validation method to the real learning goal,
+    not tooling comfort.
+  type: interactive
+  path: skills/pol-probe-advisor/SKILL.md
+- name: positioning-statement
+  description: Create a Geoffrey Moore-style positioning statement that clearly articulates
+    who your product serves, what need it addresses, how it's categorized, what benefit
+    it delivers, and how it differs from al
+  type: component
+  path: skills/positioning-statement/SKILL.md
+- name: positioning-workshop
+  description: Guide product managers through discovering and articulating product
+    positioning by asking adaptive questions about target customers, unmet needs,
+    product category, benefits, and competitive differenti
+  type: interactive
+  path: skills/positioning-workshop/SKILL.md
+- name: prd-development
+  description: Guide product managers through structured PRD (Product Requirements
+    Document) creation by orchestrating problem framing, user research synthesis,
+    solution definition, and success criteria into a cohes
+  type: workflow
+  path: skills/prd-development/SKILL.md
+- name: press-release
+  description: Create a visionary press release following Amazon's "Working Backwards"
+    methodology to define and communicate a product or feature before building it.
+    Use this to align stakeholders on the customer va
+  type: component
+  path: skills/press-release/SKILL.md
+- name: prioritization-advisor
+  description: Guide product managers in choosing the right prioritization framework
+    by asking adaptive questions about product stage, team context, decision-making
+    needs, and stakeholder dynamics. Use this to avoid
+  type: interactive
+  path: skills/prioritization-advisor/SKILL.md
+- name: problem-framing-canvas
+  description: Guide PMs through MITRE's Problem Framing Canvas with structured questions
+    across Look Inward, Look Outward, and Reframe to produce a clear, bias-resistant
+    problem statement.
+  type: interactive
+  path: skills/problem-framing-canvas/SKILL.md
+- name: problem-statement
+  description: Articulate a problem from the user's perspective using an empathy-driven
+    framework that captures who they are, what they're trying to do, what's blocking
+    them, why, and how it makes them feel. Use thi
+  type: component
+  path: skills/problem-statement/SKILL.md
+- name: product-strategy-session
+  description: Guide product managers through a comprehensive product strategy session
+    by orchestrating positioning, problem framing, customer discovery, and roadmap
+    planning skills into a cohesive end-to-end proces
+  type: workflow
+  path: skills/product-strategy-session/SKILL.md
+- name: proto-persona
+  description: Create an initial, assumption-based persona profile that synthesizes
+    available user research, market data, and stakeholder knowledge into a working
+    hypothesis about your target user. Use this to align
+  type: component
+  path: skills/proto-persona/SKILL.md
+- name: recommendation-canvas
+  description: Evaluate and propose AI product solutions using a structured canvas
+    that assesses business outcomes, customer outcomes, problem framing, solution
+    hypotheses, positioning, risks, and value justificatio
+  type: component
+  path: skills/recommendation-canvas/SKILL.md
+- name: roadmap-planning
+  description: Guide product managers through strategic roadmap planning by orchestrating
+    prioritization, epic definition, stakeholder alignment, and release sequencing
+    skills into a structured process. Use this to
+  type: workflow
+  path: skills/roadmap-planning/SKILL.md
+- name: saas-economics-efficiency-metrics
+  description: Evaluate unit economics and capital efficiency for SaaS. Covers CAC,
+    LTV, payback, margins, burn rate, Rule of 40, and magic number.
+  type: component
+  path: skills/saas-economics-efficiency-metrics/SKILL.md
+- name: saas-revenue-growth-metrics
+  description: Calculate and interpret revenue, retention, and growth metrics for
+    SaaS products. Covers revenue, ARPU/ARPA, MRR/ARR, churn, NRR, expansion, and
+    cohort analysis.
+  type: component
+  path: skills/saas-revenue-growth-metrics/SKILL.md
+- name: skill-authoring-workflow
+  description: Turn raw PM content into a compliant, publish-ready skill by choosing
+    build/add paths, running conformance checks, and updating docs before commit.
+  type: workflow
+  path: skills/skill-authoring-workflow/SKILL.md
+- name: storyboard
+  description: Create a 6-frame visual narrative that tells the story of a user's
+    journey from problem to solution, using the classic storytelling arc to build
+    empathy, illustrate value, and make abstract product co
+  type: component
+  path: skills/storyboard/SKILL.md
+- name: tam-sam-som-calculator
+  description: Guide product managers through calculating Total Addressable Market
+    (TAM), Serviceable Available Market (SAM), and Serviceable Obtainable Market (SOM)
+    for a product idea by asking adaptive, contextual
+  type: interactive
+  path: skills/tam-sam-som-calculator/SKILL.md
+- name: user-story
+  description: Create clear, concise user stories that combine Mike Cohn's user story
+    format with Gherkin-style acceptance criteria. Use this to translate user needs
+    into actionable development work that focuses on
+  type: component
+  path: skills/user-story/SKILL.md
+- name: user-story-mapping
+  description: Visualize the user journey by creating a hierarchical map that breaks
+    down high-level activities into steps and tasks, organized left-to-right as a
+    narrative flow. Use this to build shared understandi
+  type: component
+  path: skills/user-story-mapping/SKILL.md
+- name: user-story-mapping-workshop
+  description: "Guide product managers through creating a user story map by asking\
+    \ adaptive questions about the system, users, workflow, and priorities\u2014then\
+    \ generating a two-dimensional map with backbone (activitie"
+  type: interactive
+  path: skills/user-story-mapping-workshop/SKILL.md
+- name: user-story-splitting
+  description: Break down large user stories, epics, or features into smaller, independently
+    deliverable stories using systematic splitting patterns. Use this to make work
+    more manageable, reduce risk, enable faster
+  type: component
+  path: skills/user-story-splitting/SKILL.md
+- name: vp-cpo-readiness-advisor
+  description: 'Coaches Directors and executives through the transition to VP or CPO
+    across four situations: preparing, interviewing, newly landed, or recalibrating
+    at executive level.'
+  type: interactive
+  path: skills/vp-cpo-readiness-advisor/SKILL.md
+- name: workshop-facilitation
+  description: Facilitate workshop sessions in a multi-turn, one-step flow with numbered
+    recommendations at decision points and quick-select options for regular questions.
+  type: interactive
+  path: skills/workshop-facilitation/SKILL.md
@@ -0,0 +1,47 @@
+# Commands
+
+Commands are reusable workflow wrappers over one or more local PM skills.
+
+- Skills remain the source of truth for frameworks and pedagogy.
+- Commands are lightweight orchestration for fast execution.
+- Commands are written as markdown with frontmatter and can be used in any agent by referencing the file path.
+
+## Command Format
+
+Each command file should include frontmatter:
+
+```yaml
+---
+name: command-name
+description: What this command does
+argument-hint: "<what the user should provide>"
+uses:
+  - skill-name
+  - another-skill
+outputs:
+  - Output artifact 1
+  - Output artifact 2
+---
+```
+
+## Available Commands (v1)
+
+- `discover`
+- `strategy`
+- `write-prd`
+- `plan-roadmap`
+- `prioritize`
+- `leadership-transition`
+
+## Validation
+
+```bash
+python3 scripts/check-command-metadata.py
+```
+
+## Discovery
+
+```bash
+./scripts/find-a-command.sh --list-all
+./scripts/find-a-command.sh --keyword roadmap
+```
@@ -0,0 +1,44 @@
+---
+name: discover
+description: Run a structured discovery flow from problem framing through opportunity mapping and validation planning.
+argument-hint: "<problem, opportunity, or feature area>"
+uses:
+  - discovery-process
+  - problem-framing-canvas
+  - discovery-interview-prep
+  - opportunity-solution-tree
+  - pol-probe-advisor
+outputs:
+  - Discovery plan
+  - Prioritized assumptions
+  - Validation experiment backlog
+---
+
+# /discover
+
+Run a full discovery loop without manually stitching together skills.
+
+## Invocation
+
+```text
+/discover Reduce onboarding drop-off for new SMB users
+```
+
+## Workflow
+
+1. Frame the problem using `problem-framing-canvas`.
+2. Plan interview and evidence gathering with `discovery-interview-prep`.
+3. Map opportunities and options with `opportunity-solution-tree`.
+4. Select validation probes with `pol-probe-advisor`.
+5. Synthesize into a concrete execution plan using `discovery-process`.
+
+## Checkpoints
+
+- Confirm target user and business outcome before solutioning.
+- Prioritize the top 2-3 assumptions by risk.
+- Choose fast experiments before committing engineering.
+
+## Next Steps
+
+- Run `/write-prd` for the most promising validated solution.
+- Run `/prioritize` when multiple solution paths survive validation.
@@ -0,0 +1,42 @@
+---
+name: leadership-transition
+description: Guide PM to Director to VP/CPO transition planning with role-fit diagnostics and onboarding guidance.
+argument-hint: "<current role, target role, and transition scenario>"
+uses:
+  - altitude-horizon-framework
+  - director-readiness-advisor
+  - vp-cpo-readiness-advisor
+  - executive-onboarding-playbook
+outputs:
+  - Transition diagnosis
+  - Role-readiness plan
+  - 30-60-90 leadership actions
+---
+
+# /leadership-transition
+
+Use when preparing for or navigating a product leadership step-up.
+
+## Invocation
+
+```text
+/leadership-transition Senior PM moving into first Director role at a scaling SaaS
+```
+
+## Workflow
+
+1. Anchor leadership model with `altitude-horizon-framework`.
+2. Diagnose current readiness using `director-readiness-advisor`.
+3. For executive transitions, apply `vp-cpo-readiness-advisor`.
+4. Build execution plan with `executive-onboarding-playbook`.
+
+## Checkpoints
+
+- Identify where transition friction is actually occurring (scope, horizon, systems, narrative).
+- Clarify decision rights and expectations with stakeholders.
+- Define evidence-based milestones for first 30-60-90 days.
+
+## Next Steps
+
+- Re-run quarterly for recalibration.
+- Pair with `/strategy` if you also need to reset product direction.
@@ -0,0 +1,44 @@
+---
+name: plan-roadmap
+description: Turn strategy and validated opportunities into a sequenced roadmap with clear tradeoffs.
+argument-hint: "<time horizon, goals, and candidate initiatives>"
+uses:
+  - roadmap-planning
+  - epic-hypothesis
+  - prioritization-advisor
+  - user-story-mapping
+  - epic-breakdown-advisor
+outputs:
+  - Prioritized roadmap
+  - Epic hypotheses
+  - Release slices and sequencing rationale
+---
+
+# /plan-roadmap
+
+Create a roadmap that reflects strategy, risk, and delivery reality.
+
+## Invocation
+
+```text
+/plan-roadmap Q3-Q4 plan for enterprise reporting and permissions
+```
+
+## Workflow
+
+1. Build roadmap context with `roadmap-planning`.
+2. Convert initiatives into `epic-hypothesis` statements.
+3. Select the right framework via `prioritization-advisor`.
+4. Create delivery slices with `user-story-mapping`.
+5. Break oversized epics with `epic-breakdown-advisor`.
+
+## Checkpoints
+
+- Ensure every roadmap item ties to an explicit outcome.
+- Expose why items are not being prioritized.
+- Capture dependencies and sequencing risk.
+
+## Next Steps
+
+- Run `/write-prd` for the top roadmap slice.
+- Run `/discover` for high-uncertainty initiatives.
@@ -0,0 +1,44 @@
+---
+name: prioritize
+description: Select what to work on next using the right prioritization method for your context.
+argument-hint: "<candidate initiatives, constraints, and decision context>"
+uses:
+  - prioritization-advisor
+  - feature-investment-advisor
+  - acquisition-channel-advisor
+  - finance-based-pricing-advisor
+  - recommendation-canvas
+outputs:
+  - Ranked options
+  - Decision rationale
+  - Explicit tradeoffs and follow-up actions
+---
+
+# /prioritize
+
+Prioritize initiatives with context-aware financial and strategic rigor.
+
+## Invocation
+
+```text
+/prioritize Q2 backlog for activation, retention, and pricing experiments
+```
+
+## Workflow
+
+1. Choose the right framework with `prioritization-advisor`.
+2. Evaluate feature-level returns using `feature-investment-advisor`.
+3. Factor channel quality via `acquisition-channel-advisor`.
+4. Assess pricing implications using `finance-based-pricing-advisor`.
+5. Capture final recommendation in `recommendation-canvas`.
+
+## Checkpoints
+
+- Separate reversible from irreversible decisions.
+- Identify assumptions that could flip ranking outcomes.
+- Call out confidence level for each ranking decision.
+
+## Next Steps
+
+- Run `/discover` for top risky bets.
+- Run `/plan-roadmap` for approved initiatives.
@@ -0,0 +1,44 @@
+---
+name: strategy
+description: Build product strategy from positioning through opportunity and roadmap decisions.
+argument-hint: "<product, market, and strategic question>"
+uses:
+  - product-strategy-session
+  - positioning-workshop
+  - problem-statement
+  - opportunity-solution-tree
+  - roadmap-planning
+outputs:
+  - Strategy narrative
+  - Core strategic choices
+  - Sequenced roadmap direction
+---
+
+# /strategy
+
+Run an end-to-end strategy workflow with decision-quality outputs.
+
+## Invocation
+
+```text
+/strategy B2B analytics add-on for mid-market ecommerce brands
+```
+
+## Workflow
+
+1. Clarify customer and category with `positioning-workshop`.
+2. Lock the core problem with `problem-statement`.
+3. Expand options via `opportunity-solution-tree`.
+4. Orchestrate a full strategy pass with `product-strategy-session`.
+5. Sequence commitments using `roadmap-planning`.
+
+## Checkpoints
+
+- Separate strategy (choices) from execution backlog.
+- Call out explicit tradeoffs and non-goals.
+- Confirm metrics and leading indicators for each strategic bet.
+
+## Next Steps
+
+- Run `/plan-roadmap` for release-level sequencing.
+- Run `/write-prd` for top-priority initiatives.
@@ -0,0 +1,44 @@
+---
+name: write-prd
+description: Create a decision-ready PRD by chaining problem framing, requirements definition, and story scaffolding.
+argument-hint: "<feature, initiative, or product change>"
+uses:
+  - prd-development
+  - problem-statement
+  - proto-persona
+  - user-story
+  - user-story-splitting
+outputs:
+  - Structured PRD
+  - Core personas and requirements
+  - Initial implementation-ready stories
+---
+
+# /write-prd
+
+Generate a PRD that moves smoothly from strategy to delivery.
+
+## Invocation
+
+```text
+/write-prd Team inbox redesign for faster triage in customer support
+```
+
+## Workflow
+
+1. Define the problem context with `problem-statement`.
+2. Align user assumptions with `proto-persona`.
+3. Build the full document using `prd-development`.
+4. Draft initial stories with `user-story`.
+5. Split larger items with `user-story-splitting`.
+
+## Checkpoints
+
+- Validate scope boundaries before writing requirements.
+- Keep success criteria measurable and tied to outcome metrics.
+- Ensure at least one anti-pattern is called out in risks.
+
+## Next Steps
+
+- Run `/plan-roadmap` to sequence delivery.
+- Run `/prioritize` if scope exceeds current capacity.
@@ -60,6 +60,13 @@ Ask up to 3 clarifying questions when context is missing.
 2. Open `dist/skill-zips/`.
 3. Upload the ZIP in Claude Skills settings.

+### Default C: Local command runner (terminal-friendly)
+
+```bash
+./scripts/run-pm.sh skill user-story "Checkout improvements for returning users"
+./scripts/run-pm.sh command discover "Reduce onboarding drop-off for self-serve users"
+```
+
 ---

 ## Common Confusions (And Fixes)
@@ -28,6 +28,12 @@ Example:
 Use skills/prioritization-advisor/SKILL.md from deanpeters/Product-Manager-Skills and guide me through choosing a framework for a B2B roadmap.
 ```

+Command-style example:
+
+```text
+Run commands/strategy.md from deanpeters/Product-Manager-Skills for: B2B analytics add-on for mid-market ecommerce brands.
+```
+
 ---

 ## Option 2: Build a Custom GPT with Skill Knowledge (Best for Reuse)
@@ -55,6 +55,21 @@ claude "Run skills/discovery-process/SKILL.md for our enterprise customer churn
 ```
 These orchestrate multiple phases. Claude will outline the process, then execute phase by phase.

+### Command Workflows (skills + orchestration)
+
+The repo also includes a `commands/` layer for fast multi-skill execution.
+
+```bash
+claude "Run commands/discover.md for reducing onboarding drop-off in self-serve SMB accounts"
+claude "Run commands/write-prd.md for mobile onboarding redesign"
+```
+
+Or use the local launcher:
+
+```bash
+./scripts/run-pm.sh command discover "Reduce onboarding drop-off in self-serve SMB accounts" --agent claude
+```
+
 ### Working with Multiple Skills

 Chain skills explicitly:
@@ -62,6 +77,13 @@ Chain skills explicitly:
 claude "First use skills/problem-framing-canvas/SKILL.md to define the problem. Then apply skills/opportunity-solution-tree/SKILL.md to map solutions."
 ```

+Discover available command wrappers:
+
+```bash
+./scripts/find-a-command.sh --list-all
+./scripts/find-a-command.sh --keyword roadmap
+```
+
 ### Installing Skills Globally (Optional)

 You can install skills in Claude's global skills directory for access from any project:
@@ -26,6 +26,12 @@ Example:
 Using the skill at skills/prd-development/SKILL.md, create a PRD for a mobile onboarding redesign. Ask up to 3 clarifying questions first, then proceed.
 ```

+Command workflow example:
+
+```text
+Run commands/discover.md for this request: reduce onboarding drop-off for self-serve SMB users.
+```
+
 ### How to Apply Skill Types

 - **Component skills**: ask for a specific artifact (for example, user story, positioning statement, epic hypothesis).
@@ -38,6 +44,13 @@ Using the skill at skills/prd-development/SKILL.md, create a PRD for a mobile on
 First use skills/problem-framing-canvas/SKILL.md to define the problem. Then apply skills/user-story/SKILL.md to write stories for the chosen solution.
 ```

+Use local helper scripts for quick discovery and execution:
+
+```bash
+./scripts/find-a-command.sh --list-all
+./scripts/run-pm.sh command plan-roadmap "Q3-Q4 roadmap for enterprise reporting"
+```
+
 ---

 ## Option 2: Codex on ChatGPT (GitHub-Connected)
@@ -0,0 +1,72 @@
+# v0.6 Release Announcement (Mar 6, 2026) — Navigation + Commands
+
+## Post Metadata
+
+- **Post Title:** Product Manager Skills v0.6 — Faster Navigation + Command Workflows
+- **Post Subtitle:** Use PM skills faster with Start Here, command wrappers, generated catalogs, and full-library validation.
+- **Opening (first 160 chars):** v0.6 adds a command layer and generated catalogs so PM teams can find and run the right workflow fast, while keeping skills as the source of truth.
+- **Primary Link:** [Product Manager Skills repo](https://github.com/deanpeters/Product-Manager-Skills)
+
+---
+
+## Short Promotional Post
+
+v0.6 is focused on usability and speed.
+
+What shipped:
+- `START_HERE.md` for 60-second onboarding
+- New `commands/` layer for reusable multi-skill workflows
+- Generated catalogs in `catalog/` for fast navigation
+- New helper scripts: `run-pm.sh`, `find-a-command.sh`, `test-library.sh`, `generate-catalog.py`
+- Command metadata validation (`check-command-metadata.py`)
+
+Skills remain the core product.
+Commands are orchestration wrappers over existing skills.
+
+Release: [Product Manager Skills v0.6](https://github.com/deanpeters/Product-Manager-Skills)
+
+---
+
+## Long-Form Draft
+
+### Title
+Product Manager Skills v0.6: Navigation and Command Workflows
+
+### Subtitle
+How we made a 46-skill library faster to use without diluting the quality of the skills themselves
+
+### Article Body
+
+v0.6 introduces a practical command layer and navigation system on top of the existing PM skill library.
+
+The core principle is unchanged:
+- Skills are still the source of truth for pedagogy and framework depth.
+- Commands are lightweight wrappers that orchestrate multiple skills for common outcomes.
+
+What changed:
+
+1. **60-second onboarding path**
+   - Added `START_HERE.md` with three practical entry routes:
+     - I need an artifact
+     - I need help deciding
+     - I need end-to-end guidance
+
+2. **Reusable command workflows**
+   - Added `commands/` with high-value flows:
+     - `discover`
+     - `strategy`
+     - `write-prd`
+     - `plan-roadmap`
+     - `prioritize`
+     - `leadership-transition`
+
+3. **Generated navigation catalogs**
+   - Added machine and human browse indexes under `catalog/`
+   - Regenerate at any time with `python3 scripts/generate-catalog.py`
+
+4. **Validation and execution tooling**
+   - `check-command-metadata.py` validates command frontmatter and skill references
+   - `test-library.sh` validates the full library surface
+   - `run-pm.sh` enables one-command local execution scaffolding
+
+This release is aimed at scale: as the library grows beyond 60 skills, navigation and execution speed should improve, not degrade.
@@ -4,6 +4,7 @@ Canonical location for launch posts, social copy, and release-related announceme

 ## Latest

+- **2026-03-06:** [v0.6 Navigation + Commands](2026-03-06-v0-6-navigation-commands.md)
 - **2026-02-27:** [v0.5 Streamlit (beta) Playground](2026-02-27-v0-5-streamlit-beta.md)
 - **2026-02-10:** [v0.4 Facilitation Protocol Fix](2026-02-10-v0-4-facilitation-fix.md)
 - **2026-02-08:** [LinkedIn Launch](2026-02-08-linkedin-launch.md)
@@ -11,6 +12,7 @@ Canonical location for launch posts, social copy, and release-related announceme

 ## Timeline

+- [2026-03-06-v0-6-navigation-commands.md](2026-03-06-v0-6-navigation-commands.md) — v0.6 release note for command workflows, quick-start onboarding, and generated catalogs
 - [2026-02-27-v0-5-streamlit-beta.md](2026-02-27-v0-5-streamlit-beta.md) — v0.5 Streamlit (beta) release note for local playground + workflow UX improvements
 - [2026-02-10-v0-4-facilitation-fix.md](2026-02-10-v0-4-facilitation-fix.md) — v0.4 release note and root-cause/fix narrative for facilitation regression
 - [2026-02-08-linkedin-launch.md](2026-02-08-linkedin-launch.md) — Product Management Skills for Your Agents launch copy (post + article)
@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""Validate command metadata and skill references.
+
+Checks:
+- Valid YAML frontmatter
+- name present, lowercase kebab-case, and <= 64 chars
+- description present and <= 200 chars
+- argument-hint present
+- uses is a non-empty list
+- command file name matches frontmatter name
+- every referenced skill exists under skills/<skill>/SKILL.md
+- required sections exist in order: Invocation, Workflow, Checkpoints, Next Steps
+"""
+
+from __future__ import annotations
+
+import argparse
+import glob
+import os
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+try:
+    import yaml
+except ImportError:  # pragma: no cover
+    print("PyYAML is required. Install with: python3 -m pip install pyyaml", file=sys.stderr)
+    raise
+
+
+REQUIRED_SECTIONS = ["Invocation", "Workflow", "Checkpoints", "Next Steps"]
+NAME_PATTERN = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+
+
+@dataclass
+class Issue:
+    path: str
+    code: str
+    detail: str
+
+
+def split_frontmatter(text: str) -> tuple[dict | None, str]:
+    if not text.startswith("---\n"):
+        return None, text
+    parts = text.split("---", 2)
+    if len(parts) < 3:
+        return None, text
+    data = yaml.safe_load(parts[1]) or {}
+    body = parts[2]
+    return data, body
+
+
+def check_required_sections(path: str, body: str) -> list[Issue]:
+    issues: list[Issue] = []
+    headings = re.findall(r"^##\s+(.+?)\s*$", body, flags=re.MULTILINE)
+    positions: dict[str, int] = {}
+
+    for section in REQUIRED_SECTIONS:
+        try:
+            positions[section] = headings.index(section)
+        except ValueError:
+            issues.append(Issue(path, "section_missing", section))
+
+    if len(positions) == len(REQUIRED_SECTIONS):
+        ordered = [positions[section] for section in REQUIRED_SECTIONS]
+        if ordered != sorted(ordered):
+            issues.append(
+                Issue(
+                    path,
+                    "section_order_invalid",
+                    "Expected order: " + " > ".join(REQUIRED_SECTIONS),
+                )
+            )
+
+    return issues
+
+
+def check_command(path: str) -> list[Issue]:
+    if not os.path.isfile(path):
+        return [Issue(path, "file_missing", "Command file not found")]
+
+    if os.path.basename(path).lower() == "readme.md":
+        return []
+
+    with open(path, "r", encoding="utf-8") as handle:
+        text = handle.read()
+
+    issues: list[Issue] = []
+    data, body = split_frontmatter(text)
+    if data is None:
+        issues.append(Issue(path, "frontmatter_missing", "Missing or malformed frontmatter"))
+        return issues
+
+    name = str(data.get("name") or "").strip()
+    description = str(data.get("description") or "").strip()
+    argument_hint = str(data.get("argument-hint") or "").strip()
+    uses = data.get("uses")
+
+    if not name:
+        issues.append(Issue(path, "name_missing", "Frontmatter name is required"))
+    elif len(name) > 64:
+        issues.append(Issue(path, "name_too_long", f"{len(name)} chars"))
+    elif not NAME_PATTERN.fullmatch(name):
+        issues.append(Issue(path, "name_invalid_format", "Expected lowercase kebab-case"))
+
+    if not description:
+        issues.append(Issue(path, "description_missing", "Frontmatter description is required"))
+    elif len(description) > 200:
+        issues.append(Issue(path, "description_too_long", f"{len(description)} chars"))
+
+    if not argument_hint:
+        issues.append(Issue(path, "argument_hint_missing", "Frontmatter argument-hint is required"))
+
+    if not isinstance(uses, list) or not uses:
+        issues.append(Issue(path, "uses_invalid", "Frontmatter uses must be a non-empty list"))
+    else:
+        for skill_name in uses:
+            if not isinstance(skill_name, str) or not skill_name.strip():
+                issues.append(Issue(path, "uses_invalid_item", f"Invalid uses entry: {skill_name}"))
+                continue
+            skill_path = PROJECT_ROOT / "skills" / skill_name / "SKILL.md"
+            if not skill_path.is_file():
+                issues.append(Issue(path, "uses_missing_skill", skill_name))
+
+    file_name = os.path.splitext(os.path.basename(path))[0]
+    if name and file_name != name:
+        issues.append(Issue(path, "file_name_mismatch", f"file={file_name} name={name}"))
+
+    issues.extend(check_required_sections(path, body))
+    return issues
+
+
+def resolve_command_files(paths: list[str]) -> list[str]:
+    if not paths:
+        return sorted(glob.glob(str(PROJECT_ROOT / "commands" / "*.md")))
+
+    resolved: list[str] = []
+    for raw_path in paths:
+        matches = sorted(glob.glob(raw_path))
+        if matches:
+            for match in matches:
+                if os.path.isdir(match):
+                    resolved.extend(sorted(glob.glob(os.path.join(match, "*.md"))))
+                else:
+                    resolved.append(match)
+            continue
+
+        if os.path.isdir(raw_path):
+            resolved.extend(sorted(glob.glob(os.path.join(raw_path, "*.md"))))
+        else:
+            candidate = Path(raw_path)
+            if not candidate.is_absolute():
+                candidate = PROJECT_ROOT / candidate
+            resolved.append(str(candidate))
+
+    deduped: list[str] = []
+    seen: set[str] = set()
+    for path in resolved:
+        norm = os.path.normpath(path)
+        if norm not in seen:
+            seen.add(norm)
+            deduped.append(norm)
+    return deduped
+
+
+def parse_args(argv: list[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Validate command metadata and references.")
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        help="Optional command file paths. If omitted, validates commands/*.md.",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv or sys.argv[1:])
+    command_files = resolve_command_files(args.paths)
+    if not command_files:
+        print("No command files found.")
+        return 1
+
+    all_issues: list[Issue] = []
+    for path in command_files:
+        all_issues.extend(check_command(path))
+
+    if not all_issues:
+        print("All commands pass conformance checks.")
+        return 0
+
+    print("Command conformance issues detected:\n")
+    for issue in all_issues:
+        print(f"- {issue.code}: {issue.path} ({issue.detail})")
+
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
@@ -0,0 +1,253 @@
+#!/usr/bin/env bash
+#
+# find-a-command.sh - Search and rank commands by relevance
+#
+# Usage:
+#   ./scripts/find-a-command.sh --list-all
+#   ./scripts/find-a-command.sh --keyword roadmap
+#   ./scripts/find-a-command.sh --name write-prd
+#   ./scripts/find-a-command.sh --uses prd-development
+#
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+COMMAND_GLOB="$PROJECT_ROOT/commands/*.md"
+
+NAME_FILTER=""
+KEYWORD_FILTER=""
+USES_FILTER=""
+LIMIT=25
+LIST_ALL=false
+TEMP_FILE=""
+
+require_value() {
+    local option="$1"
+    local value="${2:-}"
+    if [[ -z "$value" || "$value" == -* ]]; then
+        echo "Error: Option '$option' requires a value." >&2
+        exit 1
+    fi
+}
+
+to_lower() {
+    echo "$1" | tr '[:upper:]' '[:lower:]'
+}
+
+extract_frontmatter_field() {
+    local file="$1"
+    local field="$2"
+    awk -v field="$field" '
+        BEGIN { in_frontmatter = 0 }
+        NR == 1 && $0 == "---" { in_frontmatter = 1; next }
+        in_frontmatter && $0 == "---" { exit }
+        in_frontmatter {
+            if ($0 ~ "^" field ":[[:space:]]*") {
+                sub("^" field ":[[:space:]]*", "", $0)
+                print $0
+                exit
+            }
+        }
+    ' "$file"
+}
+
+command_uses_skill() {
+    local file="$1"
+    local skill="$2"
+    awk '
+        BEGIN { in_frontmatter = 0; in_uses = 0 }
+        NR == 1 && $0 == "---" { in_frontmatter = 1; next }
+        in_frontmatter && $0 == "---" { exit }
+        in_frontmatter {
+            if ($0 ~ /^uses:[[:space:]]*$/) { in_uses = 1; next }
+            if (in_uses && $0 ~ /^[[:space:]]*-[[:space:]]+/) {
+                sub(/^[[:space:]]*-[[:space:]]+/, "", $0)
+                print $0
+                next
+            }
+            if (in_uses && $0 !~ /^[[:space:]]+/) { in_uses = 0 }
+        }
+    ' "$file" | rg -Fxqi "$skill"
+}
+
+body_matches_keyword() {
+    local file="$1"
+    local keyword="$2"
+
+    awk '
+        BEGIN { state = 0 }
+        NR == 1 && $0 == "---" { state = 1; next }
+        state == 1 && $0 == "---" { state = 2; next }
+        state == 2 { print }
+    ' "$file" | grep -Fqi "$keyword"
+}
+
+print_help() {
+    cat <<EOF_HELP
+Usage: $0 [OPTIONS] [QUERY]
+
+Find and rank commands by relevance.
+
+Options:
+  --name <text>        Filter by command name
+  --keyword <text>     Match/rank by name/description/body text
+  --uses <skill-name>  Filter commands that use a skill
+  --limit <n>          Max results (default: 25)
+  --list-all           List all commands alphabetically
+  --help, -h           Show this help
+
+Examples:
+  $0 --list-all
+  $0 --keyword roadmap
+  $0 --name write-prd
+  $0 --uses discovery-process
+EOF_HELP
+}
+
+parse_args() {
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --name)
+                require_value "--name" "${2:-}"
+                NAME_FILTER="$2"
+                shift 2
+                ;;
+            --keyword)
+                require_value "--keyword" "${2:-}"
+                KEYWORD_FILTER="$2"
+                shift 2
+                ;;
+            --uses)
+                require_value "--uses" "${2:-}"
+                USES_FILTER="$2"
+                shift 2
+                ;;
+            --limit)
+                require_value "--limit" "${2:-}"
+                if ! [[ "$2" =~ ^[0-9]+$ ]] || [[ "$2" -lt 1 ]]; then
+                    echo "Error: --limit must be a positive integer." >&2
+                    exit 1
+                fi
+                LIMIT="$2"
+                shift 2
+                ;;
+            --list-all)
+                LIST_ALL=true
+                shift
+                ;;
+            --help|-h)
+                print_help
+                exit 0
+                ;;
+            -* )
+                echo "Error: Unknown option '$1'." >&2
+                echo "Run '$0 --help' for usage."
+                exit 1
+                ;;
+            *)
+                if [[ -z "$KEYWORD_FILTER" ]]; then
+                    KEYWORD_FILTER="$1"
+                else
+                    KEYWORD_FILTER="$KEYWORD_FILTER $1"
+                fi
+                shift
+                ;;
+        esac
+    done
+}
+
+main() {
+    parse_args "$@"
+
+    local name_filter_lc keyword_lc uses_filter_lc
+    name_filter_lc="$(to_lower "$NAME_FILTER")"
+    keyword_lc="$(to_lower "$KEYWORD_FILTER")"
+    uses_filter_lc="$(to_lower "$USES_FILTER")"
+
+    if [[ "$LIST_ALL" == true ]]; then
+        for command_file in $COMMAND_GLOB; do
+            [[ -f "$command_file" ]] || continue
+            command_name="$(extract_frontmatter_field "$command_file" "name")"
+            command_desc="$(extract_frontmatter_field "$command_file" "description")"
+            if [[ -z "$command_name" ]]; then
+                continue
+            fi
+            if [[ -n "$name_filter_lc" && "$(to_lower "$command_name")" != *"$name_filter_lc"* ]]; then
+                continue
+            fi
+            if [[ -n "$uses_filter_lc" ]] && ! command_uses_skill "$command_file" "$USES_FILTER"; then
+                continue
+            fi
+            echo "$command_name|$command_desc|${command_file#$PROJECT_ROOT/}"
+        done | sort -t'|' -k1,1 | head -n "$LIMIT" | while IFS='|' read -r name desc path; do
+            printf -- "- %s - %s\n  %s\n" "$name" "$desc" "$path"
+        done
+        exit 0
+    fi
+
+    TEMP_FILE="$(mktemp)"
+    trap '[[ -n "$TEMP_FILE" ]] && rm -f "$TEMP_FILE"' EXIT
+
+    for command_file in $COMMAND_GLOB; do
+        [[ -f "$command_file" ]] || continue
+
+        local command_name command_desc command_name_lc command_desc_lc score reason
+        command_name="$(extract_frontmatter_field "$command_file" "name")"
+        command_desc="$(extract_frontmatter_field "$command_file" "description")"
+        if [[ -z "$command_name" ]]; then
+            continue
+        fi
+        command_name_lc="$(to_lower "$command_name")"
+        command_desc_lc="$(to_lower "$command_desc")"
+        score=0
+        reason="base"
+
+        if [[ -n "$name_filter_lc" && "$command_name_lc" != *"$name_filter_lc"* ]]; then
+            continue
+        fi
+
+        if [[ -n "$uses_filter_lc" ]] && ! command_uses_skill "$command_file" "$USES_FILTER"; then
+            continue
+        fi
+
+        if [[ -n "$keyword_lc" ]]; then
+            if [[ "$command_name_lc" == "$keyword_lc" ]]; then
+                score=$((score + 300))
+                reason="exact-name"
+            elif [[ "$command_name_lc" == *"$keyword_lc"* || "$command_desc_lc" == *"$keyword_lc"* ]]; then
+                score=$((score + 200))
+                reason="frontmatter"
+            elif body_matches_keyword "$command_file" "$KEYWORD_FILTER"; then
+                score=$((score + 100))
+                reason="body"
+            else
+                continue
+            fi
+        fi
+
+        if [[ -z "$keyword_lc" ]]; then
+            score=50
+            reason="list"
+        fi
+
+        printf "%s|%s|%s|%s|%s\n" \
+            "$score" \
+            "$command_name" \
+            "$command_desc" \
+            "${command_file#$PROJECT_ROOT/}" \
+            "$reason" >> "$TEMP_FILE"
+    done
+
+    if [[ ! -s "$TEMP_FILE" ]]; then
+        echo "No matching commands found."
+        exit 1
+    fi
+
+    echo "Commands:"
+    sort -t'|' -k1,1nr -k2,2 "$TEMP_FILE" | head -n "$LIMIT" | while IFS='|' read -r score name desc path reason; do
+        printf -- "- %s [score=%s, match=%s]\n  %s\n  %s\n" "$name" "$score" "$reason" "$desc" "$path"
+    done
+}
+
+main "$@"
@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Generate skill and command catalog artifacts for fast navigation."""
+
+from __future__ import annotations
+
+import glob
+import os
+from collections import defaultdict
+from pathlib import Path
+
+import yaml
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+CATALOG_DIR = PROJECT_ROOT / "catalog"
+SKILLS_GLOB = PROJECT_ROOT / "skills" / "*" / "SKILL.md"
+COMMANDS_GLOB = PROJECT_ROOT / "commands" / "*.md"
+
+SKILL_OPTIONAL_FIELDS = [
+    "domain",
+    "job",
+    "stage",
+    "time_to_value",
+    "outputs",
+    "related_skills",
+    "aliases",
+]
+
+
+def read_frontmatter(path: Path) -> tuple[dict, str]:
+    text = path.read_text(encoding="utf-8")
+    if not text.startswith("---\n"):
+        return {}, text
+    parts = text.split("---", 2)
+    if len(parts) < 3:
+        return {}, text
+    data = yaml.safe_load(parts[1]) or {}
+    body = parts[2]
+    return data, body
+
+
+def load_skills() -> list[dict]:
+    skills: list[dict] = []
+    for raw_path in sorted(glob.glob(str(SKILLS_GLOB))):
+        path = Path(raw_path)
+        data, _ = read_frontmatter(path)
+        if not data:
+            continue
+
+        item = {
+            "name": data.get("name", ""),
+            "description": data.get("description", ""),
+            "type": data.get("type", ""),
+            "path": str(path.relative_to(PROJECT_ROOT)),
+        }
+        for key in SKILL_OPTIONAL_FIELDS:
+            if key in data:
+                item[key] = data[key]
+        skills.append(item)
+
+    skills.sort(key=lambda x: x["name"])
+    return skills
+
+
+def load_commands() -> list[dict]:
+    commands: list[dict] = []
+    for raw_path in sorted(glob.glob(str(COMMANDS_GLOB))):
+        path = Path(raw_path)
+        data, _ = read_frontmatter(path)
+        if not data:
+            continue
+
+        item = {
+            "name": data.get("name", path.stem),
+            "description": data.get("description", ""),
+            "argument_hint": data.get("argument-hint", ""),
+            "uses": data.get("uses", []),
+            "outputs": data.get("outputs", []),
+            "path": str(path.relative_to(PROJECT_ROOT)),
+        }
+        commands.append(item)
+
+    commands.sort(key=lambda x: x["name"])
+    return commands
+
+
+def write_yaml(path: Path, payload: dict) -> None:
+    path.write_text(yaml.safe_dump(payload, sort_keys=False, allow_unicode=False), encoding="utf-8")
+
+
+def write_skills_by_type_markdown(path: Path, skills: list[dict]) -> None:
+    grouped: dict[str, list[dict]] = defaultdict(list)
+    for skill in skills:
+        grouped[skill.get("type", "unknown")].append(skill)
+
+    lines: list[str] = []
+    lines.append("# Skills By Type")
+    lines.append("")
+    lines.append("Generated by `scripts/generate-catalog.py`. Do not edit manually.")
+    lines.append("")
+
+    for skill_type in ["component", "interactive", "workflow"]:
+        items = grouped.get(skill_type, [])
+        lines.append(f"## {skill_type.title()} ({len(items)})")
+        lines.append("")
+        for item in items:
+            lines.append(f"- `{item['name']}` - {item['description']}")
+            lines.append(f"  - `{item['path']}`")
+        lines.append("")
+
+    path.write_text("\n".join(lines).strip() + "\n", encoding="utf-8")
+
+
+def write_commands_markdown(path: Path, commands: list[dict]) -> None:
+    lines: list[str] = []
+    lines.append("# Commands Catalog")
+    lines.append("")
+    lines.append("Generated by `scripts/generate-catalog.py`. Do not edit manually.")
+    lines.append("")
+
+    for command in commands:
+        lines.append(f"## /{command['name']}")
+        lines.append("")
+        lines.append(f"- Description: {command['description']}")
+        lines.append(f"- Argument hint: `{command['argument_hint']}`")
+        lines.append(f"- Path: `{command['path']}`")
+        uses = command.get("uses", [])
+        outputs = command.get("outputs", [])
+        lines.append("- Uses:")
+        for skill_name in uses:
+            lines.append(f"  - `{skill_name}`")
+        lines.append("- Outputs:")
+        for output in outputs:
+            lines.append(f"  - {output}")
+        lines.append("")
+
+    path.write_text("\n".join(lines).strip() + "\n", encoding="utf-8")
+
+
+def main() -> int:
+    CATALOG_DIR.mkdir(parents=True, exist_ok=True)
+
+    skills = load_skills()
+    commands = load_commands()
+
+    write_yaml(
+        CATALOG_DIR / "skills-index.yaml",
+        {
+            "generated_from": "skills/*/SKILL.md",
+            "count": len(skills),
+            "skills": skills,
+        },
+    )
+    write_yaml(
+        CATALOG_DIR / "commands-index.yaml",
+        {
+            "generated_from": "commands/*.md",
+            "count": len(commands),
+            "commands": commands,
+        },
+    )
+
+    write_skills_by_type_markdown(CATALOG_DIR / "skills-by-type.md", skills)
+    write_commands_markdown(CATALOG_DIR / "commands.md", commands)
+
+    print(f"Generated catalog for {len(skills)} skills and {len(commands)} commands.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+#
+# run-pm.sh - Fast runner for PM skills and commands
+#
+# Usage:
+#   ./scripts/run-pm.sh skill prd-development "Create a PRD for ..."
+#   ./scripts/run-pm.sh command discover "Improve activation for SMBs"
+#   ./scripts/run-pm.sh command strategy "..." --agent claude
+#
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+AGENT="print"
+MODE=""
+TARGET=""
+INPUT=""
+
+print_help() {
+    cat <<EOF_HELP
+Usage: $0 <skill|command> <name> <input> [--agent print|claude|codex]
+
+Examples:
+  $0 skill prd-development "Create a PRD for mobile onboarding redesign"
+  $0 command discover "Reduce onboarding drop-off"
+  $0 command strategy "B2B analytics add-on" --agent claude
+
+Behavior:
+  - agent=print  Prints the generated prompt (default)
+  - agent=claude Runs: claude "<prompt>"
+  - agent=codex  Runs: codex "<prompt>"
+EOF_HELP
+}
+
+require_value() {
+    local option="$1"
+    local value="${2:-}"
+    if [[ -z "$value" || "$value" == -* ]]; then
+        echo "Error: Option '$option' requires a value." >&2
+        exit 1
+    fi
+}
+
+parse_args() {
+    if [[ $# -lt 3 ]]; then
+        print_help
+        exit 1
+    fi
+
+    MODE="$1"
+    TARGET="$2"
+    INPUT="$3"
+    shift 3
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --agent)
+                require_value "--agent" "${2:-}"
+                AGENT="$2"
+                shift 2
+                ;;
+            --help|-h)
+                print_help
+                exit 0
+                ;;
+            *)
+                echo "Error: Unknown option '$1'." >&2
+                print_help
+                exit 1
+                ;;
+        esac
+    done
+
+    if [[ "$MODE" != "skill" && "$MODE" != "command" ]]; then
+        echo "Error: Mode must be 'skill' or 'command'." >&2
+        exit 1
+    fi
+
+    if [[ "$AGENT" != "print" && "$AGENT" != "claude" && "$AGENT" != "codex" ]]; then
+        echo "Error: --agent must be one of: print, claude, codex." >&2
+        exit 1
+    fi
+}
+
+build_prompt() {
+    local path
+    if [[ "$MODE" == "skill" ]]; then
+        path="$PROJECT_ROOT/skills/$TARGET/SKILL.md"
+        if [[ ! -f "$path" ]]; then
+            echo "Error: Skill not found: $TARGET" >&2
+            exit 1
+        fi
+        printf "Using the skill at %s, help with: %s" "${path#$PROJECT_ROOT/}" "$INPUT"
+    else
+        path="$PROJECT_ROOT/commands/$TARGET.md"
+        if [[ ! -f "$path" ]]; then
+            echo "Error: Command not found: $TARGET" >&2
+            exit 1
+        fi
+        printf "Run the workflow command at %s for this request: %s" "${path#$PROJECT_ROOT/}" "$INPUT"
+    fi
+}
+
+run_prompt() {
+    local prompt="$1"
+
+    if [[ "$AGENT" == "print" ]]; then
+        echo "$prompt"
+        exit 0
+    fi
+
+    if [[ "$AGENT" == "claude" ]]; then
+        if ! command -v claude >/dev/null 2>&1; then
+            echo "Error: 'claude' command not found. Use --agent print or install Claude Code CLI." >&2
+            exit 1
+        fi
+        claude "$prompt"
+        exit 0
+    fi
+
+    if ! command -v codex >/dev/null 2>&1; then
+        echo "Error: 'codex' command not found. Use --agent print or install Codex CLI." >&2
+        exit 1
+    fi
+    codex "$prompt"
+}
+
+main() {
+    parse_args "$@"
+    PROMPT="$(build_prompt)"
+    run_prompt "$PROMPT"
+}
+
+main "$@"
@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+#
+# test-library.sh - Validate the full PM skills library surface.
+#
+# Runs:
+#   1) skill metadata checks
+#   2) command metadata/reference checks
+#   3) optional skill smoke tests
+#   4) catalog generation freshness check
+#
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+RUN_SMOKE=false
+
+print_help() {
+    cat <<EOF_HELP
+Usage: $0 [--smoke]
+
+Options:
+  --smoke   Run additional skill smoke tests via scripts/test-a-skill.sh --smoke
+  --help    Show this help
+EOF_HELP
+}
+
+parse_args() {
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --smoke)
+                RUN_SMOKE=true
+                shift
+                ;;
+            --help|-h)
+                print_help
+                exit 0
+                ;;
+            *)
+                echo "Error: Unknown option '$1'" >&2
+                print_help
+                exit 1
+                ;;
+        esac
+    done
+}
+
+main() {
+    parse_args "$@"
+    cd "$PROJECT_ROOT"
+
+    echo "[1/4] Validating skills"
+    python3 "$SCRIPT_DIR/check-skill-metadata.py"
+
+    echo "[2/4] Validating commands"
+    python3 "$SCRIPT_DIR/check-command-metadata.py"
+
+    if $RUN_SMOKE; then
+        echo "[3/4] Running skill smoke tests"
+        "$SCRIPT_DIR/test-a-skill.sh" --smoke
+    else
+        echo "[3/4] Skipping smoke tests (use --smoke to enable)"
+    fi
+
+    echo "[4/4] Regenerating catalogs"
+    python3 "$SCRIPT_DIR/generate-catalog.py"
+
+    echo "Library checks complete."
+}
+
+main "$@"