Claude-Code-Workflow/.claude/commands/memory/load-skill-memory.md

name, description, argument-hint, allowed-tools, examples

name	description	argument-hint	allowed-tools	examples
load-skill-memory	Automatically discover and activate SKILL packages based on task context with intelligent matching	"task description or file path"	Bash(*), Read(*), Glob(*), Skill(*)	/memory:load-skill-memory "分析热模型builder pattern实现" /memory:load-skill-memory "修改workflow文档生成逻辑" /memory:load-skill-memory "D:\dongdiankaifa9\hydro_generator_module\builders\base.py"

Memory Load SKILL Command (/memory:load-skill-memory)

1. Overview

The memory:load-skill-memory command automatically discovers and activates the most relevant SKILL package based on task description or file path. It dynamically matches user intent against available SKILL descriptions and activates the best match.

Core Philosophy:

• Dynamic SKILL Discovery: Automatically finds relevant SKILL without manual specification
• Intelligent Matching: Matches task keywords against SKILL descriptions
• Path-Based Detection: Recognizes project paths and activates corresponding SKILL
• Automatic Activation: Uses Skill() tool to load comprehensive context

2. Parameters

• "task description or file path" (Required): Task context or file path for SKILL matching
  • Task description: "分析热模型实现", "修改workflow逻辑", "学习参数系统"
  • File path: "D:\dongdiankaifa9\hydro_generator_module\builders\base.py"
  • Domain keywords: "thermal modeling", "workflow management", "multi-physics"

3. Three-Step Execution Flow

Step 1: Discover Available SKILLs

List All SKILL Packages:

bash(ls -1 .claude/skills/ 2>/dev/null || echo "No SKILLs available")

Read Each SKILL.md for Matching:

# For each SKILL directory found
for skill in $(ls -1 .claude/skills/); do
  Read(.claude/skills/${skill}/SKILL.md)
done

Extract Matching Information:

• SKILL name
• Description (with trigger keywords)
• Location path (from description)
• Domain keywords

Step 2: Match Most Relevant SKILL

Matching Algorithm:

1. Path-Based Matching (Highest Priority):

   • Extract path from user input if provided
   • Compare against SKILL location paths in descriptions
   • Exact match: D:\dongdiankaifa9\hydro_generator_module → hydro_generator_module SKILL

2. Keyword Matching (Secondary Priority):

   • Extract keywords from task description
   • Match against SKILL description keywords
   • Score each SKILL by keyword overlap count

3. Action Matching (Tertiary Priority):

   • Detect action verbs: "分析", "修改", "学习", "实现"
   • Match against SKILL description triggers
   • Prefer SKILLs with matching action patterns

Scoring Example:

Task: "分析热模型builder pattern实现"

hydro_generator_module SKILL:
- Path match: No
- Keywords: "热模型"(1), "builder"(1), "实现"(1) = 3 points
- Action match: "analyzing"(1) = 1 point
- Total: 4 points ✅ Winner

Claude_dms3 SKILL:
- Path match: No
- Keywords: "workflow"(0) = 0 points
- Action match: "analyzing"(1) = 1 point
- Total: 1 point

No Match Handling:

⚠️  No matching SKILL found for: "{task_description}"

Available SKILLs:
- hydro_generator_module - Hydro-generator thermal modeling
- Claude_dms3 - Workflow orchestration system

Generate SKILL for your project: /memory:skill-memory [path]

Step 3: Activate Matched SKILL

Activate Best Match:

Skill(command: "{matched_skill_name}")

What Happens:

1. System reads .claude/skills/{matched_skill_name}/SKILL.md
2. Automatically loads appropriate documentation based on:
   • SKILL description triggers (analyzing, modifying, learning)
   • Current conversation context
   • Memory gaps detection
3. Progressive loading levels (0-3) handled automatically
4. Context loaded directly into conversation memory

Confirmation Output:

✅ Matched and activated SKILL: {matched_skill_name}
🎯 Match reason: {path/keyword/action match}
📦 Location: {project_path}
💡 Context loaded for: {domain_description}

4. Output Format

Success Output:

✅ Activated SKILL: {skill_name}

📦 SKILL Package Information:
- Location: {project_path}
- Description: {description from SKILL.md}
- Documentation: .workflow/docs/{skill_name}/

💡 Context loaded automatically by SKILL system based on:
- Current task requirements
- Conversation memory gaps
- SKILL description triggers

🎯 Ready for: analyzing, modifying, or learning about {domain_description}

5. Usage Examples

Example 1: Task-Based Discovery (Keyword Matching)

User Command:

/memory:load-skill-memory "分析热模型builder pattern实现"

Execution Flow:

// Step 1: Discover available SKILLs
bash(ls -1 .claude/skills/)
// Output: hydro_generator_module, Claude_dms3

// Read each SKILL.md
Read(.claude/skills/hydro_generator_module/SKILL.md)
Read(.claude/skills/Claude_dms3/SKILL.md)

// Step 2: Match keywords
Keywords extracted: ["热模型", "builder", "pattern", "实现", "分析"]

Matching scores:
- hydro_generator_module: 4 points (thermal modeling, builder, analyzing)
- Claude_dms3: 1 point (analyzing only)

Best match: hydro_generator_module

// Step 3: Activate matched SKILL
Skill(command: "hydro_generator_module")

Output:

✅ Matched and activated SKILL: hydro_generator_module
🎯 Match reason: Keywords ["thermal", "builder"] + Action ["analyzing"]
📦 Location: D:\dongdiankaifa9\hydro_generator_module
💡 Context loaded for: hydro-generator thermal modeling

Example 2: Path-Based Discovery (Direct Path Match)

User Command:

/memory:load-skill-memory "D:\dongdiankaifa9\hydro_generator_module\builders\base.py"

Execution Flow:

// Step 1: Discover SKILLs
bash(ls -1 .claude/skills/)

// Step 2: Match path
Path extracted: "D:\dongdiankaifa9\hydro_generator_module"

Matching:
- hydro_generator_module location: "D:\dongdiankaifa9\hydro_generator_module" ✅ Exact match
- Claude_dms3 location: "D:\Claude_dms3" ❌ No match

Best match: hydro_generator_module (path match - highest priority)

// Step 3: Activate
Skill(command: "hydro_generator_module")

Output:

✅ Matched and activated SKILL: hydro_generator_module
🎯 Match reason: Path match (D:\dongdiankaifa9\hydro_generator_module)
📦 Location: D:\dongdiankaifa9\hydro_generator_module
💡 Context loaded for: hydro-generator thermal modeling

Example 3: Domain Keyword Discovery

User Command:

/memory:load-skill-memory "修改workflow文档生成调度逻辑"

Execution Flow:

// Step 1: Discover SKILLs
bash(ls -1 .claude/skills/)

// Step 2: Match keywords
Keywords: ["workflow", "文档生成", "调度", "修改"]

Matching scores:
- Claude_dms3: 3 points (workflow, docs generation, modifying)
- hydro_generator_module: 1 point (modifying only)

Best match: Claude_dms3

// Step 3: Activate
Skill(command: "Claude_dms3")

Output:

✅ Matched and activated SKILL: Claude_dms3
🎯 Match reason: Keywords ["workflow", "docs"] + Action ["modifying"]
📦 Location: D:\Claude_dms3
💡 Context loaded for: workflow orchestration and documentation

6. SKILL Trigger Mechanism

How SKILL System Determines Context Loading:

The SKILL.md description includes trigger patterns that automatically activate when:

1. Keyword Matching:

   • User mentions domain keywords (e.g., "热模型", "workflow", "多物理场")
   • Description keywords match task requirements

2. Action Detection:

   • "analyzing" triggers for analysis tasks
   • "modifying" triggers for code modification
   • "learning" triggers for exploration

3. Memory Gap Detection:

   • "especially when no relevant context exists in memory"
   • System prioritizes SKILL loading when conversation lacks context

4. Path-Based Triggering:

   • User mentions file paths matching SKILL location
   • "files under this path" clause activates

Progressive Loading (Automatic):

• Level 0: ~2K tokens (Quick overview)
• Level 1: ~10K tokens (Core modules)
• Level 2: ~25K tokens (Complete system)
• Level 3: ~40K tokens (Full documentation)

System automatically selects appropriate level based on task complexity and context requirements.

7. Implementation Steps

Execution Logic:

// Step 1: Validate SKILL existence
skill_path = `.claude/skills/${skill_name}/SKILL.md`
if (!exists(skill_path)) {
  list_available_skills()
  return error_message
}

// Step 2: Activate SKILL
Skill(command: skill_name)

// Step 3: System handles automatically
// - Reads SKILL.md description
// - Matches triggers with task context
// - Loads appropriate documentation level
// - Injects context into conversation memory

// Step 4: Confirm activation
output_success_message(skill_name, project_path, description)

8. Error Handling

SKILL Not Found

❌ SKILL 'unknown_module' not found.

Available SKILLs:
- hydro_generator_module (D:\dongdiankaifa9\hydro_generator_module)
- Claude_dms3 (D:\Claude_dms3)

Activate SKILL: Skill(command: "skill_name")
Generate new SKILL: /memory:skill-memory [path]

Documentation Missing

⚠️  SKILL 'hydro_generator_module' exists but documentation incomplete.

Missing files:
- .workflow/docs/hydro_generator_module/ARCHITECTURE.md

Regenerate documentation: /memory:skill-memory --regenerate

9. Integration with Other Commands

Workflow Integration:

// 1. Activate SKILL context
Skill(command: "hydro_generator_module")

// 2. Use loaded context for planning
SlashCommand(command: "/workflow:plan \"增强thermal template支持动态阻抗\"")

// 3. Execute implementation
SlashCommand(command: "/workflow:execute")

Memory Refresh Pattern:

// Refresh SKILL context after code changes
Skill(command: "hydro_generator_module")
// System automatically detects changes and loads updated documentation

10. Token Optimization Strategy

Automatic Progressive Loading: The SKILL system automatically handles token optimization:

1. Initial Load: Starts with minimum required context
2. On-Demand Escalation: Loads more documentation if needed
3. Task-Driven: Adjusts depth based on task complexity
4. Memory-Aware: Avoids loading redundant context

Token Budget (Automatic):

• Simple queries: ~2-10K tokens
• Code analysis: ~10-25K tokens
• Implementation: ~25-40K tokens

Optimization Benefits:

• No manual level selection required
• System learns from conversation context
• Efficient memory usage
• Automatic reload when context insufficient

11. Notes

• Validation First: Always checks SKILL existence before activation
• Automatic Loading: Skill tool handles all documentation reading
• Session-Scoped: Activated SKILL context valid for current session
• Trigger-Based: Description patterns drive automatic activation
• Path-Aware: Triggers on project path mentions
• Memory-Smart: Prioritizes loading when conversation lacks context
• Read-Only: Does not modify SKILL files or documentation
• Reactivation: Can re-activate SKILL to refresh context after changes