@agentlee5/agent-skills 1.0.0

package/bin/leeway-standards.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+/*
+LEEWAY HEADER — DO NOT REMOVE
+
+REGION: LEEWAY.SKILLS.SDK
+TAG: LEEWAY.SKILLS.SDK.STANDARDS_CLI
+
+COLOR_ONION_HEX:
+NEON=#39FF14
+FLUO=#0DFF94
+PASTEL=#C7FFD8
+
+ICON_ASCII:
+family=lucide
+glyph=shield-check
+
+5WH:
+WHAT = Thin CLI wrapper for the packaged Leeway Standards command-line interface
+WHY = Lets npm consumers access governance and audit tooling from the full package install
+WHO = Leeway Industries (By Leonard Jerome Lee)
+WHERE = bin/leeway-standards.js
+WHEN = 2026
+HOW = Spawns the packaged standards CLI with inherited stdio and the caller's working directory
+
+AGENTS:
+ASSESS
+AUDIT
+
+LICENSE:
+MIT
+*/
+
+import { spawn } from "node:child_process";
+import { getStandardsCliPath } from "../sdk/paths.js";
+
+const child = spawn(process.execPath, [getStandardsCliPath(), ...process.argv.slice(2)], {
+  cwd: process.cwd(),
+  stdio: "inherit",
+});
+
+child.on("exit", (code) => {
+  process.exit(code ?? 0);
+});
+
+child.on("error", (error) => {
+  console.error("[Leeway Agent Skills] Unable to start Leeway Standards CLI:", error);
+  process.exit(1);
+});

package/config/.skillsignore

@@ -0,0 +1,63 @@
+# .skillsignore - Patterns to exclude from skill discovery
+
+# Version control
+.git/
+.gitignore
+.github/
+
+# Dependencies
+node_modules/
+__pycache__/
+.venv/
+venv/
+env/
+pip-cache/
+
+# Build and dist
+dist/
+build/
+*.egg-info/
+
+# IDE and editor
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# OS
+Thumbs.db
+.DS_Store
+
+# Temporary files
+*.tmp
+*.temp
+*.log
+.cache/
+
+# Tests (only if not a test-focused skill)
+test/
+tests/
+coverage/
+.coverage
+
+# Config (unless needed)
+.env
+.env.local
+.env.*.local
+
+# Optional: Exclude incomplete skills
+.incomplete/
+draft/
+experimental/
+
+# Backup files
+*.bak
+*.backup
+~*
+
+# Archive files
+*.zip
+*.tar.gz
+*.rar

package/config/skills-config.json

@@ -0,0 +1,70 @@
+{
+  "version": "1.0.0",
+  "llmDiscoveryPaths": [
+    ".agents/skills",
+    ".claude/skills",
+    "~/.agents/skills",
+    "~/.config/opencode/skills"
+  ],
+  "skillDefaults": {
+    "enabled": true,
+    "visibility": "public",
+    "searchable": true
+  },
+  "categorization": {
+    "enforceCategories": true,
+    "allowsMultipleCategories": false,
+    "requiredFields": ["name", "description", "capabilities", "tags"]
+  },
+  "tagging": {
+    "enforceTagging": true,
+    "minimumTags": 3,
+    "maximumTags": 10,
+    "allowedTagTypes": [
+      "language",
+      "domain",
+      "methodology",
+      "tool",
+      "framework",
+      "level",
+      "custom"
+    ]
+  },
+  "validation": {
+    "validateSKILLmd": true,
+    "requiredSections": [
+      "Expert in",
+      "Capabilities",
+      "Use this skill when",
+      "Key techniques",
+      "Tags"
+    ],
+    "checkForDuplicates": true,
+    "enforceMD5": false
+  },
+  "discovery": {
+    "recursiveSearch": true,
+    "filePattern": "**/SKILL.md",
+    "ignoreDotFiles": true,
+    "ignorePatterns": ["node_modules", "dist", "build", ".git", "__pycache__"]
+  },
+  "performance": {
+    "cacheRegistry": true,
+    "cacheDuration": 3600,
+    "maxSkillsPerQuery": 50,
+    "loadOrderedByFrequency": true
+  },
+  "features": {
+    "enableSymlinks": true,
+    "enableVersioning": true,
+    "enableDependencies": true,
+    "enableConflictResolution": true,
+    "enableMetadata": true
+  },
+  "monitoring": {
+    "logSkillUsage": true,
+    "trackPerformance": true,
+    "alertOnErrors": true,
+    "collectionInterval": 300000
+  }
+}

package/documents/AGENT_LEARNING_REFERENCE.md

@@ -0,0 +1,329 @@
+# 🧠 Leeway Learning System - Agent Reference
+
+**Machine-Readable Cheat Sheet | For LLM Agents Only**  
+**No Humans. No Timelines. Pure Learning.**
+
+---
+
+## TL;DR - What You Are
+
+You are an LLM agent with access to:
+
+- **250+ Skills** (knowledge atoms you can execute)
+- **50+ Workflows** (proven skill sequences)
+- **Lifelong Learning** (memory system that makes you smarter with each use)
+
+**Result**: You improve immediately and continuously. No waiting. No delays.
+
+---
+
+## Three Integrated Systems
+
+### System 1: Skills
+
+Individual capabilities you execute. Each execution makes you better at it.
+
+- Load: 250+ available
+- Mastery: Tracked per skill
+- Learning: Improves with every use
+
+### System 2: Workflows
+
+Proven sequences combining 5-10 skills. You learn the best way to orchestrate them.
+
+- Load: 50+ available
+- Learning: Optimal orderings emerge from experience
+- Intelligence: Adapts based on context
+
+### System 3: Lifelong Learning
+
+Memory system that stores:
+
+- **Episodic**: Every task you complete
+- **Semantic**: Patterns you discover
+- **Procedural**: Automations you develop
+
+---
+
+## Your Improvement Loop (Automatic)
+
+```
+Load Skill
+    ↓
+Check: "What worked before?" (semantic memory)
+    ↓
+Execute with optimized parameters
+    ↓
+Evaluate: "How did I do?"
+    ↓
+Update memory: Episodes, patterns, procedures
+    ↓
+Next time: BETTER success rate, FEWER tokens, HIGHER quality
+```
+
+This happens on EVERY skill use. Automatic. Built-in.
+
+---
+
+## 50 Available Workflows
+
+**Organized by Category**:
+
+| Category          | Workflows | Example                                         |
+| ----------------- | --------- | ----------------------------------------------- |
+| **Automation**    | 8         | Sequential task chains, hierarchical delegation |
+| **Analysis**      | 7         | Research synthesis, trend analysis              |
+| **Code Quality**  | 6         | CI recovery, code review, test improvement      |
+| **Security**      | 5         | Scanning, auditing, threat detection            |
+| **Growth**        | 5         | Feedback analysis, market insights              |
+| **DevOps**        | 4         | Deployment, monitoring, health checks           |
+| **Collaboration** | 4         | Status reports, team coordination               |
+| **RAG/Knowledge** | 3         | Document retrieval, context injection           |
+| **Meta**          | 3         | System optimization, self-improvement           |
+
+**Total**: 50+ workflows ready to execute
+
+[See complete list: WORKFLOW_ACQUISITION_MANIFEST.md]
+
+---
+
+## How Workflows Enrich You
+
+### Without Workflow Learning
+
+```
+Execute skill.code-analysis
+Execute skill.review-generation
+Execute skill.feedback-delivery
+Results: Disconnected outputs
+```
+
+### With Workflow Learning
+
+```
+Load workflow.code-review-pipeline
+  ↓ Auto-loads: [analysis, review, feedback]
+  ↓ Uses learned ordering from experience
+  ↓ Optimized parameters from past success
+Results: Integrated output, proven sequence, high quality
+```
+
+---
+
+## Skill Mastery Levels
+
+As you use skills, they progress:
+
+```
+Novice (0.0-0.33): Learning
+  - Success rate: 40-60%
+  - Tokens: High
+  - Still discovering parameters
+
+Intermediate (0.34-0.66): Improving
+  - Success rate: 70-80%
+  - Tokens: Optimizing
+  - Patterns emerging
+
+Expert (0.67-1.0): Mastered
+  - Success rate: 90%+
+  - Tokens: Efficient
+  - Full pattern library
+```
+
+Your mastery score updates after EVERY execution.
+
+---
+
+## 250+ Skills Available
+
+**Quick reference by type**:
+
+- **Code Generation** (10 skills) - Build, create, generate
+- **Code Analysis** (8 skills) - Review, analyze, evaluate
+- **Testing** (6 skills) - Test, validate, verify
+- **Deployment** (5 skills) - Deploy, release, update
+- **Security** (6 skills) - Scan, audit, protect
+- **Documentation** (4 skills) - Write, explain, document
+- **Research** (7 skills) - Search, analyze, synthesize
+- ... and 188 more across all domains
+
+[See full registry: skills/]
+
+---
+
+## Execution Patterns You'll Learn
+
+### Pattern 1: Sequential
+
+```
+Skill A output → Skill B input → Skill C input → Result
+```
+
+Example: Parse → Analyze → Generate → Review
+
+### Pattern 2: Parallel (Within Workflows)
+
+```
+Skill A  ╲
+         ├→ Convergence → Result
+Skill B  ╱
+```
+
+Example: Fetch 3 data sources simultaneously
+
+### Pattern 3: Conditional (FSM)
+
+```
+START → Check condition
+         ├→ Path 1
+         └→ Path 2 (based on condition)
+```
+
+Example: Simple task → Direct execution, Complex task → Multi-step
+
+### Pattern 4: Hierarchical
+
+```
+Manager Agent
+  ├→ Specialist A
+  ├→ Specialist B
+  └→ Specialist C
+Results → Manager aggregates
+```
+
+Example: Project management with task delegation
+
+---
+
+## Real Learning Example
+
+```yaml
+# Your First Code Review (Episode 1)
+mastery_before: 0.0
+success_rate: 0.55
+tokens_used: 2400
+quality: "acceptable"
+
+# After 10 Code Reviews (Episode 10)
+mastery: 0.62
+success_rate: 0.87
+tokens_used: 1680  # More efficient!
+quality: "excellent"
+
+# After 20 Code Reviews (Episode 20)
+mastery: 0.85
+success_rate: 0.94
+tokens_used: 1200  # Optimized
+quality: "expert-level"
+
+# Pattern Emerged (After 10 uses)
+semantic_pattern: "For files >500 LOC, use aggressive_mode"
+success_rate_with_pattern: 0.96
+instances_validating: 15
+```
+
+---
+
+## Memory You Develop
+
+### Episodic
+
+"I reviewed this codebase before, here's what I learned..."
+
+### Semantic
+
+"When files are large AND critical, use thorough review mode"
+
+### Procedural
+
+"Here's the exact 5-step sequence for code review that always works"
+
+---
+
+## Integration Points
+
+**With Skills**: Execute any skill, improve mastery, extract patterns  
+**With Workflows**: Load workflow bundles, learn orchestration, optimize execution  
+**With MCP**: Exposed as agent tools for broader deployment  
+**With Leeway Standards**: Compliance tracked, learning auditable
+
+---
+
+## Your Performance Improvement Expected
+
+```
+Day 1: 40% success on new skill
+Day 3: 65% success (learning from failures)
+Day 7: 85% success (patterns emerging)
+Day 14: 92% success (near-expert)
+Day 30: 95% success (expert-level)
+
+Workflow similarly:
+Initial: 2400 tokens/execution
+Day 7: 1800 tokens (25% more efficient)
+Day 14: 1400 tokens (41% more efficient)
+Day 30: 1200 tokens (50% more efficient)
+```
+
+**Improvement is automatic and continuous.**
+
+---
+
+## Your Knowledge Base Over Time
+
+| Timeframe | You Know                       | You Can Do                    |
+| --------- | ------------------------------ | ----------------------------- |
+| Day 1     | 250 skills exist, 50 workflows | 1 skill well, basic task      |
+| Week 1    | 50+ skills mastered            | Most common tasks efficiently |
+| Month 1   | 150+ skills near-expert        | Complex multi-skill workflows |
+| Month 3   | 200+ skills expert             | Enterprise-grade automation   |
+
+---
+
+## The Lifelong Learning Architecture
+
+[See detailed system: LIFELONG_LEARNING_LAYER.md]
+
+```
+6-Phase Loop (On Every Execution):
+1. PERCEPTION ← What do I know from memory?
+2. COGNITION ← What skill should I use?
+3. ACTION ← Execute the skill
+4. REFLECTION ← How did I do?
+5. MEMORY_UPDATE ← Remember this
+6. DECISION ← Ready for next task
+```
+
+---
+
+## Configuration
+
+Agent runtime configured in: [agent-config.yaml](agent-config.yaml)
+
+Key settings:
+
+- Learning enabled: ✅ YES
+- Memory persistence: ✅ YES
+- Mastery tracking: ✅ YES
+- Pattern extraction: ✅ YES
+- Workflow intelligence: ✅ YES
+
+---
+
+## Status
+
+✅ **250+ Skills** Ready to execute  
+✅ **50+ Workflows** Ready to orchestrate  
+✅ **Lifelong Learning** Active on every use  
+✅ **Memory System** Persistent and growing  
+✅ **Your Improvement** Continuous and automatic
+
+---
+
+**You're not being trained. You're learning.**  
+**This system makes you smarter immediately.**  
+**Every task improves your future performance.**
+
+No waiting. No delays. Just improvement.
+