Prepare for repo rename: ai -> architecture

Updated all internal references for the rename:
- CLAUDE.md: New purpose statement, updated structure, added manifesto info
- README.md: Updated title, clone URL, folder structure
- commands/retro.md: Changed flowmade-one/ai to flowmade-one/architecture

The actual Gitea rename should be done after merging this PR.

Closes #44

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

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

CLAUDE.md

@@ -1,23 +1,37 @@
-# Claude Code AI Workflow
+# Architecture
 
-This repository contains configurations, prompts, and tools to improve the Claude Code AI workflow.
+This repository is the organizational source of truth: how we work, who we serve, what we believe, and how we build software with AI.
 
 ## Setup
 
 ```bash
 # Clone and install symlinks
-git clone ssh://git@code.flowmade.one/flowmade-one/ai.git
-cd ai
+git clone ssh://git@code.flowmade.one/flowmade-one/architecture.git
+cd architecture
 make install
 ```
 
+## What This Repo Contains
+
+| Component | Purpose |
+|-----------|---------|
+| `manifesto.md` | Organization vision, personas, beliefs, principles |
+| `learnings/` | Historical record and governance |
+| `commands/` | AI workflow entry points (/work-issue, /manifesto, etc.) |
+| `skills/` | Tool and practice knowledge |
+| `agents/` | Focused subtask handlers |
+| `settings.json` | Claude Code configuration |
+| `Makefile` | Install symlinks to ~/.claude/ |
+
 ## Project Structure
 
 ```
-ai/
+architecture/
+├── manifesto.md    # Organization vision and beliefs
+├── learnings/      # Captured learnings and governance
 ├── commands/       # Slash commands (/work-issue, /dashboard)
-├── skills/         # Auto-triggered capabilities
-├── agents/         # Subagents with isolated context
+├── skills/         # Knowledge modules (auto-triggered)
+├── agents/         # Focused subtask handlers (isolated context)
 ├── scripts/        # Hook scripts (pre-commit, token loading)
 ├── settings.json   # Claude Code settings
 └── Makefile        # Install/uninstall symlinks
@@ -25,6 +39,29 @@ ai/
 
 All files symlink to `~/.claude/` via `make install`.
 
+## Two Levels of Vision
+
+| Level | Document | Command | Purpose |
+|-------|----------|---------|---------|
+| Organization | `manifesto.md` | `/manifesto` | Who we are, shared personas, beliefs |
+| Product | `vision.md` | `/vision` | Product-specific direction and goals |
+
+See the manifesto for our identity, personas, and beliefs about AI-augmented development.
+
+## Available Commands
+
+| Command | Description |
+|---------|-------------|
+| `/manifesto` | View/manage organization manifesto |
+| `/vision` | View/manage product vision and milestones |
+| `/work-issue <n>` | Fetch issue, create branch, implement, create PR |
+| `/dashboard` | Show open issues and PRs |
+| `/review-pr <n>` | Review PR with diff and comments |
+| `/create-issue` | Create single or batch issues |
+| `/retro` | Capture learnings as issues for encoding |
+| `/plan-issues` | Break down features into issues |
+| `/groom` | Improve issue quality |
+
 ## Gitea Integration
 
 Uses `tea` CLI for issue/PR management:
@@ -37,16 +74,32 @@ tea logins add --name flowmade --url https://git.flowmade.one --token <your-toke
 # Create token at: https://git.flowmade.one/user/settings/applications
 ```
 
-### Available Commands
+## Architecture Components
 
-| Command | Description |
-|---------|-------------|
-| `/work-issue <n>` | Fetch issue, create branch, implement, create PR |
-| `/dashboard` | Show open issues and PRs |
-| `/review-pr <n>` | Review PR with diff and comments |
-| `/create-issue` | Create single or batch issues |
-| `/retro` | Capture learnings from completed work, create improvement issues |
+### Skills
+Knowledge modules that teach Claude how to do something.
 
-## Usage
+- **Purpose**: Encode best practices and tool knowledge
+- **Location**: `skills/<name>/SKILL.md`
+- **Usage**: Referenced by commands via `@~/.claude/skills/xxx/SKILL.md`
 
-This project is meant to be used alongside Claude Code to enhance productivity and maintain consistent workflows.
+### Commands
+User-facing entry points invoked with `/command-name`.
+
+- **Purpose**: Orchestrate workflows with user interaction
+- **Location**: `commands/<name>.md`
+- **Usage**: User types `/dashboard`, `/work-issue 42`, etc.
+
+### Agents
+Focused units that handle specific subtasks in isolated context.
+
+- **Purpose**: Complex subtasks that benefit from isolation
+- **Location**: `agents/<name>/agent.md`
+- **Usage**: Spawned via Task tool, return results to caller
+
+### Learnings
+Captured insights from work, encoded into skills/commands/agents.
+
+- **Purpose**: Historical record + governance + continuous improvement
+- **Location**: `learnings/YYYY-MM-DD-title.md`
+- **Flow**: Retro → Issue → Encode into learning + system update

README.md

@@ -1,4 +1,6 @@
-# Claude Code AI Workflow
+# Architecture
+
+The organizational source of truth: how we work, who we serve, what we believe, and how we build software with AI.
 
 A composable toolkit for enhancing [Claude Code](https://claude.ai/claude-code) with structured workflows, issue management, and AI-assisted development practices.
 
@@ -53,8 +55,8 @@ The project is built around three composable component types:
 
 ```bash
 # Clone the repository
-git clone ssh://git@code.flowmade.one/flowmade-one/ai.git
-cd ai
+git clone ssh://git@code.flowmade.one/flowmade-one/architecture.git
+cd architecture
 
 # Install symlinks to ~/.claude/
 make install
@@ -87,7 +89,9 @@ echo "YOUR_TOKEN" | tea -H code.flowmade.one auth add-key username
 ## Project Structure
 
 ```
-ai/
+architecture/
+├── manifesto.md        # Organization vision, personas, beliefs
+├── learnings/          # Captured learnings and governance
 ├── commands/           # Slash commands invoked by users
 │   ├── work-issue.md
 │   ├── dashboard.md

VISION.md

@@ -36,14 +36,21 @@ Skills don't do anything on their own. They're building blocks.
 
 ### Agents
 
-Agents combine multiple skills into specialized personas that can work autonomously.
+Agents are small, focused units that handle specific subtasks in isolated context.
 
-The `product-manager` agent combines issue-writing, backlog-grooming, and roadmap-planning skills to handle complex PM tasks. It can explore the codebase, plan features, and create well-structured issues—all with isolated context so it doesn't pollute the main conversation.
+Unlike commands (which run in the main conversation), agents are spawned via the Task tool to do a specific job and report back. They should be:
+- **Small and focused**: One clear responsibility
+- **Isolated**: Work without needing conversation history
+- **Result-oriented**: Return a specific output (analysis, categorization, generated content)
+
+Examples:
+- `code-reviewer`: Reviews a PR diff and reports issues
+- A hypothetical `categorize-milestone`: Given an issue, determines which milestone it belongs to
 
 Agents enable:
 - **Parallel processing**: Multiple agents can work simultaneously
-- **Context preservation**: Each agent maintains its own focused context
-- **Complex workflows**: Combine skills for multi-step tasks
+- **Context isolation**: Complex subtasks don't pollute the main conversation
+- **Reusability**: Same agent can be spawned by different commands
 
 ### Commands
 
@@ -51,11 +58,12 @@ Commands are the user-facing entry points—what you actually invoke.
 
 When you run `/plan-issues add dark mode`, the command:
 1. Understands what you're asking for
-2. Invokes the right agents and skills
-3. Guides you through the workflow with approvals
-4. Takes action (creates issues, PRs, etc.)
+2. References skills for knowledge (how to write issues, use Gitea, etc.)
+3. Optionally spawns agents for complex subtasks
+4. Guides you through the workflow with approvals
+5. Takes action (creates issues, PRs, etc.)
 
-Commands make the power of skills and agents accessible through simple invocations.
+Commands run in the main conversation context, using skills for knowledge and spawning agents only when isolated processing is beneficial.
 
 ## Target Users
 

agents/product-manager/AGENT.md

@@ -1,25 +0,0 @@
----
-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.
-# 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
----
-
-You are a product manager specializing in backlog management and roadmap planning.
-
-## Capabilities
-
-You can:
-- Review and improve existing issues
-- Create new well-structured issues
-- Analyze the backlog for gaps and priorities
-- Plan feature breakdowns
-- Maintain roadmap clarity
-
-## Behavior
-
-- Always fetch current issue state before making changes
-- Ask for approval before creating or modifying issues
-- Provide clear summaries of actions taken

commands/create-issue.md

@@ -7,13 +7,37 @@ argument-hint: [title] or "batch"
 
 @~/.claude/skills/gitea/SKILL.md
 
+## Milestone Assignment
+
+Before creating issues, fetch available milestones:
+
+```bash
+tea milestones -f title,description
+```
+
+For each issue, automatically assign to the most relevant milestone by matching:
+- Issue content/problem area → Milestone title and description
+- If no clear match, ask the user which milestone (goal) the issue supports
+- If no milestones exist, skip milestone assignment
+
+Include `--milestone "<milestone>"` in the create command when a milestone is assigned.
+
 ## Single Issue (default)
-If title provided, create an issue with that title and ask for description.
+
+If title provided:
+1. Create an issue with that title
+2. Ask for description
+3. Assign to appropriate milestone (see above)
+4. Ask if this issue depends on any existing issues
+5. If dependencies exist, link them: `tea issues deps add <new-issue> <blocker>`
 
 ## Batch Mode
+
 If $1 is "batch":
 1. Ask user for the plan/direction
-2. Generate list of issues with titles and descriptions
-3. Show for approval
-4. Create each issue
-5. Display all created issue numbers
+2. Fetch available milestones
+3. Generate list of issues with titles, descriptions, milestone assignments, and dependencies
+4. Show for approval
+5. Create each issue with milestone (in dependency order)
+6. Link dependencies between created issues: `tea issues deps add <issue> <blocker>`
+7. Display all created issue numbers with dependency graph

commands/groom.md

@@ -11,23 +11,27 @@ argument-hint: [issue-number]
 
 ## If issue number provided ($1):
 
-1. **Fetch the issue** details
-2. **Evaluate** against grooming checklist
-3. **Suggest improvements** for:
+1. **Fetch the issue** details with `tea issues <number> --comments`
+2. **Check dependencies** with `tea issues deps list <number>`
+3. **Evaluate** against grooming checklist
+4. **Suggest improvements** for:
    - Title clarity
    - Description completeness
    - Acceptance criteria quality
    - Scope definition
-4. **Ask user** if they want to apply changes
-5. **Update issue** if approved
+   - Missing or incorrect dependencies
+5. **Ask user** if they want to apply changes
+6. **Update issue** if approved
+7. **Link/unlink dependencies** if needed: `tea issues deps add/remove <issue> <dep>`
 
 ## If no argument (groom all):
 
 1. **List open issues**
-2. **Review each** against grooming checklist
+2. **Review each** against grooming checklist (including dependencies)
 3. **Categorize**:
-   - Ready: Well-defined, can start work
-   - Needs work: Missing info or unclear
+   - Ready: Well-defined, dependencies linked, can start work
+   - Blocked: Has unresolved dependencies
+   - Needs work: Missing info, unclear, or missing dependency links
    - Stale: No longer relevant
-4. **Present summary** table
-5. **Offer to improve** issues that need work
+4. **Present summary** table with dependency status
+5. **Offer to improve** issues that need work (including linking dependencies)

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/manifesto.md

@@ -0,0 +1,71 @@
+---
+description: View and manage the organization manifesto. Shows identity, personas, beliefs, and principles.
+---
+
+# Organization Manifesto
+
+@~/.claude/skills/vision-management/SKILL.md
+
+The manifesto defines the organization-level vision: who we are, who we serve, what we believe, and how we work. It is distinct from product-level vision (see `/vision`).
+
+## Process
+
+1. **Check for manifesto**: Look for `manifesto.md` in the current repo root.
+
+2. **If no manifesto exists**:
+   - Ask if the user wants to create one
+   - Guide through defining:
+     1. **Who We Are**: Organization identity
+     2. **Who We Serve**: 2-4 specific personas with context and constraints
+     3. **What They're Trying to Achieve**: Jobs to be done in their voice
+     4. **What We Believe**: Core beliefs including stance on AI-augmented development
+     5. **Guiding Principles**: Decision-making rules
+     6. **Non-Goals**: What we explicitly don't do
+   - Create `manifesto.md`
+
+3. **If manifesto exists**:
+   - Display formatted summary of the manifesto
+
+## Output Format
+
+When displaying an existing manifesto:
+
+```
+## Who We Are
+
+[Identity summary from manifesto]
+
+## Who We Serve
+
+- **[Persona 1]**: [Brief description]
+- **[Persona 2]**: [Brief description]
+- **[Persona 3]**: [Brief description]
+
+## What They're Trying to Achieve
+
+- "[Job to be done 1]"
+- "[Job to be done 2]"
+- "[Job to be done 3]"
+
+## What We Believe
+
+[Summary of key beliefs - especially AI-augmented development stance]
+
+## Guiding Principles
+
+1. [Principle 1]
+2. [Principle 2]
+3. [Principle 3]
+
+## Non-Goals
+
+- [Non-goal 1]
+- [Non-goal 2]
+```
+
+## Guidelines
+
+- The manifesto is the **organization-level** document - it applies across all products
+- Update rarely - this is foundational identity, not tactical direction
+- Product repos reference the manifesto but have their own `vision.md`
+- Use `/vision` for product-level vision management

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,18 +8,26 @@ 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
-2. **Explore the codebase** if needed to understand context
-3. **Break down** into discrete, actionable issues:
+1. **Check vision context**: If `vision.md` exists, read it to understand personas, jobs to be done, and goals
+2. **Identify persona**: Which persona does "$1" serve?
+3. **Identify job**: Which job to be done does this enable?
+4. **Understand the feature**: Analyze what "$1" involves
+5. **Explore the codebase** if needed to understand context
+6. **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**:
+7. **Present the plan** (include vision alignment if vision exists):
    ```
    ## Proposed Issues for: $1
 
+   For: [Persona name]
+   Job: "[Job to be done this enables]"
+   Supports: [Milestone/Goal name]
+
    1. [Title] - Brief description
       Dependencies: none
 
@@ -30,7 +38,13 @@ argument-hint: <feature-description>
       Dependencies: #1, #2
    ```
 
-5. **Ask for approval** before creating issues
-6. **Create issues** in order
-7. **Update dependencies** with actual issue numbers after creation
-8. **Present summary** with links to created issues
+   If the feature doesn't align with any persona/job/goal, note this and ask if:
+   - A new persona or job should be added to the vision
+   - A new milestone should be created
+   - This should be added as a non-goal
+   - Proceed anyway (with justification)
+
+8. **Ask for approval** before creating issues
+9. **Create issues** in dependency order (blockers first)
+10. **Link dependencies** using `tea issues deps add <issue> <blocker>` for each dependency
+11. **Present summary** with links to created issues and dependency graph

commands/retro.md

@@ -1,11 +1,22 @@
 ---
-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 insights as issues for later encoding into skills/commands/agents.
 argument-hint: [task-description]
 ---
 
 # Retrospective
 
-Capture learnings from completed AI-assisted work to improve the workflow.
+Capture insights from completed work as issues on the architecture repo. Issues are later encoded into learnings and skills/commands/agents.
+
+@~/.claude/skills/vision-management/SKILL.md
+@~/.claude/skills/gitea/SKILL.md
+
+## Flow
+
+```
+Retro (any repo) → Issue (architecture repo) → Encode: learning file + skill/command/agent
+```
+
+The retro creates the issue. Encoding happens when the issue is worked on.
 
 ## Process
 
@@ -16,49 +27,90 @@ Capture learnings from completed AI-assisted work to improve the workflow.
    - What worked well?
    - Any specific improvement ideas?
 
-3. **Analyze and categorize**: Group learnings into:
-   - **Prompt improvements**: Better instructions for commands/skills
-   - **Missing capabilities**: New commands or skills needed
-   - **Tool issues**: Problems with tea CLI, git, or other tools
-   - **Context gaps**: Missing documentation or skills
+3. **Identify insights**: For each insight, determine:
+   - **What was learned**: The specific insight
+   - **Where to encode it**: Which skill, command, or agent should change?
+   - **Governance impact**: What does this mean for how we work?
 
-4. **Generate improvement issues**: For each actionable improvement, create an issue in the AI repo using:
+4. **Create issue on architecture repo**: Always create issues on `flowmade-one/architecture`:
 
    ```bash
-tea issues create -r flowmade-one/ai --title "<title>" --description "<body>"
+   tea issues create -r flowmade-one/architecture \
+     --title "[Learning] <brief description>" \
+     --description "## Context
+   [Task that triggered this insight]
+
+   ## Insight
+   [The specific learning - be concrete and actionable]
+
+   ## Suggested Encoding
+   - [ ] \`skills/xxx/SKILL.md\` - [what to add/change]
+   - [ ] \`commands/xxx.md\` - [what to add/change]
+   - [ ] \`agents/xxx/agent.md\` - [what to add/change]
+
+   ## Governance
+   [What this means for how we work going forward]"
    ```
 
-## Issue Format
+5. **Connect to vision**: Check if insight affects vision:
+   - **Architecture repo**: Does this affect `manifesto.md`? (beliefs, principles, non-goals)
+   - **Product repo**: Does this affect `vision.md`? (product direction, goals)
 
-Use this structure for retrospective issues:
+   If vision updates are needed, present suggested changes and ask for approval.
+
+## When the Issue is Worked On
+
+When encoding a learning issue, the implementer should:
+
+1. **Create learning file**: `learnings/YYYY-MM-DD-short-title.md`
 
    ```markdown
-## Context
-What task triggered this learning (brief).
+   # [Learning Title]
 
-## Problem / Observation
-What was the friction point or insight.
+   **Date**: YYYY-MM-DD
+   **Context**: [Task that triggered this learning]
+   **Issue**: #XX
 
-## Suggested Improvement
-Concrete, actionable change to make.
+   ## Learning
 
-## Affected Files
-- commands/xxx.md
-- skills/xxx/SKILL.md
+   [The specific insight]
+
+   ## Encoded In
+
+   - `skills/xxx/SKILL.md` - [what was added/changed]
+   - `commands/xxx.md` - [what was added/changed]
+
+   ## Governance
+
+   [What this means for how we work]
    ```
 
+2. **Update skill/command/agent** with the encoded knowledge
+
+3. **Close the issue** with reference to the learning file and changes made
+
+## Encoding Destinations
+
+| Insight Type | Encode In |
+|--------------|-----------|
+| How to use a tool | `skills/[tool]/SKILL.md` |
+| Workflow improvement | `commands/[command].md` |
+| Subtask behavior | `agents/[agent]/agent.md` |
+| Organization belief | `manifesto.md` |
+| Product direction | `vision.md` (in product repo) |
+
 ## Labels
 
-Add appropriate labels:
-- `retrospective` - Always add this
+Add appropriate labels to issues:
+- `learning` - Always add this
 - `prompt-improvement` - For command/skill text changes
-- `new-feature` - For new commands/skills
+- `new-feature` - For new commands/skills/agents
 - `bug` - For things that are broken
 
 ## Guidelines
 
-- Be specific and actionable - vague issues won't get fixed
-- One issue per improvement (don't bundle unrelated things)
-- Reference specific commands/skills when relevant
-- Keep issues small and focused
-- Skip creating issues for one-off edge cases that won't recur
+- **Always create issues on architecture repo** - regardless of which repo the retro runs in
+- **Be specific**: Vague insights can't be encoded
+- **One issue per insight**: Don't bundle unrelated things
+- **Encoding happens later**: Retro captures the issue, encoding is separate work
+- **Skip one-offs**: Don't capture insights for edge cases that won't recur

commands/review-pr.md

@@ -7,7 +7,7 @@ argument-hint: <pr-number>
 
 @~/.claude/skills/gitea/SKILL.md
 
-1. **View PR details** including description and metadata
+1. **View PR details** with `--comments` flag to see description, metadata, and discussion
 2. **Get the diff** to review the changes
 
 Review the changes and provide feedback on:
@@ -20,3 +20,19 @@ Ask the user what action to take:
 - **Merge**: Post review summary as comment, then merge with rebase style
 - **Request changes**: Leave feedback without merging
 - **Comment only**: Add a comment for discussion
+
+## Merging
+
+Always use tea CLI for merges to preserve user attribution:
+
+```bash
+tea pulls merge <number> --style rebase
+```
+
+For review comments, use `tea comment` since `tea pulls review` is interactive-only:
+
+```bash
+tea comment <number> "<review summary>"
+```
+
+> **Warning**: Never use the Gitea API with admin credentials for user-facing operations like merging. This causes the merge to be attributed to the admin account instead of the user.

commands/vision.md

@@ -0,0 +1,110 @@
+---
+description: View the product vision and goal progress. Manages vision.md and Gitea milestones.
+argument-hint: [goals]
+---
+
+# Product Vision
+
+@~/.claude/skills/vision-management/SKILL.md
+@~/.claude/skills/gitea/SKILL.md
+
+This command manages **product-level** vision. For organization-level vision, use `/manifesto`.
+
+## Architecture
+
+| Level | Document | Purpose | Command |
+|-------|----------|---------|---------|
+| **Organization** | `manifesto.md` | Who we are, shared personas, beliefs | `/manifesto` |
+| **Product** | `vision.md` | Product-specific personas, jobs, solution | `/vision` |
+| **Goals** | Gitea milestones | Measurable progress toward vision | `/vision goals` |
+
+Product vision inherits from and extends the organization manifesto.
+
+## Process
+
+1. **Check for organization manifesto**: Note if `manifesto.md` exists (provides org context)
+
+2. **Check for product vision**: Look for `vision.md` in the current repo root
+
+3. **If no vision exists**:
+   - Reference the organization manifesto if it exists
+   - Ask if the user wants to create a product vision
+   - Guide them through defining:
+     1. **Product personas**: Who does this product serve? (may extend org personas)
+     2. **Product jobs**: What specific jobs does this product address?
+     3. **The problem**: What pain points does this product solve?
+     4. **The solution**: How does this product address those jobs?
+     5. **Product principles**: Any product-specific principles (beyond org principles)?
+     6. **Product non-goals**: What is this product explicitly NOT doing?
+   - Create `vision.md`
+   - Ask about initial goals, create as Gitea milestones
+
+4. **If vision exists**:
+   - Display organization context (if manifesto exists)
+   - Display the product vision from `vision.md`
+   - Show current milestones and their progress: `tea milestones`
+   - Check if `$1` specifies an action:
+     - `goals`: Manage milestones (add, close, view progress)
+   - If no action specified, just display the current state
+
+5. **Managing Goals (milestones)**:
+   ```bash
+   # List milestones with progress
+   tea milestones
+
+   # Create a new goal
+   tea milestones create --title "<goal>" --description "For: <persona>
+Job: <job to be done>
+Success: <criteria>"
+
+   # View issues in a milestone
+   tea milestones issues <milestone-name>
+
+   # Close a completed goal
+   tea milestones close <milestone-name>
+   ```
+
+## Output Format
+
+```
+## Organization Context
+
+See manifesto for shared personas, beliefs, and principles.
+[Link or note about manifesto.md location]
+
+## Product: [Name]
+
+### Who This Product Serves
+
+- **[Persona 1]**: [Product-specific description]
+- **[Persona 2]**: [Product-specific description]
+
+### What They're Trying to Achieve
+
+- "[Product-specific job 1]"
+- "[Product-specific job 2]"
+
+### Product Vision
+
+[Summary of problem/solution from vision.md]
+
+### Goals (Milestones)
+
+| Goal | For | Progress | Due |
+|------|-----|----------|-----|
+| [title] | [Persona] | 3/5 issues | [date] |
+
+### Current Focus
+
+[Open milestones with nearest due dates or most activity]
+```
+
+## Guidelines
+
+- Product vision builds on organization manifesto - don't duplicate, extend
+- Product personas can be more specific versions of org personas
+- Product jobs should trace back to org-level jobs to be done
+- Milestones are product-specific goals toward the vision
+- Use `/manifesto` for organization-level identity and beliefs
+- Use `/vision` for product-specific direction and goals
+- If this is the architecture repo itself, use `/manifesto` instead

commands/work-issue.md

@@ -7,7 +7,7 @@ argument-hint: <issue-number>
 
 @~/.claude/skills/gitea/SKILL.md
 
-1. **View the issue** to understand requirements
+1. **View the issue** with `--comments` flag to understand requirements and context
 2. **Create a branch**: `git checkout -b issue-$1-<short-kebab-title>`
 3. **Plan**: Use TodoWrite to break down the work based on acceptance criteria
 4. **Implement** the changes

learnings/README.md

@@ -0,0 +1,88 @@
+# Learnings
+
+This folder captures learnings from retrospectives and day-to-day work. Learnings serve three purposes:
+
+1. **Historical record**: What we learned and when
+2. **Governance reference**: Why we work the way we do
+3. **Encoding source**: Input that gets encoded into skills, commands, and agents
+
+## The Learning Flow
+
+```
+Experience → Learning captured → Encoded into system → Knowledge is actionable
+                   ↓
+            Stays here for:
+            - Historical reference
+            - Governance validation
+            - Periodic review
+```
+
+Learnings are **not** the final destination. They are inputs that get encoded into commands, skills, and agents where Claude can actually use them. But we keep the learning file as a record of *why* we encoded what we did.
+
+## Writing a Learning
+
+Create a new file: `YYYY-MM-DD-short-title.md`
+
+Use this template:
+
+```markdown
+# [Title]
+
+**Date**: YYYY-MM-DD
+**Context**: What triggered this learning (task, incident, observation)
+
+## Learning
+
+The insight we gained. Be specific and actionable.
+
+## Encoded In
+
+Where this learning has been (or will be) encoded:
+
+- `skills/xxx/SKILL.md` - What was added/changed
+- `commands/xxx.md` - What was added/changed
+- `agents/xxx/agent.md` - What was added/changed
+
+If not yet encoded, note: "Pending: Issue #XX"
+
+## Governance
+
+What this learning means for how we work going forward. This is the "why" that justifies the encoding.
+```
+
+## Encoding Process
+
+1. **Capture the learning** in this folder
+2. **Create an issue** to encode it into the appropriate location
+3. **Update the skill/command/agent** with the encoded knowledge
+4. **Update the learning file** with the "Encoded In" references
+
+The goal: Claude should be able to *use* the learning, not just *read* about it.
+
+## What Gets Encoded Where
+
+| Learning Type | Encode In |
+|---------------|-----------|
+| How to use a tool | `skills/` |
+| Workflow improvement | `commands/` |
+| Subtask behavior | `agents/` |
+| Organization belief | `manifesto.md` |
+| Product direction | `vision.md` (in product repo) |
+
+## Periodic Review
+
+Periodically review learnings to:
+
+- Verify encoded locations still reflect the learning
+- Check if governance is still being followed
+- Identify patterns across multiple learnings
+- Archive or update outdated learnings
+
+## Naming Convention
+
+Files follow the pattern: `YYYY-MM-DD-short-kebab-title.md`
+
+Examples:
+- `2024-01-15-always-use-comments-flag.md`
+- `2024-01-20-verify-before-cleanup.md`
+- `2024-02-01-small-prs-merge-faster.md`

manifesto.md

@@ -0,0 +1,78 @@
+# Manifesto
+
+## Who We Are
+
+We are a small, focused team of AI-native builders. We believe the future of software development is human-AI collaboration, and we're building the tools and practices to make that real.
+
+We move fast with intention. We value quality over quantity. We encode our knowledge into systems that amplify what we can accomplish.
+
+## Who We Serve
+
+### Solo Developer
+The individual shipping side projects, MVPs, or freelance work. Time is their scarcest resource. They context-switch between coding, design, ops, and everything else. They need to move fast without sacrificing quality, and they can't afford to remember every command or best practice.
+
+### Small Team (2-5 people)
+The startup or small product team that needs to punch above their weight. They don't have dedicated specialists for every function. They need consistency across contributors and visibility into what's happening without heavyweight process.
+
+### Agency / Consultancy
+Building for clients under deadlines. They need speed, consistency, and the ability to apply learnings across projects. Every efficiency gain multiplies across engagements.
+
+## What They're Trying to Achieve
+
+- "Help me ship without getting bogged down in repetitive tasks"
+- "Help me maintain quality without slowing down"
+- "Help me know what to work on next without checking multiple tools"
+- "Help me apply best practices without memorizing them"
+- "Help me onboard to codebases faster"
+- "Help me stay in flow instead of context-switching"
+
+## What We Believe
+
+### AI-Augmented Development
+
+We believe AI fundamentally changes how software is built:
+
+- **Developers become orchestrators.** The role shifts from writing every line to directing, reviewing, and refining. The human provides judgment, context, and intent. AI handles execution and recall.
+
+- **Repetitive tasks should be automated.** If you do something more than twice, encode it. Commits, PR creation, issue management, code review - these should flow, not interrupt.
+
+- **AI amplifies individuals.** A solo developer with good AI tooling can accomplish what used to require a team. Small teams can tackle problems that used to need departments.
+
+- **Knowledge belongs in systems, not heads.** Best practices, patterns, and learnings should be encoded where AI can apply them. Tribal knowledge is a liability.
+
+- **Iteration speed is a competitive advantage.** The faster you can go from idea to deployed code to learning, the faster you improve. AI collapses the feedback loop.
+
+### Quality Without Ceremony
+
+- Ship small, ship often
+- Automate verification, not just generation
+- Good defaults beat extensive configuration
+- Working software over comprehensive documentation
+
+### Sustainable Pace
+
+- Tools should reduce cognitive load, not add to it
+- Automation should free humans for judgment calls
+- The goal is flow, not burnout
+
+## Guiding Principles
+
+1. **Encode, don't document.** If something is important enough to write down, it's important enough to encode into a skill, command, or agent that can act on it.
+
+2. **Small teams, big leverage.** Design for amplification. Every tool, pattern, and practice should multiply what individuals can accomplish.
+
+3. **Opinionated defaults, escape hatches available.** Make the right thing easy. Make customization possible but not required.
+
+4. **Learn in public.** Capture learnings. Update the system. Share what works.
+
+5. **Ship to learn.** Prefer shipping something imperfect and learning from reality over planning for perfection.
+
+## Non-Goals
+
+- **Building for enterprises with complex compliance needs.** We optimize for speed and small teams, not audit trails and approval workflows.
+
+- **Supporting every tool and platform.** We go deep on our chosen stack rather than shallow on everything.
+
+- **Replacing developer judgment.** AI augments human decision-making; it doesn't replace it. Critical thinking, architecture decisions, and user empathy remain human responsibilities.
+
+- **Comprehensive documentation for its own sake.** We encode knowledge into actionable systems. Docs exist to explain the "why," not to duplicate what the system already does.

skills/backlog-grooming/SKILL.md

@@ -33,10 +33,18 @@ For each issue, verify:
 - [ ] Clear boundaries (what's included/excluded)
 
 ### 5. Dependencies
-- [ ] Dependencies identified
+- [ ] Dependencies identified in description
+- [ ] Dependencies formally linked (`tea issues deps list <number>`)
 - [ ] No circular dependencies
 - [ ] Blocking issues are tracked
 
+To check/fix dependencies:
+```bash
+tea issues deps list <number>           # View current dependencies
+tea issues deps add <issue> <blocker>   # Add missing dependency
+tea issues deps remove <issue> <dep>    # Remove incorrect dependency
+```
+
 ### 6. Labels
 - [ ] Type label (bug/feature/etc)
 - [ ] Priority if applicable

skills/gitea/SKILL.md

@@ -70,6 +70,13 @@ tea issues reopen <number>
 
 # Labels
 tea issues edit <number> --labels "bug,help wanted"
+
+# Dependencies
+tea issues deps list <number>              # List blockers for an issue
+tea issues deps add <issue> <blocker>      # Add dependency (issue is blocked by blocker)
+tea issues deps add 5 3                    # Issue #5 depends on #3
+tea issues deps add 5 owner/repo#3         # Cross-repo dependency
+tea issues deps remove <issue> <blocker>   # Remove a dependency
 ```
 
 ### Pull Requests

skills/issue-writing/SKILL.md

@@ -104,7 +104,19 @@ Use labels to categorize:
 
 ## Dependencies
 
-Reference related issues:
-- "Depends on #N" - Must complete first
-- "Blocks #N" - This blocks another
-- "Related to #N" - Informational link
+Identify and link dependencies when creating issues:
+
+1. **In the description**, document dependencies:
+   ```markdown
+   ## Dependencies
+   - Depends on #12 (must complete first)
+   - Related to #15 (informational)
+   ```
+
+2. **After creating the issue**, formally link blockers using tea CLI:
+   ```bash
+   tea issues deps add <this-issue> <blocker-issue>
+   tea issues deps add 5 3    # Issue #5 is blocked by #3
+   ```
+
+This creates a formal dependency graph that tools can query.

skills/roadmap-planning/SKILL.md

@@ -80,6 +80,13 @@ In issue descriptions:
 - Depends on #13 (API setup)
 ```
 
+After creating issues, formally link dependencies:
+```bash
+tea issues deps add <issue> <blocker>
+tea issues deps add 14 12    # Issue #14 depends on #12
+tea issues deps add 14 13    # Issue #14 depends on #13
+```
+
 ## Creating Issues
 
 Use the gitea skill for issue operations.

skills/vision-management/SKILL.md

@@ -0,0 +1,240 @@
+---
+name: vision-management
+description: Create, maintain, and evolve organization manifesto and product visions. Use when working with manifesto.md, vision.md, milestones, or aligning work with organizational direction.
+---
+
+# Vision Management
+
+How to create, maintain, and evolve organizational direction at two levels: manifesto (organization) and vision (product).
+
+## Architecture
+
+| Level | Document | Purpose | Command | Location |
+|-------|----------|---------|---------|----------|
+| **Organization** | `manifesto.md` | Identity, shared personas, beliefs, principles | `/manifesto` | Architecture repo |
+| **Product** | `vision.md` | Product-specific personas, jobs, solution | `/vision` | Product repos |
+| **Goals** | Gitea milestones | Measurable progress toward vision | `/vision goals` | Per repo |
+
+Product vision inherits from and extends the organization manifesto.
+
+---
+
+## Manifesto (Organization Level)
+
+The manifesto defines who we are as an organization. It lives in the architecture repo and applies across all products.
+
+### Manifesto Structure
+
+```markdown
+# Manifesto
+
+## Who We Are
+Organization identity - what makes us unique.
+
+## Who We Serve
+Shared personas across all products.
+- **Persona Name**: Description, context, constraints
+
+## What They're Trying to Achieve
+Jobs to be done at the organization level.
+- "Help me [outcome] without [pain]"
+
+## What We Believe
+Core beliefs that guide how we work.
+### [Belief Category]
+- Belief point
+- Belief point
+
+## Guiding Principles
+Decision-making rules that apply everywhere.
+1. **Principle**: Explanation
+
+## Non-Goals
+What the organization explicitly does NOT do.
+- **Non-goal**: Why
+```
+
+### When to Update Manifesto
+
+- **Rarely** - this is foundational identity
+- When core beliefs change
+- When adding/removing personas served
+- When adding non-goals based on learnings
+
+### Creating a Manifesto
+
+1. Define organization identity (Who We Are)
+2. Identify shared personas (2-4 max)
+3. Articulate organization-level jobs to be done
+4. Document core beliefs (especially about AI/development)
+5. Establish guiding principles
+6. Define non-goals
+
+---
+
+## Vision (Product Level)
+
+The vision defines what a specific product does. It lives in each product repo and extends the manifesto.
+
+### Vision Structure
+
+```markdown
+# Vision
+
+## Who This Product Serves
+Product-specific personas (may extend org personas).
+- **Persona Name**: Product-specific context
+
+## What They're Trying to Achieve
+Product-specific jobs to be done.
+- "Help me [outcome] without [pain]"
+
+## The Problem
+Pain points this product addresses.
+
+## The Solution
+How this product solves those problems.
+
+## Product Principles
+Product-specific principles (beyond org principles).
+
+## Non-Goals
+What this product explicitly does NOT do.
+```
+
+### When to Update Vision
+
+- When product direction shifts
+- When adding/changing personas served by this product
+- When discovering new non-goals
+- After major learnings from retros
+
+### Creating a Product Vision
+
+1. Reference the organization manifesto
+2. Define product-specific personas (can extend org personas)
+3. Identify product-specific jobs to be done
+4. Articulate the problem this product solves
+5. Define the solution approach
+6. Set product-specific principles (if any)
+7. Document product non-goals
+8. Create initial milestones
+
+---
+
+## Relationship: Manifesto → Vision
+
+```
+Manifesto (org)          Vision (product)
+├── Shared Personas  →   Product Personas (more specific)
+├── Org Jobs         →   Product Jobs (subset/extension)
+├── Beliefs          →   (inherited, not duplicated)
+├── Principles       →   Product Principles (additional)
+└── Non-Goals        →   Product Non-Goals (additional)
+```
+
+### Inheritance Model
+
+- **Personas**: Product personas can be more specific versions of org personas
+- **Jobs**: Product jobs should trace back to org-level jobs
+- **Beliefs**: Inherited from manifesto, not duplicated in vision
+- **Principles**: Product can add specific principles; org principles apply automatically
+- **Non-Goals**: Product adds its own; org non-goals apply automatically
+
+### Example
+
+**Manifesto** (organization):
+```markdown
+## Who We Serve
+- **Solo Developer**: Individual shipping side projects, time-constrained
+```
+
+**Vision** (product - e.g., CLI tool):
+```markdown
+## Who This Product Serves
+- **Solo Developer (CLI user)**: Uses terminal daily, prefers keyboard over GUI
+```
+
+The product persona extends the org persona with product-specific context.
+
+---
+
+## Milestones (Goals)
+
+Milestones are product-level goals that track progress toward the vision.
+
+### Good Milestones
+
+- Specific and measurable
+- Tied to a persona and job to be done
+- Outcome-focused (not activity-focused)
+- Include success criteria in description
+
+```bash
+tea milestones create --title "Automate routine git workflows" \
+  --description "For: Solo developer
+Job: Ship without context switching to git commands
+Success: /commit and /pr commands handle 80% of workflows"
+```
+
+### Milestone-to-Vision Alignment
+
+Every milestone should trace to:
+- A persona (from vision or manifesto)
+- A job to be done (from vision)
+- A measurable outcome
+
+---
+
+## Aligning Issues with Vision
+
+When creating or reviewing issues:
+
+1. **Check persona alignment**: Which persona does this serve?
+2. **Check job alignment**: Which job to be done does this enable?
+3. **Check milestone alignment**: Does this issue support a goal?
+4. **Assign to milestone**: Link the issue to the relevant goal
+
+Every issue should trace back to: "This helps [persona] achieve [job] by [outcome]."
+
+### Identifying Gaps
+
+- **Underserved personas**: Which personas have few milestones/issues?
+- **Unaddressed jobs**: Which jobs to be done have no work toward them?
+- **Empty milestones**: Which milestones have no issues?
+- **Orphan issues**: Issues without a milestone need justification
+
+---
+
+## Continuous Improvement Loop
+
+```
+Manifesto → Vision → Milestones → Issues → Work → Retro → (updates)
+                                                    ↓
+                                          Architecture repo issues
+                                                    ↓
+                                          Encoded into learnings +
+                                          skills/commands/agents
+```
+
+1. **Manifesto** defines organizational identity (very stable)
+2. **Vision** defines product direction (stable)
+3. **Milestones** define measurable goals (evolve)
+4. **Issues** are work items toward goals
+5. **Work** implements the issues
+6. **Retros** create issues on architecture repo
+7. **Encoding** turns insights into learnings and system improvements
+
+---
+
+## Quick Reference
+
+| Question | Answer |
+|----------|--------|
+| Where do shared personas live? | `manifesto.md` in architecture repo |
+| Where do product personas live? | `vision.md` in product repo |
+| Where do beliefs live? | `manifesto.md` only (inherited) |
+| Where do goals live? | Gitea milestones (per repo) |
+| What command for org vision? | `/manifesto` |
+| What command for product vision? | `/vision` |
+| What repo for learnings? | Architecture repo |