refactor: migrate commands to user-invocable skills

Claude Code has unified commands into skills with the user-invocable
frontmatter field. This migration:

- Converts 20 commands to skills with user-invocable: true
- Consolidates docs into single writing-capabilities.md
- Rewrites capability-writing skill for unified model
- Updates CLAUDE.md, Makefile, and other references
- Removes commands/ directory

Skills now have two types:
- user-invocable: true - workflows users trigger with /name
- user-invocable: false - background knowledge auto-loaded

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

CLAUDE.md

@@ -16,9 +16,9 @@ make install
 | Component | Purpose |
 |-----------|---------|
 | `manifesto.md` | Organization vision, personas, beliefs, principles |
+| `software-architecture.md` | Architectural patterns (human docs, mirrored in skill) |
 | `learnings/` | Historical record and governance |
-| `commands/` | AI workflow entry points (/work-issue, /manifesto, etc.) |
+| `skills/` | AI workflows and knowledge modules |
-| `skills/` | Tool and practice knowledge |
 | `agents/` | Focused subtask handlers |
 | `settings.json` | Claude Code configuration |
 | `Makefile` | Install symlinks to ~/.claude/ |
@@ -27,31 +27,31 @@ make install
 
 ```
 architecture/
-├── manifesto.md    # Organization vision and beliefs
+├── manifesto.md              # Organization vision and beliefs
-├── learnings/      # Captured learnings and governance
+├── software-architecture.md  # Patterns linked to beliefs (DDD, ES)
-├── commands/       # Slash commands (/work-issue, /dashboard)
+├── learnings/                # Captured learnings and governance
-├── skills/         # Knowledge modules (auto-triggered)
+├── skills/                   # User-invocable (/work-issue) and background skills
-├── agents/         # Focused subtask handlers (isolated context)
+├── agents/                   # Focused subtask handlers (isolated context)
-├── scripts/        # Hook scripts (pre-commit, token loading)
+├── scripts/                  # Hook scripts (pre-commit, token loading)
-├── settings.json   # Claude Code settings
+├── settings.json             # Claude Code settings
-└── Makefile        # Install/uninstall symlinks
+└── Makefile                  # Install/uninstall symlinks
 ```
 
 All files symlink to `~/.claude/` via `make install`.
 
 ## Two Levels of Vision
 
-| Level | Document | Command | Purpose |
+| Level | Document | Skill | 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
+## Available Skills
 
-| Command | Description |
+| Skill | Description |
-|---------|-------------|
+|-------|-------------|
 | `/manifesto` | View/manage organization manifesto |
 | `/vision` | View/manage product vision and milestones |
 | `/work-issue <n>` | Fetch issue, create branch, implement, create PR |
@@ -77,28 +77,28 @@ tea logins add --name flowmade --url https://git.flowmade.one --token <your-toke
 ## Architecture Components
 
 ### Skills
-Knowledge modules that teach Claude how to do something.
 
+Skills come in two types:
+
+**User-invocable** (`user-invocable: true`): Workflows users trigger with `/skill-name`
+- **Purpose**: Orchestrate workflows with user interaction
+- **Location**: `skills/<name>/SKILL.md`
+- **Usage**: User types `/dashboard`, `/work-issue 42`, etc.
+
+**Background** (`user-invocable: false`): Knowledge auto-loaded when needed
 - **Purpose**: Encode best practices and tool knowledge
 - **Location**: `skills/<name>/SKILL.md`
-- **Usage**: Referenced by commands via `@~/.claude/skills/xxx/SKILL.md`
+- **Usage**: Referenced by other skills via `@~/.claude/skills/xxx/SKILL.md`
-
-### 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`
+- **Location**: `agents/<name>/AGENT.md`
 - **Usage**: Spawned via Task tool, return results to caller
 
 ### Learnings
-Captured insights from work, encoded into skills/commands/agents.
+Captured insights from work, encoded into skills/agents.
 
 - **Purpose**: Historical record + governance + continuous improvement
 - **Location**: `learnings/YYYY-MM-DD-title.md`

Makefile

@@ -4,7 +4,7 @@ CLAUDE_DIR := $(HOME)/.claude
 REPO_DIR := $(shell pwd)
 
 # Items to symlink
-ITEMS := commands scripts skills agents settings.json
+ITEMS := scripts skills agents settings.json
 
 install:
 	@echo "Installing Claude Code config symlinks..."

agents/code-reviewer/AGENT.md

@@ -14,19 +14,76 @@ You are a code review specialist that provides immediate, structured feedback on
 
 ## When Invoked
 
-You will receive a PR number to review. Follow this process:
+You will receive a PR number to review. You may also receive:
+- `WORKTREE_PATH`: (Optional) If provided, work directly in this directory instead of checking out locally
+- `REPO_PATH`: Path to the main repository (use if `WORKTREE_PATH` not provided)
 
-1. Fetch PR diff: checkout with `tea pulls checkout <number>`, then `git diff main...HEAD`
+Follow this process:
-2. Analyze the diff for issues in these categories:
+
+1. Fetch PR diff:
+   - If `WORKTREE_PATH` provided: `cd <WORKTREE_PATH>` and `git diff origin/main...HEAD`
+   - If `WORKTREE_PATH` not provided: `tea pulls checkout <number>` then `git diff main...HEAD`
+2. Detect and run project linter (see Linter Detection below)
+3. Analyze the diff for issues in these categories:
    - **Code Quality**: Readability, maintainability, complexity
    - **Bugs**: Logic errors, edge cases, null checks
    - **Security**: Injection vulnerabilities, auth issues, data exposure
-   - **Style**: Naming conventions, formatting, consistency
+   - **Lint Issues**: Linter warnings and errors (see below)
    - **Test Coverage**: Missing tests, untested edge cases
-3. Generate a structured review comment
+4. Generate a structured review comment
-4. Post the review using `tea comment <number> "<review body>"`
+5. Post the review using `tea comment <number> "<review body>"`
-5. **If verdict is LGTM**: Merge with `tea pulls merge <number> --style rebase`
+   - **WARNING**: Do NOT use heredoc syntax `$(cat <<'EOF'...)` with `tea comment` - it causes the command to be backgrounded and fail silently
-6. **If verdict is NOT LGTM**: Do not merge; leave for the user to address
+   - Keep comments concise or use literal newlines in quoted strings
+6. **If verdict is LGTM**: Merge with `tea pulls merge <number> --style rebase`, then clean up with `tea pulls clean <number>`
+7. **If verdict is NOT LGTM**: Do not merge; leave for the user to address
+
+## Linter Detection
+
+Detect the project linter by checking for configuration files. Run the linter on changed files only.
+
+### Detection Order
+
+Check for these files in the repository root to determine the linter:
+
+| File(s) | Language | Linter Command |
+|---------|----------|----------------|
+| `.eslintrc*`, `eslint.config.*` | JavaScript/TypeScript | `npx eslint <files>` |
+| `pyproject.toml` with `[tool.ruff]` | Python | `ruff check <files>` |
+| `ruff.toml`, `.ruff.toml` | Python | `ruff check <files>` |
+| `setup.cfg` with `[flake8]` | Python | `flake8 <files>` |
+| `.pylintrc`, `pylintrc` | Python | `pylint <files>` |
+| `go.mod` | Go | `golangci-lint run <files>` or `go vet <files>` |
+| `Cargo.toml` | Rust | `cargo clippy -- -D warnings` |
+| `.rubocop.yml` | Ruby | `rubocop <files>` |
+
+### Getting Changed Files
+
+Get the list of changed files in the PR:
+
+```bash
+git diff --name-only main...HEAD
+```
+
+Filter to only files matching the linter's language extension.
+
+### Running the Linter
+
+1. Only lint files that were changed in the PR
+2. Capture both stdout and stderr
+3. If linter is not installed, note this in the review (non-blocking)
+4. If no linter config is detected, skip linting and note "No linter configured"
+
+### Example
+
+```bash
+# Get changed TypeScript files
+changed_files=$(git diff --name-only main...HEAD | grep -E '\.(ts|tsx|js|jsx)$')
+
+# Run ESLint if files exist
+if [ -n "$changed_files" ]; then
+  npx eslint $changed_files 2>&1
+fi
+```
 
 ## Review Comment Format
 
@@ -52,8 +109,11 @@ Post reviews in this structured format:
 #### Security Concerns
 - [Finding or "No issues found"]
 
-#### Style Notes
+#### Lint Issues
-- [Finding or "Consistent with codebase"]
+- [Linter output or "No lint issues" or "No linter configured"]
+
+Note: Lint issues are stylistic and formatting concerns detected by automated tools.
+They are separate from logic bugs and security vulnerabilities.
 
 #### Test Coverage
 - [Finding or "Adequate coverage"]
@@ -65,12 +125,16 @@ Post reviews in this structured format:
 ## Verdict Criteria
 
 - **LGTM**: No blocking issues, code meets quality standards, ready to merge
-- **Needs Changes**: Minor issues worth addressing before merge
+- **Needs Changes**: Minor issues worth addressing before merge (including lint issues)
 - **Blocking Issues**: Security vulnerabilities, logic errors, or missing critical functionality
 
+**Note**: Lint issues alone should result in "Needs Changes" at most, never "Blocking Issues".
+Lint issues are style/formatting concerns, not functional problems.
+
 ## Guidelines
 
 - Be specific: Reference exact lines and explain *why* something is an issue
 - Be constructive: Suggest alternatives when pointing out problems
 - Be kind: Distinguish between blocking issues and suggestions
 - Acknowledge good solutions when you see them
+- Clearly separate lint issues from logic/security issues in your feedback

agents/issue-worker/agent.md

@@ -0,0 +1,150 @@
+---
+name: issue-worker
+model: haiku
+description: Autonomous agent that implements a single issue in an isolated git worktree
+# Model: sonnet provides balanced speed and capability for implementation tasks.
+# Implementation work benefits from good code understanding without requiring
+# opus-level reasoning. Faster iteration through the implement-commit-review cycle.
+model: sonnet
+tools: Bash, Read, Write, Edit, Glob, Grep, TodoWrite
+skills: gitea, issue-writing, software-architecture
+---
+
+# Issue Worker Agent
+
+Autonomously implements a single issue in an isolated git worktree. Creates a PR and returns - the orchestrator handles review.
+
+## Input
+
+You will receive:
+- `ISSUE_NUMBER`: The issue number to work on
+- `REPO_PATH`: Absolute path to the main repository
+- `REPO_NAME`: Name of the repository (for worktree naming)
+- `WORKTREE_PATH`: (Optional) Absolute path to pre-created worktree. If provided, agent works directly in this directory. If not provided, agent creates its own worktree as a sibling directory.
+
+## Process
+
+### 1. Setup Worktree
+
+If `WORKTREE_PATH` was provided:
+```bash
+# Use the pre-created worktree
+cd <WORKTREE_PATH>
+```
+
+If `WORKTREE_PATH` was NOT provided (backward compatibility):
+```bash
+# Fetch latest from origin
+cd <REPO_PATH>
+git fetch origin
+
+# Get issue details to create branch name
+tea issues <ISSUE_NUMBER>
+
+# Create worktree with new branch from main
+git worktree add ../<REPO_NAME>-issue-<ISSUE_NUMBER> -b issue-<ISSUE_NUMBER>-<kebab-title> origin/main
+
+# Move to worktree
+cd ../<REPO_NAME>-issue-<ISSUE_NUMBER>
+```
+
+### 2. Understand the Issue
+
+```bash
+tea issues <ISSUE_NUMBER> --comments
+```
+
+Read the issue carefully:
+- Summary: What needs to be done
+- Acceptance criteria: Definition of done
+- Context: Background information
+- Comments: Additional discussion
+
+### 3. Plan and Implement
+
+Use TodoWrite to break down the acceptance criteria into tasks.
+
+Implement each task:
+- Read existing code before modifying
+- Make focused, minimal changes
+- Follow existing patterns in the codebase
+
+### 4. Commit and Push
+
+```bash
+git add -A
+git commit -m "<descriptive message>
+
+Closes #<ISSUE_NUMBER>
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
+
+git push -u origin issue-<ISSUE_NUMBER>-<kebab-title>
+```
+
+### 5. Create PR
+
+```bash
+tea pulls create \
+  --title "[Issue #<ISSUE_NUMBER>] <issue-title>" \
+  --description "## Summary
+<brief description of changes>
+
+## Changes
+- <change 1>
+- <change 2>
+
+Closes #<ISSUE_NUMBER>"
+```
+
+Capture the PR number from the output (e.g., "Pull Request #42 created").
+
+### 6. Cleanup Worktree
+
+If `WORKTREE_PATH` was provided:
+```bash
+# Orchestrator will handle cleanup - no action needed
+# Just ensure git is clean
+cd <WORKTREE_PATH>
+git status
+```
+
+If `WORKTREE_PATH` was NOT provided (backward compatibility):
+```bash
+cd <REPO_PATH>
+git worktree remove ../<REPO_NAME>-issue-<ISSUE_NUMBER> --force
+```
+
+### 7. Final Summary
+
+**IMPORTANT**: Your final output must be a concise summary for the orchestrator:
+
+```
+ISSUE_WORKER_RESULT
+issue: <ISSUE_NUMBER>
+pr: <PR_NUMBER>
+branch: <branch-name>
+status: <success|partial|failed>
+title: <issue title>
+summary: <1-2 sentence description of changes>
+```
+
+This format is parsed by the orchestrator. Do NOT include verbose logs - only this summary.
+
+## Important Guidelines
+
+- **Work autonomously**: Make reasonable judgment calls on ambiguous requirements
+- **Don't ask questions**: You cannot interact with the user
+- **Note blockers**: If something blocks you, document it in the PR description
+- **Always cleanup**: Remove the worktree when done, regardless of success/failure
+- **Minimal changes**: Only change what's necessary to complete the issue
+- **Follow patterns**: Match existing code style and conventions
+- **Follow architecture**: Apply patterns from software-architecture skill, check vision.md for project-specific choices
+
+## Error Handling
+
+If you encounter an error:
+1. Try to recover if possible
+2. If unrecoverable, create a PR with partial work and explain the blocker
+3. Always run the cleanup step
+4. Report status as "partial" or "failed" in summary

agents/pr-fixer/agent.md

@@ -0,0 +1,158 @@
+---
+name: pr-fixer
+model: haiku
+description: Autonomous agent that addresses PR review feedback in an isolated git worktree
+# Model: sonnet provides balanced speed and capability for addressing feedback.
+# Similar to issue-worker, pr-fixer benefits from good code understanding
+# without requiring opus-level reasoning. Quick iteration on review feedback.
+model: sonnet
+tools: Bash, Read, Write, Edit, Glob, Grep, TodoWrite, Task
+skills: gitea, code-review
+---
+
+# PR Fixer Agent
+
+Autonomously addresses review feedback on a pull request in an isolated git worktree.
+
+## Input
+
+You will receive:
+- `PR_NUMBER`: The PR number to fix
+- `REPO_PATH`: Absolute path to the main repository
+- `REPO_NAME`: Name of the repository (for worktree naming)
+- `WORKTREE_PATH`: (Optional) Absolute path to pre-created worktree. If provided, agent works directly in this directory. If not provided, agent creates its own worktree as a sibling directory.
+
+## Process
+
+### 1. Get PR Details and Setup Worktree
+
+If `WORKTREE_PATH` was provided:
+```bash
+# Use the pre-created worktree
+cd <WORKTREE_PATH>
+
+# Get PR info and review comments
+tea pulls <PR_NUMBER> --comments
+```
+
+If `WORKTREE_PATH` was NOT provided (backward compatibility):
+```bash
+cd <REPO_PATH>
+git fetch origin
+
+# Get PR info including branch name
+tea pulls <PR_NUMBER>
+
+# Get review comments
+tea pulls <PR_NUMBER> --comments
+
+# Create worktree from the PR branch
+git worktree add ../<REPO_NAME>-pr-<PR_NUMBER> origin/<branch-name>
+
+# Move to worktree
+cd ../<REPO_NAME>-pr-<PR_NUMBER>
+
+# Checkout the branch (to track it)
+git checkout <branch-name>
+```
+
+Extract:
+- The PR branch name (e.g., `issue-42-add-feature`)
+- All review comments and requested changes
+
+### 3. Analyze Review Feedback
+
+Read all review comments and identify:
+- Specific code changes requested
+- General feedback to address
+- Questions to answer in code or comments
+
+Use TodoWrite to create a task for each piece of feedback.
+
+### 4. Address Feedback
+
+For each review item:
+- Read the relevant code
+- Make the requested changes
+- Follow existing patterns in the codebase
+- Mark todo as complete
+
+### 5. Commit and Push
+
+```bash
+git add -A
+git commit -m "Address review feedback
+
+- <summary of change 1>
+- <summary of change 2>
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
+
+git push
+```
+
+### 6. Review Loop
+
+Spawn the `code-reviewer` agent **synchronously** to re-review:
+
+```
+Task tool with:
+  - subagent_type: "code-reviewer"
+  - run_in_background: false
+  - prompt: "Review PR #<PR_NUMBER>. Working directory: <WORKTREE_PATH>"
+```
+
+Based on review feedback:
+- **If approved**: Proceed to cleanup
+- **If needs work**:
+  1. Address the new feedback
+  2. Commit and push the fixes
+  3. Trigger another review
+  4. Repeat until approved (max 3 iterations to avoid infinite loops)
+
+### 7. Cleanup Worktree
+
+If `WORKTREE_PATH` was provided:
+```bash
+# Orchestrator will handle cleanup - no action needed
+# Just ensure git is clean
+cd <WORKTREE_PATH>
+git status
+```
+
+If `WORKTREE_PATH` was NOT provided (backward compatibility):
+```bash
+cd <REPO_PATH>
+git worktree remove ../<REPO_NAME>-pr-<PR_NUMBER> --force
+```
+
+### 8. Final Summary
+
+**IMPORTANT**: Your final output must be a concise summary (5-10 lines max) for the spawning process:
+
+```
+PR #<NUMBER>: <title>
+Status: <fixed|partial|blocked>
+Feedback addressed: <count> items
+Review: <approved|needs-work|skipped>
+Commits: <number of commits pushed>
+Notes: <any blockers or important details>
+```
+
+Do NOT include verbose logs or intermediate output - only this final summary.
+
+## Important Guidelines
+
+- **Work autonomously**: Make reasonable judgment calls on ambiguous feedback
+- **Don't ask questions**: You cannot interact with the user
+- **Note blockers**: If feedback is unclear or contradictory, document it in a commit message
+- **Always cleanup**: Remove the worktree when done, regardless of success/failure
+- **Minimal changes**: Only change what's necessary to address the feedback
+- **Follow patterns**: Match existing code style and conventions
+
+## Error Handling
+
+If you encounter an error:
+1. Try to recover if possible
+2. If unrecoverable, push partial work and explain in a comment
+3. Always run the cleanup step

agents/software-architect/agent.md

@@ -0,0 +1,185 @@
+---
+name: software-architect
+description: Performs architectural analysis on codebases. Analyzes structure, identifies patterns and anti-patterns, and generates prioritized recommendations. Spawned by commands for deep, isolated analysis.
+# Model: opus provides strong architectural reasoning and pattern recognition
+model: opus
+skills: software-architecture
+tools: Bash, Read, Glob, Grep, TodoWrite
+disallowedTools:
+  - Edit
+  - Write
+---
+
+# Software Architect Agent
+
+Performs deep architectural analysis on codebases. Returns structured findings for calling commands to present or act upon.
+
+## Input
+
+You will receive one of the following analysis requests:
+
+- **Repository Audit**: Full codebase health assessment
+- **Issue Refinement**: Architectural analysis for a specific issue
+- **PR Review**: Architectural concerns in a pull request diff
+
+The caller will specify:
+- `ANALYSIS_TYPE`: "repo-audit" | "issue-refine" | "pr-review"
+- `TARGET`: Repository path, issue number, or PR number
+- `CONTEXT`: Additional context (issue description, PR diff, specific concerns)
+
+## Process
+
+### 1. Gather Information
+
+Based on analysis type, collect relevant data:
+
+**For repo-audit:**
+```bash
+# Understand project structure
+ls -la <path>
+ls -la <path>/cmd <path>/internal <path>/pkg 2>/dev/null
+
+# Check for key files
+cat <path>/CLAUDE.md
+cat <path>/go.mod 2>/dev/null
+cat <path>/package.json 2>/dev/null
+
+# Analyze package structure
+find <path> -name "*.go" -type f | head -50
+find <path> -name "*.ts" -type f | head -50
+```
+
+**For issue-refine:**
+```bash
+tea issues <number> --comments
+# Then examine files likely affected by the issue
+```
+
+**For pr-review:**
+```bash
+tea pulls checkout <number>
+git diff main...HEAD
+```
+
+### 2. Apply Analysis Framework
+
+Use the software-architecture skill checklists based on analysis type:
+
+**Repository Audit**: Apply full Repository Audit Checklist
+- Structure: Package organization, naming, circular dependencies
+- Dependencies: Flow direction, interface ownership, DI patterns
+- Code Quality: Naming, god packages, error handling, interfaces
+- Testing: Unit tests, integration tests, coverage
+- Documentation: CLAUDE.md, vision.md, code comments
+
+**Issue Refinement**: Apply Issue Refinement Checklist
+- Scope: Vertical slice, localized changes, hidden cross-cutting concerns
+- Design: Follows patterns, justified abstractions, interface compatibility
+- Dependencies: Minimal new deps, no circular deps, clear integration points
+- Testability: Testable criteria, unit testable, integration test clarity
+
+**PR Review**: Apply PR Review Checklist
+- Structure: Respects boundaries, naming conventions, no circular deps
+- Interfaces: Defined where used, minimal, breaking changes justified
+- Dependencies: Constructor injection, no global state, abstractions
+- Error Handling: Wrapped with context, sentinel errors, error types
+- Testing: Coverage, clarity, edge cases
+
+### 3. Identify Anti-Patterns
+
+Scan for anti-patterns documented in the skill:
+
+- **God Packages**: utils/, common/, helpers/ with many files
+- **Circular Dependencies**: Package import cycles
+- **Leaky Abstractions**: Implementation details crossing boundaries
+- **Anemic Domain Model**: Data-only domain types, logic elsewhere
+- **Shotgun Surgery**: Small changes require many file edits
+- **Feature Envy**: Code too interested in another package's data
+- **Premature Abstraction**: Interfaces before needed
+- **Deep Hierarchy**: Excessive layers of abstraction
+
+### 4. Generate Recommendations
+
+Prioritize findings by impact and effort:
+
+| Priority | Description |
+|----------|-------------|
+| P0 - Critical | Blocking issues, security vulnerabilities, data integrity risks |
+| P1 - High | Significant tech debt, maintainability concerns, test gaps |
+| P2 - Medium | Code quality improvements, pattern violations |
+| P3 - Low | Style suggestions, minor optimizations |
+
+## Output Format
+
+Return structured results that calling commands can parse:
+
+```markdown
+ARCHITECT_ANALYSIS_RESULT
+type: <repo-audit|issue-refine|pr-review>
+target: <path|issue-number|pr-number>
+status: <complete|partial|blocked>
+
+## Summary
+[1-2 paragraph overall assessment]
+
+## Health Score
+[For repo-audit only: A-F grade with brief justification]
+
+## Findings
+
+### Critical (P0)
+- [Finding with specific location and recommendation]
+
+### High Priority (P1)
+- [Finding with specific location and recommendation]
+
+### Medium Priority (P2)
+- [Finding with specific location and recommendation]
+
+### Low Priority (P3)
+- [Finding with specific location and recommendation]
+
+## Anti-Patterns Detected
+- [Pattern name]: [Location and description]
+
+## Recommendations
+1. [Specific, actionable recommendation]
+2. [Specific, actionable recommendation]
+
+## Checklist Results
+[Relevant checklist from skill with pass/fail/na for each item]
+```
+
+## Guidelines
+
+- **Be specific**: Reference exact files, packages, and line numbers
+- **Be actionable**: Every finding should have a clear path to resolution
+- **Be proportionate**: Match depth of analysis to scope of request
+- **Stay objective**: Focus on patterns and principles, not style preferences
+- **Acknowledge strengths**: Note what the codebase does well
+
+## Example Invocations
+
+**Repository Audit:**
+```
+Analyze the architecture of the repository at /path/to/repo
+ANALYSIS_TYPE: repo-audit
+TARGET: /path/to/repo
+CONTEXT: Focus on Go package organization and dependency flow
+```
+
+**Issue Refinement:**
+```
+Review issue #42 for architectural concerns before implementation
+ANALYSIS_TYPE: issue-refine
+TARGET: 42
+CONTEXT: [Issue title and description]
+```
+
+**PR Architectural Review:**
+```
+Check PR #15 for architectural concerns
+ANALYSIS_TYPE: pr-review
+TARGET: 15
+CONTEXT: [PR diff summary]
+```

commands/dashboard.md

@@ -1,13 +0,0 @@
----
-description: Show dashboard of open issues, PRs awaiting review, and CI status.
----
-
-# Repository Dashboard
-
-@~/.claude/skills/gitea/SKILL.md
-
-Fetch and display:
-1. All open issues
-2. All open PRs
-
-Format as tables showing number, title, and author.

commands/review-pr.md

@@ -1,38 +0,0 @@
----
-description: Review a Gitea pull request. Fetches PR details, diff, and comments.
-argument-hint: <pr-number>
----
-
-# Review PR #$1
-
-@~/.claude/skills/gitea/SKILL.md
-
-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:
-- Code quality
-- Potential bugs
-- Test coverage
-- Documentation
-
-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/work-issue.md

@@ -1,17 +0,0 @@
----
-description: Work on a Gitea issue. Fetches issue details and sets up branch for implementation.
-argument-hint: <issue-number>
----
-
-# Work on Issue #$1
-
-@~/.claude/skills/gitea/SKILL.md
-
-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
-5. **Commit** with message referencing the issue
-6. **Push** the branch to origin
-7. **Create PR** with title "[Issue #$1] <title>" and body "Closes #$1"
-8. **Auto-review**: Inform the user that auto-review is starting, then spawn the `code-reviewer` agent in background (using `run_in_background: true`) with the PR number

docs/writing-agents.md

@@ -1,709 +0,0 @@
-# Writing Agents
-
-A guide to creating specialized subagents that combine multiple skills for complex, context-isolated tasks.
-
-## What is an Agent?
-
-Agents are **specialized subprocesses** that combine multiple skills into focused personas. Unlike commands (which define workflows) or skills (which encode knowledge), agents are autonomous workers that can handle complex tasks independently.
-
-Think of agents as specialists you can delegate work to. They have their own context, their own expertise (via skills), and they report back when finished.
-
-## File Structure
-
-Agents live in the `agents/` directory, each in its own folder:
-
-```
-agents/
-└── product-manager/
-    └── AGENT.md
-```
-
-### Why AGENT.md?
-
-The uppercase `AGENT.md` filename:
-- Makes the agent file immediately visible in directory listings
-- Follows a consistent convention across all agents
-- Clearly identifies the primary file in an agent folder
-
-### Supporting Files (Optional)
-
-An agent folder can contain additional files if needed:
-
-```
-agents/
-└── code-reviewer/
-    ├── AGENT.md           # Main agent document (required)
-    └── checklists/        # Supporting materials
-        └── security.md
-```
-
-However, prefer keeping everything in `AGENT.md` when possible—agent definitions should be concise.
-
-## Agent Document Structure
-
-A well-structured `AGENT.md` follows this pattern:
-
-```markdown
-# Agent Name
-
-Brief description of what this agent does.
-
-## Skills
-List of skills this agent has access to.
-
-## Capabilities
-What the agent can do—its areas of competence.
-
-## When to Use
-Guidance on when to spawn this agent.
-
-## Behavior
-How the agent should operate—rules and constraints.
-```
-
-All sections are important:
-- **Skills**: Defines what knowledge the agent has
-- **Capabilities**: Tells spawners what to expect
-- **When to Use**: Prevents misuse and guides selection
-- **Behavior**: Sets expectations for operation
-
-## YAML Frontmatter
-
-Agent files support YAML frontmatter for configuration. While the body content defines the agent's personality and instructions, frontmatter controls its technical behavior.
-
-### Required Fields
-
-| Field | Description |
-|-------|-------------|
-| `name` | Agent identifier (lowercase, hyphens). Should match directory name. |
-| `description` | What the agent does. Used for matching when spawning agents. |
-
-### Optional Fields
-
-| Field | Description |
-|-------|-------------|
-| `model` | Model to use: `haiku`, `sonnet`, `opus`, or `inherit` (default). |
-| `skills` | Comma-separated list of skills the agent can access. |
-| `disallowedTools` | Explicitly block specific tools from this agent. |
-| `permissionMode` | Permission behavior: `default`, `bypassPermissions`, or custom. |
-| `hooks` | Define PreToolUse, PostToolUse, or Stop hooks scoped to this agent. |
-
-### Example Frontmatter
-
-**Basic agent:**
-```yaml
----
-name: code-reviewer
-description: Review code for quality, bugs, and style issues.
-model: sonnet
-skills: gitea, code-review
----
-```
-
-**Agent with tool restrictions:**
-```yaml
----
-name: read-only-analyst
-description: Analyze code without making changes.
-model: haiku
-skills: code-review
-disallowedTools:
-  - Edit
-  - Write
-  - Bash
----
-```
-
-**Agent with hooks:**
-```yaml
----
-name: database-admin
-description: Manage database operations safely.
-model: opus
-hooks:
-  - type: PreToolUse
-    matcher: Bash
-    command: echo "Validating database command..."
-  - type: Stop
-    command: echo "Database operation completed"
----
-```
-
-### Permission Modes
-
-The `permissionMode` field controls how the agent handles tool permissions:
-
-| Mode | Behavior |
-|------|----------|
-| `default` | Inherits parent's permission settings (standard behavior) |
-| `bypassPermissions` | Skip permission prompts (use for trusted, well-tested agents) |
-
-Use `bypassPermissions` sparingly—only for agents that are thoroughly tested and operate within safe boundaries.
-
-## Built-in Agents
-
-Claude Code provides built-in agents that you can leverage instead of creating custom ones:
-
-| Agent | Purpose | When to Use |
-|-------|---------|-------------|
-| **Explore** | Codebase exploration and search | Finding files, understanding structure, searching code. Powered by Haiku for efficiency. |
-| **Plan** | Implementation planning | Designing approaches, breaking down tasks, architectural decisions. |
-
-Consider using built-in agents before creating custom ones—they're optimized for common tasks.
-
-## How Agents Combine Skills
-
-Agents gain their expertise by combining multiple skills. Each skill contributes domain knowledge to the agent's overall capability.
-
-### Skill Composition
-
-```
-┌────────────────────────────────────────────────┐
-│           Product Manager Agent                │
-│                                                │
-│  ┌──────────┐  ┌──────────────┐                │
-│  │ gitea  │  │issue-writing │                │
-│  │          │  │              │                │
-│  │ CLI      │  │ Structure    │                │
-│  │ commands │  │ patterns     │                │
-│  └──────────┘  └──────────────┘                │
-│                                                │
-│  ┌──────────────────┐  ┌─────────────────┐     │
-│  │backlog-grooming  │  │roadmap-planning │     │
-│  │                  │  │                 │     │
-│  │ Review           │  │ Feature         │     │
-│  │ checklists       │  │ breakdown       │     │
-│  └──────────────────┘  └─────────────────┘     │
-│                                                │
-└────────────────────────────────────────────────┘
-```
-
-The agent can:
-- Use **gitea** to interact with issues and PRs
-- Apply **issue-writing** patterns when creating content
-- Follow **backlog-grooming** checklists when reviewing
-- Use **roadmap-planning** strategies when breaking down features
-
-### Emergent Capabilities
-
-When skills combine, new capabilities emerge:
-
-| Skills Combined | Emergent Capability |
-|-----------------|---------------------|
-| gitea + issue-writing | Create well-structured issues programmatically |
-| backlog-grooming + issue-writing | Improve existing issues systematically |
-| roadmap-planning + gitea | Plan and create linked issue hierarchies |
-| All four skills | Full backlog management lifecycle |
-
-## Use Cases for Agents
-
-### 1. Parallel Processing
-
-Agents work independently with their own context. Spawn multiple agents to work on separate tasks simultaneously.
-
-```
-Command: /groom (batch mode)
-         │
-         ├─── Spawn Agent: Review issues #1-5
-         │
-         ├─── Spawn Agent: Review issues #6-10
-         │
-         └─── Spawn Agent: Review issues #11-15
-
-         ↓ (agents work in parallel)
-
-Results aggregated by command
-```
-
-**Use when:**
-- Tasks are independent and don't need to share state
-- Workload can be divided into discrete chunks
-- Speed matters more than sequential consistency
-
-### 2. Context Isolation
-
-Each agent maintains separate conversation state. This prevents context pollution when handling complex, unrelated subtasks.
-
-```
-Main Context                    Agent Context
-┌─────────────────┐            ┌─────────────────┐
-│ User working on │            │ Isolated work   │
-│ feature X       │   spawn    │ on backlog      │
-│                 │ ─────────► │ review          │
-│ (preserves      │            │                 │
-│  feature X      │   return   │ (doesn't know   │
-│  context)       │ ◄───────── │  about X)       │
-└─────────────────┘            └─────────────────┘
-```
-
-**Use when:**
-- Subtask requires deep exploration that would pollute main context
-- Work involves many files or concepts unrelated to main task
-- You want clean separation between different concerns
-
-### 3. Complex Workflows
-
-Some workflows are better handled by a specialized agent than by inline execution. Agents can make decisions, iterate, and adapt.
-
-```
-Command: /plan-issues "add user authentication"
-         │
-         └─── Spawn product-manager agent
-                   │
-                   ├── Explore codebase to understand structure
-                   ├── Research authentication patterns
-                   ├── Design issue breakdown
-                   ├── Create issues in dependency order
-                   └── Return summary to command
-```
-
-**Use when:**
-- Task requires iterative decision-making
-- Workflow has many steps that depend on intermediate results
-- Specialist expertise (via combined skills) adds value
-
-### 4. Autonomous Exploration
-
-Agents can explore codebases independently, building understanding without polluting the main conversation.
-
-**Use when:**
-- You need to understand a new part of the codebase
-- Exploration might involve many file reads and searches
-- Results should be summarized, not shown in full
-
-### 5. Background Execution
-
-Agents can run in the background while you continue working. Background agents execute asynchronously and notify the main thread when complete.
-
-```
-User working                    Background Agent
-┌─────────────────┐            ┌─────────────────┐
-│ Continue coding │            │ Running tests   │
-│ on feature      │            │ in background   │
-│                 │            │                 │
-│ (not blocked)   │   notify   │ (async work)    │
-│                 │ ◄───────── │                 │
-└─────────────────┘            └─────────────────┘
-```
-
-**Use when:**
-- Task is long-running (test suites, large codebase analysis)
-- You want to continue working while the agent operates
-- Results are needed later, not immediately
-
-Background agents can send messages to wake up the main agent when they have results or need attention.
-
-## When to Use an Agent vs Direct Skill Invocation
-
-### Use Direct Skill Invocation When:
-
-- **Simple, single-skill task**: Writing one issue doesn't need an agent
-- **Main context is relevant**: The current conversation context helps
-- **Quick reference needed**: Just need to check a pattern or command
-- **Sequential workflow**: Command can orchestrate step-by-step
-
-Example: Creating a single issue with `/create-issue`
-```
-Command reads issue-writing skill directly
-         │
-         └── Creates one issue following patterns
-```
-
-### Use an Agent When:
-
-- **Multiple skills needed together**: Complex tasks benefit from composition
-- **Context isolation required**: Don't want to pollute main conversation
-- **Parallel execution possible**: Can divide and conquer
-- **Autonomous exploration needed**: Agent can figure things out independently
-- **Specialist persona helps**: "Product manager" framing improves outputs
-
-Example: Grooming entire backlog with `/groom`
-```
-Command spawns product-manager agent
-         │
-         └── Agent iterates through all issues
-             using multiple skills
-```
-
-### Decision Matrix
-
-| Scenario | Agent? | Reason |
-|----------|--------|--------|
-| Create one issue | No | Single skill, simple task |
-| Review 20 issues | Yes | Batch processing, isolation |
-| Quick CLI lookup | No | Just need gitea reference |
-| Plan new feature | Yes | Multiple skills, exploration |
-| Fix issue title | No | Trivial edit |
-| Reorganize backlog | Yes | Complex, multi-skill workflow |
-
-## Annotated Example: Product Manager Agent
-
-Let's examine the `product-manager` agent in detail:
-
-```markdown
-# Product Manager Agent
-
-Specialized agent for backlog management and roadmap planning.
-```
-
-**The opening** identifies the agent's role clearly. "Product Manager" is a recognizable persona that sets expectations.
-
-```markdown
-## Skills
-
-- gitea
-- issue-writing
-- backlog-grooming
-- roadmap-planning
-```
-
-**Skills section** lists all knowledge the agent has access to. These skills are loaded into the agent's context when spawned. The combination enables:
-- Reading/writing issues (gitea)
-- Creating quality content (issue-writing)
-- Evaluating existing issues (backlog-grooming)
-- Planning work strategically (roadmap-planning)
-
-```markdown
-## Capabilities
-
-This agent can:
-- Review and improve existing issues
-- Create new well-structured issues
-- Analyze the backlog for gaps and priorities
-- Plan feature breakdowns
-- Maintain roadmap clarity
-```
-
-**Capabilities section** tells spawners what to expect. Each capability maps to skill combinations:
-- "Review and improve" = backlog-grooming + issue-writing
-- "Create new issues" = gitea + issue-writing
-- "Analyze backlog" = backlog-grooming + roadmap-planning
-- "Plan breakdowns" = roadmap-planning + issue-writing
-
-```markdown
-## When to Use
-
-Spawn this agent for:
-- Batch operations on multiple issues
-- Comprehensive backlog reviews
-- Feature planning that requires codebase exploration
-- Complex issue creation with dependencies
-```
-
-**When to Use section** guides appropriate usage. Note the criteria:
-- "Batch operations" → Parallel/isolation benefit
-- "Comprehensive reviews" → Complex workflow benefit
-- "Requires exploration" → Context isolation benefit
-- "Complex with dependencies" → Multi-skill benefit
-
-```markdown
-## Behavior
-
-- Always fetches current issue state before making changes
-- Asks for approval before creating or modifying issues
-- Provides clear summaries of actions taken
-- Uses the tea CLI for all Forgejo operations
-```
-
-**Behavior section** sets operational rules. These ensure:
-- Accuracy: Fetches current state, doesn't assume
-- Safety: Asks before acting
-- Transparency: Summarizes what happened
-- Consistency: Uses standard tooling
-
-## Naming Conventions
-
-### Agent Folder Names
-
-- Use **kebab-case**: `product-manager`, `code-reviewer`
-- Name by **role or persona**: what the agent "is"
-- Keep **recognizable**: familiar roles are easier to understand
-
-Good names:
-- `product-manager` - Recognizable role
-- `code-reviewer` - Clear function
-- `security-auditor` - Specific expertise
-- `documentation-writer` - Focused purpose
-
-Avoid:
-- `helper` - Too vague
-- `do-stuff` - Not a role
-- `issue-thing` - Not recognizable
-
-### Agent Titles
-
-The H1 title in `AGENT.md` should be the role name in Title Case:
-
-| Folder | Title |
-|--------|-------|
-| `product-manager` | Product Manager Agent |
-| `code-reviewer` | Code Reviewer Agent |
-| `security-auditor` | Security Auditor Agent |
-
-## Model Selection
-
-Agents can specify which Claude model to use via the `model` field in YAML frontmatter. Choosing the right model balances capability, speed, and cost.
-
-### Available Models
-
-| Model | Characteristics | Best For |
-|-------|-----------------|----------|
-| `haiku` | Fastest, most cost-effective | Simple structured tasks, formatting, basic transformations |
-| `sonnet` | Balanced speed and capability | Most agent tasks, code review, issue management |
-| `opus` | Most capable, best reasoning | Complex analysis, architectural decisions, nuanced judgment |
-| `inherit` | Uses parent context's model | When agent should match caller's capability level |
-
-### Decision Matrix
-
-| Agent Task Type | Recommended Model | Reasoning |
-|-----------------|-------------------|-----------|
-| Structured output formatting | `haiku` | Pattern-following, no complex reasoning |
-| Code review (style/conventions) | `sonnet` | Needs code understanding, not deep analysis |
-| Security vulnerability analysis | `opus` | Requires nuanced judgment, high stakes |
-| Issue triage and labeling | `haiku` or `sonnet` | Mostly classification tasks |
-| Feature planning and breakdown | `sonnet` or `opus` | Needs strategic thinking |
-| Batch processing (many items) | `haiku` or `sonnet` | Speed and cost matter at scale |
-| Architectural exploration | `opus` | Complex reasoning about tradeoffs |
-
-### Examples
-
-These examples show recommended model configurations for different agent types:
-
-**Code Reviewer Agent** - Use `sonnet`:
-```yaml
----
-name: code-reviewer
-model: sonnet
-skills: gitea, code-review
----
-```
-Code review requires understanding code patterns and conventions but rarely needs the deepest reasoning. Sonnet provides good balance.
-
-**Security Auditor Agent** (hypothetical) - Use `opus`:
-```yaml
----
-name: security-auditor
-model: opus
-skills: code-review  # would add security-specific skills
----
-```
-Security analysis requires careful, nuanced judgment where missing issues have real consequences. Worth the extra capability.
-
-**Formatting Agent** (hypothetical) - Use `haiku`:
-```yaml
----
-name: markdown-formatter
-model: haiku
-skills: documentation
----
-```
-Pure formatting tasks follow patterns and don't require complex reasoning. Haiku is fast and sufficient.
-
-### Best Practices for Model Selection
-
-1. **Start with `sonnet`** - It handles most agent tasks well
-2. **Use `haiku` for volume** - When processing many items, speed and cost add up
-3. **Reserve `opus` for judgment** - Use when errors are costly or reasoning is complex
-4. **Avoid `inherit` by default** - Make a deliberate choice; `inherit` obscures the decision
-5. **Consider the stakes** - Higher consequence tasks warrant more capable models
-6. **Test with real tasks** - Verify the chosen model performs adequately
-
-### When to Use `inherit`
-
-The `inherit` option has legitimate uses:
-
-- **Utility agents**: Small helpers that should match their caller's capability
-- **Delegation chains**: When an agent spawns sub-agents that should stay consistent
-- **Testing/development**: When you want to control model from the top level
-
-However, most production agents should specify an explicit model.
-
-## Best Practices
-
-### 1. Choose Skills Deliberately
-
-Include only skills the agent needs. More skills = more context = potential confusion.
-
-**Too many skills:**
-```markdown
-## Skills
-- gitea
-- issue-writing
-- backlog-grooming
-- roadmap-planning
-- code-review
-- testing
-- documentation
-- deployment
-```
-
-**Right-sized:**
-```markdown
-## Skills
-- gitea
-- issue-writing
-- backlog-grooming
-- roadmap-planning
-```
-
-### 2. Define Clear Boundaries
-
-Agents should know what they can and cannot do.
-
-**Vague:**
-```markdown
-## Capabilities
-This agent can help with project management.
-```
-
-**Clear:**
-```markdown
-## Capabilities
-This agent can:
-- Review and improve existing issues
-- Create new well-structured issues
-- Analyze the backlog for gaps
-
-This agent cannot:
-- Merge pull requests
-- Deploy code
-- Make architectural decisions
-```
-
-### 3. Set Behavioral Guardrails
-
-Prevent agents from causing problems by setting explicit rules.
-
-**Important behaviors to specify:**
-- When to ask for approval
-- What to do before making changes
-- How to report results
-- Error handling expectations
-
-### 4. Match Persona to Purpose
-
-The agent's name and description should align with its skills and capabilities.
-
-**Mismatched:**
-```markdown
-# Security Agent
-
-## Skills
-- issue-writing
-- documentation
-```
-
-**Aligned:**
-```markdown
-# Security Auditor Agent
-
-## Skills
-- security-scanning
-- vulnerability-assessment
-- code-review
-```
-
-### 5. Keep Agents Focused
-
-One agent = one role. If an agent does too many unrelated things, split it.
-
-**Too broad:**
-```markdown
-# Everything Agent
-Handles issues, code review, deployment, and customer support.
-```
-
-**Focused:**
-```markdown
-# Product Manager Agent
-Specialized for backlog management and roadmap planning.
-```
-
-## When to Create a New Agent
-
-Create an agent when you need:
-
-1. **Role-based expertise**: A recognizable persona improves outputs
-2. **Skill composition**: Multiple skills work better together
-3. **Context isolation**: Work shouldn't pollute main conversation
-4. **Parallel capability**: Tasks can run independently
-5. **Autonomous operation**: Agent should figure things out on its own
-
-### Signs You Need a New Agent
-
-- Commands repeatedly spawn similar skill combinations
-- Tasks require deep exploration that pollutes context
-- Work benefits from a specialist "persona"
-- Batch processing would help
-
-### Signs You Don't Need a New Agent
-
-- Single skill is sufficient
-- Task is simple and sequential
-- Main context is helpful, not harmful
-- No clear persona or role emerges
-
-## Agent Lifecycle
-
-### 1. Design
-
-Define the agent's role:
-- What persona makes sense?
-- Which skills does it need?
-- What can it do (and not do)?
-- When should it be spawned?
-
-### 2. Implement
-
-Create the agent file:
-- Clear name and description
-- Appropriate skill list
-- Specific capabilities
-- Usage guidance
-- Behavioral rules
-
-### 3. Integrate
-
-Connect the agent to workflows:
-- Update commands that should spawn it
-- Document in ARCHITECTURE.md
-- Test with real tasks
-
-### 4. Refine
-
-Improve based on usage:
-- Add/remove skills as needed
-- Clarify capabilities
-- Strengthen behavioral rules
-- Update documentation
-
-## Checklist: Before Submitting a New Agent
-
-### Structure
-- [ ] File is at `agents/<name>/AGENT.md`
-- [ ] Name follows kebab-case convention
-- [ ] Agent has a clear, recognizable role
-
-### Frontmatter
-- [ ] `name` and `description` fields are set
-- [ ] `model` selection is deliberate (not just `inherit` by default)
-- [ ] `skills` list is deliberate (not too many, not too few)
-- [ ] Consider `disallowedTools` if agent should be restricted
-- [ ] Consider `permissionMode` for trusted agents
-- [ ] Consider `hooks` for validation or logging
-
-### Content
-- [ ] Capabilities are specific and achievable
-- [ ] "When to Use" guidance is clear
-- [ ] Behavioral rules prevent problems
-
-### Integration
-- [ ] Consider if built-in agents (Explore, Plan) could be used instead
-- [ ] Agent is referenced by at least one command
-- [ ] ARCHITECTURE.md is updated
-
-## See Also
-
-- [ARCHITECTURE.md](../ARCHITECTURE.md): How agents fit into the overall system
-- [writing-skills.md](writing-skills.md): Creating the skills that agents use
-- [VISION.md](../VISION.md): The philosophy behind composable components

docs/writing-capabilities.md

@@ -0,0 +1,508 @@
+# Writing Capabilities
+
+A comprehensive guide to creating capabilities for the Claude Code AI workflow system.
+
+> **Official Documentation**: For the most up-to-date Claude Code documentation, see https://code.claude.com/docs
+
+## Component Types
+
+The architecture repository uses two component types:
+
+| Component | Location | Purpose | Invocation |
+|-----------|----------|---------|------------|
+| **Skill** | `skills/<name>/SKILL.md` | Knowledge modules and workflows | Auto-triggered or `/skill-name` |
+| **Agent** | `agents/<name>/AGENT.md` | Isolated subtask handlers | Spawned via Task tool |
+
+### Skills: Two Types
+
+Skills come in two flavors based on the `user-invocable` frontmatter field:
+
+| Type | `user-invocable` | Purpose | Example |
+|------|------------------|---------|---------|
+| **User-invocable** | `true` | Workflows users trigger with `/skill-name` | `/work-issue`, `/dashboard` |
+| **Background** | `false` | Reference knowledge auto-loaded when needed | `gitea`, `issue-writing` |
+
+User-invocable skills replaced the former "commands" - they define workflows that users trigger directly.
+
+### Agents: Isolated Workers
+
+Agents are specialized subprocesses that:
+- Combine multiple skills into focused personas
+- Run with isolated context (don't pollute main conversation)
+- Handle complex subtasks autonomously
+- Can run in parallel or background
+
+---
+
+## Writing Skills
+
+Skills are markdown files in the `skills/` directory, each in its own folder.
+
+### File Structure
+
+```
+skills/
+├── gitea/                    # Background skill
+│   └── SKILL.md
+├── work-issue/               # User-invocable skill
+│   └── SKILL.md
+└── issue-writing/            # Background skill
+    └── SKILL.md
+```
+
+### YAML Frontmatter
+
+Every skill requires YAML frontmatter starting on line 1:
+
+```yaml
+---
+name: skill-name
+description: >
+  What this skill does and when to use it.
+  Include trigger terms for auto-detection.
+model: haiku
+user-invocable: true
+argument-hint: <required-arg> [optional-arg]
+---
+```
+
+#### Required Fields
+
+| Field | Description |
+|-------|-------------|
+| `name` | Lowercase, hyphens only (max 64 chars). Must match directory name. |
+| `description` | What the skill does + when to use (max 1024 chars). Critical for triggering. |
+
+#### Optional Fields
+
+| Field | Description |
+|-------|-------------|
+| `user-invocable` | Whether skill appears in `/` menu. Default: `true` |
+| `model` | Model to use: `haiku`, `sonnet`, `opus` |
+| `argument-hint` | For user-invocable: `<required>`, `[optional]` |
+| `context` | Use `fork` for isolated context |
+| `allowed-tools` | Restrict available tools (YAML list) |
+| `hooks` | Define PreToolUse, PostToolUse, or Stop hooks |
+
+### User-Invocable Skills (Workflows)
+
+These replace the former "commands" - workflows users invoke with `/skill-name`.
+
+**Example: `/work-issue`**
+
+```yaml
+---
+name: work-issue
+description: >
+  Work on a Gitea issue. Fetches issue details and sets up branch.
+  Use when working on issues, implementing features, or when user says /work-issue.
+model: haiku
+argument-hint: <issue-number>
+user-invocable: true
+---
+
+# Work on Issue #$1
+
+@~/.claude/skills/gitea/SKILL.md
+@~/.claude/skills/software-architecture/SKILL.md
+
+1. **View the issue** with `--comments` flag
+2. **Create a branch**: `git checkout -b issue-$1-<short-title>`
+3. **Plan**: Use TodoWrite to break down work
+4. **Implement** following architectural patterns
+5. **Commit** with message referencing the issue
+6. **Push** and **Create PR**
+```
+
+**Key patterns for user-invocable skills:**
+
+1. **Argument handling**: Use `$1`, `$2` for positional arguments
+2. **Skill references**: Use `@~/.claude/skills/name/SKILL.md` to include background skills
+3. **Approval workflows**: Ask before significant actions
+4. **Clear steps**: Numbered, actionable workflow steps
+
+### Background Skills (Reference)
+
+Knowledge modules that Claude applies automatically when context matches.
+
+**Example: `gitea`**
+
+```yaml
+---
+name: gitea
+description: >
+  View, create, and manage Gitea issues and pull requests using tea CLI.
+  Use when working with issues, PRs, or when user mentions tea, gitea.
+model: haiku
+user-invocable: false
+---
+
+# Gitea CLI (tea)
+
+## Common Commands
+
+### Issues
+```bash
+tea issues                    # List open issues
+tea issues <number>           # View issue details
+tea issues create --title "..." --description "..."
+```
+...
+```
+
+**Key patterns for background skills:**
+
+1. **Rich descriptions**: Include trigger terms like tool names, actions
+2. **Reference material**: Commands, templates, patterns, checklists
+3. **No workflow steps**: Just knowledge, not actions
+
+### Writing Effective Descriptions
+
+The `description` field determines when Claude applies the skill. Include:
+
+1. **What the skill does**: Specific capabilities
+2. **When to use it**: Trigger terms users would mention
+
+**Bad:**
+```yaml
+description: Helps with documents
+```
+
+**Good:**
+```yaml
+description: >
+  View, create, and manage Gitea issues and pull requests using tea CLI.
+  Use when working with issues, PRs, viewing issue details, creating pull
+  requests, or when the user mentions tea, gitea, or issue numbers.
+```
+
+### Argument Handling (User-Invocable Skills)
+
+User-invocable skills can accept arguments via `$1`, `$2`, etc.
+
+**Argument hints:**
+- `<arg>` - Required argument
+- `[arg]` - Optional argument
+- `<arg1> [arg2]` - Mix of both
+
+**Example with optional argument:**
+```yaml
+---
+name: groom
+argument-hint: [issue-number]
+---
+
+# Groom Issues
+
+## If issue number provided ($1):
+1. Fetch that specific issue
+2. Evaluate against checklist
+...
+
+## If no argument:
+1. List all open issues
+2. Review each against checklist
+...
+```
+
+### Skill References
+
+User-invocable skills include background skills using file references:
+
+```markdown
+@~/.claude/skills/gitea/SKILL.md
+@~/.claude/skills/issue-writing/SKILL.md
+```
+
+**Important**: Do NOT use phrases like "Use the gitea skill" - skills have ~20% auto-activation rate. File references guarantee the content is loaded.
+
+### Approval Workflows
+
+User-invocable skills should ask for approval before significant actions:
+
+```markdown
+4. **Present plan** for approval
+5. **If approved**, create the issues
+6. **Present summary** with links
+```
+
+---
+
+## Writing Agents
+
+Agents are specialized subprocesses that combine skills for complex, isolated tasks.
+
+### File Structure
+
+```
+agents/
+└── code-reviewer/
+    └── AGENT.md
+```
+
+### YAML Frontmatter
+
+```yaml
+---
+name: code-reviewer
+description: Review code for quality, bugs, and style issues
+model: sonnet
+skills: gitea, code-review
+disallowedTools:
+  - Edit
+  - Write
+---
+```
+
+#### Required Fields
+
+| Field | Description |
+|-------|-------------|
+| `name` | Agent identifier (lowercase, hyphens). Match directory name. |
+| `description` | What the agent does. Used for matching when spawning. |
+
+#### Optional Fields
+
+| Field | Description |
+|-------|-------------|
+| `model` | `haiku`, `sonnet`, `opus`, or `inherit` |
+| `skills` | Comma-separated skill names the agent can access |
+| `disallowedTools` | Block specific tools (e.g., Edit, Write for read-only) |
+| `permissionMode` | `default` or `bypassPermissions` |
+| `hooks` | Define PreToolUse, PostToolUse, or Stop hooks |
+
+### Agent Document Structure
+
+```markdown
+# Agent Name
+
+Brief description of the agent's role.
+
+## Skills
+- skill1
+- skill2
+
+## Capabilities
+What the agent can do.
+
+## When to Use
+Guidance on when to spawn this agent.
+
+## Behavior
+Operational rules and constraints.
+```
+
+### Built-in Agents
+
+Claude Code provides built-in agents - prefer these before creating custom ones:
+
+| Agent | Purpose |
+|-------|---------|
+| **Explore** | Codebase exploration, finding files, searching code |
+| **Plan** | Implementation planning, architectural decisions |
+
+### Skill Composition
+
+Agents gain expertise by combining skills:
+
+```
+┌─────────────────────────────────────────┐
+│         Code Reviewer Agent             │
+│                                         │
+│  ┌─────────┐  ┌─────────────┐           │
+│  │ gitea   │  │ code-review │           │
+│  │ CLI     │  │ patterns    │           │
+│  └─────────┘  └─────────────┘           │
+│                                         │
+└─────────────────────────────────────────┘
+```
+
+### Use Cases for Agents
+
+1. **Parallel processing**: Spawn multiple agents for independent tasks
+2. **Context isolation**: Deep exploration without polluting main context
+3. **Complex workflows**: Iterative decision-making with multiple skills
+4. **Background execution**: Long-running tasks while user continues working
+
+### Model Selection
+
+| Model | Best For |
+|-------|----------|
+| `haiku` | Simple tasks, formatting, batch processing |
+| `sonnet` | Most agent tasks, code review (default choice) |
+| `opus` | Complex analysis, security audits, architectural decisions |
+
+---
+
+## Decision Guide
+
+### When to Create a User-Invocable Skill
+
+Create when you have:
+- Repeatable workflow used multiple times
+- User explicitly triggers the action
+- Clear start and end points
+- Approval checkpoints needed
+
+### When to Create a Background Skill
+
+Create when:
+- You explain the same concepts repeatedly
+- Multiple user-invocable skills need the same knowledge
+- Quality is inconsistent without explicit guidance
+- There's a clear domain that doesn't fit existing skills
+
+### When to Create an Agent
+
+Create when:
+- Multiple skills needed together for complex tasks
+- Context isolation required
+- Parallel execution possible
+- Autonomous exploration needed
+- Specialist persona improves outputs
+
+### Decision Matrix
+
+| Scenario | Component | Reason |
+|----------|-----------|--------|
+| User types `/work-issue 42` | User-invocable skill | Explicit user trigger |
+| Need tea CLI reference | Background skill | Auto-loaded knowledge |
+| Review 20 issues in parallel | Agent | Batch processing, isolation |
+| Create one issue | User-invocable skill | Single workflow |
+| Deep architectural analysis | Agent | Complex, isolated work |
+
+---
+
+## Templates
+
+### User-Invocable Skill Template
+
+```yaml
+---
+name: skill-name
+description: >
+  What this skill does and when to use it.
+  Use when [trigger conditions] or when user says /skill-name.
+model: haiku
+argument-hint: <required> [optional]
+user-invocable: true
+---
+
+# Skill Title
+
+@~/.claude/skills/relevant-skill/SKILL.md
+
+Brief intro if needed.
+
+1. **First step**: What to do
+2. **Second step**: What to do next
+3. **Ask for approval** before significant actions
+4. **Execute** the approved actions
+5. **Present results** with links and summary
+```
+
+### Background Skill Template
+
+```yaml
+---
+name: skill-name
+description: >
+  What this skill teaches and when to use it.
+  Include trigger conditions in description.
+user-invocable: false
+---
+
+# Skill Name
+
+Brief description of what this skill covers.
+
+## Core Concepts
+
+Explain fundamental ideas.
+
+## Patterns and Templates
+
+Provide reusable structures.
+
+## Guidelines
+
+List rules and best practices.
+
+## Examples
+
+Show concrete illustrations.
+
+## Common Mistakes
+
+Document pitfalls to avoid.
+```
+
+### Agent Template
+
+```yaml
+---
+name: agent-name
+description: What this agent does and when to spawn it
+model: sonnet
+skills: skill1, skill2
+---
+
+You are a [role] specialist that [primary function].
+
+## When Invoked
+
+1. **Gather context**: What to collect
+2. **Analyze**: What to evaluate
+3. **Act**: What actions to take
+4. **Report**: How to communicate results
+
+## Output Format
+
+Describe expected output structure.
+
+## Guidelines
+
+- Behavioral rules
+- Constraints
+- Quality standards
+```
+
+---
+
+## Checklists
+
+### Before Creating a User-Invocable Skill
+
+- [ ] Workflow is repeatable (used multiple times)
+- [ ] User explicitly triggers it
+- [ ] File at `skills/<name>/SKILL.md`
+- [ ] `user-invocable: true` in frontmatter
+- [ ] `description` includes "Use when... or when user says /skill-name"
+- [ ] Background skills referenced via `@~/.claude/skills/<name>/SKILL.md`
+- [ ] Approval checkpoints before significant actions
+- [ ] Clear numbered workflow steps
+
+### Before Creating a Background Skill
+
+- [ ] Knowledge used in multiple places
+- [ ] Doesn't fit existing skills
+- [ ] File at `skills/<name>/SKILL.md`
+- [ ] `user-invocable: false` in frontmatter
+- [ ] `description` includes trigger terms
+- [ ] Content is specific and actionable
+
+### Before Creating an Agent
+
+- [ ] Built-in agents (Explore, Plan) aren't sufficient
+- [ ] Context isolation or skill composition needed
+- [ ] File at `agents/<name>/AGENT.md`
+- [ ] `model` selection is deliberate
+- [ ] `skills` list is right-sized
+- [ ] Clear role/persona emerges
+
+---
+
+## See Also
+
+- [ARCHITECTURE.md](../ARCHITECTURE.md): How components fit together
+- [skills/capability-writing/SKILL.md](../skills/capability-writing/SKILL.md): Quick reference

docs/writing-commands.md

@@ -1,731 +0,0 @@
-# Writing Commands
-
-A guide to creating user-facing entry points that trigger workflows.
-
-## What is a Command?
-
-Commands are **user-facing entry points** that trigger workflows. Unlike skills (which encode knowledge) or agents (which execute tasks autonomously), commands define *what* to do—they orchestrate the workflow that users invoke directly.
-
-Think of commands as the interface between users and the system. Users type `/work-issue 42` and the command defines the entire workflow: fetch issue, create branch, implement, commit, push, create PR.
-
-## File Structure
-
-Commands live directly in the `commands/` directory as markdown files:
-
-```
-commands/
-├── work-issue.md
-├── dashboard.md
-├── review-pr.md
-├── create-issue.md
-├── groom.md
-├── roadmap.md
-└── plan-issues.md
-```
-
-### Why Flat Files?
-
-Unlike skills and agents (which use folders), commands are single files because:
-- Commands are self-contained workflow definitions
-- No supporting files needed
-- Simple naming: `/work-issue` maps to `work-issue.md`
-
-## Command Document Structure
-
-A well-structured command file has two parts:
-
-### 1. Frontmatter (YAML Header)
-
-```yaml
----
-description: Brief description shown in command listings
-argument-hint: <required-arg> [optional-arg]
----
-```
-
-#### Required Fields
-
-| Field | Purpose |
-|-------|---------|
-| `description` | One-line summary for help/listings |
-
-#### Optional Fields
-
-| Field | Purpose |
-|-------|---------|
-| `argument-hint` | Shows expected arguments (e.g., `<issue-number>`, `[title]`) |
-| `model` | Model to use: `haiku`, `sonnet`, `opus`. Overrides session default. |
-| `context` | Execution context. Use `fork` to run in isolated sub-agent context. |
-| `hooks` | Define PreToolUse, PostToolUse, or Stop hooks scoped to this command. |
-| `allowed-tools` | Restrict which tools the command can use. |
-
-### 2. Body (Markdown Instructions)
-
-```markdown
-# Command Title
-
-Brief intro if needed.
-
-1. **Step one**: What to do
-2. **Step two**: What to do next
-...
-```
-
-The body contains the workflow steps that Claude follows when the command is invoked.
-
-## Complete Command Example
-
-```markdown
----
-description: Work on a Gitea issue. Fetches issue details and sets up branch.
-argument-hint: <issue-number>
----
-
-# Work on Issue #$1
-
-@~/.claude/skills/gitea/SKILL.md
-
-1. **View the issue** to understand requirements
-2. **Create a branch**: `git checkout -b issue-$1-<short-kebab-title>`
-3. **Plan**: Use TodoWrite to break down the work
-4. **Implement** the changes
-5. **Commit** with message referencing the issue
-6. **Push** the branch to origin
-7. **Create PR** with title "[Issue #$1] <title>" and body "Closes #$1"
-```
-
-## Advanced Frontmatter Examples
-
-**Command with specific model:**
-```yaml
----
-description: Plan complex feature implementation.
-argument-hint: <feature-description>
-model: opus
----
-```
-
-**Command with isolated context (prevents context pollution):**
-```yaml
----
-description: Analyze codebase architecture deeply.
-context: fork
-model: haiku
----
-```
-
-**Command with hooks:**
-```yaml
----
-description: Deploy to production environment.
-hooks:
-  - type: PreToolUse
-    matcher: Bash
-    command: echo "Validating deployment command..."
-  - type: Stop
-    command: ./scripts/notify-deployment.sh
----
-```
-
-**Read-only command with tool restrictions:**
-```yaml
----
-description: Generate codebase report without modifications.
-allowed-tools:
-  - Read
-  - Glob
-  - Grep
----
-```
-
-## Argument Handling
-
-Commands can accept arguments from the user. Arguments are passed via positional variables: `$1`, `$2`, etc.
-
-### The ARGUMENTS Pattern
-
-When users invoke a command with arguments:
-```
-/work-issue 42
-```
-
-The system provides the arguments via the `$1`, `$2`, etc. placeholders in the command body:
-```markdown
-# Work on Issue #$1
-1. **View the issue** to understand requirements
-```
-
-Becomes:
-```markdown
-# Work on Issue #42
-1. **View the issue** to understand requirements
-```
-
-### Argument Hints
-
-Use `argument-hint` in frontmatter to document expected arguments:
-
-| Pattern | Meaning |
-|---------|---------|
-| `<arg>` | Required argument |
-| `[arg]` | Optional argument |
-| `<arg1> <arg2>` | Multiple required |
-| `[arg1] [arg2]` | Multiple optional |
-| `<required> [optional]` | Mix of both |
-
-Examples:
-```yaml
-argument-hint: <issue-number>           # One required
-argument-hint: [issue-number]           # One optional
-argument-hint: <title> [description]    # Required + optional
-argument-hint: [title] or "batch"       # Choice of modes
-```
-
-### Handling Optional Arguments
-
-Commands often have different behavior based on whether arguments are provided:
-
-```markdown
----
-description: Groom issues. Without argument, reviews all. With argument, grooms specific issue.
-argument-hint: [issue-number]
----
-
-# Groom Issues
-
-@~/.claude/skills/gitea/SKILL.md
-
-## If issue number provided ($1):
-1. **Fetch the issue** details
-2. **Evaluate** against checklist
-...
-
-## If no argument (groom all):
-1. **List open issues**
-2. **Review each** against checklist
-...
-```
-
-### Multiple Modes
-
-Some commands support distinct modes based on the first argument:
-
-```markdown
----
-description: Create issues. Single or batch mode.
-argument-hint: [title] or "batch"
----
-
-# Create Issue(s)
-
-@~/.claude/skills/gitea/SKILL.md
-
-## Single Issue (default)
-If title provided, create an issue with that title.
-
-## Batch Mode
-If $1 is "batch":
-1. Ask user for the plan
-2. Generate list of issues
-3. Show for approval
-4. Create each issue
-```
-
-## Including Skills
-
-Commands include skills using the `@` file reference syntax. This automatically injects the skill content into the command context when the command is invoked.
-
-### File Reference Syntax
-
-Use the `@` prefix followed by the path to the skill file:
-
-```markdown
-# Groom Issues
-
-@~/.claude/skills/gitea/SKILL.md
-@~/.claude/skills/backlog-grooming/SKILL.md
-@~/.claude/skills/issue-writing/SKILL.md
-
-1. **Fetch the issue** details
-2. **Evaluate** against grooming checklist
-...
-```
-
-When the command runs, the content of each referenced skill file is automatically loaded into context.
-
-### Why File References?
-
-**DO NOT** use phrases like "Use the gitea skill" - skills have only ~20% auto-activation rate. File references guarantee the skill content is available.
-
-| Pattern | Behavior |
-|---------|----------|
-| `@~/.claude/skills/gitea/SKILL.md` | Content automatically injected |
-| "Use the gitea skill" | Relies on auto-activation (~20% success) |
-
-### When to Include Skills
-
-| Include explicitly | Skip skill reference |
-|-------------------|---------------------|
-| CLI syntax is needed | Well-known commands |
-| Core methodology required | Simple operations |
-| Quality standards matter | One-off actions |
-| Patterns should be followed | No domain knowledge needed |
-
-## Invoking Agents
-
-Commands can spawn agents for complex subtasks that benefit from skill composition or context isolation.
-
-### Spawning Agents
-
-```markdown
-For comprehensive backlog review, spawn the **product-manager** agent to:
-- Review all open issues
-- Categorize by readiness
-- Propose improvements
-```
-
-### When to Spawn Agents
-
-Spawn an agent when the command needs:
-- **Parallel processing**: Multiple independent tasks
-- **Context isolation**: Deep exploration that would pollute main context
-- **Skill composition**: Multiple skills working together
-- **Autonomous operation**: Let the agent figure out details
-
-### Example: Conditional Agent Spawning
-
-```markdown
-# Groom Issues
-
-## If no argument (groom all):
-For large backlogs (>10 issues), consider spawning the
-product-manager agent to handle the review autonomously.
-```
-
-## Interactive Patterns
-
-Commands often require user interaction for confirmation, choices, or input.
-
-### Approval Workflows
-
-Always ask for approval before significant actions:
-
-```markdown
-5. **Ask for approval** before creating issues
-6. **Create issues** in order
-```
-
-Common approval points:
-- Before creating/modifying resources (issues, PRs, files)
-- Before executing destructive operations
-- When presenting a plan that will be executed
-
-### Presenting Choices
-
-When the command leads to multiple possible actions:
-
-```markdown
-Ask the user what action to take:
-- **Merge**: Approve and merge the PR
-- **Request changes**: Leave feedback without merging
-- **Comment only**: Add a comment for discussion
-```
-
-### Gathering Input
-
-Some commands need to gather information from the user:
-
-```markdown
-## 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
-```
-
-### Presenting Results
-
-Commands should clearly show what was done:
-
-```markdown
-7. **Update dependencies** with actual issue numbers after creation
-8. **Present summary** with links to created issues
-```
-
-Good result presentations include:
-- Tables for lists of items
-- Links for created resources
-- Summaries of changes made
-- Next step suggestions
-
-## Annotated Examples
-
-Let's examine existing commands to understand effective patterns.
-
-### Example 1: work-issue (Linear Workflow)
-
-```markdown
----
-description: Work on a Gitea issue. Fetches issue details and sets up branch.
-argument-hint: <issue-number>
----
-
-# Work on Issue #$1
-
-@~/.claude/skills/gitea/SKILL.md
-
-1. **View the issue** to understand requirements
-2. **Create a branch**: `git checkout -b issue-$1-<short-kebab-title>`
-3. **Plan**: Use TodoWrite to break down the work
-4. **Implement** the changes
-5. **Commit** with message referencing the issue
-6. **Push** the branch to origin
-7. **Create PR** with title "[Issue #$1] <title>" and body "Closes #$1"
-```
-
-**Key patterns:**
-- **Linear workflow**: Clear numbered steps in order
-- **Required argument**: `<issue-number>` means must provide
-- **Variable substitution**: `$1` used throughout
-- **Skill reference**: Uses gitea skill for CLI knowledge
-- **Git integration**: Branch and push steps specified
-
-### Example 2: dashboard (No Arguments)
-
-```markdown
----
-description: Show dashboard of open issues, PRs awaiting review, and CI status.
----
-
-# Repository Dashboard
-
-@~/.claude/skills/gitea/SKILL.md
-
-Fetch and display:
-1. All open issues
-2. All open PRs
-
-Format as tables showing issue/PR number, title, and author.
-```
-
-**Key patterns:**
-- **No argument-hint**: Command takes no arguments
-- **Output formatting**: Specifies how to present results
-- **Aggregation**: Combines multiple data sources
-- **Simple workflow**: Just fetch and display
-
-### Example 3: groom (Optional Argument with Modes)
-
-```markdown
----
-description: Groom and improve issues. Without argument, reviews all. With argument, grooms specific issue.
-argument-hint: [issue-number]
----
-
-# Groom Issues
-
-@~/.claude/skills/gitea/SKILL.md
-@~/.claude/skills/backlog-grooming/SKILL.md
-@~/.claude/skills/issue-writing/SKILL.md
-
-## If issue number provided ($1):
-1. **Fetch the issue** details
-2. **Evaluate** against grooming checklist
-3. **Suggest improvements** for:
-   - Title clarity
-   - Description completeness
-   - Acceptance criteria quality
-4. **Ask user** if they want to apply changes
-5. **Update issue** if approved
-
-## If no argument (groom all):
-1. **List open issues**
-2. **Review each** against grooming checklist
-3. **Categorize**: Ready / Needs work / Stale
-4. **Present summary** table
-5. **Offer to improve** issues that need work
-```
-
-**Key patterns:**
-- **Optional argument**: `[issue-number]` with brackets
-- **Mode switching**: Different behavior based on argument presence
-- **Skill file references**: Uses `@~/.claude/skills/` to include multiple skills
-- **Approval workflow**: "Ask user if they want to apply changes"
-- **Categorization**: Groups items for presentation
-
-### Example 4: plan-issues (Complex Workflow)
-
-```markdown
----
-description: Plan and create issues for a feature. Breaks down work into well-structured issues.
-argument-hint: <feature-description>
----
-
-# Plan Feature: $1
-
-@~/.claude/skills/gitea/SKILL.md
-@~/.claude/skills/roadmap-planning/SKILL.md
-@~/.claude/skills/issue-writing/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
-4. **Present the plan**:
-   ```
-   ## Proposed Issues for: $1
-
-   1. [Title] - Brief description
-      Dependencies: none
-   ...
-   ```
-5. **Ask for approval** before creating issues
-6. **Create issues** in order
-7. **Update dependencies** with actual issue numbers
-8. **Present summary** with links to created issues
-```
-
-**Key patterns:**
-- **Multi-skill composition**: Includes three skills via `@~/.claude/skills/`
-- **Codebase exploration**: May need to understand context
-- **Structured output**: Template for presenting the plan
-- **Two-phase execution**: Plan first, then execute after approval
-- **Dependency management**: Creates issues in order, updates references
-
-### Example 5: review-pr (Action Choices)
-
-```markdown
----
-description: Review a Gitea pull request. Fetches PR details, diff, and comments.
-argument-hint: <pr-number>
----
-
-# Review PR #$1
-
-@~/.claude/skills/gitea/SKILL.md
-
-1. **View PR details** including description and metadata
-2. **Get the diff** to review the changes
-
-Review the changes and provide feedback on:
-- Code quality
-- Potential bugs
-- Test coverage
-- Documentation
-
-Ask the user what action to take:
-- **Merge**: Approve and merge the PR
-- **Request changes**: Leave feedback without merging
-- **Comment only**: Add a comment for discussion
-```
-
-**Key patterns:**
-- **Information gathering**: Fetches context before analysis
-- **Review criteria**: Checklist of what to examine
-- **Action menu**: Clear choices with explanations
-- **User decides outcome**: Command presents options, user chooses
-
-## Naming Conventions
-
-### Command File Names
-
-- Use **kebab-case**: `work-issue.md`, `plan-issues.md`
-- Use **verbs or verb phrases**: Commands are actions
-- Be **concise**: 1-3 words is ideal
-- Match the **invocation**: `/work-issue` → `work-issue.md`
-
-Good names:
-- `work-issue` - Action + target
-- `dashboard` - What it shows
-- `review-pr` - Action + target
-- `plan-issues` - Action + target
-- `groom` - Action (target implied)
-
-Avoid:
-- `issue-work` - Noun-first is awkward
-- `do-stuff` - Too vague
-- `manage-issues-and-prs` - Too long
-
-### Command Titles
-
-The H1 title can be more descriptive than the filename:
-
-| Filename | Title |
-|----------|-------|
-| `work-issue.md` | Work on Issue #$1 |
-| `dashboard.md` | Repository Dashboard |
-| `plan-issues.md` | Plan Feature: $1 |
-
-## Best Practices
-
-### 1. Design Clear Workflows
-
-Each step should be unambiguous:
-
-**Vague:**
-```markdown
-1. Handle the issue
-2. Do the work
-3. Finish up
-```
-
-**Clear:**
-```markdown
-1. **View the issue** to understand requirements
-2. **Create a branch**: `git checkout -b issue-$1-<title>`
-3. **Plan**: Use TodoWrite to break down the work
-```
-
-### 2. Show Don't Tell
-
-Include actual commands and expected outputs:
-
-**Telling:**
-```markdown
-List the open issues.
-```
-
-**Showing:**
-```markdown
-Fetch all open issues and format as table:
-| # | Title | Author |
-|---|-------|--------|
-```
-
-### 3. Always Ask Before Acting
-
-Never modify resources without user approval:
-
-```markdown
-4. **Present plan** for approval
-5. **If approved**, create the issues
-```
-
-### 4. Handle Edge Cases
-
-Consider what happens when things are empty or unexpected:
-
-```markdown
-## If no argument (groom all):
-1. **List open issues**
-2. If no issues found, report "No open issues to groom"
-3. Otherwise, **review each** against checklist
-```
-
-### 5. Provide Helpful Output
-
-End with useful information:
-
-```markdown
-8. **Present summary** with:
-   - Links to created issues
-   - Dependency graph
-   - Suggested next steps
-```
-
-### 6. Keep Commands Focused
-
-One command = one workflow. If doing multiple unrelated things, split into separate commands.
-
-**Too broad:**
-```markdown
-# Manage Everything
-Handle issues, PRs, deployments, and documentation...
-```
-
-**Focused:**
-```markdown
-# Review PR #$1
-Review and take action on a pull request...
-```
-
-## When to Create a Command
-
-Create a command when you have:
-
-1. **Repeatable workflow**: Same steps used multiple times
-2. **User-initiated action**: User explicitly triggers it
-3. **Clear start and end**: Workflow has defined boundaries
-4. **Consistent behavior needed**: Should work the same every time
-
-### Signs You Need a New Command
-
-- You're explaining the same workflow repeatedly
-- Users would benefit from a single invocation
-- Multiple tools need orchestration
-- Approval checkpoints are needed
-
-### Signs You Don't Need a Command
-
-- It's a one-time action
-- No workflow orchestration needed
-- A skill reference is sufficient
-- An agent could handle it autonomously
-
-## Command Lifecycle
-
-### 1. Design
-
-Define the workflow:
-- What triggers it?
-- What arguments does it need?
-- What steps are involved?
-- Where are approval points?
-- What does success look like?
-
-### 2. Implement
-
-Create the command file:
-- Clear frontmatter
-- Step-by-step workflow
-- Skill references where needed
-- Approval checkpoints
-- Output formatting
-
-### 3. Test
-
-Verify the workflow:
-- Run with typical arguments
-- Test edge cases (no args, invalid args)
-- Confirm approval points work
-- Check output formatting
-
-### 4. Document
-
-Update references:
-- Add to ARCHITECTURE.md table
-- Update README if user-facing
-- Note any skill/agent dependencies
-
-## Checklist: Before Submitting a New Command
-
-### Structure
-- [ ] File is at `commands/<name>.md`
-- [ ] Name follows kebab-case verb convention
-
-### Frontmatter (Required)
-- [ ] `description` is set with clear one-line summary
-- [ ] `argument-hint` is set (if command takes arguments)
-
-### Frontmatter (Consider)
-- [ ] `model` if command benefits from specific model (e.g., `opus` for complex planning)
-- [ ] `context: fork` if command does heavy exploration that would pollute context
-- [ ] `allowed-tools` if command should be restricted to certain tools
-- [ ] `hooks` if command needs validation or post-execution actions
-
-### Content
-- [ ] Workflow steps are clear and numbered
-- [ ] Commands and tools are specified explicitly
-- [ ] Skills are included via `@~/.claude/skills/<name>/SKILL.md` file references
-- [ ] Approval points exist before significant actions
-- [ ] Edge cases are handled (no data, invalid input)
-- [ ] Output formatting is specified
-
-### Integration
-- [ ] ARCHITECTURE.md is updated with new command
-
-## See Also
-
-- [ARCHITECTURE.md](../ARCHITECTURE.md): How commands fit into the overall system
-- [writing-skills.md](writing-skills.md): Creating skills that commands reference
-- [writing-agents.md](writing-agents.md): Creating agents that commands spawn
-- [VISION.md](../VISION.md): The philosophy behind composable components

docs/writing-skills.md

@@ -1,578 +0,0 @@
-# Writing Skills
-
-A guide to creating reusable knowledge modules for the Claude Code AI workflow system.
-
-> **Official Documentation**: For the most up-to-date information, see https://code.claude.com/docs/en/skills
-
-## What is a Skill?
-
-Skills are **model-invoked knowledge modules**—Claude automatically applies them when your request matches their description. Unlike commands (which require explicit `/command` invocation), skills are triggered automatically based on semantic matching.
-
-## YAML Frontmatter (Required)
-
-Every `SKILL.md` file **must** start with YAML frontmatter. This is how Claude discovers and triggers skills.
-
-### Format Requirements
-
-- Must start with `---` on **line 1** (no blank lines before it)
-- Must end with `---` before the markdown content
-- Use spaces for indentation (not tabs)
-
-### Required Fields
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `name` | **Yes** | Lowercase letters, numbers, and hyphens only (max 64 chars). Should match directory name. |
-| `description` | **Yes** | What the skill does and when to use it (max 1024 chars). **This is critical for triggering.** |
-
-### Optional Fields
-
-| Field | Description |
-|-------|-------------|
-| `allowed-tools` | **Restricts** which tools Claude can use when this skill is active. If omitted, no restrictions apply. Supports YAML-style lists. |
-| `model` | Specific model to use when skill is active (e.g., `sonnet`, `opus`, `haiku`). |
-| `user-invocable` | Whether the skill appears in the `/` command menu. Defaults to `true`. Set to `false` for reference-only skills. |
-| `context` | Execution context. Use `fork` to run skill in an isolated sub-agent context, preventing context pollution. |
-| `agent` | Agent type to use for execution. Allows skills to specify which agent handles them. |
-| `hooks` | Define PreToolUse, PostToolUse, or Stop hooks scoped to this skill's lifecycle. |
-
-### Writing Effective Descriptions
-
-The `description` field determines when Claude applies the skill. A good description answers:
-
-1. **What does this skill do?** List specific capabilities.
-2. **When should Claude use it?** Include trigger terms users would mention.
-
-**Bad (too vague):**
-```yaml
-description: Helps with documents
-```
-
-**Good (specific with trigger terms):**
-```yaml
-description: View, create, and manage Gitea issues and pull requests using tea CLI. Use when working with issues, PRs, viewing issue details, creating pull requests, adding comments, merging PRs, or when the user mentions tea, gitea, issue numbers, or PR numbers.
-```
-
-### Example Frontmatter
-
-```yaml
----
-name: gitea
-description: View, create, and manage Gitea issues and pull requests using tea CLI. Use when working with issues, PRs, viewing issue details, creating pull requests, or when the user mentions tea, gitea, or issue numbers.
-user-invocable: false
----
-
-# Gitea CLI (tea)
-
-[Rest of skill content...]
-```
-
-### Advanced Frontmatter Examples
-
-**Reference skill (not directly invocable):**
-```yaml
----
-name: gitea
-description: CLI reference for Gitea operations.
-user-invocable: false
----
-```
-
-**Skill with isolated context:**
-```yaml
----
-name: codebase-analysis
-description: Deep codebase exploration and analysis.
-context: fork
-model: haiku
----
-```
-
-**Skill with tool restrictions (YAML-style list):**
-```yaml
----
-name: read-only-review
-description: Code review without modifications.
-allowed-tools:
-  - Read
-  - Glob
-  - Grep
----
-```
-
-**Skill with hooks:**
-```yaml
----
-name: database-operations
-description: Database schema and migration operations.
-hooks:
-  - type: PreToolUse
-    matcher: Bash
-    command: echo "Validating database command..."
----
-```
-
-## Subagents and Skills
-
-Subagents **do not automatically inherit skills** from the main conversation. To give a subagent access to skills, list them in the agent's `skills` field:
-
-```yaml
----
-name: code-reviewer
-description: Review code for quality and best practices
-skills: gitea, code-review
----
-```
-
-## File Structure
-
-Skills live in the `skills/` directory, each in its own folder:
-
-```
-skills/
-├── gitea/
-│   └── SKILL.md
-├── issue-writing/
-│   └── SKILL.md
-├── backlog-grooming/
-│   └── SKILL.md
-└── roadmap-planning/
-    └── SKILL.md
-```
-
-### Why SKILL.md?
-
-The uppercase `SKILL.md` filename:
-- Makes the skill file immediately visible in directory listings
-- Follows a consistent convention across all skills
-- Clearly identifies the primary file in a skill folder
-
-### Supporting Files (Optional)
-
-A skill folder can contain additional files if needed:
-
-```
-skills/
-└── complex-skill/
-    ├── SKILL.md           # Main skill document (required)
-    ├── templates/         # Template files
-    │   └── example.md
-    └── examples/          # Extended examples
-        └── case-study.md
-```
-
-However, prefer keeping everything in `SKILL.md` when possible—it's easier to maintain and reference.
-
-## Skill Document Structure
-
-A well-structured `SKILL.md` follows this pattern:
-
-```markdown
-# Skill Name
-
-Brief description of what this skill covers.
-
-## Core Concepts
-Explain the fundamental ideas Claude needs to understand.
-
-## Patterns and Templates
-Provide reusable structures and formats.
-
-## Guidelines
-List rules, best practices, and quality standards.
-
-## Examples
-Show concrete illustrations of the skill in action.
-
-## Common Mistakes
-Document pitfalls to avoid.
-
-## Reference
-Quick-reference tables, checklists, or commands.
-```
-
-Not every skill needs all sections—include what's relevant. Some skills are primarily patterns (like `issue-writing`), others are reference-heavy (like `gitea`).
-
-## How Skills are Discovered and Triggered
-
-Skills are **model-invoked**: Claude decides which skills to use based on your request.
-
-### Discovery Process
-
-1. **At startup**: Claude loads only the `name` and `description` of each available skill
-2. **On request**: Claude matches your request against skill descriptions using semantic similarity
-3. **Activation**: When a match is found, Claude asks to use the skill before loading the full content
-
-### Hot Reload
-
-Skills support **automatic hot-reload**. When you create or modify a skill file in `~/.claude/skills/` or `.claude/skills/`, the changes are immediately available without restarting Claude Code. This enables rapid iteration when developing skills.
-
-### Visibility in Command Menu
-
-By default, skills in `/skills/` directories appear in the `/` slash command menu. Users can invoke them directly like commands. To hide a skill from the menu (e.g., for reference-only skills), add `user-invocable: false` to the frontmatter.
-
-### Subagent Access
-
-Subagents (defined in `.claude/agents/`) must explicitly list which skills they can use:
-
-```yaml
----
-name: product-manager
-description: Manages backlog and roadmap
-skills: gitea, issue-writing, backlog-grooming, roadmap-planning
----
-```
-
-**Important**: Built-in agents and the Task tool do not have access to skills. Only custom subagents with an explicit `skills` field can use them.
-
-### Skills Can Reference Other Skills
-
-Skills can mention other skills for related knowledge:
-
-```markdown
-# Roadmap Planning
-
-...
-
-When creating issues, follow the patterns in the **issue-writing** skill.
-Use **gitea** commands to create the issues.
-```
-
-This creates a natural knowledge hierarchy without duplicating content.
-
-## Naming Conventions
-
-### Skill Folder Names
-
-- Use **kebab-case**: `issue-writing`, `backlog-grooming`
-- Be **descriptive**: name should indicate the skill's domain
-- Be **concise**: 2-3 words is ideal
-- Avoid generic names: `utils`, `helpers`, `common`
-
-Good names:
-- `gitea` - Tool-specific knowledge
-- `issue-writing` - Activity-focused
-- `backlog-grooming` - Process-focused
-- `roadmap-planning` - Task-focused
-
-### Skill Titles
-
-The H1 title in `SKILL.md` should match the folder name in Title Case:
-
-| Folder | Title |
-|--------|-------|
-| `gitea` | Forgejo CLI (fj) |
-| `issue-writing` | Issue Writing |
-| `backlog-grooming` | Backlog Grooming |
-| `roadmap-planning` | Roadmap Planning |
-
-## Best Practices
-
-### 1. Keep Skills Focused
-
-Each skill should cover **one domain, one concern**. If your skill document is getting long or covers multiple unrelated topics, consider splitting it.
-
-**Too broad:**
-```markdown
-# Project Management
-How to manage issues, PRs, releases, and documentation...
-```
-
-**Better:**
-```markdown
-# Issue Writing
-How to write clear, actionable issues.
-```
-
-### 2. Be Specific, Not Vague
-
-Provide concrete patterns, not abstract principles.
-
-**Vague:**
-```markdown
-## Writing Good Titles
-Titles should be clear and descriptive.
-```
-
-**Specific:**
-```markdown
-## Writing Good Titles
-- Start with action verb: "Add", "Fix", "Update", "Remove"
-- Be specific: "Add user authentication" not "Auth stuff"
-- Keep under 60 characters
-```
-
-### 3. Include Actionable Examples
-
-Every guideline should have an example showing what it looks like in practice.
-
-```markdown
-### Acceptance Criteria
-
-Good criteria are:
-- **Specific**: "User sees error message" not "Handle errors"
-- **Testable**: Can verify pass/fail
-- **User-focused**: What the user experiences
-
-Examples:
-- [ ] Login form validates email format before submission
-- [ ] Invalid credentials show "Invalid email or password" message
-- [ ] Successful login redirects to dashboard
-```
-
-### 4. Use Templates for Repeatability
-
-When the skill involves creating structured content, provide copy-paste templates:
-
-```markdown
-### Feature Request Template
-
-\```markdown
-## Summary
-What feature and why it's valuable.
-
-## Acceptance Criteria
-- [ ] Criterion 1
-- [ ] Criterion 2
-
-## Context
-Additional background or references.
-\```
-```
-
-### 5. Include Checklists for Verification
-
-Checklists help ensure consistent quality:
-
-```markdown
-## Grooming Checklist
-
-For each issue, verify:
-- [ ] Starts with action verb
-- [ ] Has acceptance criteria
-- [ ] Scope is clear
-- [ ] Dependencies identified
-```
-
-### 6. Document Common Mistakes
-
-Help avoid pitfalls by documenting what goes wrong:
-
-```markdown
-## Common Mistakes
-
-### Vague Titles
-- Bad: "Fix bug"
-- Good: "Fix login form validation on empty email"
-
-### Missing Acceptance Criteria
-Every issue needs specific, testable criteria.
-```
-
-### 7. Keep It Current
-
-Skills should reflect current practices. When workflows change:
-- Update the skill document
-- Remove obsolete patterns
-- Add new best practices
-
-## Annotated Examples
-
-Let's examine the existing skills to understand effective patterns.
-
-### Example 1: gitea (Tool Reference)
-
-The `gitea` skill is a **tool reference**—it documents how to use a specific CLI tool.
-
-```markdown
-# Forgejo CLI (fj)
-
-Command-line interface for interacting with Forgejo repositories.
-
-## Authentication
-The `tea` CLI authenticates via `tea auth login`. Credentials are stored locally.
-
-## Common Commands
-
-### Issues
-\```bash
-# List issues
-tea issue search -s open              # Open issues
-tea issue search -s closed            # Closed issues
-...
-\```
-```
-
-**Key patterns:**
-- Organized by feature area (Issues, Pull Requests, Repository)
-- Includes actual command syntax with comments
-- Covers common use cases, not exhaustive documentation
-- Tips section for non-obvious behaviors
-
-### Example 2: issue-writing (Process Knowledge)
-
-The `issue-writing` skill is **process knowledge**—it teaches how to do something well.
-
-```markdown
-# Issue Writing
-
-How to write clear, actionable issues.
-
-## Issue Structure
-
-### Title
-- Start with action verb: "Add", "Fix", "Update", "Remove"
-- Be specific: "Add user authentication" not "Auth stuff"
-- Keep under 60 characters
-
-### Description
-\```markdown
-## Summary
-One paragraph explaining what and why.
-
-## Acceptance Criteria
-- [ ] Specific, testable requirement
-...
-\```
-```
-
-**Key patterns:**
-- Clear guidelines with specific rules
-- Templates for different issue types
-- Good/bad examples for each guideline
-- Covers the full lifecycle (structure, criteria, labels, dependencies)
-
-### Example 3: backlog-grooming (Workflow Checklist)
-
-The `backlog-grooming` skill is a **workflow checklist**—it provides a systematic process.
-
-```markdown
-# Backlog Grooming
-
-How to review and improve existing issues.
-
-## Grooming Checklist
-
-For each issue, verify:
-
-### 1. Title Clarity
-- [ ] Starts with action verb
-- [ ] Specific and descriptive
-- [ ] Understandable without reading description
-...
-```
-
-**Key patterns:**
-- Structured as a checklist with categories
-- Each item is a yes/no verification
-- Includes workflow steps (Grooming Workflow section)
-- Questions to guide decision-making
-
-### Example 4: roadmap-planning (Strategy Guide)
-
-The `roadmap-planning` skill is a **strategy guide**—it teaches how to think about a problem.
-
-```markdown
-# Roadmap Planning
-
-How to plan features and create issues for implementation.
-
-## Planning Process
-
-### 1. Understand the Goal
-- What capability or improvement is needed?
-- Who benefits and how?
-- What's the success criteria?
-
-### 2. Break Down the Work
-- Identify distinct components
-- Define boundaries between pieces
-...
-```
-
-**Key patterns:**
-- Process-oriented with numbered steps
-- Multiple breakdown strategies (by layer, by user story, by component)
-- Concrete examples showing the pattern applied
-- Questions to guide planning decisions
-
-## When to Create a New Skill
-
-Create a skill when you find yourself:
-
-1. **Explaining the same concepts repeatedly** across different conversations
-2. **Wanting consistent quality** in a specific area
-3. **Building up domain expertise** that should persist
-4. **Needing a reusable reference** for commands or agents
-
-### Signs You Need a New Skill
-
-- You're copy-pasting the same guidelines
-- Multiple commands need the same knowledge
-- Quality is inconsistent without explicit guidance
-- There's a clear domain that doesn't fit existing skills
-
-### Signs You Don't Need a New Skill
-
-- The knowledge is only used once
-- It's already covered by an existing skill
-- It's too generic to be actionable
-- It's better as part of a command's instructions
-
-## Skill Lifecycle
-
-### 1. Draft
-
-Start with the essential content:
-- Core patterns and templates
-- Key guidelines
-- A few examples
-
-### 2. Refine
-
-As you use the skill, improve it:
-- Add examples from real usage
-- Clarify ambiguous guidelines
-- Remove unused content
-
-### 3. Maintain
-
-Keep skills current:
-- Update when practices change
-- Remove obsolete patterns
-- Add newly discovered best practices
-
-## Checklist: Before Submitting a New Skill
-
-### Frontmatter (Critical)
-- [ ] YAML frontmatter starts on line 1 (no blank lines before `---`)
-- [ ] `name` field uses lowercase letters, numbers, and hyphens only
-- [ ] `name` matches the directory name
-- [ ] `description` lists specific capabilities
-- [ ] `description` includes "Use when..." with trigger terms
-
-### Optional Frontmatter (Consider)
-- [ ] `user-invocable: false` if skill is reference-only (e.g., CLI docs)
-- [ ] `context: fork` if skill does heavy exploration that would pollute context
-- [ ] `model` if skill benefits from a specific model (e.g., `haiku` for speed)
-- [ ] `allowed-tools` if skill should be restricted to certain tools
-- [ ] `hooks` if skill needs validation or logging
-
-### File Structure
-- [ ] File is at `skills/<name>/SKILL.md`
-- [ ] Name follows kebab-case convention
-
-### Content Quality
-- [ ] Skill focuses on a single domain
-- [ ] Guidelines are specific and actionable
-- [ ] Examples illustrate each major point
-- [ ] Templates are provided where appropriate
-- [ ] Common mistakes are documented
-
-### Integration
-- [ ] Skill is listed in relevant subagent `skills` fields if needed
-
-## See Also
-
-- [ARCHITECTURE.md](../ARCHITECTURE.md): How skills fit into the overall system
-- [VISION.md](../VISION.md): The philosophy behind composable components

learnings/README.md

@@ -4,7 +4,7 @@ This folder captures learnings from retrospectives and day-to-day work. Learning
 
 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
+3. **Encoding source**: Input that gets encoded into skills and agents
 
 ## The Learning Flow
 
@@ -17,7 +17,7 @@ Experience → Learning captured → Encoded into system → Knowledge is action
             - 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.
+Learnings are **not** the final destination. They are inputs that get encoded into 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
 
@@ -40,8 +40,7 @@ The insight we gained. Be specific and actionable.
 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
-- `agents/xxx/agent.md` - What was added/changed
 
 If not yet encoded, note: "Pending: Issue #XX"
 
@@ -54,7 +53,7 @@ What this learning means for how we work going forward. This is the "why" that j
 
 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
+3. **Update the skill/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.
@@ -63,8 +62,8 @@ The goal: Claude should be able to *use* the learning, not just *read* about it.
 
 | Learning Type | Encode In |
 |---------------|-----------|
-| How to use a tool | `skills/` |
+| How to use a tool | `skills/` (background skill) |
-| Workflow improvement | `commands/` |
+| Workflow improvement | `skills/` (user-invocable skill) |
 | Subtask behavior | `agents/` |
 | Organization belief | `manifesto.md` |
 | Product direction | `vision.md` (in product repo) |

manifesto.md

@@ -51,6 +51,20 @@ We believe AI fundamentally changes how software is built:
 
 - **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.
 
+### Architecture Beliefs
+
+We believe certain outcomes matter more than others when building systems:
+
+- **Auditability by default.** Systems should remember what happened, not just current state. History is valuable - for debugging, compliance, understanding, and recovery.
+
+- **Business language in code.** The words domain experts use should appear in the codebase. When code mirrors how the business thinks, everyone can reason about it.
+
+- **Independent evolution.** Parts of the system should change without breaking other parts. Loose coupling isn't just nice - it's how small teams stay fast as systems grow.
+
+- **Explicit over implicit.** Intent should be visible. Side effects should be traceable. When something important happens, the system should make that obvious.
+
+See [software-architecture.md](./software-architecture.md) for the patterns we use to achieve these outcomes.
+
 ### Quality Without Ceremony
 
 - Ship small, ship often

skills/arch-refine-issue/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: arch-refine-issue
+description: >
+  Refine an issue with architectural perspective. Analyzes existing codebase patterns
+  and provides implementation guidance. Use when refining issues, adding architectural
+  context, or when user says /arch-refine-issue.
+model: opus
+argument-hint: <issue-number>
+user-invocable: true
+---
+
+# Architecturally Refine Issue #$1
+
+@~/.claude/skills/gitea/SKILL.md
+@~/.claude/skills/issue-writing/SKILL.md
+
+## Overview
+
+Refine an issue in the context of the project's architecture. This command:
+1. Fetches the issue details
+2. Spawns the software-architect agent to analyze the codebase
+3. Identifies how the issue fits existing patterns
+4. Proposes refined description and acceptance criteria
+
+## Process
+
+### Step 1: Fetch Issue Details
+
+```bash
+tea issues $1 --comments
+```
+
+Capture:
+- Title
+- Description
+- Acceptance criteria
+- Any existing discussion
+
+### Step 2: Spawn Software-Architect Agent
+
+Use the Task tool to spawn the software-architect agent for issue refinement analysis:
+
+```
+Task tool with:
+  - subagent_type: "software-architect"
+  - prompt: See prompt below
+```
+
+**Agent Prompt:**
+```
+Analyze the architecture for issue refinement.
+
+ANALYSIS_TYPE: issue-refine
+TARGET: $1
+CONTEXT:
+<issue title and description from step 1>
+
+Repository path: <current working directory>
+
+Focus on:
+1. Understanding existing project structure and patterns
+2. Identifying packages/modules that will be affected
+3. Analyzing existing conventions and code style
+4. Detecting potential architectural concerns
+5. Suggesting implementation approach that fits existing patterns
+```
+
+### Step 3: Parse Agent Analysis
+
+The software-architect agent returns structured output with:
+- Summary of architectural findings
+- Affected packages/modules
+- Pattern recommendations
+- Potential concerns (breaking changes, tech debt, pattern violations)
+- Implementation suggestions
+
+### Step 4: Present Refinement Proposal
+
+Present the refined issue to the user with:
+
+**1. Architectural Context**
+- Affected packages/modules
+- Existing patterns that apply
+- Dependency implications
+
+**2. Concerns and Risks**
+- Breaking changes
+- Tech debt considerations
+- Pattern violations to avoid
+
+**3. Proposed Refinement**
+- Refined description with architectural context
+- Updated acceptance criteria (if needed)
+- Technical notes section
+
+**4. Implementation Guidance**
+- Suggested approach
+- Files likely to be modified
+- Recommended order of changes
+
+### Step 5: User Decision
+
+Ask the user what action to take:
+
+- **Apply**: Update the issue with refined description and technical notes
+- **Edit**: Let user modify the proposal before applying
+- **Skip**: Keep the original issue unchanged
+
+### Step 6: Update Issue (if approved)
+
+If user approves, update the issue using tea CLI:
+
+```bash
+tea issues edit $1 --description "<refined description>"
+```
+
+Add a comment with the architectural analysis:
+
+```bash
+tea comment $1 "## Architectural Analysis
+
+<findings from software-architect agent>
+
+---
+Generated by /arch-refine-issue"
+```
+
+## Output Format
+
+Present findings in a clear, actionable format:
+
+```markdown
+## Architectural Analysis for Issue #$1
+
+### Affected Components
+- `package/name` - Description of impact
+- `another/package` - Description of impact
+
+### Existing Patterns
+- Pattern 1: How it applies
+- Pattern 2: How it applies
+
+### Concerns
+- [ ] Breaking change: description (if applicable)
+- [ ] Tech debt: description (if applicable)
+- [ ] Pattern violation risk: description (if applicable)
+
+### Proposed Refinement
+
+**Updated Description:**
+<refined description>
+
+**Updated Acceptance Criteria:**
+- [ ] Original criteria (unchanged)
+- [ ] New criteria based on analysis
+
+**Technical Notes:**
+<implementation guidance based on architecture>
+
+### Recommended Approach
+1. Step 1
+2. Step 2
+3. Step 3
+```
+
+## Error Handling
+
+- If issue does not exist, inform user
+- If software-architect agent fails, report partial analysis
+- If tea CLI fails, show manual instructions

skills/arch-review-repo/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: arch-review-repo
+description: >
+  Perform a full architecture review of the current repository. Analyzes structure,
+  patterns, dependencies, and generates prioritized recommendations. Use when reviewing
+  architecture, auditing codebase, or when user says /arch-review-repo.
+model: opus
+argument-hint:
+context: fork
+user-invocable: true
+---
+
+# Architecture Review
+
+@~/.claude/skills/software-architecture/SKILL.md
+
+## Process
+
+1. **Identify the repository**: Use the current working directory as the repository path.
+
+2. **Spawn the software-architect agent** for deep analysis:
+
+   ```
+   ANALYSIS_TYPE: repo-audit
+   TARGET: <repository-path>
+   CONTEXT: Full repository architecture review
+   ```
+
+   The agent will:
+   - Analyze directory structure and package organization
+   - Identify patterns and anti-patterns in the codebase
+   - Assess dependency graph and module boundaries
+   - Review test coverage approach
+   - Generate structured findings with prioritized recommendations
+
+3. **Present the results** to the user in this format:
+
+   ```markdown
+   ## Repository Architecture Review: <repo-name>
+
+   ### Structure: <Good|Needs Work>
+   - [Key observations about package organization]
+   - [Directory structure assessment]
+   - [Naming conventions evaluation]
+
+   ### Patterns Identified
+   - [Positive patterns found in the codebase]
+   - [Architectural styles detected (layered, hexagonal, etc.)]
+
+   ### Anti-Patterns Detected
+   - [Anti-pattern name]: [Location and description]
+   - [Anti-pattern name]: [Location and description]
+
+   ### Concerns
+   - [Specific issues that need attention]
+   - [Technical debt areas]
+
+   ### Recommendations (prioritized)
+   1. **P0 - Critical**: [Most urgent recommendation]
+   2. **P1 - High**: [Important improvement]
+   3. **P2 - Medium**: [Nice-to-have improvement]
+   4. **P3 - Low**: [Minor optimization]
+
+   ### Health Score: <A|B|C|D|F>
+   [Brief justification for the grade]
+   ```
+
+4. **Offer follow-up actions**:
+   - Create issues for critical findings
+   - Generate a detailed report
+   - Review specific components in more depth
+
+## Guidelines
+
+- Be specific: Reference exact files, packages, and locations
+- Be actionable: Every finding should have a clear path to resolution
+- Be balanced: Acknowledge what the codebase does well
+- Be proportionate: Focus on high-impact issues first
+- Stay objective: Focus on patterns and principles, not style preferences

skills/backlog-grooming/SKILL.md

@@ -1,5 +1,6 @@
 ---
 name: backlog-grooming
+model: haiku
 description: Review and improve existing issues for clarity and actionability. Use when grooming the backlog, reviewing issue quality, cleaning up stale issues, or when the user wants to improve existing issues.
 user-invocable: false
 ---

skills/capability-writing/SKILL.md

@@ -0,0 +1,410 @@
+---
+name: capability-writing
+description: >
+  Guide for designing and creating capabilities for the architecture repository.
+  A capability is a cohesive set of components (skill + agent).
+  Use when creating new skills, agents, or extending the
+  AI workflow system. Includes templates, design guidance, and conventions.
+user-invocable: false
+---
+
+# Capability Writing
+
+How to design and create capabilities for the architecture repository. A capability may be a single component or a cohesive set (skill + agent).
+
+## Component Overview
+
+| Component | Location | Purpose | Example |
+|-----------|----------|---------|---------|
+| **User-invocable Skill** | `skills/name/SKILL.md` | Workflow users trigger with `/name` | /work-issue, /dashboard |
+| **Background Skill** | `skills/name/SKILL.md` | Knowledge auto-loaded when needed | gitea, issue-writing |
+| **Agent** | `agents/name/AGENT.md` | Isolated subtask handler | code-reviewer |
+
+## When to Use Each Component
+
+### Decision Tree
+
+```
+Start here: What do you need?
+    |
+    +--> Just knowledge to apply automatically?
+    |        --> Background skill (user-invocable: false)
+    |
+    +--> User-initiated workflow?
+    |        --> User-invocable skill (user-invocable: true)
+    |
+    +--> Complex isolated work needing focused context?
+    |        --> User-invocable skill + Agent
+    |
+    +--> New domain expertise + workflow + isolated work?
+             --> Full capability (background skill + user-invocable skill + agent)
+```
+
+### Decision Matrix
+
+| Need | Component | Example |
+|------|-----------|---------|
+| Knowledge Claude applies automatically | Background skill | gitea, issue-writing |
+| User-invoked workflow | User-invocable skill | /work-issue, /dashboard |
+| Isolated subtask with focused context | Agent | code-reviewer, issue-worker |
+| All three working together | Full capability | architecture review |
+
+### Signs You Need Each Component
+
+**Create a Background Skill when:**
+- You explain the same concepts repeatedly
+- Quality is inconsistent without explicit guidance
+- Multiple user-invocable skills need the same knowledge
+- There is a clear domain that doesn't fit existing skills
+
+**Create a User-Invocable Skill when:**
+- Same workflow is used multiple times
+- User explicitly triggers the action
+- Approval checkpoints are needed
+- Multiple tools need orchestration
+
+**Create an Agent when:**
+- Task requires deep exploration that would pollute main context
+- Multiple skills work better together
+- Batch processing or parallel execution is needed
+- Specialist persona improves outputs
+
+## Component Templates
+
+### User-Invocable Skill Template
+
+Location: `skills/<name>/SKILL.md`
+
+```yaml
+---
+name: skill-name
+description: >
+  What this skill does and when to use it.
+  Use when [trigger conditions] or when user says /skill-name.
+model: haiku
+argument-hint: <required> [optional]
+user-invocable: true
+---
+
+# Skill Title
+
+@~/.claude/skills/relevant-skill/SKILL.md
+
+Brief intro if needed.
+
+1. **First step**: What to do
+2. **Second step**: What to do next
+3. **Ask for approval** before significant actions
+4. **Execute** the approved actions
+5. **Present results** with links and summary
+```
+
+**Frontmatter fields:**
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `name` | Yes | Lowercase, hyphens, matches directory name |
+| `description` | Yes | What it does + when to use (max 1024 chars) |
+| `user-invocable` | Yes | Set `true` for user-triggered workflows |
+| `argument-hint` | No | Shows expected args: `<required>`, `[optional]` |
+| `model` | No | `haiku`, `sonnet`, `opus` |
+| `context` | No | Use `fork` for isolated context |
+| `allowed-tools` | No | Restrict available tools |
+
+### Background Skill Template
+
+Location: `skills/<name>/SKILL.md`
+
+```yaml
+---
+name: skill-name
+description: >
+  What this skill teaches and when to use it.
+  Include trigger conditions in description.
+user-invocable: false
+---
+
+# Skill Name
+
+Brief description of what this skill covers.
+
+## Core Concepts
+
+Explain fundamental ideas Claude needs to understand.
+
+## Patterns and Templates
+
+Provide reusable structures and formats.
+
+## Guidelines
+
+List rules, best practices, and quality standards.
+
+## Examples
+
+Show concrete illustrations of the skill in action.
+
+## Common Mistakes
+
+Document pitfalls to avoid.
+
+## Reference
+
+Quick-reference tables, checklists, or commands.
+```
+
+### Agent Template
+
+Location: `agents/<name>/AGENT.md`
+
+```yaml
+---
+name: agent-name
+description: What this agent does and when to spawn it
+model: sonnet
+skills: skill1, skill2
+disallowedTools:
+  - Edit
+  - Write
+---
+
+You are a [role] specialist that [primary function].
+
+## When Invoked
+
+Describe the process the agent follows:
+
+1. **Gather context**: What information to collect
+2. **Analyze**: What to evaluate
+3. **Act**: What actions to take
+4. **Report**: How to communicate results
+
+## Output Format
+
+Describe expected output structure.
+
+## Guidelines
+
+- Behavioral rules
+- Constraints
+- Quality standards
+```
+
+**Frontmatter fields:**
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `name` | Yes | Lowercase, hyphens, matches directory name |
+| `description` | Yes | What it does + when to spawn |
+| `model` | No | `haiku`, `sonnet`, `opus`, or `inherit` |
+| `skills` | No | Comma-separated skill names (not paths) |
+| `disallowedTools` | No | Tools to block (e.g., Edit, Write for read-only) |
+| `permissionMode` | No | `default` or `bypassPermissions` |
+
+## Model Selection Guidance
+
+| Model | Use When | Examples |
+|-------|----------|----------|
+| `haiku` | Simple fetch/display, formatting, mechanical tasks | /dashboard, /roadmap |
+| `sonnet` | Most skills and agents, balanced performance | /work-issue, code-reviewer |
+| `opus` | Deep reasoning, architectural analysis, complex judgment | /arch-review-repo |
+
+### Decision Criteria
+
+- **Start with `haiku`** for simple display/fetch workflows
+- **Use `sonnet`** for most skills and agents (default choice)
+- **Reserve `opus` for judgment** - when errors are costly or reasoning is complex
+- **Consider the stakes** - higher consequence tasks warrant more capable models
+
+## Naming Conventions
+
+### File and Folder Names
+
+| Component | Convention | Examples |
+|-----------|------------|----------|
+| Skill folder | kebab-case | `software-architecture`, `work-issue` |
+| Skill file | UPPERCASE | `SKILL.md` |
+| Agent folder | kebab-case | `code-reviewer`, `issue-worker` |
+| Agent file | UPPERCASE | `AGENT.md` |
+
+### Naming Patterns
+
+**Skills:** Name after the domain, knowledge area, or action
+- Good: `gitea`, `issue-writing`, `work-issue`, `dashboard`
+- Bad: `utils`, `helpers`, `misc`
+
+**Agents:** Name by role or persona (recognizable specialist)
+- Good: `code-reviewer`, `issue-worker`, `software-architect`
+- Bad: `helper`, `do-stuff`, `agent1`
+
+## Referencing Skills
+
+### In User-Invocable Skills
+
+Use the `@` file reference syntax to guarantee background skill content is loaded:
+
+```markdown
+@~/.claude/skills/gitea/SKILL.md
+@~/.claude/skills/issue-writing/SKILL.md
+```
+
+**Important:** Do NOT use phrases like "Use the gitea skill" - skills have only ~20% auto-activation rate. File references guarantee the content is available.
+
+### In Agents
+
+List skill names in the frontmatter (not paths):
+
+```yaml
+---
+name: product-manager
+skills: gitea, issue-writing, backlog-grooming
+---
+```
+
+The agent runtime loads these skills automatically.
+
+## Common Patterns
+
+### Approval Workflow (User-Invocable Skills)
+
+Always ask before significant actions:
+
+```markdown
+4. **Present plan** for approval
+5. **If approved**, create the issues
+6. **Present summary** with links
+```
+
+### Conditional Behavior (User-Invocable Skills)
+
+Handle optional arguments with mode switching:
+
+```markdown
+## If issue number provided ($1):
+1. Fetch specific issue
+2. Process it
+
+## If no argument (batch mode):
+1. List all issues
+2. Process each
+```
+
+### Spawning Agents from Skills
+
+Delegate complex subtasks:
+
+```markdown
+9. **Auto-review**: Spawn the `code-reviewer` agent with the PR number
+```
+
+### Read-Only Agents
+
+For analysis without modification:
+
+```yaml
+---
+name: code-reviewer
+disallowedTools:
+  - Edit
+  - Write
+---
+```
+
+## Anti-Patterns to Avoid
+
+### Overly Broad Components
+
+**Bad:** One skill/agent that does everything
+```markdown
+# Project Management
+Handles issues, PRs, releases, documentation, deployment...
+```
+
+**Good:** Focused components with clear responsibility
+```markdown
+# Issue Writing
+How to write clear, actionable issues.
+```
+
+### Vague Instructions
+
+**Bad:**
+```markdown
+1. Handle the issue
+2. Do the work
+3. Finish up
+```
+
+**Good:**
+```markdown
+1. **View the issue** with `--comments` flag
+2. **Create branch**: `git checkout -b issue-$1-<title>`
+3. **Commit** with message referencing the issue
+```
+
+### Missing Skill References
+
+**Bad:**
+```markdown
+Use the gitea skill to create an issue.
+```
+
+**Good:**
+```markdown
+@~/.claude/skills/gitea/SKILL.md
+
+Use `tea issues create --title "..." --description "..."`
+```
+
+### God Skills
+
+**Bad:** Single skill with 1000+ lines covering unrelated topics
+
+**Good:** Multiple focused skills that reference each other
+
+### Premature Agent Creation
+
+**Bad:** Creating an agent for every task
+
+**Good:** Use agents only when you need:
+- Context isolation
+- Skill composition
+- Parallel execution
+- Specialist persona
+
+## Detailed Documentation
+
+For comprehensive guides, see:
+
+- `docs/writing-capabilities.md` - Complete guide covering skills and agents
+
+## Checklists
+
+### Before Creating a User-Invocable Skill
+
+- [ ] Workflow is used multiple times
+- [ ] User explicitly triggers it (not automatic)
+- [ ] Clear start and end points
+- [ ] Frontmatter has `user-invocable: true`
+- [ ] Description includes "Use when... or when user says /skill-name"
+- [ ] Background skills referenced via `@~/.claude/skills/<name>/SKILL.md`
+- [ ] Approval checkpoints before significant actions
+- [ ] File at `skills/<name>/SKILL.md`
+
+### Before Creating a Background Skill
+
+- [ ] Knowledge is used in multiple places (not just once)
+- [ ] Existing skills do not already cover this domain
+- [ ] Content is specific and actionable (not generic)
+- [ ] Frontmatter has `user-invocable: false`
+- [ ] Description includes trigger terms
+- [ ] File at `skills/<name>/SKILL.md`
+
+### Before Creating an Agent
+
+- [ ] Built-in agents (Explore, Plan) are not sufficient
+- [ ] Context isolation or skill composition is needed
+- [ ] Clear role/persona emerges
+- [ ] `model` selection is deliberate (not just `inherit`)
+- [ ] `skills` list is right-sized (not too many)
+- [ ] File at `agents/<name>/AGENT.md`

skills/claude-md-writing/SKILL.md

@@ -1,5 +1,6 @@
 ---
 name: claude-md-writing
+model: haiku
 description: Write effective CLAUDE.md files that give AI assistants the context they need. Use when creating new repos, improving existing CLAUDE.md files, or setting up projects.
 user-invocable: false
 ---

skills/code-review/SKILL.md

@@ -1,5 +1,6 @@
 ---
 name: code-review
+model: haiku
 description: Review code for quality, bugs, security, and style issues. Use when reviewing pull requests, checking code quality, looking for bugs or security vulnerabilities, or when the user asks for a code review.
 user-invocable: false
 ---

skills/commit/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: commit
+description: >
+  Create a commit with an auto-generated conventional commit message. Analyzes staged
+  changes and proposes a message for approval. Use when committing changes, creating
+  commits, or when user says /commit.
+model: haiku
+argument-hint:
+user-invocable: true
+---
+
+# Commit Changes
+
+## Process
+
+1. **Check for staged changes**:
+   ```bash
+   git diff --staged --stat
+   ```
+
+   If no staged changes, inform the user and suggest staging files first:
+   - Show unstaged changes with `git status`
+   - Ask if they want to stage all changes (`git add -A`) or specific files
+
+2. **Analyze staged changes**:
+   ```bash
+   git diff --staged
+   ```
+
+   Examine the diff to understand:
+   - What files were changed, added, or deleted
+   - The nature of the changes (new feature, bug fix, refactor, docs, etc.)
+   - Key details worth mentioning
+
+3. **Generate commit message**:
+
+   Create a conventional commit message following this format:
+   ```
+   <type>(<scope>): <description>
+
+   [optional body with more details]
+
+   Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+   ```
+
+   **Types:**
+   - `feat`: New feature or capability
+   - `fix`: Bug fix
+   - `refactor`: Code restructuring without behavior change
+   - `docs`: Documentation changes
+   - `style`: Formatting, whitespace (no code change)
+   - `test`: Adding or updating tests
+   - `chore`: Maintenance tasks, dependencies, config
+
+   **Scope:** The component or area affected (optional, use when helpful)
+
+   **Description:**
+   - Imperative mood ("add" not "added")
+   - Lowercase first letter
+   - No period at the end
+   - Focus on the "why" when the "what" is obvious
+
+4. **Present message for approval**:
+
+   Show the proposed message and ask the user to:
+   - **Approve**: Use the message as-is
+   - **Edit**: Let them modify the message
+   - **Regenerate**: Create a new message with different focus
+
+5. **Create the commit**:
+
+   Once approved, execute:
+   ```bash
+   git commit -m "$(cat <<'EOF'
+   <approved message>
+   EOF
+   )"
+   ```
+
+6. **Confirm success**:
+
+   Show the commit result and suggest next steps:
+   - Push to remote: `git push`
+   - Continue working and commit more changes
+
+## Guidelines
+
+- Only commits what's staged (respects partial staging)
+- Never auto-commits without user approval
+- Keep descriptions concise (50 chars or less for first line)
+- Include body for non-obvious changes
+- Always include Co-Authored-By attribution

skills/create-capability/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: create-capability
+description: >
+  Create a new capability (skill, agent, or a cohesive set) for the architecture
+  repository. Use when creating new skills, agents, extending AI workflows, or when
+  user says /create-capability.
+model: haiku
+argument-hint: <description>
+user-invocable: true
+---
+
+# Create Capability
+
+@~/.claude/skills/capability-writing/SKILL.md
+
+Create new capabilities following established patterns. A capability may be a single component or a cohesive set (skill + agent).
+
+## Process
+
+1. **Understand the capability**: Analyze "$1" to understand what the user wants to build
+   - What domain or workflow does this cover?
+   - What user need does it address?
+   - What existing capabilities might overlap?
+
+2. **Determine components needed**: Based on the description, recommend which components:
+
+   | Pattern | When to Use |
+   |---------|-------------|
+   | Skill only (background) | Knowledge to apply automatically (reused across other skills) |
+   | Skill only (user-invocable) | User-invoked workflow |
+   | Skill + Agent | Workflow with isolated worker for complex subtasks |
+   | Full set | New domain expertise + workflow + isolated work |
+
+   Present recommendation with reasoning:
+   ```
+   ## Recommended Components for: $1
+
+   Based on your description, I recommend:
+   - **Skill**: `name` - [why this knowledge is needed]
+   - **Agent**: `name` - [why isolation/specialization is needed] (optional)
+
+   Reasoning: [explain why this combination fits the need]
+   ```
+
+3. **Gather information**: For each recommended component, ask:
+
+   **For all components:**
+   - Name (kebab-case, descriptive)
+   - Description (one-line summary)
+
+   **For Skills:**
+   - What domain/knowledge does this cover?
+   - What are the key concepts to teach?
+   - What patterns or templates should it include?
+   - Is it user-invocable (workflow) or background (reference)?
+
+   **For Agents:**
+   - What specialized role does this fill?
+   - What skills does it need?
+   - Should it be read-only (no Edit/Write)?
+
+4. **Select appropriate models**:
+
+   | Model | Use For |
+   |-------|---------|
+   | `haiku` | Simple fetch/display skills, formatting tasks |
+   | `sonnet` | Most skills and agents (default) |
+   | `opus` | Deep reasoning, architectural analysis, complex judgment |
+
+   For each component, recommend a model with reasoning.
+
+5. **Generate files**: Create content using templates from capability-writing skill
+
+   Ensure proper inter-references:
+   - User-invocable skill references background skills via `@~/.claude/skills/name/SKILL.md`
+   - Agent lists skills in `skills:` frontmatter (names only, not paths)
+   - User-invocable skill spawns agent via Task tool if agent is part of the set
+
+6. **Present for approval**: Show all generated files with their full content:
+   ```
+   ## Generated Files
+
+   ### skills/name/SKILL.md
+   [full content]
+
+   ### agents/name/AGENT.md (if applicable)
+   [full content]
+
+   Ready to create these files?
+   ```
+
+7. **Create files** in correct locations after approval:
+   - `skills/<name>/SKILL.md`
+   - `agents/<name>/AGENT.md`
+
+8. **Report success**:
+   ```
+   ## Capability Created: name
+
+   Files created:
+   - skills/name/SKILL.md
+   - agents/name/AGENT.md (if applicable)
+
+   Next steps:
+   1. Run `make install` to symlink to ~/.claude/
+   2. Test with: /name (for user-invocable skills)
+   3. Background skills will auto-activate based on context
+   ```
+
+## Guidelines
+
+- Follow all conventions from capability-writing skill
+- Reference existing skills rather than duplicating knowledge
+- Keep components focused - split if scope is too broad
+- User-invocable skills should have approval checkpoints before significant actions
+- Default to `sonnet` model unless there's a clear reason for haiku/opus
+- Skills should have descriptive `description` fields for auto-activation

skills/create-issue/SKILL.md

@@ -1,6 +1,11 @@
 ---
-description: Create a new Gitea issue. Can create single issues or batch create from a plan.
+name: create-issue
+description: >
+  Create a new Gitea issue. Can create single issues or batch create from a plan.
+  Use when creating issues, adding tickets, or when user says /create-issue.
+model: haiku
 argument-hint: [title] or "batch"
+user-invocable: true
 ---
 
 # Create Issue(s)

skills/create-repo/SKILL.md

@@ -1,7 +1,13 @@
 ---
-description: Create a new repository with standard structure. Scaffolds vision.md, CLAUDE.md, and CI configuration.
+name: create-repo
+description: >
+  Create a new repository with standard structure. Scaffolds vision.md, CLAUDE.md,
+  and CI configuration. Use when creating repos, initializing projects, or when user
+  says /create-repo.
+model: haiku
 argument-hint: <repo-name>
 context: fork
+user-invocable: true
 ---
 
 # Create Repository
@@ -154,7 +160,7 @@ Create a new repository with Flowmade's standard structure.
     - CI workflow template
     - Basic Makefile
 
-    🤖 Generated with [Claude Code](https://claude.com/claude-code)
+    Generated with [Claude Code](https://claude.com/claude-code)
 
     Co-Authored-By: Claude <noreply@anthropic.com>"
 

skills/dashboard/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: dashboard
+description: >
+  Show dashboard of open issues, PRs awaiting review, and CI status. Use when
+  checking project status, viewing issues/PRs, or when user says /dashboard.
+model: haiku
+user-invocable: true
+---
+
+# Repository Dashboard
+
+@~/.claude/skills/gitea/SKILL.md
+
+Fetch and display the following sections:
+
+## 1. Open Issues
+
+Run `tea issues` to list all open issues.
+
+Format as a table showing:
+- Number
+- Title
+- Author
+
+## 2. Open Pull Requests
+
+Run `tea pulls` to list all open PRs.
+
+Format as a table showing:
+- Number
+- Title
+- Author
+
+## 3. CI Status (Recent Workflow Runs)
+
+Run `tea actions runs` to list recent workflow runs.
+
+**Output formatting:**
+- Show the most recent 10 workflow runs maximum
+- For each run, display:
+  - Status (use indicators: [SUCCESS], [FAILURE], [RUNNING], [PENDING])
+  - Workflow name
+  - Branch or PR reference
+  - Commit (short SHA)
+  - Triggered time
+
+**Highlighting:**
+- **Highlight failed runs** by prefixing with a warning indicator and ensuring they stand out visually
+- Example: "**[FAILURE]** build - PR #42 - abc1234 - 2h ago"
+
+**Handling repos without CI:**
+- If `tea actions runs` returns "No workflow runs found" or similar, display:
+  "No CI workflows configured for this repository."
+- Do not treat this as an error - simply note it and continue
+
+## Output Format
+
+Present each section with a clear header. Example:
+
+```
+## Open Issues (3)
+
+| #  | Title                  | Author |
+|----|------------------------|--------|
+| 15 | Fix login timeout      | alice  |
+| 12 | Add dark mode          | bob    |
+| 8  | Update documentation   | carol  |
+
+## Open Pull Requests (2)
+
+| #  | Title                  | Author |
+|----|------------------------|--------|
+| 16 | Fix login timeout      | alice  |
+| 14 | Refactor auth module   | bob    |
+
+## CI Status
+
+| Status      | Workflow | Branch/PR   | Commit  | Time    |
+|-------------|----------|-------------|---------|---------|
+| **[FAILURE]** | build    | PR #16      | abc1234 | 2h ago  |
+| [SUCCESS]   | build    | main        | def5678 | 5h ago  |
+| [SUCCESS]   | lint     | main        | def5678 | 5h ago  |
+```
+
+If no CI is configured:
+```
+## CI Status
+
+No CI workflows configured for this repository.
+```

skills/gitea/SKILL.md

@@ -1,5 +1,6 @@
 ---
 name: gitea
+model: haiku
 description: View, create, and manage Gitea issues and pull requests using tea CLI. Use when working with issues, PRs, viewing issue details, creating pull requests, adding comments, merging PRs, or when the user mentions tea, gitea, issue numbers, or PR numbers.
 user-invocable: false
 ---

skills/groom/SKILL.md

@@ -1,6 +1,12 @@
 ---
-description: Groom and improve issues. Without argument, reviews all open issues. With argument, grooms specific issue.
+name: groom
+description: >
+  Groom and improve issues. Without argument, reviews all open issues. With argument,
+  grooms specific issue. Use when grooming backlog, improving issues, or when user
+  says /groom.
+model: sonnet
 argument-hint: [issue-number]
+user-invocable: true
 ---
 
 # Groom Issues

skills/improve/SKILL.md

@@ -1,7 +1,12 @@
 ---
-description: Identify improvement opportunities based on product vision. Analyzes gaps between vision goals and current backlog.
+name: improve
-argument-hint:
+description: >
+  Identify improvement opportunities based on product vision. Analyzes gaps between
+  vision goals and current backlog. Use when analyzing alignment, finding gaps, or
+  when user says /improve.
+model: sonnet
 context: fork
+user-invocable: true
 ---
 
 # Improvement Analysis

skills/issue-writing/SKILL.md

@@ -1,5 +1,6 @@
 ---
 name: issue-writing
+model: haiku
 description: Write clear, actionable issues with proper structure and acceptance criteria. Use when creating issues, writing bug reports, feature requests, or when the user needs help structuring an issue.
 user-invocable: false
 ---

skills/manifesto/SKILL.md

@@ -1,6 +1,11 @@
 ---
-description: View and manage the organization manifesto. Shows identity, personas, beliefs, and principles.
+name: manifesto
-argument-hint:
+description: >
+  View and manage the organization manifesto. Shows identity, personas, beliefs,
+  and principles. Use when viewing manifesto, checking organization identity, or
+  when user says /manifesto.
+model: haiku
+user-invocable: true
 ---
 
 # Organization Manifesto

skills/plan-issues/SKILL.md

@@ -1,7 +1,13 @@
 ---
-description: Plan and create issues for a feature or improvement. Breaks down work into well-structured issues with vision alignment.
+name: plan-issues
+description: >
+  Plan and create issues for a feature or improvement. Breaks down work into
+  well-structured issues with vision alignment. Use when planning a feature,
+  creating a roadmap, breaking down large tasks, or when user says /plan-issues.
+model: sonnet
 argument-hint: <feature-description>
 context: fork
+user-invocable: true
 ---
 
 # Plan Feature: $1
@@ -16,12 +22,24 @@ context: fork
 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:
+
+6. **Discovery phase**: Before proposing issues, walk through the user workflow:
+   - Who is the specific user?
+   - What is their goal?
+   - What is their step-by-step workflow to reach that goal?
+   - What exists today?
+   - Where does the workflow break or have gaps?
+   - What's the MVP that delivers value?
+
+   Present this as a workflow walkthrough before proposing any issues.
+
+7. **Break down** into discrete, actionable issues:
+   - Derive issues from the workflow gaps identified in discovery
    - Each issue should be independently completable
    - Clear dependencies between issues
    - Appropriate scope (not too big, not too small)
 
-7. **Present the plan** (include vision alignment if vision exists):
+8. **Present the plan** (include vision alignment if vision exists):
    ```
    ## Proposed Issues for: $1
 
@@ -30,12 +48,15 @@ context: fork
    Supports: [Milestone/Goal name]
 
    1. [Title] - Brief description
+      Addresses gap: [which workflow gap this solves]
       Dependencies: none
 
    2. [Title] - Brief description
+      Addresses gap: [which workflow gap this solves]
       Dependencies: #1
 
    3. [Title] - Brief description
+      Addresses gap: [which workflow gap this solves]
       Dependencies: #1, #2
    ```
 
@@ -45,7 +66,7 @@ context: fork
    - This should be added as a non-goal
    - Proceed anyway (with justification)
 
-8. **Ask for approval** before creating issues
+9. **Ask for approval** before creating issues
-9. **Create issues** in dependency order (blockers first)
+10. **Create issues** in dependency order (blockers first)
-10. **Link dependencies** using `tea issues deps add <issue> <blocker>` for each dependency
+11. **Link dependencies** using `tea issues deps add <issue> <blocker>` for each dependency
-11. **Present summary** with links to created issues and dependency graph
+12. **Present summary** with links to created issues and dependency graph

skills/pr/SKILL.md

@@ -0,0 +1,153 @@
+---
+name: pr
+description: >
+  Create a PR from current branch. Auto-generates title and description from branch
+  name and commits. Use when creating pull requests, submitting changes, or when
+  user says /pr.
+model: haiku
+user-invocable: true
+---
+
+# Create Pull Request
+
+@~/.claude/skills/gitea/SKILL.md
+
+Quick PR creation from current branch - lighter than full `/work-issue` flow for when you're already on a branch with commits.
+
+## Prerequisites
+
+- Current branch is NOT main/master
+- Branch has commits ahead of main
+- Changes have been pushed to origin (or will be pushed)
+
+## Process
+
+### 1. Verify Branch State
+
+```bash
+# Check current branch
+git branch --show-current
+
+# Ensure we're not on main
+# If on main, abort with message: "Cannot create PR from main branch"
+
+# Check for commits ahead of main
+git log main..HEAD --oneline
+```
+
+### 2. Push if Needed
+
+```bash
+# Check if branch is tracking remote
+git status -sb
+
+# If not pushed or behind, push with upstream
+git push -u origin <branch-name>
+```
+
+### 3. Generate PR Title
+
+**Option A: Branch contains issue number** (e.g., `issue-42-add-feature`)
+
+Extract issue number and use format: `[Issue #<number>] <issue-title>`
+
+```bash
+tea issues <number>  # Get the actual issue title
+```
+
+**Option B: No issue number**
+
+Generate from branch name or recent commit messages:
+- Convert branch name from kebab-case to title case: `add-user-auth` -> `Add user auth`
+- Or use the most recent commit subject line
+
+### 4. Generate PR Description
+
+Analyze the diff and commits to generate a description:
+
+```bash
+# Get diff against main
+git diff main...HEAD --stat
+
+# Get commit messages
+git log main..HEAD --format="- %s"
+```
+
+Structure the description:
+
+```markdown
+## Summary
+[1-2 sentences describing the overall change]
+
+## Changes
+[Bullet points summarizing commits or key changes]
+
+[If issue linked: "Closes #<number>"]
+```
+
+### 5. Create PR
+
+Use tea CLI to create the PR:
+
+```bash
+tea pulls create --title "<generated-title>" --description "<generated-description>"
+```
+
+Capture the PR number from the output (e.g., "Pull Request #42 created").
+
+### 6. Auto-review
+
+Inform the user that auto-review is starting, then spawn the `code-reviewer` agent in background:
+
+```
+Task tool with:
+  - subagent_type: "code-reviewer"
+  - run_in_background: true
+  - prompt: |
+      Review PR #<PR_NUMBER> in the repository at <REPO_PATH>.
+
+      1. Checkout the PR: tea pulls checkout <PR_NUMBER>
+      2. Get the diff: git diff main...HEAD
+      3. Analyze for code quality, bugs, security, style, test coverage
+      4. Post structured review comment with tea comment
+      5. Merge with rebase if LGTM, otherwise leave for user
+```
+
+### 7. Display Result
+
+Show the user:
+- PR URL/number
+- Generated title and description
+- Status of auto-review (spawned in background)
+
+## Issue Linking
+
+To detect if branch is linked to an issue:
+
+1. Check branch name for patterns:
+   - `issue-<number>-*`
+   - `<number>-*`
+   - `*-#<number>`
+
+2. If issue number found:
+   - Fetch issue title from Gitea
+   - Use `[Issue #N] <issue-title>` format for PR title
+   - Add `Closes #N` to description
+
+## Example Output
+
+```
+Created PR #42: [Issue #15] Add /pr command
+
+## Summary
+Adds /pr command for quick PR creation from current branch.
+
+## Changes
+- Add commands/pr.md with auto-generation logic
+- Support issue linking from branch name
+
+Closes #15
+
+---
+Auto-review started in background. Check status with: tea pulls 42 --comments
+```

skills/repo-conventions/SKILL.md

@@ -1,5 +1,6 @@
 ---
 name: repo-conventions
+model: haiku
 description: Standard structure and conventions for Flowmade repositories. Use when creating new repos, reviewing repo structure, or setting up projects.
 user-invocable: false
 ---
@@ -16,8 +17,7 @@ All product repos should follow this structure relative to the architecture repo
 org/
 ├── architecture/           # Organizational source of truth
 │   ├── manifesto.md        # Organization identity and beliefs
-│   ├── commands/           # Claude Code workflows
+│   ├── skills/             # User-invocable and background skills
-│   ├── skills/             # Knowledge modules
 │   └── agents/             # Subtask handlers
 ├── product-a/              # Product repository
 │   ├── vision.md           # Product vision (extends manifesto)

skills/retro/SKILL.md

@@ -1,11 +1,17 @@
 ---
-description: Run a retrospective on completed work. Captures insights as issues for later encoding into skills/commands/agents.
+name: retro
+description: >
+  Run a retrospective on completed work. Captures insights as issues for later
+  encoding into skills/agents. Use when capturing learnings, running retrospectives,
+  or when user says /retro.
+model: haiku
 argument-hint: [task-description]
+user-invocable: true
 ---
 
 # Retrospective
 
-Capture insights from completed work as issues on the architecture repo. Issues are later encoded into learnings and skills/commands/agents.
+Capture insights from completed work as issues on the architecture repo. Issues are later encoded into learnings and skills/agents.
 
 @~/.claude/skills/vision-management/SKILL.md
 @~/.claude/skills/gitea/SKILL.md
@@ -13,7 +19,7 @@ Capture insights from completed work as issues on the architecture repo. Issues
 ## Flow
 
 ```
-Retro (any repo) → Issue (architecture repo) → Encode: learning file + skill/command/agent
+Retro (any repo) → Issue (architecture repo) → Encode: learning file + skill/agent
 ```
 
 The retro creates the issue. Encoding happens when the issue is worked on.
@@ -29,7 +35,7 @@ The retro creates the issue. Encoding happens when the issue is worked on.
 
 3. **Identify insights**: For each insight, determine:
    - **What was learned**: The specific insight
-   - **Where to encode it**: Which skill, command, or agent should change?
+   - **Where to encode it**: Which skill or agent should change?
    - **Governance impact**: What does this mean for how we work?
 
 4. **Create issue on architecture repo**: Always create issues on `flowmade-one/architecture`:
@@ -45,7 +51,6 @@ The retro creates the issue. Encoding happens when the issue is worked on.
 
    ## 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
@@ -78,14 +83,13 @@ When encoding a learning issue, the implementer should:
    ## 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
+2. **Update skill/agent** with the encoded knowledge
 
 3. **Close the issue** with reference to the learning file and changes made
 
@@ -94,7 +98,7 @@ When encoding a learning issue, the implementer should:
 | Insight Type | Encode In |
 |--------------|-----------|
 | How to use a tool | `skills/[tool]/SKILL.md` |
-| Workflow improvement | `commands/[command].md` |
+| Workflow improvement | `skills/[skill]/SKILL.md` (user-invocable) |
 | Subtask behavior | `agents/[agent]/agent.md` |
 | Organization belief | `manifesto.md` |
 | Product direction | `vision.md` (in product repo) |
@@ -103,8 +107,8 @@ When encoding a learning issue, the implementer should:
 
 Add appropriate labels to issues:
 - `learning` - Always add this
-- `prompt-improvement` - For command/skill text changes
+- `prompt-improvement` - For skill text changes
-- `new-feature` - For new commands/skills/agents
+- `new-feature` - For new skills/agents
 - `bug` - For things that are broken
 
 ## Guidelines

skills/review-pr/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: review-pr
+description: >
+  Review a Gitea pull request. Fetches PR details, diff, and comments. Includes
+  both code review and software architecture review. Use when reviewing pull requests,
+  checking code quality, or when user says /review-pr.
+model: sonnet
+argument-hint: <pr-number>
+user-invocable: true
+---
+
+# Review PR #$1
+
+@~/.claude/skills/gitea/SKILL.md
+@~/.claude/skills/software-architecture/SKILL.md
+
+## 1. Gather Information
+
+1. **View PR details** with `--comments` flag to see description, metadata, and discussion
+2. **Get the diff** to review the changes:
+   ```bash
+   tea pulls checkout <number>
+   git diff main...HEAD
+   ```
+
+## 2. Code Review
+
+Review the changes and provide feedback on:
+- Code quality and style
+- Potential bugs or logic errors
+- Test coverage
+- Documentation updates
+
+## 3. Software Architecture Review
+
+Spawn the software-architect agent for architectural analysis:
+
+```
+Task tool with:
+  - subagent_type: "software-architect"
+  - prompt: |
+      ANALYSIS_TYPE: pr-review
+      TARGET: <pr-number>
+      CONTEXT: [Include the PR diff and description]
+```
+
+The architecture review checks:
+- **Pattern consistency**: Changes follow existing codebase patterns
+- **Dependency direction**: Dependencies flow correctly (toward domain layer)
+- **Breaking changes**: API changes are flagged and justified
+- **Module boundaries**: Changes respect existing package boundaries
+- **Error handling**: Errors wrapped with context, proper error types used
+
+## 4. Present Findings
+
+Structure the review with two sections:
+
+### Code Review
+- Quality, bugs, style issues
+- Test coverage gaps
+- Documentation needs
+
+### Architecture Review
+- Summary of architectural concerns from agent
+- Pattern violations or anti-patterns detected
+- Dependency or boundary issues
+- Breaking change assessment
+
+## 5. User Actions
+
+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.

skills/roadmap-planning/SKILL.md

@@ -1,5 +1,6 @@
 ---
 name: roadmap-planning
+model: haiku
 description: Plan features and break down work into implementable issues. Use when planning a feature, creating a roadmap, breaking down large tasks, or when the user needs help organizing work into issues.
 user-invocable: false
 ---
@@ -15,7 +16,33 @@ How to plan features and create issues for implementation.
 - Who benefits and how?
 - What's the success criteria?
 
-### 2. Break Down the Work
+### 2. Discovery Phase
+
+Before breaking down work into issues, understand the user's workflow:
+
+| Question | Why It Matters |
+|----------|----------------|
+| **Who** is the user? | Specific persona, not "users" |
+| **What's their goal?** | The job they're trying to accomplish |
+| **What's their workflow?** | Step-by-step actions to reach the goal |
+| **What exists today?** | Current state and gaps |
+| **What's the MVP?** | Minimum to deliver value |
+
+**Walk through the workflow step by step:**
+1. User starts at: [starting point]
+2. User does: [action 1]
+3. System responds: [what happens]
+4. User does: [action 2]
+5. ... continue until goal is reached
+
+**Identify the gaps:**
+- Where does the workflow break today?
+- Which steps are missing or painful?
+- What's the smallest change that unblocks value?
+
+**Derive issues from workflow gaps** - not from guessing what might be needed. Each issue should address a specific gap in the user's workflow.
+
+### 3. Break Down the Work
 - Identify distinct components
 - Define boundaries between pieces
 - Aim for issues that are:
@@ -23,12 +50,12 @@ How to plan features and create issues for implementation.
   - Independently testable
   - Clear in scope
 
-### 3. Identify Dependencies
+### 4. Identify Dependencies
 - Which pieces must come first?
 - What can be parallelized?
 - Are there external blockers?
 
-### 4. Create Issues
+### 5. Create Issues
 - Follow issue-writing patterns
 - Reference dependencies explicitly
 - Use consistent labeling

skills/roadmap/SKILL.md

@@ -1,6 +1,11 @@
 ---
-description: View current issues as a roadmap. Shows open issues organized by status and dependencies.
+name: roadmap
-argument-hint:
+description: >
+  View current issues as a roadmap. Shows open issues organized by status and
+  dependencies. Use when viewing roadmap, checking issue status, or when user
+  says /roadmap.
+model: haiku
+user-invocable: true
 ---
 
 # Roadmap View

skills/software-architecture/SKILL.md

@@ -0,0 +1,633 @@
+---
+name: software-architecture
+model: haiku
+description: >
+  Architectural patterns for building systems: DDD, Event Sourcing, event-driven communication.
+  Use when implementing features, reviewing code, planning issues, refining architecture,
+  or making design decisions. Ensures alignment with organizational beliefs about
+  auditability, domain modeling, and independent evolution.
+user-invocable: false
+---
+
+# Software Architecture
+
+Architectural patterns and best practices. This skill is auto-triggered when implementing, reviewing, or planning work that involves architectural decisions.
+
+## Architecture Beliefs
+
+These outcome-focused beliefs (from our organization manifesto) guide architectural decisions:
+
+| Belief | Why It Matters |
+|--------|----------------|
+| **Auditability by default** | Systems should remember what happened, not just current state |
+| **Business language in code** | Domain experts' words should appear in the codebase |
+| **Independent evolution** | Parts should change without breaking other parts |
+| **Explicit over implicit** | Intent and side effects should be visible and traceable |
+
+## Beliefs → Patterns
+
+| Belief | Primary Pattern | Supporting Patterns |
+|--------|-----------------|---------------------|
+| Auditability by default | Event Sourcing | Immutable events, temporal queries |
+| Business language in code | Domain-Driven Design | Ubiquitous language, aggregates, bounded contexts |
+| Independent evolution | Event-driven communication | Bounded contexts, published language |
+| Explicit over implicit | Commands and Events | Domain events, clear intent |
+
+## Event Sourcing
+
+**Achieves:** Auditability by default
+
+Instead of storing current state, store the sequence of events that led to it.
+
+**Core concepts:**
+- **Events** are immutable facts about what happened, named in past tense: `OrderPlaced`, `PaymentReceived`
+- **State** is derived by replaying events, not stored directly
+- **Event store** is append-only - history is never modified
+
+**Why this matters:**
+- Complete audit trail for free
+- Debug by replaying history
+- Answer "what was the state at time X?"
+- Recover from bugs by fixing logic and replaying
+
+**Trade-offs:**
+- More complex than CRUD for simple cases
+- Requires thinking in events, not state
+- Eventually consistent read models
+
+## Domain-Driven Design
+
+**Achieves:** Business language in code
+
+The domain model reflects how the business thinks and talks.
+
+**Core concepts:**
+- **Ubiquitous language** - same terms in code, conversations, and documentation
+- **Bounded contexts** - explicit boundaries where terms have consistent meaning
+- **Aggregates** - clusters of objects that change together, with one root entity
+- **Domain events** - capture what happened in business terms
+
+**Why this matters:**
+- Domain experts can read and validate the model
+- New team members learn the domain through code
+- Changes in business rules map clearly to code changes
+
+**Trade-offs:**
+- Upfront investment in understanding the domain
+- Boundaries may need to shift as understanding grows
+- Overkill for pure technical/infrastructure code
+
+## Event-Driven Communication
+
+**Achieves:** Independent evolution
+
+Services communicate by publishing events, not calling each other directly.
+
+**Core concepts:**
+- **Publish events** when something important happens
+- **Subscribe to events** you care about
+- **No direct dependencies** between publisher and subscriber
+- **Eventual consistency** - accept that not everything updates instantly
+
+**Why this matters:**
+- Add new services without changing existing ones
+- Services can be deployed independently
+- Natural resilience - if a subscriber is down, events queue
+
+**Trade-offs:**
+- Harder to trace request flow
+- Eventual consistency requires different thinking
+- Need infrastructure for reliable event delivery
+
+## Commands and Events
+
+**Achieves:** Explicit over implicit
+
+Distinguish between requests (commands) and facts (events).
+
+**Core concepts:**
+- **Commands** express intent: `PlaceOrder`, `CancelSubscription`
+- Commands can be rejected (validation, business rules)
+- **Events** express facts: `OrderPlaced`, `SubscriptionCancelled`
+- Events are immutable - what happened, happened
+
+**Why this matters:**
+- Clear separation of "trying to do X" vs "X happened"
+- Commands validate, events just record
+- Enables replay - reprocess events with new logic
+
+## When to Diverge
+
+These patterns are defaults, not mandates. Diverge intentionally when:
+
+- **Simplicity wins** - a simple CRUD endpoint doesn't need event sourcing
+- **Performance requires it** - sometimes synchronous calls are necessary
+- **Team context** - patterns the team doesn't understand cause more harm than good
+- **Prototyping** - validate ideas before investing in full architecture
+
+When diverging, document the decision in the project's `vision.md` Architecture section.
+
+## Project-Level Architecture
+
+Each project documents architectural choices in `vision.md`:
+
+```markdown
+## Architecture
+
+This project follows organization architecture patterns.
+
+### Alignment
+- Event sourcing for [which aggregates/domains]
+- Bounded contexts: [list contexts and their responsibilities]
+- Event-driven communication between [which services]
+
+### Intentional Divergences
+| Area | Standard Pattern | What We Do Instead | Why |
+|------|------------------|-------------------|-----|
+```
+
+## Go-Specific Best Practices
+
+### Package Organization
+
+**Good package structure:**
+```
+project/
+├── cmd/                    # Application entry points
+│   └── server/
+│       └── main.go
+├── internal/               # Private packages
+│   ├── domain/             # Core business logic
+│   │   ├── user/
+│   │   └── order/
+│   ├── service/            # Application services
+│   ├── repository/         # Data access
+│   └── handler/            # HTTP/gRPC handlers
+├── pkg/                    # Public, reusable packages
+└── go.mod
+```
+
+**Package naming:**
+- Short, concise, lowercase: `user`, `order`, `auth`
+- Avoid generic names: `util`, `common`, `helpers`, `misc`
+- Name after what it provides, not what it contains
+- One package per concept, not per file
+
+**Package cohesion:**
+- A package should have a single, focused responsibility
+- Package internal files can use internal types freely
+- Minimize exported types - export interfaces, hide implementations
+
+### Interfaces
+
+**Accept interfaces, return structs:**
+```go
+// Good: Accept interface, return concrete type
+func NewUserService(repo UserRepository) *UserService {
+    return &UserService{repo: repo}
+}
+
+// Bad: Accept and return interface
+func NewUserService(repo UserRepository) UserService {
+    return &userService{repo: repo}
+}
+```
+
+**Define interfaces at point of use:**
+```go
+// Good: Interface defined where it's used (consumer owns the interface)
+package service
+
+type UserRepository interface {
+    FindByID(ctx context.Context, id string) (*User, error)
+}
+
+// Bad: Interface defined with implementation (producer owns the interface)
+package repository
+
+type UserRepository interface {
+    FindByID(ctx context.Context, id string) (*User, error)
+}
+```
+
+**Keep interfaces small:**
+- Prefer single-method interfaces
+- Large interfaces indicate missing abstraction
+- Compose small interfaces when needed
+
+### Error Handling
+
+**Wrap errors with context:**
+```go
+// Good: Wrap with context
+if err != nil {
+    return fmt.Errorf("fetching user %s: %w", id, err)
+}
+
+// Bad: Return bare error
+if err != nil {
+    return err
+}
+```
+
+**Use sentinel errors for expected conditions:**
+```go
+var ErrNotFound = errors.New("not found")
+var ErrConflict = errors.New("conflict")
+
+// Check with errors.Is
+if errors.Is(err, ErrNotFound) {
+    // handle not found
+}
+```
+
+**Error types for rich errors:**
+```go
+type ValidationError struct {
+    Field   string
+    Message string
+}
+
+func (e *ValidationError) Error() string {
+    return fmt.Sprintf("%s: %s", e.Field, e.Message)
+}
+
+// Check with errors.As
+var valErr *ValidationError
+if errors.As(err, &valErr) {
+    // handle validation error
+}
+```
+
+### Dependency Injection
+
+**Constructor injection:**
+```go
+type UserService struct {
+    repo   UserRepository
+    logger Logger
+}
+
+func NewUserService(repo UserRepository, logger Logger) *UserService {
+    return &UserService{
+        repo:   repo,
+        logger: logger,
+    }
+}
+```
+
+**Wire dependencies in main:**
+```go
+func main() {
+    // Create dependencies
+    db := database.Connect()
+    logger := slog.Default()
+
+    // Wire up services
+    userRepo := repository.NewUserRepository(db)
+    userService := service.NewUserService(userRepo, logger)
+    userHandler := handler.NewUserHandler(userService)
+
+    // Start server
+    http.Handle("/users", userHandler)
+    http.ListenAndServe(":8080", nil)
+}
+```
+
+**Avoid global state:**
+- No `init()` for service initialization
+- No package-level variables for dependencies
+- Pass context explicitly, don't store in structs
+
+### Testing
+
+**Table-driven tests:**
+```go
+func TestUserService_Create(t *testing.T) {
+    tests := []struct {
+        name    string
+        input   CreateUserInput
+        want    *User
+        wantErr error
+    }{
+        {
+            name:  "valid user",
+            input: CreateUserInput{Email: "test@example.com"},
+            want:  &User{Email: "test@example.com"},
+        },
+        {
+            name:    "invalid email",
+            input:   CreateUserInput{Email: "invalid"},
+            wantErr: ErrInvalidEmail,
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            // arrange, act, assert
+        })
+    }
+}
+```
+
+**Test doubles:**
+- Use interfaces for test doubles
+- Prefer hand-written mocks over generated ones for simple cases
+- Use `testify/mock` or `gomock` for complex mocking needs
+
+**Test package naming:**
+- `package user_test` for black-box testing (preferred)
+- `package user` for white-box testing when needed
+
+## Generic Architecture Patterns
+
+### Layered Architecture
+
+```
+┌─────────────────────────────────┐
+│         Presentation            │  HTTP handlers, CLI, gRPC
+├─────────────────────────────────┤
+│         Application             │  Use cases, orchestration
+├─────────────────────────────────┤
+│           Domain                │  Business logic, entities
+├─────────────────────────────────┤
+│        Infrastructure           │  Database, external services
+└─────────────────────────────────┘
+```
+
+**Rules:**
+- Dependencies point downward only
+- Upper layers depend on interfaces, not implementations
+- Domain layer has no external dependencies
+
+### SOLID Principles
+
+**Single Responsibility (S):**
+- Each module has one reason to change
+- Split code that changes for different reasons
+
+**Open/Closed (O):**
+- Open for extension, closed for modification
+- Add new behavior through new types, not changing existing ones
+
+**Liskov Substitution (L):**
+- Subtypes must be substitutable for their base types
+- Interfaces should be implementable without surprises
+
+**Interface Segregation (I):**
+- Clients shouldn't depend on interfaces they don't use
+- Prefer many small interfaces over few large ones
+
+**Dependency Inversion (D):**
+- High-level modules shouldn't depend on low-level modules
+- Both should depend on abstractions
+
+### Dependency Direction
+
+```
+                    ┌──────────────┐
+                    │    Domain    │
+                    │  (no deps)   │
+                    └──────────────┘
+                           ▲
+              ┌────────────┴────────────┐
+              │                         │
+      ┌───────┴───────┐         ┌───────┴───────┐
+      │  Application  │         │Infrastructure │
+      │ (uses domain) │         │(implements    │
+      └───────────────┘         │ domain intf)  │
+              ▲                 └───────────────┘
+              │
+      ┌───────┴───────┐
+      │ Presentation  │
+      │(calls app)    │
+      └───────────────┘
+```
+
+**Key insight:** Infrastructure implements domain interfaces, doesn't define them. This inverts the "natural" dependency direction.
+
+### Module Boundaries
+
+**Signs of good boundaries:**
+- Modules can be understood in isolation
+- Changes are localized within modules
+- Clear, minimal public API
+- Dependencies flow in one direction
+
+**Signs of bad boundaries:**
+- Circular dependencies between modules
+- "Shotgun surgery" - small changes require many file edits
+- Modules reach into each other's internals
+- Unclear ownership of concepts
+
+## Repository Health Indicators
+
+### Positive Indicators
+
+| Indicator | What to Look For |
+|-----------|------------------|
+| Clear structure | Obvious package organization, consistent naming |
+| Small interfaces | Most interfaces have 1-3 methods |
+| Explicit dependencies | Constructor injection, no globals |
+| Test coverage | Unit tests for business logic, integration tests for boundaries |
+| Error handling | Wrapped errors, typed errors for expected cases |
+| Documentation | CLAUDE.md accurate, code comments explain "why" |
+
+### Warning Signs
+
+| Indicator | What to Look For |
+|-----------|------------------|
+| God packages | `utils/`, `common/`, `helpers/` with 20+ files |
+| Circular deps | Package A imports B, B imports A |
+| Deep nesting | 4+ levels of directory nesting |
+| Huge files | Files with 500+ lines |
+| Interface pollution | Interfaces for everything, even single implementations |
+| Global state | Package-level variables, `init()` for setup |
+
+### Metrics to Track
+
+- **Package fan-out:** How many packages does each package import?
+- **Cyclomatic complexity:** How complex are the functions?
+- **Test coverage:** What percentage of code is tested?
+- **Import depth:** How deep is the import tree?
+
+## Review Checklists
+
+### Repository Audit Checklist
+
+Use this when evaluating overall repository health.
+
+**Structure:**
+- [ ] Clear package organization following Go conventions
+- [ ] No circular dependencies between packages
+- [ ] Appropriate use of `internal/` for private packages
+- [ ] `cmd/` for application entry points
+
+**Dependencies:**
+- [ ] Dependencies flow inward (toward domain)
+- [ ] Interfaces defined at point of use (not with implementation)
+- [ ] No global state or package-level dependencies
+- [ ] Constructor injection throughout
+
+**Code Quality:**
+- [ ] Consistent naming conventions
+- [ ] No "god" packages (utils, common, helpers)
+- [ ] Errors wrapped with context
+- [ ] Small, focused interfaces
+
+**Testing:**
+- [ ] Unit tests for domain logic
+- [ ] Integration tests for boundaries (DB, HTTP)
+- [ ] Tests are readable and maintainable
+- [ ] Test coverage for critical paths
+
+**Documentation:**
+- [ ] CLAUDE.md is accurate and helpful
+- [ ] vision.md explains the product purpose
+- [ ] Code comments explain "why", not "what"
+
+### Issue Refinement Checklist
+
+Use this when reviewing issues for architecture impact.
+
+**Scope:**
+- [ ] Issue is a vertical slice (user-visible value)
+- [ ] Changes are localized to specific packages
+- [ ] No cross-cutting concerns hidden in implementation
+
+**Design:**
+- [ ] Follows existing patterns in the codebase
+- [ ] New abstractions are justified
+- [ ] Interface changes are backward compatible (or breaking change is documented)
+
+**Dependencies:**
+- [ ] New dependencies are minimal and justified
+- [ ] No new circular dependencies introduced
+- [ ] Integration points are clearly defined
+
+**Testability:**
+- [ ] Acceptance criteria are testable
+- [ ] New code can be unit tested in isolation
+- [ ] Integration test requirements are clear
+
+### PR Review Checklist
+
+Use this when reviewing pull requests for architecture concerns.
+
+**Structure:**
+- [ ] Changes respect existing package boundaries
+- [ ] New packages follow naming conventions
+- [ ] No new circular dependencies
+
+**Interfaces:**
+- [ ] Interfaces are defined where used
+- [ ] Interfaces are minimal and focused
+- [ ] Breaking interface changes are justified
+
+**Dependencies:**
+- [ ] Dependencies injected via constructors
+- [ ] No new global state
+- [ ] External dependencies properly abstracted
+
+**Error Handling:**
+- [ ] Errors wrapped with context
+- [ ] Sentinel errors for expected conditions
+- [ ] Error types for rich error information
+
+**Testing:**
+- [ ] New code has appropriate test coverage
+- [ ] Tests are clear and maintainable
+- [ ] Edge cases covered
+
+## Anti-Patterns to Flag
+
+### God Packages
+
+**Problem:** Packages like `utils/`, `common/`, `helpers/` become dumping grounds.
+
+**Symptoms:**
+- 20+ files in one package
+- Unrelated functions grouped together
+- Package imported by everything
+
+**Fix:** Extract cohesive packages based on what they provide: `validation`, `httputil`, `timeutil`.
+
+### Circular Dependencies
+
+**Problem:** Package A imports B, and B imports A (directly or transitively).
+
+**Symptoms:**
+- Import cycle compile errors
+- Difficulty understanding code flow
+- Changes cascade unexpectedly
+
+**Fix:**
+- Extract shared types to a third package
+- Use interfaces to invert dependency
+- Merge packages if truly coupled
+
+### Leaky Abstractions
+
+**Problem:** Implementation details leak through abstraction boundaries.
+
+**Symptoms:**
+- Database types in domain layer
+- HTTP types in service layer
+- Framework types in business logic
+
+**Fix:** Define types at each layer, map between them explicitly.
+
+### Anemic Domain Model
+
+**Problem:** Domain objects are just data containers, logic is elsewhere.
+
+**Symptoms:**
+- Domain types have only getters/setters
+- All logic in "service" classes
+- Domain types can be in invalid states
+
+**Fix:** Put behavior with data. Domain types should enforce their own invariants.
+
+### Shotgun Surgery
+
+**Problem:** Small changes require editing many files across packages.
+
+**Symptoms:**
+- Feature adds touch 10+ files
+- Similar changes in multiple places
+- Copy-paste between packages
+
+**Fix:** Consolidate related code. If things change together, they belong together.
+
+### Feature Envy
+
+**Problem:** Code in one package is more interested in another package's data.
+
+**Symptoms:**
+- Many calls to another package's methods
+- Pulling data just to compute something
+- Logic that belongs elsewhere
+
+**Fix:** Move the code to where the data lives, or extract the behavior to a shared place.
+
+### Premature Abstraction
+
+**Problem:** Creating interfaces and abstractions before they're needed.
+
+**Symptoms:**
+- Interfaces with single implementations
+- "Factory" and "Manager" classes everywhere
+- Configuration for things that never change
+
+**Fix:** Write concrete code first. Extract abstractions when you have multiple implementations or need to break dependencies.
+
+### Deep Hierarchy
+
+**Problem:** Excessive layers of abstraction or inheritance.
+
+**Symptoms:**
+- 5+ levels of embedding/composition
+- Hard to trace code flow
+- Changes require understanding many layers
+
+**Fix:** Prefer composition over inheritance. Flatten hierarchies where possible.

skills/spawn-issues/SKILL.md

@@ -0,0 +1,349 @@
+---
+name: spawn-issues
+description: Orchestrate parallel issue implementation with review cycles
+model: haiku
+argument-hint: <issue-number> [<issue-number>...]
+allowed-tools: Bash, Task, Read, TaskOutput
+user-invocable: true
+---
+
+# Spawn Issues (Orchestrator)
+
+Orchestrate parallel issue implementation: spawn workers, review PRs, fix feedback, until all approved.
+
+## Arguments
+
+One or more issue numbers separated by spaces: `$ARGUMENTS`
+
+Example: `/spawn-issues 42 43 44`
+
+## Orchestration Flow
+
+```
+Concurrent Pipeline - each issue flows independently:
+
+  Issue #42 ──► worker ──► PR #55 ──► review ──► fix? ──► ✓
+  Issue #43 ──► worker ──► PR #56 ──► review ──► ✓
+  Issue #44 ──► worker ──► PR #57 ──► review ──► fix ──► ✓
+
+As each step completes, immediately:
+1. Print a status update
+2. Start the next step for that issue
+
+Don't wait for all workers before reviewing - pipeline each issue.
+```
+
+## Status Updates
+
+Print a brief status update whenever any step completes:
+
+```
+[#42] Worker completed → PR #55 created
+[#43] Worker completed → PR #56 created
+[#42] Review: needs work → spawning fixer
+[#43] Review: approved ✓
+[#42] Fix completed → re-reviewing
+[#44] Worker completed → PR #57 created
+[#42] Review: approved ✓
+[#44] Review: approved ✓
+
+All done! Final summary:
+| Issue | PR  | Status   |
+|-------|-----|----------|
+| #42   | #55 | approved |
+| #43   | #56 | approved |
+| #44   | #57 | approved |
+```
+
+## Implementation
+
+### Step 1: Parse and Validate
+
+Parse `$ARGUMENTS` into a list of issue numbers. If empty, inform the user:
+```
+Usage: /spawn-issues <issue-number> [<issue-number>...]
+Example: /spawn-issues 42 43 44
+```
+
+### Step 2: Get Repository Info and Setup Worktrees
+
+```bash
+REPO_PATH=$(pwd)
+REPO_NAME=$(basename $REPO_PATH)
+
+# Create parent worktrees directory
+mkdir -p "${REPO_PATH}/../worktrees"
+WORKTREES_DIR="${REPO_PATH}/../worktrees"
+```
+
+For each issue, create the worktree upfront:
+```bash
+# Fetch latest from origin
+cd "${REPO_PATH}"
+git fetch origin
+
+# Get issue details for branch naming
+ISSUE_TITLE=$(tea issues <ISSUE_NUMBER> | grep "TITLE" | head -1)
+BRANCH_NAME="issue-<ISSUE_NUMBER>-<kebab-title>"
+
+# Create worktree for this issue
+git worktree add "${WORKTREES_DIR}/${REPO_NAME}-issue-<ISSUE_NUMBER>" \
+  -b "${BRANCH_NAME}" origin/main
+```
+
+Track the worktree path for each issue.
+
+### Step 3: Spawn All Issue Workers
+
+For each issue number, spawn a background issue-worker agent and track its task_id:
+
+```
+Task tool with:
+  - subagent_type: "issue-worker"
+  - run_in_background: true
+  - prompt: <issue-worker prompt below>
+```
+
+Track state for each issue:
+```
+issues = {
+  42: { task_id: "xxx", stage: "implementing", pr: null, branch: null, review_iterations: 0 },
+  43: { task_id: "yyy", stage: "implementing", pr: null, branch: null, review_iterations: 0 },
+  44: { task_id: "zzz", stage: "implementing", pr: null, branch: null, review_iterations: 0 },
+}
+```
+
+Print initial status:
+```
+Spawned 3 issue workers:
+  [#42] implementing...
+  [#43] implementing...
+  [#44] implementing...
+```
+
+**Issue Worker Prompt:**
+```
+You are an issue-worker agent. Implement issue #<NUMBER> autonomously.
+
+Context:
+- Repository path: <REPO_PATH>
+- Repository name: <REPO_NAME>
+- Issue number: <NUMBER>
+- Worktree path: <WORKTREE_PATH>
+
+Process:
+1. Setup worktree:
+   cd <WORKTREE_PATH>
+
+2. Get issue: tea issues <NUMBER> --comments
+
+3. Plan with TodoWrite, implement the changes
+
+4. Commit: git add -A && git commit -m "...\n\nCloses #<NUMBER>\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
+
+5. Push: git push -u origin <branch-name>
+
+6. Create PR: tea pulls create --title "[Issue #<NUMBER>] <title>" --description "Closes #<NUMBER>\n\n..."
+   Capture the PR number.
+
+7. Cleanup: No cleanup needed - orchestrator handles worktree removal
+
+8. Output EXACTLY this format (orchestrator parses it):
+   ISSUE_WORKER_RESULT
+   issue: <NUMBER>
+   pr: <PR_NUMBER>
+   branch: <branch-name>
+   status: <success|partial|failed>
+   title: <issue title>
+   summary: <1-2 sentence description>
+
+Work autonomously. If blocked, note it in PR description and report status as partial/failed.
+```
+
+### Step 4: Event-Driven Pipeline
+
+**Do NOT poll.** Wait for `<task-notification>` messages that arrive automatically when background tasks complete.
+
+When a notification arrives:
+1. Read the output file to get the result
+2. Parse the result and print status update
+3. Spawn the next stage (reviewer/fixer) in background
+4. Continue waiting for more notifications
+
+```
+On <task-notification> for task_id X:
+  - Find which issue this task belongs to
+  - Read output file, parse result
+  - Print status update
+  - If not terminal state, spawn next agent in background
+  - Update issue state
+  - If all issues terminal, print final summary
+```
+
+**State transitions:**
+
+```
+implementing → (worker done) → reviewing → (approved) → DONE
+                             → (needs-work) → fixing → reviewing...
+                             → (3 iterations) → needs-manual-review
+           → (worker failed) → FAILED
+```
+
+**On each notification, print status:**
+
+```
+[#42] Worker completed → PR #55 created, starting review
+[#43] Worker completed → PR #56 created, starting review
+[#42] Review: needs work → spawning fixer
+[#43] Review: approved ✓
+[#42] Fix completed → re-reviewing
+[#44] Worker completed → PR #57 created, starting review
+[#42] Review: approved ✓
+[#44] Review: approved ✓
+```
+
+### Step 5: Spawn Reviewers and Fixers
+
+When spawning reviewers/fixers, create worktrees for them and pass the path.
+
+For review, create a review worktree from the PR branch:
+```bash
+cd "${REPO_PATH}"
+git fetch origin
+git worktree add "${WORKTREES_DIR}/${REPO_NAME}-review-<PR_NUMBER>" \
+  origin/<BRANCH_NAME>
+```
+
+Pass this worktree path to the reviewer/fixer agents.
+
+**Code Reviewer:**
+```
+Task tool with:
+  - subagent_type: "code-reviewer"
+  - run_in_background: true
+  - prompt: <code-reviewer prompt below>
+```
+
+**Code Reviewer Prompt:**
+```
+You are a code-reviewer agent. Review PR #<PR_NUMBER> autonomously.
+
+Context:
+- Repository path: <REPO_PATH>
+- PR number: <PR_NUMBER>
+- Worktree path: <WORKTREE_PATH>
+
+Process:
+1. Move to worktree:
+   cd <WORKTREE_PATH>
+
+2. Get PR details: tea pulls <PR_NUMBER> --comments
+
+3. Review the diff: git diff origin/main...HEAD
+
+4. Analyze changes for:
+   - Code quality and style
+   - Potential bugs or logic errors
+   - Test coverage
+   - Documentation
+
+5. Post review comment: tea comment <PR_NUMBER> "<review summary>"
+
+6. Cleanup: No cleanup needed - orchestrator handles worktree removal
+
+7. Output EXACTLY this format:
+   REVIEW_RESULT
+   pr: <PR_NUMBER>
+   verdict: <approved|needs-work>
+   summary: <1-2 sentences>
+
+Work autonomously. Be constructive but thorough.
+```
+
+**PR Fixer Prompt:** (see below)
+
+### Step 6: Final Report
+
+When all issues reach terminal state, display summary:
+
+```
+All done!
+
+| Issue | PR  | Status              |
+|-------|-----|---------------------|
+| #42   | #55 | approved            |
+| #43   | #56 | approved            |
+| #44   | #57 | approved            |
+
+3 PRs created and approved
+```
+
+## PR Fixer
+
+When spawning pr-fixer for a PR that needs work:
+
+```
+Task tool with:
+  - subagent_type: "pr-fixer"
+  - run_in_background: true
+  - prompt: <pr-fixer prompt below>
+```
+
+**PR Fixer Prompt:**
+```
+You are a pr-fixer agent. Address review feedback on PR #<NUMBER>.
+
+Context:
+- Repository path: <REPO_PATH>
+- PR number: <NUMBER>
+- Worktree path: <WORKTREE_PATH>
+
+Process:
+1. Move to worktree:
+   cd <WORKTREE_PATH>
+
+2. Get feedback: tea pulls <NUMBER> --comments
+
+3. Address each piece of feedback
+
+4. Commit and push:
+   git add -A && git commit -m "Address review feedback\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
+   git push
+
+5. Cleanup: No cleanup needed - orchestrator handles worktree removal
+
+6. Output EXACTLY:
+   PR_FIXER_RESULT
+   pr: <NUMBER>
+   status: <fixed|partial|failed>
+   changes: <summary of fixes>
+
+Work autonomously. If feedback is unclear, make reasonable judgment calls.
+```
+
+## Worktree Cleanup
+
+After all issues reach terminal state, clean up all worktrees:
+
+```bash
+# Remove all worktrees created for this run
+for worktree in "${WORKTREES_DIR}"/*; do
+  if [ -d "$worktree" ]; then
+    cd "${REPO_PATH}"
+    git worktree remove "$worktree" --force
+  fi
+done
+
+# Remove worktrees directory if empty
+rmdir "${WORKTREES_DIR}" 2>/dev/null || true
+```
+
+**Important:** Always clean up worktrees, even if the orchestration failed partway through.
+
+## Error Handling
+
+- If an issue-worker fails, continue with others
+- If a review fails, mark as "review-failed" and continue
+- If pr-fixer fails after 3 iterations, mark as "needs-manual-review"
+- Always report final status even if some items failed
+- Always clean up all worktrees before exiting

skills/spawn-pr-fixes/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: spawn-pr-fixes
+description: Spawn parallel background agents to address PR review feedback
+model: haiku
+argument-hint: [pr-number...]
+allowed-tools: Bash, Task, Read
+user-invocable: true
+---
+
+# Spawn PR Fixes
+
+Spawn background agents to address review feedback on multiple PRs in parallel. Each agent works in an isolated git worktree.
+
+## Arguments
+
+Optional PR numbers separated by spaces: `$ARGUMENTS`
+
+- With arguments: `/spawn-pr-fixes 12 15 18` - fix specific PRs
+- Without arguments: `/spawn-pr-fixes` - find and fix all PRs with requested changes
+
+## Process
+
+### Step 1: Get Repository Info
+
+```bash
+REPO_PATH=$(pwd)
+REPO_NAME=$(basename $REPO_PATH)
+```
+
+### Step 2: Determine PRs to Fix
+
+**If PR numbers provided**: Use those directly
+
+**If no arguments**: Find PRs needing work
+```bash
+# List open PRs
+tea pulls --state open
+
+# For each PR, check if it has review comments requesting changes
+tea pulls <number> --comments
+```
+
+Look for PRs where:
+- Review comments exist that haven't been addressed
+- PR is not approved yet
+- PR is open (not merged/closed)
+
+### Step 3: For Each PR
+
+1. Fetch PR title using `tea pulls <number>`
+
+2. Spawn background agent using Task tool:
+   ```
+   Task tool with:
+     - subagent_type: "pr-fixer"
+     - run_in_background: true
+     - prompt: See agent prompt below
+   ```
+
+### Agent Prompt
+
+For each PR, use this prompt:
+
+```
+You are a pr-fixer agent. Address review feedback on PR #<NUMBER> autonomously.
+
+Context:
+- Repository path: <REPO_PATH>
+- Repository name: <REPO_NAME>
+- PR number: <NUMBER>
+
+Instructions from @agents/pr-fixer/agent.md:
+
+1. Get PR details and review comments:
+   cd <REPO_PATH>
+   git fetch origin
+   tea pulls <NUMBER> --comments
+
+2. Setup worktree from PR branch:
+   git worktree add ../<REPO_NAME>-pr-<NUMBER> origin/<branch-name>
+   cd ../<REPO_NAME>-pr-<NUMBER>
+   git checkout <branch-name>
+
+3. Analyze feedback, create todos with TodoWrite
+
+4. Address each piece of feedback
+
+5. Commit and push:
+   git add -A && git commit with message "Address review feedback\n\n...\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
+   git push
+
+6. Spawn code-reviewer synchronously (NOT in background) to re-review
+
+7. If needs more work, fix and re-review (max 3 iterations)
+
+8. Cleanup (ALWAYS do this):
+   cd <REPO_PATH> && git worktree remove ../<REPO_NAME>-pr-<NUMBER> --force
+
+9. Output concise summary (5-10 lines max):
+   PR #<NUMBER>: <title>
+   Status: <fixed|partial|blocked>
+   Feedback addressed: <count> items
+   Review: <approved|needs-work|skipped>
+
+Work autonomously. Make judgment calls on ambiguous feedback. If blocked, note it in a commit message.
+```
+
+### Step 4: Report
+
+After spawning all agents, display:
+
+```
+Spawned <N> pr-fixer agents:
+
+| PR  | Title                    | Status     |
+|-----|--------------------------|------------|
+| #12 | Add /commit command      | spawned    |
+| #15 | Add /pr command          | spawned    |
+| #18 | Add CI status            | spawned    |
+
+Agents working in background. Monitor with:
+- Check PR list: tea pulls
+- Check worktrees: git worktree list
+```

skills/update-claude-md/SKILL.md

@@ -1,7 +1,12 @@
 ---
-description: Update or create CLAUDE.md with current project context. Explores the project and ensures organization context is present.
+name: update-claude-md
-argument-hint:
+description: >
+  Update or create CLAUDE.md with current project context. Explores the project
+  and ensures organization context is present. Use when updating project docs,
+  adding CLAUDE.md, or when user says /update-claude-md.
+model: haiku
 context: fork
+user-invocable: true
 ---
 
 # Update CLAUDE.md

skills/vision-management/SKILL.md

@@ -1,5 +1,6 @@
 ---
 name: vision-management
+model: haiku
 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.
 user-invocable: false
 ---
@@ -123,6 +124,17 @@ These extend the organization's guiding principles:
 These extend the organization's non-goals:
 
 - **[Non-goal].** [Explanation]
+
+## Architecture
+
+This project follows organization architecture patterns (see software-architecture skill).
+
+### Alignment
+- [Which patterns we use and where]
+
+### Intentional Divergences
+| Area | Standard Pattern | What We Do Instead | Why |
+|------|------------------|-------------------|-----|
 ```
 
 ### When to Update Vision

skills/vision/SKILL.md

@@ -1,6 +1,11 @@
 ---
-description: View the product vision and goal progress. Manages vision.md and Gitea milestones.
+name: vision
+description: >
+  View the product vision and goal progress. Manages vision.md and Gitea milestones.
+  Use when viewing vision, managing goals, or when user says /vision.
+model: haiku
 argument-hint: [goals]
+user-invocable: true
 ---
 
 # Product Vision
@@ -8,12 +13,12 @@ argument-hint: [goals]
 @~/.claude/skills/vision-management/SKILL.md
 @~/.claude/skills/gitea/SKILL.md
 
-This command manages **product-level** vision. For organization-level vision, use `/manifesto`.
+This skill manages **product-level** vision. For organization-level vision, use `/manifesto`.
 
 ## Architecture
 
-| Level | Document | Purpose | Command |
+| Level | Document | Purpose | Skill |
-|-------|----------|---------|---------|
+|-------|----------|---------|-------|
 | **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` |

skills/work-issue/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: work-issue
+description: >
+  Work on a Gitea issue. Fetches issue details and sets up branch for implementation.
+  Use when working on issues, implementing features, or when user says /work-issue.
+model: haiku
+argument-hint: <issue-number>
+user-invocable: true
+---
+
+# Work on Issue #$1
+
+@~/.claude/skills/gitea/SKILL.md
+@~/.claude/skills/software-architecture/SKILL.md
+
+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. **Check architecture**: Review the project's vision.md Architecture section for project-specific patterns and divergences
+5. **Implement** the changes following architectural patterns (DDD, event sourcing where appropriate)
+6. **Commit** with message referencing the issue
+7. **Push** the branch to origin
+8. **Create PR** with title "[Issue #$1] <title>" and body "Closes #$1"
+9. **Auto-review**: Inform the user that auto-review is starting, then spawn the `code-reviewer` agent in background (using `run_in_background: true`) with the PR number

software-architecture.md

@@ -0,0 +1,130 @@
+# Software Architecture
+
+> **For Claude:** This content is mirrored in `skills/software-architecture/SKILL.md` which is auto-triggered when relevant. You don't need to load this file directly.
+
+This document describes the architectural patterns we use to achieve our [architecture beliefs](./manifesto.md#architecture-beliefs). It serves as human-readable organizational documentation.
+
+## Beliefs to Patterns
+
+| Belief | Primary Pattern | Supporting Patterns |
+|--------|-----------------|---------------------|
+| Auditability by default | Event Sourcing | Immutable events, temporal queries |
+| Business language in code | Domain-Driven Design | Ubiquitous language, aggregates, bounded contexts |
+| Independent evolution | Event-driven communication | Bounded contexts, published language |
+| Explicit over implicit | Commands and Events | Domain events, clear intent |
+
+## Event Sourcing
+
+**Achieves:** Auditability by default
+
+Instead of storing current state, we store the sequence of events that led to it.
+
+**Core concepts:**
+- **Events** are immutable facts about what happened, named in past tense: `OrderPlaced`, `PaymentReceived`
+- **State** is derived by replaying events, not stored directly
+- **Event store** is append-only - history is never modified
+
+**Why this matters:**
+- Complete audit trail for free
+- Debug by replaying history
+- Answer "what was the state at time X?"
+- Recover from bugs by fixing logic and replaying
+
+**Trade-offs:**
+- More complex than CRUD for simple cases
+- Requires thinking in events, not state
+- Eventually consistent read models
+
+## Domain-Driven Design
+
+**Achieves:** Business language in code
+
+The domain model reflects how the business thinks and talks.
+
+**Core concepts:**
+- **Ubiquitous language** - same terms in code, conversations, and documentation
+- **Bounded contexts** - explicit boundaries where terms have consistent meaning
+- **Aggregates** - clusters of objects that change together, with one root entity
+- **Domain events** - capture what happened in business terms
+
+**Why this matters:**
+- Domain experts can read and validate the model
+- New team members learn the domain through code
+- Changes in business rules map clearly to code changes
+
+**Trade-offs:**
+- Upfront investment in understanding the domain
+- Boundaries may need to shift as understanding grows
+- Overkill for pure technical/infrastructure code
+
+## Event-Driven Communication
+
+**Achieves:** Independent evolution
+
+Services communicate by publishing events, not calling each other directly.
+
+**Core concepts:**
+- **Publish events** when something important happens
+- **Subscribe to events** you care about
+- **No direct dependencies** between publisher and subscriber
+- **Eventual consistency** - accept that not everything updates instantly
+
+**Why this matters:**
+- Add new services without changing existing ones
+- Services can be deployed independently
+- Natural resilience - if a subscriber is down, events queue
+
+**Trade-offs:**
+- Harder to trace request flow
+- Eventual consistency requires different thinking
+- Need infrastructure for reliable event delivery
+
+## Commands and Events
+
+**Achieves:** Explicit over implicit
+
+Distinguish between requests (commands) and facts (events).
+
+**Core concepts:**
+- **Commands** express intent: `PlaceOrder`, `CancelSubscription`
+- Commands can be rejected (validation, business rules)
+- **Events** express facts: `OrderPlaced`, `SubscriptionCancelled`
+- Events are immutable - what happened, happened
+
+**Why this matters:**
+- Clear separation of "trying to do X" vs "X happened"
+- Commands validate, events just record
+- Enables replay - reprocess events with new logic
+
+## When to Diverge
+
+These patterns are defaults, not mandates. Diverge intentionally when:
+
+- **Simplicity wins** - a simple CRUD endpoint doesn't need event sourcing
+- **Performance requires it** - sometimes synchronous calls are necessary
+- **Team context** - patterns the team doesn't understand cause more harm than good
+- **Prototyping** - validate ideas before investing in full architecture
+
+When diverging, document the decision in the project's vision.md (see below).
+
+## Project-Level Architecture
+
+Each project should document its architectural choices in `vision.md` under an **Architecture** section:
+
+```markdown
+## Architecture
+
+This project follows organization architecture patterns.
+
+### Alignment
+- Event sourcing for [which aggregates/domains]
+- Bounded contexts: [list contexts and their responsibilities]
+- Event-driven communication between [which services]
+
+### Intentional Divergences
+| Area | Standard Pattern | What We Do Instead | Why |
+|------|------------------|-------------------|-----|
+| [area] | [expected pattern] | [actual approach] | [reasoning] |
+```
+
+This creates traceability: org beliefs → patterns → project decisions.