@lavralabs/lavra 0.7.0

package/plugins/lavra/skills/create-agent-skills/workflows/add-reference.md

@@ -0,0 +1,55 @@
+# Workflow: Add a Reference to Existing Skill
+
+<required_reading>
+**Read these reference files NOW:**
+1. references/recommended-structure.md
+2. references/skill-structure.md
+</required_reading>
+
+<process>
+## Step 1: Select the Skill
+
+```bash
+ls ~/.claude/skills/
+```
+
+Present numbered list, ask: "Which skill needs a new reference?"
+
+## Step 2: Analyze Current Structure
+
+Determine if references/ folder exists and what references are already present.
+
+## Step 3: Gather Reference Requirements
+
+Ask:
+- What knowledge should this reference contain?
+- Which workflows will use it?
+- Is this reusable across workflows or specific to one?
+
+## Step 4: Create the Reference File
+
+Create `references/{reference-name}.md` with structured content.
+
+## Step 5: Update SKILL.md
+
+Add the new reference to the reference index.
+
+## Step 6: Update Workflows That Need It
+
+Add to relevant workflows' required_reading sections.
+
+## Step 7: Verify
+
+- [ ] Reference file exists and is well-structured
+- [ ] Reference is in SKILL.md reference_index
+- [ ] Relevant workflows have it in required_reading
+- [ ] No broken references
+</process>
+
+<success_criteria>
+Reference addition is complete when:
+- [ ] Reference file created with useful content
+- [ ] Added to reference_index in SKILL.md
+- [ ] Relevant workflows updated to read it
+- [ ] Content is reusable (not workflow-specific)
+</success_criteria>

package/plugins/lavra/skills/create-agent-skills/workflows/add-script.md

@@ -0,0 +1,59 @@
+# Workflow: Add a Script to a Skill
+
+<required_reading>
+**Read these reference files NOW:**
+1. references/using-scripts.md
+</required_reading>
+
+<process>
+## Step 1: Identify the Skill
+
+Ask (if not already provided):
+- Which skill needs a script?
+- What operation should the script perform?
+
+## Step 2: Analyze Script Need
+
+Confirm this is a good script candidate:
+- [ ] Same code runs across multiple invocations
+- [ ] Operation is error-prone when rewritten
+- [ ] Consistency matters more than flexibility
+
+## Step 3: Create Scripts Directory
+
+```bash
+mkdir -p ~/.claude/skills/{skill-name}/scripts
+```
+
+## Step 4: Design Script
+
+Gather requirements for inputs, outputs, errors, and idempotency.
+
+## Step 5: Write Script File
+
+Create `scripts/{script-name}.{ext}` with purpose comment, usage instructions, input validation, error handling, and clear output.
+
+## Step 6: Make Executable (if bash)
+
+```bash
+chmod +x ~/.claude/skills/{skill-name}/scripts/{script-name}.sh
+```
+
+## Step 7: Update Workflow to Use Script
+
+Add the script invocation to the relevant workflow.
+
+## Step 8: Test
+
+Verify the script runs correctly within the workflow.
+</process>
+
+<success_criteria>
+Script is complete when:
+- [ ] scripts/ directory exists
+- [ ] Script file has proper structure
+- [ ] Script is executable (if bash)
+- [ ] At least one workflow references the script
+- [ ] No hardcoded secrets or credentials
+- [ ] Tested with real invocation
+</success_criteria>

package/plugins/lavra/skills/create-agent-skills/workflows/add-template.md

@@ -0,0 +1,51 @@
+# Workflow: Add a Template to a Skill
+
+<required_reading>
+**Read these reference files NOW:**
+1. references/using-templates.md
+</required_reading>
+
+<process>
+## Step 1: Identify the Skill
+
+Ask (if not already provided):
+- Which skill needs a template?
+- What output does this template structure?
+
+## Step 2: Analyze Template Need
+
+Confirm this is a good template candidate:
+- [ ] Output has consistent structure across uses
+- [ ] Structure matters more than creative generation
+- [ ] Filling placeholders is more reliable than blank-page generation
+
+## Step 3: Create Templates Directory
+
+```bash
+mkdir -p ~/.claude/skills/{skill-name}/templates
+```
+
+## Step 4: Design Template Structure
+
+Gather requirements for sections, placeholders, and static content.
+
+## Step 5: Write Template File
+
+Create `templates/{template-name}.md` with clear section markers, `{{PLACEHOLDER}}` syntax, and brief inline guidance.
+
+## Step 6: Update Workflow to Use Template
+
+Add template read and fill instructions to the relevant workflow.
+
+## Step 7: Test
+
+Verify template is used correctly and all placeholders get filled.
+</process>
+
+<success_criteria>
+Template is complete when:
+- [ ] templates/ directory exists
+- [ ] Template file has clear structure with placeholders
+- [ ] At least one workflow references the template
+- [ ] Tested with real invocation
+</success_criteria>

package/plugins/lavra/skills/create-agent-skills/workflows/add-workflow.md

@@ -0,0 +1,54 @@
+# Workflow: Add a Workflow to Existing Skill
+
+<required_reading>
+**Read these reference files NOW:**
+1. references/recommended-structure.md
+2. references/workflows-and-validation.md
+</required_reading>
+
+<process>
+## Step 1: Select the Skill
+
+```bash
+ls ~/.claude/skills/
+```
+
+Present numbered list, ask: "Which skill needs a new workflow?"
+
+## Step 2: Analyze Current Structure
+
+Determine if it's a simple skill or already has workflows/.
+
+## Step 3: Gather Workflow Requirements
+
+Ask what the workflow should do and when it would be used.
+
+## Step 4: Upgrade to Router Pattern (if needed)
+
+If skill is currently simple, ask if it should be restructured first.
+
+## Step 5: Create the Workflow File
+
+Create `workflows/{workflow-name}.md` with required_reading, process, and success_criteria.
+
+## Step 6: Update SKILL.md
+
+Add the new workflow to intake question, routing table, and workflows index.
+
+## Step 7: Create References (if needed)
+
+If the workflow needs domain knowledge that doesn't exist yet.
+
+## Step 8: Test
+
+Invoke the skill and verify the new workflow routes and executes correctly.
+</process>
+
+<success_criteria>
+Workflow addition is complete when:
+- [ ] Skill upgraded to router pattern (if needed)
+- [ ] Workflow file created with required_reading, process, success_criteria
+- [ ] SKILL.md intake updated with new option
+- [ ] SKILL.md routing updated
+- [ ] Tested and working
+</success_criteria>

package/plugins/lavra/skills/create-agent-skills/workflows/audit-skill.md

@@ -0,0 +1,63 @@
+# Workflow: Audit a Skill
+
+<required_reading>
+**Read these reference files NOW:**
+1. references/recommended-structure.md
+2. references/skill-structure.md
+</required_reading>
+
+<process>
+## Step 1: List Available Skills
+
+Enumerate skills in chat as numbered list:
+```bash
+ls ~/.claude/skills/
+```
+
+Ask: "Which skill would you like to audit? (enter number or name)"
+
+## Step 2: Read the Skill
+
+After user selects, read the full skill structure.
+
+## Step 3: Run Audit Checklist
+
+### YAML Frontmatter
+- [ ] Has `name:` field (lowercase-with-hyphens)
+- [ ] Name matches directory name
+- [ ] Has `description:` field
+- [ ] Description says what it does AND when to use it
+- [ ] Description is third person
+
+### Structure
+- [ ] SKILL.md under 500 lines
+- [ ] All XML tags properly closed
+- [ ] Has required tags
+- [ ] Has success_criteria
+
+### Content Quality
+- [ ] Principles are actionable (not vague platitudes)
+- [ ] Steps are specific (not "do the thing")
+- [ ] Success criteria are verifiable
+- [ ] No redundant content across files
+
+## Step 4: Generate Report
+
+Present findings with passing items, issues found, and score.
+
+## Step 5: Offer Fixes
+
+If issues found, ask:
+"Would you like me to fix these issues?"
+1. **Fix all** - Apply all recommended fixes
+2. **Fix one by one** - Review each fix before applying
+3. **Just the report** - No changes needed
+</process>
+
+<success_criteria>
+Audit is complete when:
+- [ ] Skill fully read and analyzed
+- [ ] All checklist items evaluated
+- [ ] Report presented to user
+- [ ] Fixes applied (if requested)
+</success_criteria>

package/plugins/lavra/skills/create-agent-skills/workflows/create-domain-expertise-skill.md

@@ -0,0 +1,68 @@
+# Workflow: Create Exhaustive Domain Expertise Skill
+
+<objective>
+Build a comprehensive execution skill that does real work in a specific domain. Domain expertise skills are full-featured build skills with exhaustive domain knowledge in references, complete workflows for the full lifecycle (build -> debug -> optimize -> ship), and can be both invoked directly by users AND loaded by other skills for domain knowledge.
+</objective>
+
+<required_reading>
+**Read these reference files NOW:**
+1. references/recommended-structure.md
+2. references/core-principles.md
+</required_reading>
+
+<process>
+## Step 1: Identify Domain
+
+Ask user what domain expertise to build. Get specific about the scope.
+
+## Step 2: Confirm Target Location
+
+Domain expertise skills go in: `~/.claude/skills/expertise/{domain-name}/`
+
+## Step 3: Identify Workflows
+
+Cover the FULL lifecycle: build-new, add-feature, debug, write-tests, optimize-performance, ship.
+
+## Step 4: Exhaustive Research Phase
+
+Run multiple web searches to ensure coverage of current ecosystem, architecture patterns, lifecycle tooling, common pitfalls, and real-world usage.
+
+## Step 5: Organize Knowledge Into Domain Areas
+
+Structure references by domain concerns, NOT by arbitrary categories.
+
+## Step 6: Create SKILL.md
+
+Use router pattern with essential principles, intake, routing, reference_index, workflows_index.
+
+## Step 7: Write Workflows
+
+Each workflow includes required_reading, implementation steps, verification steps, and success criteria.
+
+## Step 8: Write Comprehensive References
+
+Each reference includes decision guidance, comparisons, code examples, and anti-patterns.
+
+## Step 9: Validate Completeness
+
+Ask: "Could a user build a professional {domain thing} from scratch through shipping using just this skill?"
+
+## Step 10: Create Directory and Files
+
+Write all SKILL.md, workflow files, and reference files.
+
+## Step 11: Final Quality Check
+
+Review entire skill for completeness and accuracy.
+</process>
+
+<success_criteria>
+Domain expertise skill is complete when:
+- [ ] Comprehensive research completed
+- [ ] Knowledge organized by domain areas
+- [ ] Essential principles in SKILL.md
+- [ ] Full lifecycle covered (build -> debug -> test -> optimize -> ship)
+- [ ] Each workflow has required_reading + implementation steps + verification
+- [ ] Each reference has decision trees and comparisons
+- [ ] User can build something professional from scratch through shipping
+</success_criteria>

package/plugins/lavra/skills/create-agent-skills/workflows/create-new-skill.md

@@ -0,0 +1,92 @@
+# Workflow: Create a New Skill
+
+<required_reading>
+**Read these reference files NOW:**
+1. references/recommended-structure.md
+2. references/skill-structure.md
+3. references/core-principles.md
+</required_reading>
+
+<process>
+## Step 1: Adaptive Requirements Gathering
+
+**If user provided context** (e.g., "build a skill for X"):
+-> Analyze what's stated, what can be inferred, what's unclear
+-> Skip to asking about genuine gaps only
+
+**If user just invoked skill without context:**
+-> Ask what they want to build
+
+## Step 2: Research Trigger (If External API)
+
+**When external service detected**, ask:
+"This involves [service name] API. Would you like me to research current endpoints and patterns before building?"
+
+## Step 3: Decide Structure
+
+**Simple skill (single workflow, <200 lines):**
+-> Single SKILL.md file with all content
+
+**Complex skill (multiple workflows OR domain knowledge):**
+-> Router pattern:
+```
+skill-name/
+├── SKILL.md (router + principles)
+├── workflows/ (procedures - FOLLOW)
+├── references/ (knowledge - READ)
+├── templates/ (output structures - COPY + FILL)
+└── scripts/ (reusable code - EXECUTE)
+```
+
+## Step 4: Create Directory
+
+```bash
+mkdir -p ~/.claude/skills/{skill-name}
+# If complex:
+mkdir -p ~/.claude/skills/{skill-name}/workflows
+mkdir -p ~/.claude/skills/{skill-name}/references
+```
+
+## Step 5: Write SKILL.md
+
+**Simple skill:** Write complete skill file with YAML frontmatter, objective, quick_start, content sections, success_criteria.
+
+**Complex skill:** Write router with frontmatter, essential_principles, intake, routing, reference_index, workflows_index.
+
+## Step 6: Write Workflows (if complex)
+
+For each workflow, include required_reading, process, and success_criteria sections.
+
+## Step 7: Write References (if needed)
+
+Domain knowledge that multiple workflows might need.
+
+## Step 8: Validate Structure
+
+Check:
+- [ ] YAML frontmatter valid
+- [ ] Name matches directory (lowercase-with-hyphens)
+- [ ] Description says what it does AND when to use it (third person)
+- [ ] Required tags present
+- [ ] All referenced files exist
+- [ ] SKILL.md under 500 lines
+
+## Step 9: Test
+
+Invoke the skill and observe:
+- Does it ask the right intake question?
+- Does it load the right workflow?
+- Does output match expectations?
+
+Iterate based on real usage, not assumptions.
+</process>
+
+<success_criteria>
+Skill is complete when:
+- [ ] Requirements gathered with appropriate questions
+- [ ] Directory structure correct
+- [ ] SKILL.md has valid frontmatter
+- [ ] All workflows have required_reading + process + success_criteria
+- [ ] References contain reusable domain knowledge
+- [ ] Tested with real invocation
+</success_criteria>

package/plugins/lavra/skills/create-agent-skills/workflows/get-guidance.md

@@ -0,0 +1,70 @@
+# Workflow: Get Guidance on Skill Design
+
+<required_reading>
+**Read these reference files NOW:**
+1. references/core-principles.md
+2. references/recommended-structure.md
+</required_reading>
+
+<process>
+## Step 1: Understand the Problem Space
+
+Ask the user:
+- What task or domain are you trying to support?
+- Is this something you do repeatedly?
+- What makes it complex enough to need a skill?
+
+## Step 2: Determine If a Skill Is Right
+
+**Create a skill when:**
+- Task is repeated across multiple sessions
+- Domain knowledge doesn't change frequently
+- Complex enough to benefit from structure
+
+**Don't create a skill when:**
+- One-off task
+- Changes constantly
+- Too simple
+- Better as a slash command
+
+## Step 3: Map the Workflows
+
+Ask: "What are the different things someone might want to do with this skill?"
+
+## Step 4: Identify Domain Knowledge
+
+Ask: "What knowledge is needed regardless of which workflow?"
+
+## Step 5: Draft the Structure
+
+Based on answers, recommend simple or router pattern.
+
+## Step 6: Identify Essential Principles
+
+Ask: "What rules should ALWAYS apply, no matter which workflow?"
+
+## Step 7: Present Recommendation
+
+If yes -> offer to switch to "Create a new skill" workflow.
+If no -> clarify and iterate.
+</process>
+
+<decision_framework>
+## Quick Decision Framework
+
+| Situation | Recommendation |
+|-----------|----------------|
+| Single task, repeat often | Simple skill |
+| Multiple related tasks | Router + workflows |
+| Complex domain, many patterns | Router + workflows + references |
+| User-triggered, fresh context | Slash command, not skill |
+| One-off task | No skill needed |
+</decision_framework>
+
+<success_criteria>
+Guidance is complete when:
+- [ ] User understands if they need a skill
+- [ ] Structure is recommended and explained
+- [ ] Workflows are identified
+- [ ] User is ready to build (or decided not to)
+</success_criteria>

package/plugins/lavra/skills/create-agent-skills/workflows/upgrade-to-router.md

@@ -0,0 +1,68 @@
+# Workflow: Upgrade Skill to Router Pattern
+
+<required_reading>
+**Read these reference files NOW:**
+1. references/recommended-structure.md
+2. references/skill-structure.md
+</required_reading>
+
+<process>
+## Step 1: Select the Skill
+
+Present numbered list, ask: "Which skill should be upgraded to the router pattern?"
+
+## Step 2: Verify It Needs Upgrading
+
+Good candidate for upgrade:
+- Over 200 lines
+- Multiple distinct use cases
+- Essential principles that shouldn't be skipped
+- Growing complexity
+
+## Step 3: Identify Components
+
+Analyze the current skill and identify:
+1. **Essential principles** - Rules that apply to ALL use cases
+2. **Distinct workflows** - Different things a user might want to do
+3. **Reusable knowledge** - Patterns, examples, technical details
+
+## Step 4: Create Directory Structure
+
+```bash
+mkdir -p ~/.claude/skills/{skill-name}/workflows
+mkdir -p ~/.claude/skills/{skill-name}/references
+```
+
+## Step 5: Extract Workflows
+
+For each identified workflow, create a workflow file with required_reading, process, and success_criteria.
+
+## Step 6: Extract References
+
+For each identified reference topic, create a reference file.
+
+## Step 7: Rewrite SKILL.md as Router
+
+Replace with router structure including essential_principles, intake, routing, reference_index, workflows_index.
+
+## Step 8: Verify Nothing Was Lost
+
+- [ ] All principles preserved (now inline)
+- [ ] All procedures preserved (now in workflows)
+- [ ] All knowledge preserved (now in references)
+- [ ] No orphaned content
+
+## Step 9: Test
+
+Invoke the upgraded skill and verify routing works correctly.
+</process>
+
+<success_criteria>
+Upgrade is complete when:
+- [ ] workflows/ directory created with workflow files
+- [ ] references/ directory created (if needed)
+- [ ] SKILL.md rewritten as router
+- [ ] Essential principles inline in SKILL.md
+- [ ] All original content preserved
+- [ ] Tested and working
+</success_criteria>

package/plugins/lavra/skills/create-agent-skills/workflows/verify-skill.md

@@ -0,0 +1,63 @@
+# Workflow: Verify Skill Content Accuracy
+
+<required_reading>
+**Read these reference files NOW:**
+1. references/skill-structure.md
+</required_reading>
+
+<purpose>
+Audit checks structure. **Verify checks truth.**
+
+Skills contain claims about external things: APIs, CLI tools, frameworks, services. These change over time. This workflow checks if a skill's content is still accurate.
+</purpose>
+
+<process>
+## Step 1: Select the Skill
+
+Present numbered list, ask: "Which skill should I verify for accuracy?"
+
+## Step 2: Read and Categorize
+
+Categorize by primary dependency type:
+
+| Type | Verification Method |
+|------|---------------------|
+| **API/Service** | WebSearch |
+| **CLI Tools** | Run commands |
+| **Framework** | Check docs |
+| **Pure Process** | No external deps |
+
+## Step 3: Extract Verifiable Claims
+
+Scan skill content and extract CLI tools, API endpoints, framework patterns, file paths.
+
+## Step 4: Verify by Type
+
+Verify each claim using appropriate method for its type.
+
+## Step 5: Generate Freshness Report
+
+Present findings with verified, outdated, broken, and unverifiable items.
+
+## Step 6: Offer Updates
+
+If issues found, offer to update all, review each, or just keep the report.
+
+## Step 7: Suggest Verification Schedule
+
+| Skill Type | Recommended Frequency |
+|------------|----------------------|
+| API/Service | Every 1-2 months |
+| Framework | Every 3-6 months |
+| CLI Tools | Every 6 months |
+| Pure Process | Annually |
+</process>
+
+<success_criteria>
+Verification is complete when:
+- [ ] Skill categorized by dependency type
+- [ ] Verifiable claims extracted
+- [ ] Each claim checked with appropriate method
+- [ ] Freshness report generated
+- [ ] Updates applied (if requested)
+</success_criteria>