Problem

When Hermes updates core skills, locally modified skills are preserved (which is correct). However, when a skill receives improvements/fixes on the Hermes repo side, these changes are never propagated to local kept/changed skills.

This creates a dilemma for users:

• Keep local modifications → miss upstream bug fixes and improvements
• Accept upstream update → lose local customizations

Current Behavior

1. User modifies a core skill (e.g., github-pr-workflow)
2. Hermes releases an update with improvements to that skill
3. User's local version is kept, but improvements from upstream are silently ignored
4. User continues using outdated skill version indefinitely

Desired Behavior

A mechanism to detect and optionally merge upstream skill improvements with local modifications.

Proposed Solutions

Option A: Three-way merge on update

• When updating, detect if local skill differs from both:
  • The user's modified version (local)
  • The original version at time of local modification (base)
  • The new upstream version (remote)
• If upstream changed, attempt three-way merge
• On conflict, present diff to user for resolution

Option B: Update notifications

• Track upstream skill versions/changelogs
• Notify user: "Skill github-pr-workflow has upstream updates (bug fixes: X, Y)"
• Provide commands: hermes skill diff <name>, hermes skill merge <name>

Option C: Patch-based local overrides

• Store local changes as patches/overlays rather than full file copies
• Apply patches on top of latest upstream skill
• Cleaner separation of concerns

Workarounds Tried

Currently manual:

1. Check Hermes repo for skill changes
2. Manually diff local vs upstream
3. Painstakingly merge improvements

This is tedious and error-prone.

Additional Context

This is especially painful for frequently-improved skills (e.g., github-* skills, systematic-debugging). Users who customize these skills effectively fork themselves away from ongoing maintenance.

Happy to discuss implementation approach or help test solutions!