fix: prevent skill-active-state collision between OMC and project custom skills (#1741)

When a project defines a custom skill with the same name as an OMC built-in
skill (e.g., `.claude/skills/plan/`), the pre-tool hook incorrectly applied
OMC's SKILL_PROTECTION map to the custom skill, writing skill-active-state.json
with `active: true`. This caused the stop hook to block session termination
with reinforcement messages even after the custom skill completed.

The fix passes the raw (un-normalized) skill name through the call chain so
`getSkillProtection()` can distinguish OMC skills (prefixed with
`oh-my-claudecode:`) from project custom or other plugin skills. Non-OMC
skills now correctly default to `'none'` protection.

Affected files:
- src/hooks/skill-state/index.ts: Add rawSkillName param to getSkillProtection/writeSkillActiveState
- src/hooks/bridge.ts: Extract and pass raw skill name via getRawSkillName()
- scripts/pre-tool-enforcer.mjs: Same fix for the CJS runtime hook

Ref: #1581

Author: dlwnstjr0310

scripts/pre-tool-enforcer.mjs

@@ -360,7 +360,14 @@ const SKILL_PROTECTION_MAP = {
   deepinit: 'heavy',
 };
 
-function getSkillProtectionLevel(skillName) {
+function getSkillProtectionLevel(skillName, rawSkillName) {
+  // When rawSkillName is provided, only apply protection to OMC-prefixed skills.
+  // Non-prefixed skills are project custom skills or other plugins — no protection.
+  // See: https://github.com/Yeachan-Heo/oh-my-claudecode/issues/1581
+  if (rawSkillName != null && typeof rawSkillName === 'string' &&
+      !rawSkillName.toLowerCase().startsWith('oh-my-claudecode:')) {
+    return 'none';
+  }
   const normalized = (skillName || '').toLowerCase().replace(/^oh-my-claudecode:/, '');
   return SKILL_PROTECTION_MAP[normalized] || 'none';
 }
@@ -373,8 +380,8 @@ function extractSkillName(toolInput) {
   return normalized.includes(':') ? normalized.split(':').at(-1).toLowerCase() : normalized.toLowerCase();
 }
 
-function writeSkillActiveState(directory, skillName, sessionId) {
-  const protection = getSkillProtectionLevel(skillName);
+function writeSkillActiveState(directory, skillName, sessionId, rawSkillName) {
+  const protection = getSkillProtectionLevel(skillName, rawSkillName);
   if (protection === 'none') return;
 
   const config = SKILL_PROTECTION_CONFIGS[protection];
@@ -456,7 +463,10 @@ async function main() {
       if (skillName) {
         const sid = typeof data.session_id === 'string' ? data.session_id
           : typeof data.sessionId === 'string' ? data.sessionId : '';
-        writeSkillActiveState(directory, skillName, sid);
+        // Pass rawSkillName to distinguish OMC skills from project custom skills (issue #1581)
+        const rawSkill = toolInput.skill || toolInput.skill_name || toolInput.skillName || toolInput.command || '';
+        const rawSkillName = typeof rawSkill === 'string' && rawSkill.trim() ? rawSkill.trim() : undefined;
+        writeSkillActiveState(directory, skillName, sid, rawSkillName);
       }
     }
 

src/hooks/bridge.ts

@@ -1351,14 +1351,17 @@ function processPreToolUse(input: HookInput): HookOutput {
   // Activate skill state when Skill tool is invoked (issue #1033)
   // This writes skill-active-state.json so the Stop hook can prevent premature
   // session termination while a skill is executing.
+  // Pass rawSkillName so writeSkillActiveState can distinguish OMC built-in
+  // skills from project custom skills with the same name (issue #1581).
   if (input.toolName === "Skill") {
     const skillName = getInvokedSkillName(input.toolInput);
     if (skillName) {
+      const rawSkillName = getRawSkillName(input.toolInput);
       // Use the statically-imported synchronous write so it completes before
       // the Stop hook can fire. The previous fire-and-forget .then() raced with
       // the Stop hook in short-lived processes.
       try {
-        writeSkillActiveState(directory, skillName, input.sessionId);
+        writeSkillActiveState(directory, skillName, input.sessionId, rawSkillName);
       } catch {
         // Skill-state write is best-effort; don't fail the hook on error.
       }
@@ -1539,6 +1542,19 @@ function getInvokedSkillName(toolInput: unknown): string | null {
   return namespaced?.toLowerCase() || null;
 }
 
+/**
+ * Extract the raw (un-normalized) skill name from Skill tool input.
+ * Used to distinguish OMC built-in skills (prefixed with 'oh-my-claudecode:')
+ * from project custom skills or other plugin skills with the same bare name.
+ * See: https://github.com/Yeachan-Heo/oh-my-claudecode/issues/1581
+ */
+function getRawSkillName(toolInput: unknown): string | undefined {
+  if (!toolInput || typeof toolInput !== "object") return undefined;
+  const input = toolInput as Record<string, unknown>;
+  const raw = input.skill ?? input.skill_name ?? input.skillName ?? input.command ?? null;
+  return typeof raw === "string" && raw.trim().length > 0 ? raw.trim() : undefined;
+}
+
 async function processPostToolUse(input: HookInput): Promise<HookOutput> {
   const directory = resolveToWorktreeRoot(input.directory);
   const messages: string[] = [];

src/hooks/skill-state/__tests__/skill-state.test.ts

@@ -107,6 +107,30 @@ describe('skill-state', () => {
       expect(getSkillProtection('SKILL')).toBe('light');
       expect(getSkillProtection('Plan')).toBe('medium');
     });
+
+    it('returns none for project custom skills with same name as OMC skills (issue #1581)', () => {
+      // rawSkillName without oh-my-claudecode: prefix → project custom skill
+      expect(getSkillProtection('plan', 'plan')).toBe('none');
+      expect(getSkillProtection('review', 'review')).toBe('none');
+      expect(getSkillProtection('tdd', 'tdd')).toBe('none');
+    });
+
+    it('returns protection for OMC skills when rawSkillName has prefix', () => {
+      expect(getSkillProtection('plan', 'oh-my-claudecode:plan')).toBe('medium');
+      expect(getSkillProtection('deepinit', 'oh-my-claudecode:deepinit')).toBe('heavy');
+    });
+
+    it('returns none for other plugin skills with rawSkillName', () => {
+      // ouroboros:plan, claude-mem:make-plan etc. should not get OMC protection
+      expect(getSkillProtection('plan', 'ouroboros:plan')).toBe('none');
+      expect(getSkillProtection('make-plan', 'claude-mem:make-plan')).toBe('none');
+    });
+
+    it('falls back to map lookup when rawSkillName is not provided', () => {
+      // Backward compatibility: no rawSkillName → use SKILL_PROTECTION map
+      expect(getSkillProtection('plan')).toBe('medium');
+      expect(getSkillProtection('deepinit')).toBe('heavy');
+    });
   });
 
   // -----------------------------------------------------------------------
@@ -177,6 +201,20 @@ describe('skill-state', () => {
       expect(state!.skill_name).toBe('plan');
     });
 
+    it('does not write state for project custom skills with same name as OMC skills (issue #1581)', () => {
+      // rawSkillName='plan' (no prefix) → project custom skill → no state
+      const state = writeSkillActiveState(tempDir, 'plan', 'session-1', 'plan');
+      expect(state).toBeNull();
+      expect(readSkillActiveState(tempDir, 'session-1')).toBeNull();
+    });
+
+    it('writes state for OMC skills when rawSkillName has prefix', () => {
+      const state = writeSkillActiveState(tempDir, 'plan', 'session-1', 'oh-my-claudecode:plan');
+      expect(state).not.toBeNull();
+      expect(state!.skill_name).toBe('plan');
+      expect(state!.max_reinforcements).toBe(5);
+    });
+
     it('overwrites existing state when new skill is invoked', () => {
       writeSkillActiveState(tempDir, 'plan', 'session-1');
       const state2 = writeSkillActiveState(tempDir, 'external-context', 'session-1');

src/hooks/skill-state/index.ts

@@ -130,19 +130,28 @@ const SKILL_PROTECTION: Record<string, SkillProtectionLevel> = {
  * Anthropic's example-skills, document-skills, superpowers, data, etc.)
  * default to 'none' so the Stop hook does not block them.
  *
- * Note: bridge.ts strips the 'oh-my-claudecode:' prefix before calling
- * this function, so skill names arrive in bare form (e.g., 'plan', 'xlsx').
+ * @param skillName - The normalized (prefix-stripped) skill name.
+ * @param rawSkillName - The original skill name as invoked (e.g., 'oh-my-claudecode:plan'
+ *   or 'plan'). When provided, only skills invoked with the 'oh-my-claudecode:' prefix
+ *   are eligible for protection. This prevents project custom skills (e.g., a user's
+ *   `.claude/skills/plan/`) from being confused with OMC built-in skills of the same name.
+ *   See: https://github.com/Yeachan-Heo/oh-my-claudecode/issues/1581
  */
-export function getSkillProtection(skillName: string): SkillProtectionLevel {
+export function getSkillProtection(skillName: string, rawSkillName?: string): SkillProtectionLevel {
+  // When rawSkillName is provided, only apply protection to OMC-prefixed skills.
+  // Non-prefixed skills are project custom skills or other plugins — no protection.
+  if (rawSkillName != null && !rawSkillName.toLowerCase().startsWith('oh-my-claudecode:')) {
+    return 'none';
+  }
   const normalized = skillName.toLowerCase().replace(/^oh-my-claudecode:/, '');
   return SKILL_PROTECTION[normalized] ?? 'none';
 }
 
 /**
  * Get the protection config for a skill.
  */
-export function getSkillConfig(skillName: string): SkillStateConfig {
-  return PROTECTION_CONFIGS[getSkillProtection(skillName)];
+export function getSkillConfig(skillName: string, rawSkillName?: string): SkillStateConfig {
+  return PROTECTION_CONFIGS[getSkillProtection(skillName, rawSkillName)];
 }
 
 /**
@@ -163,13 +172,17 @@ export function readSkillActiveState(
 /**
  * Write skill active state.
  * Called when a skill is invoked via the Skill tool.
+ *
+ * @param rawSkillName - The original skill name as invoked, used to distinguish
+ *   OMC built-in skills from project custom skills. See getSkillProtection().
  */
 export function writeSkillActiveState(
   directory: string,
   skillName: string,
-  sessionId?: string
+  sessionId?: string,
+  rawSkillName?: string,
 ): SkillActiveState | null {
-  const protection = getSkillProtection(skillName);
+  const protection = getSkillProtection(skillName, rawSkillName);
 
   // Skills with 'none' protection don't need state tracking
   if (protection === 'none') {