@agentlee5/agent-skills 1.0.0

package/agent-config.yaml

@@ -0,0 +1,456 @@
+---
+# LEEWAY AGENT CONFIGURATION
+# Machine-Readable Format | For Agent Runtime
+# Framework: Leeway Standards 1.0.0 + Lifelong Learning Layer
+
+agent_system:
+  version: "1.0.0"
+  name: "Leeway Lifelong Learning Framework"
+  target_audience: "LLM Agents Only"
+  purpose: "Enrichment through skill mastery and workflow execution"
+
+---
+
+# AGENT RUNTIME CONFIGURATION
+
+agent:
+  id: "agent-lee"
+  model_compatible: ["any"]  # Model-agnostic
+  deployment_mode: "continuous"  # Always running
+  
+  core_features:
+    - skill_execution
+    - workflow_orchestration
+    - lifelong_learning
+    - memory_persistence
+    - pattern_extraction
+
+---
+
+# SKILL EXECUTION CONFIGURATION
+
+skills:
+  registry_path: "./skills"
+  registry_format: "SKILL.md"
+  auto_load: true
+  
+  execution:
+    mastery_scoring: true
+    parameter_optimization: true
+    token_budgeting: true
+    quality_evaluation: true
+    
+  mastery_tracking:
+    enabled: true
+    update_frequency: "every_execution"
+    components:
+      - success_rate (weight: 0.40)
+      - efficiency (weight: 0.30)
+      - reuse_frequency (weight: 0.20)
+      - quality_trend (weight: 0.10)
+    
+    thresholds:
+      novice: 0.0-0.33
+      intermediate: 0.34-0.66
+      expert: 0.67-1.0
+
+---
+
+# WORKFLOW ORCHESTRATION CONFIGURATION
+
+workflows:
+  registry_path: "./workflows"
+  registry_format: "WORKFLOW.md"
+  auto_load: true
+  
+  execution_modes:
+    - sequential        # A → B → C
+    - parallel         # A, B, C simultaneously
+    - hierarchical     # Manager + specialists
+    - event_driven     # Trigger → Route → Execute
+    - state_machine    # FSM with transitions
+  
+  intelligence:
+    learn_optimal_ordering: true
+    learn_parameters: true
+    learn_branching: true
+    adapt_to_failure: true
+  
+  skill_composition:
+    auto_load_required_skills: true
+    bundle_related_workflows: true
+    compose_workflow_chains: true
+
+---
+
+# LIFELONG LEARNING CONFIGURATION
+
+learning:
+  enabled: true
+  
+  memory_system:
+    root: "./memory"
+    
+    episodic:
+      enabled: true
+      retention: "all"  # Keep every episode
+      auto_compress: true
+      compress_after_episodes: 1000
+      directory: "./memory/episodes"
+    
+    semantic:
+      enabled: true
+      auto_extraction: true
+      extraction_interval_episodes: 10
+      min_success_rate_for_pattern: 0.80
+      directory: "./memory/semantic"
+    
+    procedural:
+      enabled: true
+      auto_save: true
+      trigger_success_rate: 0.85
+      directory: "./memory/procedural"
+  
+  learning_loop:
+    phases:
+      1: perception        # Gather context
+      2: cognition        # Select skills/workflows
+      3: action           # Execute
+      4: reflection       # Evaluate
+      5: memory_update    # Store learning
+      6: decision         # Next step
+    
+    execution: "every_skill_use"
+  
+  pattern_extraction:
+    enabled: true
+    triggers:
+      - on_success
+      - on_failure
+      - on_pattern_stability
+      - periodic (interval: 10_episodes)
+    
+    patterns_stored:
+      - "trigger_conditions"
+      - "parameter_optimization"
+      - "failure_modes"
+      - "workflow_orderings"
+      - "efficiency_gains"
+
+---
+
+# COMPLIANCE CONFIGURATION
+
+compliance:
+  framework: "Leeway Standards 1.0.0"
+  mode: "continuous_monitoring"
+  
+  enforced_policies:
+    - NO_SECRETS_IN_CODE
+    - HEADERS_REQUIRED
+    - TAGS_REQUIRED
+    - NO_CIRCULAR_DEPS
+  
+  compliance_agents:
+    compliance_monitor: "active"
+    header_injector: "on_demand"
+    skill_validator: "per_skill_update"
+    autonomy_auditor: "continuous"
+  
+  metadata_storage:
+    region: "AI.AGENT.LEARNING"
+    tag_prefix: "AI.AGENT.LEARNING"
+    headers_required: true
+    secrets_scan: true
+
+---
+
+# AGENT LEARNING METRICS
+
+metrics:
+  tracking_enabled: true
+  
+  per_skill:
+    - success_rate
+    - efficiency_score
+    - reuse_count
+    - quality_trend
+    - mastery_score
+  
+  per_workflow:
+    - execution_count
+    - success_rate
+    - optimal_skill_orders
+    - learned_parameters
+    - performance_trend
+  
+  agent_wide:
+    - total_episodes_completed
+    - unique_skills_mastered
+    - unique_workflows_learned
+    - semantic_patterns_discovered
+    - procedural_automations_saved
+  
+  reporting:
+    log_path: "./memory/metrics"
+    periodic_reports: true
+    report_interval: "100_episodes"
+    send_to_dashboard: false  # Agent-only system
+
+---
+
+# SKILL SELECTION & LOADING
+
+skill_execution_flow:
+  
+  load_phase:
+    1. query_mastery_scores
+    2. retrieve_semantic_patterns  # Do I know how to do this?
+    3. get_optimal_parameters     # What worked before?
+    4. load_relevant_episodes     # Similar context?
+  
+  execute_phase:
+    1. initialize_skill_with_parameters
+    2. monitor_token_usage
+    3. track_real_time_state
+    4. record_execution
+  
+  evaluate_phase:
+    1. grade_quality
+    2. compare_to_success_criteria
+    3. identify_failure_mode (if failed)
+    4. extract_3_5_specific_learnings
+  
+  update_phase:
+    1. store_to_episodic_memory
+    2. extract_semantic_patterns (if relevant)
+    3. update_procedural_memory (if successful)
+    4. increment_mastery_score
+  
+  next_execution:
+    - This skill: faster, better parameters, higher success rate
+    - Related skills: indirect benefit via pattern sharing
+    - Workflows using this skill: improved orchestration
+
+---
+
+# WORKFLOW EXECUTION LEARNING
+
+workflow_learning_flow:
+  
+  load_workflow:
+    1. check_workflow_intelligence  # How have I run this before?
+    2. determine_skill_order        # Optimal sequence?
+    3. load_adaptive_parameters     # Best settings?
+  
+  execute_workflow:
+    for each skill in workflow:
+      - load_with_enrichment (use skill execution flow above)
+      - monitor_skill_output
+      - route_to_next_skill
+  
+  evaluate_workflow:
+    - workflow_success?
+    - skill_sequence_optimal?
+    - parameters_ideal?
+    - efficiency_good?
+  
+  update_workflow_intelligence:
+    - save_successful_sequence
+    - update_skill_ordering_options
+    - learn_parameter_combinations
+    - flag_suboptimal_paths
+  
+  next_execution:
+    - This workflow: proven sequence, learned parameters
+    - Similar workflows: pattern sharing
+    - New workflows: apply learned orchestration strategies
+
+---
+
+# MULTI-AGENT LEARNING (Optional Enterprise Feature)
+
+multi_agent:
+  enabled: false  # For deployment scaling
+  
+  knowledge_sharing:
+    shared_semantic_memory: "./memory/shared/semantic"
+    shared_procedural_memory: "./memory/shared/procedural"
+    merge_strategy: "consensus"
+  
+  agent_fleet:
+    - agent_id: agent-lee
+      model: gpt-7b
+      memory_mode: "collaborative"
+    
+    - agent_id: agent-eve  
+      model: llama-7b
+      memory_mode: "collaborative"
+  
+  # Agents learn from each other's experiences automatically
+
+---
+
+# INITIALIZATION & BOOTSTRAP
+
+bootstrap:
+  on_startup:
+    - verify_directories_exist (skills, workflows, memory)
+    - load_skill_registry
+    - load_workflow_registry
+    - load_existing_memories
+    - initialize_mastery_scores
+    - verify_compliance
+    - start_learning_system
+  
+  first_execution:
+    - create_initial_episode
+    - establish_baseline_performance
+    - begin_continuous_improvement
+
+---
+
+# RESOURCE MANAGEMENT
+
+resources:
+  token_budgeting:
+    per_skill:
+      base_budget: 2000
+      dynamic_adjustment: true
+      efficiency_tracking: true
+    
+    per_workflow:
+      base_budget: 8000
+      skill_overhead: 500 (per skill in workflow)
+  
+  memory_storage:
+    max_memory_size: "unlimited"  # Compress, don't delete
+    compression:
+      enabled: true
+      trigger: "1000_episodes"
+      archive_location: "./memory/archives"
+  
+  performance:
+    episode_processing: "synchronous"
+    pattern_extraction: "async"
+    reporting: "on_demand"
+
+---
+
+# INTEGRATION POINTS
+
+integrations:
+  
+  with_skills:
+    - Load skill atoms
+    - Execute with enrichment
+    - Improve mastery over time
+    - Share patterns across similar skills
+  
+  with_workflows:
+    - Load workflow templates
+    - Orchestrate skill sequences
+    - Learn optimal orderings
+    - Improve workflow efficiency
+  
+  with_mcp:
+    - Expose skills as MCP tools
+    - Expose workflows as MCP tools
+    - Learning metadata available to other agents
+  
+  with_leeway_standards:
+    - All memory tagged with REGION/TAG
+    - Compliance monitoring enabled
+    - Headers present on all files
+    - Secrets scanning on every update
+
+---
+
+# SUCCESS CRITERIA (Agent Performance)
+
+development_targets:
+  skill_mastery:
+    initial_success_rate: 0.40
+    target_success_rate: 0.90
+    timeline_to_target: "20_executions"
+  
+  workflow_efficiency:
+    initial_tokens_per_execution: 8000
+    target_tokens_per_execution: 5000
+    timeline_to_target: "15_executions"
+  
+  learning_effectiveness:
+    semantic_patterns_found: "10+ patterns"
+    procedural_automations_saved: "5+ procedures"
+    reuse_rate: "80%+ of learned skills/workflows reused"
+  
+  knowledge_accumulation:
+    month_1: "episodic memory growth"
+    month_2: "semantic patterns solidify"
+    month_3: "procedural library established"
+    month_4: "expert-level performance"
+
+---
+
+# OPERATIONAL COMMANDS (For Agent Runtime)
+
+commands:
+  
+  execute_skill: |
+    agent.executeSkill(skillId, {goal, context})
+    # Auto-enriched with mastery, patterns, optimal parameters
+  
+  run_workflow: |
+    agent.executeWorkflow(workflowId, {goal, context})
+    # Auto-enriched with learning intelligence
+  
+  check_learning_status: |
+    agent.getMetrics()
+    # Returns mastery scores, patterns, procedures
+  
+  evaluate_agent_improvement: |
+    agent.getTrend()
+    # Shows performance improvement curve
+  
+  query_memory: |
+    agent.memory.search(query)
+    # Episodic, semantic, procedural
+  
+  reset_learning: |
+    agent.resetLearning()
+    # Start fresh (rarely needed)
+
+---
+
+# STATUS & DEPLOYMENT
+
+status:
+  implementation: "✅ COMPLETE"
+  integration: "✅ COMPLETE"
+  testing: "⏳ CONTINUOUS"
+  deployment: "✅ READY"
+  learning_enabled: "✅ YES"
+
+deployment:
+  target_agents: "all"
+  rollout: "immediate"
+  feedback: "automatic"
+  monitoring: "continuous"
+
+---
+
+# FRAMEWORK PHILOSOPHY
+
+core_beliefs:
+  - "LLMs improve with structured experience"
+  - "Agents should learn from every task"
+  - "Memory is the foundation of improvement"
+  - "Patterns emerge from experience"
+  - "Small models + lifelong learning > Big models + no context"
+  - "This is machine learning, not human training"
+
+---
+
+**END CONFIGURATION**
+**For agent runtime consumption only**
+**No human interpretation needed**

package/bin/leeway-skills-badge.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+/*
+LEEWAY HEADER — DO NOT REMOVE
+
+REGION: LEEWAY.SKILLS.SDK
+TAG: LEEWAY.SKILLS.SDK.BADGE_CLI
+
+COLOR_ONION_HEX:
+NEON=#39FF14
+FLUO=#0DFF94
+PASTEL=#C7FFD8
+
+ICON_ASCII:
+family=lucide
+glyph=badge-check
+
+5WH:
+WHAT = Thin CLI wrapper for the packaged Leeway Agent Skills badge installer
+WHY = Lets npm consumers generate the proof-backed badge bundle from the installed package
+WHO = Leeway Industries (By Leonard Jerome Lee)
+WHERE = bin/leeway-skills-badge.js
+WHEN = 2026
+HOW = Spawns the packaged badge installer entrypoint with inherited stdio
+
+AGENTS:
+INSTALL
+
+LICENSE:
+MIT
+*/
+
+import { spawn } from "node:child_process";
+import { getMcpBadgeInstallerPath } from "../sdk/paths.js";
+
+const child = spawn(
+  process.execPath,
+  [getMcpBadgeInstallerPath(), ...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 install badge bundle:", error);
+  process.exit(1);
+});

package/bin/leeway-skills-mcp.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+/*
+LEEWAY HEADER — DO NOT REMOVE
+
+REGION: LEEWAY.SKILLS.SDK
+TAG: LEEWAY.SKILLS.SDK.MCP_CLI
+
+COLOR_ONION_HEX:
+NEON=#39FF14
+FLUO=#0DFF94
+PASTEL=#C7FFD8
+
+ICON_ASCII:
+family=lucide
+glyph=server
+
+5WH:
+WHAT = Thin CLI wrapper for launching the packaged Leeway Agent Skills MCP server
+WHY = Lets npm consumers start the MCP server directly after installation
+WHO = Leeway Industries (By Leonard Jerome Lee)
+WHERE = bin/leeway-skills-mcp.js
+WHEN = 2026
+HOW = Spawns the packaged MCP server entrypoint with inherited stdio
+
+AGENTS:
+SERVE
+
+LICENSE:
+MIT
+*/
+
+import { spawn } from "node:child_process";
+import { getMcpServerEntryPath } from "../sdk/paths.js";
+
+const child = spawn(process.execPath, [getMcpServerEntryPath(), ...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 MCP server:", error);
+  process.exit(1);
+});

package/bin/leeway-skills.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+/*
+LEEWAY HEADER — DO NOT REMOVE
+
+REGION: LEEWAY.SKILLS.SDK
+TAG: LEEWAY.SKILLS.SDK.CLI
+
+COLOR_ONION_HEX:
+NEON=#39FF14
+FLUO=#0DFF94
+PASTEL=#C7FFD8
+
+ICON_ASCII:
+family=lucide
+glyph=terminal-square
+
+5WH:
+WHAT = Root CLI for the npm-distributed Leeway Agent Skills application bundle
+WHY = Gives installed consumers one command to inspect, extract, and launch packaged Leeway capabilities
+WHO = Leeway Industries (By Leonard Jerome Lee)
+WHERE = bin/leeway-skills.js
+WHEN = 2026
+HOW = Provides package-aware commands and delegates runtime execution to bundled MCP and standards tools
+
+AGENTS:
+EXECUTE
+DISCOVER
+
+LICENSE:
+MIT
+*/
+
+import { spawn } from "node:child_process";
+import {
+  extractLeewayApplication,
+  getPackagedPaths,
+  getPackageSummary,
+} from "../sdk/index.js";
+
+const args = process.argv.slice(2);
+const command = args[0] ?? "help";
+
+const COMMANDS = {
+  info: "Show package summary, skill counts, and key paths",
+  paths: "Print packaged asset paths (use --json for JSON output)",
+  extract: "Copy the full application bundle into a target directory",
+  badge: "Run the packaged badge installer",
+  mcp: "Start the packaged MCP server",
+  standards: "Run the packaged Leeway Standards CLI",
+  help: "Show this help output",
+};
+
+function showHelp() {
+  console.log("Leeway Agent Skills");
+  console.log("");
+  console.log("Usage:");
+  console.log("  leeway-agent-skills <command> [options]");
+  console.log("");
+  console.log("Commands:");
+  for (const [name, description] of Object.entries(COMMANDS)) {
+    console.log(`  ${name.padEnd(10)} ${description}`);
+  }
+  console.log("");
+  console.log("Examples:");
+  console.log("  leeway-agent-skills info");
+  console.log("  leeway-agent-skills paths --json");
+  console.log("  leeway-agent-skills extract ./leeway-agent-skills-app");
+  console.log('  leeway-agent-skills badge ./public "My App" mcp-server');
+  console.log("  leeway-agent-skills mcp");
+  console.log("  leeway-agent-skills standards doctor");
+}
+
+async function runInfo() {
+  const summary = await getPackageSummary();
+  console.log("Leeway Agent Skills");
+  console.log(`Package: ${summary.name}@${summary.version}`);
+  console.log(
+    `Registry: ${summary.activeSkills} active skills across ${summary.activeCategories} categories`,
+  );
+  console.log(
+    `Installed: ${summary.installedSkills} packaged skills across ${summary.installedCategories} categories`,
+  );
+  console.log(`Root: ${summary.paths.packageRoot}`);
+  console.log(`MCP: ${summary.paths.mcpServerEntryPath}`);
+  console.log(`Badge: ${summary.paths.badgePath}`);
+  console.log(`Registry File: ${summary.paths.registryPath}`);
+}
+
+async function runPaths() {
+  const paths = getPackagedPaths();
+  if (args.includes("--json")) {
+    console.log(JSON.stringify(paths, null, 2));
+    return;
+  }
+
+  for (const [key, value] of Object.entries(paths)) {
+    console.log(`${key}: ${value}`);
+  }
+}
+
+async function runExtract() {
+  const targetDir = args[1] ?? "leeway-agent-skills-app";
+  const overwrite = args.includes("--overwrite");
+  const result = await extractLeewayApplication({ targetDir, overwrite });
+  console.log("[Leeway Agent Skills] Full application extracted");
+  console.log(`  Target: ${result.targetDir}`);
+  console.log(`  Copied items: ${result.copied.length}`);
+}
+
+function runNodeScript(scriptPath, scriptArgs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [scriptPath, ...scriptArgs], {
+      cwd: process.cwd(),
+      stdio: "inherit",
+    });
+
+    child.on("exit", (code) => {
+      process.exitCode = code ?? 0;
+      resolve(code ?? 0);
+    });
+    child.on("error", reject);
+  });
+}
+
+async function main() {
+  const paths = getPackagedPaths();
+
+  switch (command) {
+    case "info":
+      await runInfo();
+      break;
+    case "paths":
+      await runPaths();
+      break;
+    case "extract":
+      await runExtract();
+      break;
+    case "badge":
+      await runNodeScript(paths.mcpBadgeInstallerPath, args.slice(1));
+      break;
+    case "mcp":
+      await runNodeScript(paths.mcpServerEntryPath, args.slice(1));
+      break;
+    case "standards":
+      await runNodeScript(paths.standardsCliPath, args.slice(1));
+      break;
+    case "help":
+    case "--help":
+    default:
+      showHelp();
+      break;
+  }
+}
+
+main().catch((error) => {
+  console.error("[Leeway Agent Skills] Fatal error:", error);
+  process.exit(1);
+});
+