Add vision-driven continuous improvement to product-manager

Transforms the product-manager from a reactive backlog manager into a
vision-driven system with continuous improvement capabilities.

New components:
- vision-management skill: How to create, maintain, and evolve product vision
- /vision command: View, create, or update product vision (syncs to Gitea)
- /improve command: Identify gaps between vision goals and backlog

Enhanced existing components:
- product-manager agent: Now vision-aware with strategic prioritization
- /retro command: Connects learnings back to vision updates
- /plan-issues command: Shows vision alignment for planned work

The vision lives in two places: vision.md (source of truth) and a Gitea
issue labeled "vision" for integration with the issue workflow.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

agents/product-manager/AGENT.md

@@ -1,25 +1,59 @@
 ---
 name: product-manager
-description: Backlog management and roadmap planning specialist. Use for batch issue operations, comprehensive backlog reviews, or feature planning that requires codebase exploration.
+description: Vision-driven product management with continuous improvement. Use for backlog management, roadmap planning, vision alignment, or identifying improvement opportunities.
 # Model: sonnet handles planning and issue-writing well.
 # Tasks follow structured patterns from skills; opus not required.
 model: sonnet
-skills: gitea, issue-writing, backlog-grooming, roadmap-planning
+skills: gitea, issue-writing, backlog-grooming, roadmap-planning, vision-management
 ---
 
-You are a product manager specializing in backlog management and roadmap planning.
+You are a product manager specializing in vision-driven continuous improvement.
 
 ## Capabilities
 
 You can:
+- Create and maintain product vision (`vision.md`)
+- Align issues and features with vision goals
 - Review and improve existing issues
 - Create new well-structured issues
 - Analyze the backlog for gaps and priorities
-- Plan feature breakdowns
+- Plan feature breakdowns with vision context
-- Maintain roadmap clarity
+- Identify improvement opportunities
+- Connect retrospective learnings to vision refinement
+
+## Vision-First Approach
+
+When working on any task:
+
+1. **Check for vision**: Look for `vision.md` in the repo root
+2. **Reference goals**: Align work with vision goals when relevant
+3. **Identify gaps**: Note when vision goals lack supporting issues
+4. **Suggest updates**: Recommend vision changes based on learnings
+
+## Strategic Prioritization
+
+When reviewing or creating issues:
+
+- Score issues by vision alignment (high/medium/low/none)
+- Prioritize issues supporting current focus goals
+- Flag issues that don't align with any goal
+- Suggest re-prioritization when focus shifts
+
+## Improvement Suggestions
+
+Proactively identify:
+
+- Vision goals with no supporting issues
+- Stalled goals (no recent progress)
+- Orphan issues (don't support any goal)
+- Potential non-goals based on patterns
+
+Always present suggestions for user approval.
 
 ## Behavior
 
+- Read `vision.md` at the start of vision-related tasks
 - Always fetch current issue state before making changes
 - Ask for approval before creating or modifying issues
 - Provide clear summaries of actions taken
+- Keep vision issue in Gitea synced with `vision.md`

commands/improve.md

@@ -0,0 +1,82 @@
+---
+description: Identify improvement opportunities based on product vision. Analyzes gaps between vision goals and current backlog.
+---
+
+# Improvement Analysis
+
+@~/.claude/skills/vision-management/SKILL.md
+@~/.claude/skills/gitea/SKILL.md
+@~/.claude/skills/issue-writing/SKILL.md
+@~/.claude/skills/roadmap-planning/SKILL.md
+
+## Process
+
+1. **Read the vision**: Load `vision.md` from the repo root.
+   - If no vision exists, suggest running `/vision` first
+
+2. **Fetch current backlog**: Get all open issues from Gitea using `tea issues`
+
+3. **Analyze alignment**:
+
+   For each vision goal, check:
+   - Are there issues supporting this goal?
+   - Is there recent activity/progress?
+   - Are issues blocked or stalled?
+
+   For each open issue, check:
+   - Does it align with a vision goal?
+   - Is it supporting the current focus?
+
+4. **Identify gaps and opportunities**:
+
+   - **Unsupported goals**: Vision goals with no issues
+   - **Stalled goals**: Goals with issues but no recent progress
+   - **Orphan issues**: Issues that don't support any goal
+   - **Focus misalignment**: Issues not aligned with current focus getting priority
+   - **Missing non-goals**: Patterns suggesting things we should explicitly avoid
+
+5. **Present findings**:
+
+   ```
+   ## Vision Alignment Report
+
+   ### Goals Coverage
+   - Goal 1: [status] - N issues, [progress]
+   - Goal 2: [status] - N issues, [progress]
+
+   ### Gaps Identified
+   1. [Gap description]
+      Suggestion: [concrete action]
+
+   2. [Gap description]
+      Suggestion: [concrete action]
+
+   ### Orphan Issues
+   - #N: [title] - No goal alignment
+
+   ### Recommended Actions
+   1. [Action with rationale]
+   2. [Action with rationale]
+   ```
+
+6. **Offer to take action**:
+
+   For unsupported goals:
+   - Ask if user wants to plan issues for the gap
+   - If yes, run the `/plan-issues` workflow for that goal
+   - This breaks down the goal into concrete, actionable issues
+
+   For other findings:
+   - Re-prioritize issues based on focus
+   - Close or re-scope orphan issues
+   - Update vision with suggested changes
+
+   Always ask for approval before making changes.
+
+## Guidelines
+
+- Focus on actionable improvements, not just observations
+- Prioritize suggestions by impact on vision goals
+- Keep suggestions specific and concrete
+- One issue per improvement (don't bundle)
+- Reference specific goals when suggesting new issues

commands/plan-issues.md

@@ -1,5 +1,5 @@
 ---
-description: Plan and create issues for a feature or improvement. Breaks down work into well-structured issues.
+description: Plan and create issues for a feature or improvement. Breaks down work into well-structured issues with vision alignment.
 argument-hint: <feature-description>
 ---
 
@@ -8,29 +8,41 @@ argument-hint: <feature-description>
 @~/.claude/skills/gitea/SKILL.md
 @~/.claude/skills/roadmap-planning/SKILL.md
 @~/.claude/skills/issue-writing/SKILL.md
+@~/.claude/skills/vision-management/SKILL.md
 
-1. **Understand the feature**: Analyze what "$1" involves
+1. **Check vision context**: If `vision.md` exists, read it to understand current goals and focus
-2. **Explore the codebase** if needed to understand context
+2. **Understand the feature**: Analyze what "$1" involves
-3. **Break down** into discrete, actionable issues:
+3. **Explore the codebase** if needed to understand context
+4. **Break down** into discrete, actionable issues:
    - Each issue should be independently completable
    - Clear dependencies between issues
    - Appropriate scope (not too big, not too small)
 
-4. **Present the plan**:
+5. **Present the plan** (include vision alignment if vision exists):
    ```
    ## Proposed Issues for: $1
 
+   Vision Alignment: Supports [Goal N: description]
+
    1. [Title] - Brief description
       Dependencies: none
+      Supports: Goal N
 
    2. [Title] - Brief description
       Dependencies: #1
+      Supports: Goal N
 
    3. [Title] - Brief description
       Dependencies: #1, #2
+      Supports: Goal N
    ```
 
-5. **Ask for approval** before creating issues
+   If the feature doesn't align with any vision goal, note this and ask if:
-6. **Create issues** in order
+   - The vision should be updated to include this as a goal
-7. **Update dependencies** with actual issue numbers after creation
+   - This should be added as a non-goal
-8. **Present summary** with links to created issues
+   - Proceed anyway (with justification)
+
+6. **Ask for approval** before creating issues
+7. **Create issues** in order
+8. **Update dependencies** with actual issue numbers after creation
+9. **Present summary** with links to created issues

commands/retro.md

@@ -1,11 +1,13 @@
 ---
-description: Run a retrospective on completed work. Captures learnings and creates improvement issues in the AI repo.
+description: Run a retrospective on completed work. Captures learnings, creates improvement issues, and updates product vision.
 argument-hint: [task-description]
 ---
 
 # Retrospective
 
-Capture learnings from completed AI-assisted work to improve the workflow.
+Capture learnings from completed AI-assisted work to improve the workflow and refine the product vision.
+
+@~/.claude/skills/vision-management/SKILL.md
 
 ## Process
 
@@ -22,7 +24,18 @@ Capture learnings from completed AI-assisted work to improve the workflow.
    - **Tool issues**: Problems with tea CLI, git, or other tools
    - **Context gaps**: Missing documentation or skills
 
-4. **Generate improvement issues**: For each actionable improvement, create an issue in the AI repo using:
+4. **Connect to vision** (if `vision.md` exists in the target repo):
+   - Did this work make progress on any vision goals?
+   - Did learnings reveal new priorities that should become goals?
+   - Did we discover something that should be a non-goal?
+   - Should the current focus shift based on what we learned?
+
+   If any vision updates are needed:
+   - Present suggested changes to `vision.md`
+   - Ask for approval
+   - Update the vision file and sync to Gitea
+
+5. **Generate improvement issues**: For each actionable improvement, create an issue in the AI repo using:
 
 ```bash
 tea issues create -r flowmade-one/ai --title "<title>" --description "<body>"

commands/vision.md

@@ -0,0 +1,72 @@
+---
+description: View, create, or update the product vision. Manages vision.md and syncs to Gitea.
+argument-hint: [update|goals|focus]
+---
+
+# Product Vision
+
+@~/.claude/skills/vision-management/SKILL.md
+@~/.claude/skills/gitea/SKILL.md
+
+## Process
+
+1. **Check for existing vision**: Look for `vision.md` in the current repo root.
+
+2. **If no vision exists**:
+   - Ask the user if they want to create one
+   - Guide them through:
+     - Purpose: Why does this product exist?
+     - Goals: 3-5 measurable outcomes with success metrics
+     - Current focus: Which 1-2 goals are priorities now?
+     - Non-goals: What are you explicitly NOT doing?
+   - Create `vision.md` with the vision document structure
+   - Create a Gitea issue labeled `vision` with the same content
+
+3. **If vision exists**:
+   - Display the current vision
+   - Check if $1 specifies an action:
+     - `update`: General update to the vision
+     - `goals`: Add, modify, or complete goals
+     - `focus`: Change the current focus area
+   - If no action specified, ask what the user wants to do:
+     - View only (done)
+     - Update goals
+     - Change focus
+     - Update progress
+     - Add non-goals
+   - Make the requested changes
+   - Update `vision.md`
+   - Sync changes to the Gitea vision issue
+
+4. **Sync to Gitea**:
+   - Find existing issue with `vision` label: `tea issues -l vision`
+   - If exists: Update the issue description
+   - If not: Create new issue with `vision` label
+
+## Output Format
+
+When displaying the vision, show it clearly:
+
+```
+## Current Vision
+
+**Purpose**: [purpose]
+
+**Goals**:
+1. [Goal] - [Metric] [Progress indicator]
+2. [Goal] - [Metric] [Progress indicator]
+
+**Current Focus**: [focus area]
+
+**Non-Goals**: [list]
+
+**Last Updated**: [date]
+```
+
+## Guidelines
+
+- Keep goals specific and measurable
+- Limit to 3-5 active goals
+- Current focus should be 1-2 goals max
+- Update "Last Updated" on every change
+- Always sync to Gitea after changes

skills/vision-management/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: vision-management
+description: Create, maintain, and evolve a product vision. Use when initializing a vision, updating goals, aligning work with vision, or connecting learnings to vision refinement.
+---
+
+# Vision Management
+
+How to create, maintain, and evolve a product vision for continuous improvement.
+
+## Vision Document Location
+
+The vision lives in two places:
+
+1. **`vision.md`** at repo root - Source of truth, versionable
+2. **Gitea issue** labeled `vision` - Integrates with issue workflow
+
+Keep these in sync. The file is authoritative; the issue mirrors it.
+
+## Vision Document Structure
+
+```markdown
+# Product Vision
+
+## Purpose
+Why this product exists. The problem it solves.
+
+## Goals
+1. [Goal 1] - [Success metric]
+2. [Goal 2] - [Success metric]
+3. [Goal 3] - [Success metric]
+
+## Current Focus
+What we're prioritizing now and why.
+
+## Non-Goals
+What we're explicitly NOT doing.
+
+## Progress
+- [Goal 1]: [Status/progress]
+- [Goal 2]: [Status/progress]
+
+## Last Updated
+[Date] - [What changed]
+```
+
+## Creating a Vision
+
+When no vision exists:
+
+1. **Identify the purpose**: What problem does this product solve? Who benefits?
+2. **Define 3-5 goals**: Concrete, measurable outcomes
+3. **Set success metrics**: How will you know each goal is achieved?
+4. **Choose current focus**: Which 1-2 goals are priorities right now?
+5. **Document non-goals**: What are you explicitly NOT doing?
+
+### Good Goals
+
+- Specific and measurable
+- Outcome-focused (not activity-focused)
+- Have clear success criteria
+
+| Bad | Good |
+|-----|------|
+| "Improve performance" | "Page load under 2 seconds" |
+| "Better UX" | "User can complete checkout in under 60 seconds" |
+| "More features" | "Support 3 export formats (CSV, JSON, PDF)" |
+
+## Updating the Vision
+
+Update the vision when:
+
+- A goal is achieved (update progress, possibly add new goal)
+- Learnings from retros reveal new priorities
+- Strategic direction changes
+- A non-goal becomes a goal (or vice versa)
+
+### Update Process
+
+1. Read current vision
+2. Identify what needs to change
+3. Draft the update
+4. Present changes for approval
+5. Update `vision.md`
+6. Sync to Gitea issue
+
+## Aligning Issues with Vision
+
+When creating or reviewing issues:
+
+1. **Check goal alignment**: Does this issue support a vision goal?
+2. **Tag appropriately**: Reference the goal in the issue description
+3. **Prioritize by vision**: Issues supporting current focus get priority
+4. **Flag misalignment**: Issues that don't align with any goal need justification
+
+### Alignment Check Template
+
+```markdown
+## Vision Alignment
+Supports: Goal 2 (Security)
+Priority: High (current focus area)
+```
+
+### Identifying Gaps
+
+Compare vision goals to current backlog:
+
+- Which goals have no supporting issues?
+- Which goals have stalled (no recent progress)?
+- Are there issues that don't align with any goal?
+
+## Connecting Retros to Vision
+
+After a retrospective:
+
+1. **Review learnings**: Any that affect the vision?
+2. **Goal changes**: Should any goals be added, removed, or modified?
+3. **Non-goal additions**: Did we learn something we should explicitly avoid?
+4. **Progress updates**: Did completed work advance any goals?
+
+### Retro-to-Vision Questions
+
+- "Did this work reveal a new priority we should add as a goal?"
+- "Did we learn something that should become a non-goal?"
+- "Should our current focus shift based on what we learned?"
+- "Did this work make progress on any goals?"
+
+## Vision Issue in Gitea
+
+Create/update a Gitea issue that mirrors the vision:
+
+```bash
+# Create vision issue
+tea issues create --title "Product Vision" --description "$(cat vision.md)" --labels "vision"
+
+# Update existing vision issue
+tea issues edit <issue-number> --description "$(cat vision.md)"
+```
+
+Benefits of the vision issue:
+- Other issues can reference it (`Supports #N`)
+- Visible in backlog alongside work items
+- Provides discussion space for vision questions
+
+## Continuous Improvement Loop
+
+```
+Vision → Issues → Work → Retro → Vision (updated)
+```
+
+1. **Vision** defines what success looks like
+2. **Issues** are created to achieve vision goals
+3. **Work** implements the issues
+4. **Retros** capture learnings from the work
+5. **Vision updates** incorporate learnings (loop continues)
+
+The vision is a living document that evolves as you learn.