claudecode-omc 4.8.2 → 4.8.4

package/skills/tdd-generator/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: tdd-generator
+description: Test-driven workflow for unit, component, and E2E testing. Enforces Red-Green-Refactor and generates the right test type for changed code.
+---
+
+# TDD Generator
+
+Use this skill to drive implementation through tests first.
+
+## Workflow
+
+1. Detect target type:
+   - Pure logic -> unit tests
+   - UI behavior -> component/integration tests
+   - User journeys -> E2E tests
+2. RED:
+   - Write failing test first
+3. GREEN:
+   - Implement minimal code to pass
+4. REFACTOR:
+   - Improve structure while keeping tests green
+5. Add regression cases for discovered bugs and edges.
+
+## Recommended Stack
+
+- Unit/component: Vitest + Testing Library
+- E2E: Playwright
+
+## E2E Agent Option
+
+For large journey suites, you can run Playwright test agents:
+
+```bash
+npx playwright test --init-agents
+npx playwright test --agent=planner
+npx playwright test --agent=generator
+npx playwright test --agent=healer --repeat
+```
+
+## Quality Rules
+
+- Test behavior, not private implementation details.
+- Prefer semantic queries (`getByRole`, `getByLabelText`) for UI tests.
+- Keep one assertion intent per test case.
+- Add explicit edge cases and failure-path coverage.
+
+## References
+
+- Playwright best practices: https://playwright.dev/docs/best-practices
+- Vitest guide: https://vitest.dev/guide/
+

package/skills/team/SKILL.md

@@ -21,7 +21,7 @@ The `swarm` compatibility alias was removed in #1131.
 ### Parameters
 
 - **N** - Number of teammate agents (1-20). Optional; defaults to auto-sizing based on task decomposition.
-- **agent-type** - OMC agent to spawn for the `team-exec` stage (e.g., executor, build-fixer, designer, codex, gemini). Optional; defaults to stage-aware routing. Use `codex` to spawn Codex CLI workers or `gemini` for Gemini CLI workers (requires respective CLIs installed). See Stage Agent Routing below.
+- **agent-type** - OMC agent to spawn for the `team-exec` stage (e.g., executor, debugger, designer, codex, gemini). Optional; defaults to stage-aware routing. Use `codex` to spawn Codex CLI workers or `gemini` for Gemini CLI workers (requires respective CLIs installed). See Stage Agent Routing below.
 - **task** - High-level task to decompose and distribute among teammates
 - **ralph** - Optional modifier. When present, wraps the team pipeline in Ralph's persistence loop (retry on failure, architect verification before completion). See Team + Ralph Composition below.
 
@@ -29,7 +29,7 @@ The `swarm` compatibility alias was removed in #1131.
 
 ```bash
 /team 5:executor "fix all TypeScript errors across the project"
-/team 3:build-fixer "fix build errors in src/"
+/team 3:debugger "fix build errors in src/"
 /team 4:designer "implement responsive layouts for all page components"
 /team "refactor the auth module with security review"
 /team ralph "build a complete REST API for user management"
@@ -102,9 +102,9 @@ Each pipeline stage uses **specialized agents** -- not just executors. The lead
 |-------|----------------|-----------------|-------------------|
 | **team-plan** | `explore` (haiku), `planner` (opus) | `analyst` (opus), `architect` (opus) | Use `analyst` for unclear requirements. Use `architect` for systems with complex boundaries. |
 | **team-prd** | `analyst` (opus) | `critic` (opus) | Use `critic` to challenge scope. |
-| **team-exec** | `executor` (sonnet) | `deep-executor` (opus), `build-fixer` (sonnet), `designer` (sonnet), `writer` (haiku), `test-engineer` (sonnet) | Match agent to subtask type. Use `deep-executor` for complex autonomous work, `designer` for UI, `build-fixer` for compilation issues, `writer` for docs, `test-engineer` for test creation. |
-| **team-verify** | `verifier` (sonnet) | `test-engineer` (sonnet), `security-reviewer` (sonnet), `code-reviewer` (opus), `quality-reviewer` (sonnet) | Always run `verifier`. Add `security-reviewer` for auth/crypto changes. Add `code-reviewer` for >20 files or architectural changes. Add `quality-reviewer` (model=haiku) for style/formatting checks. |
-| **team-fix** | `executor` (sonnet) | `build-fixer` (sonnet), `debugger` (sonnet), `deep-executor` (opus) | Use `build-fixer` for type/build errors. Use `debugger` for regression isolation. Use `deep-executor` for complex multi-file fixes. |
+| **team-exec** | `executor` (sonnet) | `executor` (opus), `debugger` (sonnet), `designer` (sonnet), `writer` (haiku), `test-engineer` (sonnet) | Match agent to subtask type. Use `executor` (model=opus) for complex autonomous work, `designer` for UI, `debugger` for compilation issues, `writer` for docs, `test-engineer` for test creation. |
+| **team-verify** | `verifier` (sonnet) | `test-engineer` (sonnet), `security-reviewer` (sonnet), `code-reviewer` (opus) | Always run `verifier`. Add `security-reviewer` for auth/crypto changes. Add `code-reviewer` for >20 files or architectural changes. `code-reviewer` also covers style/formatting checks. |
+| **team-fix** | `executor` (sonnet) | `debugger` (sonnet), `executor` (opus) | Use `debugger` for type/build errors and regression isolation. Use `executor` (model=opus) for complex multi-file fixes. |
 
 **Routing rules:**
 
@@ -134,7 +134,7 @@ Each pipeline stage uses **specialized agents** -- not just executors. The lead
   - Exit (fail): fix tasks are generated and control moves to `team-fix`.
 - **team-fix**
   - Entry: verification found defects/regressions/incomplete criteria.
-  - Agents: `executor`/`build-fixer`/`debugger` depending on defect type.
+  - Agents: `executor`/`debugger` depending on defect type.
   - Exit: fixes are complete and flow returns to `team-exec` then `team-verify`.
 
 ### Verify/Fix Loop and Stop Conditions

package/skills/test-coverage/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: test-coverage
+description: Analyze coverage, prioritize untested risk hotspots, generate missing tests, and verify threshold improvements.
+---
+
+# Test Coverage
+
+Use this skill to close meaningful coverage gaps, not just raise percentages.
+
+## Workflow
+
+1. Run coverage:
+   - `pnpm test --coverage` or `npx vitest run --coverage`
+2. Parse summary and rank low-coverage files by risk:
+   - Business-critical logic
+   - Error handling paths
+   - Security-sensitive branches
+3. Generate targeted tests:
+   - Unit for pure functions
+   - Integration for service/API boundaries
+   - E2E for critical user journeys
+4. Re-run coverage and report before/after delta.
+
+## Coverage Rules
+
+- Use thresholds per project policy; default target can start at 80%.
+- Cover meaningful branches and failure modes, not only statements.
+- Exclude generated/build/vendor files explicitly.
+- Enable all-file analysis when feasible to avoid hidden zero-coverage files.
+
+## Vitest Guidance
+
+- Default provider is V8; use Istanbul if project requires instrumentation parity.
+- Configure `coverage.include`, `coverage.exclude`, and `coverage.thresholds`.
+
+## References
+
+- Vitest coverage guide: https://vitest.dev/guide/coverage.html
+- Vitest coverage config: https://vitest.dev/config/#coverage
+

package/skills/test-gen/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: test-gen
+description: Post-change intelligent test generation workflow that detects stack, analyzes changed files, and produces acceptance plus regression tests.
+---
+
+# Test Generation Workflow
+
+Use this skill after code changes to generate the right tests quickly.
+
+## Workflow
+
+### Phase 1: Detect context
+
+```bash
+omc test detect-stack
+omc test changed
+omc test analyze path/to/file
+```
+
+Prefer `omc test changed` when the goal is to cover the current diff.
+
+### Phase 2: Generate testing pack
+
+```bash
+omc test gen path/to/file
+```
+
+Expected artifacts:
+
+- test plan
+- acceptance checklist
+- regression checklist
+
+### Phase 3: Write or update tests
+
+Choose test depth by risk:
+
+- Pure logic -> unit tests
+- UI behavior -> component/integration tests
+- Async I/O or cross-boundary behavior -> integration tests
+- Critical user flows -> E2E tests
+
+### Phase 4: Verify
+
+Run the smallest targeted test command first, then broaden if needed.
+
+If higher orchestration is needed, combine with:
+
+- `/oh-my-claudecode:tdd-generator`
+- `/oh-my-claudecode:test-coverage`
+- `/oh-my-claudecode:ultraqa`
+
+## Rules
+
+- Do not stop at happy-path-only coverage.
+- Add regression assertions for risk signals.
+- Avoid implementation-detail-only tests.
+- If no safe automated test can be added, provide a concrete manual regression checklist.
+
+## Output
+
+Always report:
+
+1. analyzed target files
+2. generated/updated test files
+3. acceptance items covered
+4. regression items covered
+5. commands executed
+6. remaining gaps
+

package/templates/hooks/code-simplifier.mjs

@@ -136,7 +136,7 @@ async function main() {
     }
 
     process.stdout.write(
-      JSON.stringify({ decision: 'block', reason: buildMessage(files) }) + '\n',
+      JSON.stringify({ continue: false, decision: 'block', reason: buildMessage(files) }) + '\n',
     );
   } catch (error) {
     try {

package/templates/hooks/keyword-detector.mjs

@@ -9,16 +9,18 @@
  * 1. cancelomc/stopomc: Stop active modes
  * 2. ralph: Persistence mode until task completion
  * 3. autopilot: Full autonomous execution
- * 4. team: Coordinated team execution
+ * 4. team: Explicit-only via /team (not auto-triggered)
  * 5. ultrawork/ulw: Maximum parallel execution
-* 6. pipeline: Sequential agent chaining
+ * 6. ccg: Claude-Codex-Gemini tri-model orchestration
  * 7. ralplan: Iterative planning with consensus
- * 8. plan: Planning interview mode
- * 9. tdd: Test-driven development
- * 10. ultrathink: Extended reasoning
- * 11. deepsearch: Codebase search (restricted patterns)
- * 12. analyze: Analysis mode (restricted patterns)
- * 13. ccg: Claude-Codex-Gemini tri-model orchestration
+ * 8. deep interview: Socratic interview workflow
+ * 9. ai-slop-cleaner: Cleanup/deslop anti-slop workflow
+ * 10. tdd: Test-driven development
+ * 11. code review: Comprehensive review mode
+ * 12. security review: Security-focused review mode
+ * 13. ultrathink: Extended reasoning
+ * 14. deepsearch: Codebase search (restricted patterns)
+ * 15. analyze: Analysis mode (restricted patterns)
  */
 
 import { writeFileSync, mkdirSync, existsSync, unlinkSync, readFileSync } from 'fs';
@@ -49,6 +51,40 @@ Use your extended thinking capabilities to provide the most thorough and well-re
 ---
 `;
 
+const ANALYZE_MESSAGE = `<analyze-mode>
+ANALYSIS MODE. Gather context before diving deep:
+- Search relevant code paths first
+- Compare working vs broken behavior
+- Synthesize findings before proposing changes
+</analyze-mode>
+
+---
+`;
+
+const TDD_MESSAGE = `<tdd-mode>
+[TDD MODE ACTIVATED]
+Write or update tests first when practical, confirm they fail for the right reason, then implement the minimal fix and re-run verification.
+</tdd-mode>
+
+---
+`;
+
+const CODE_REVIEW_MESSAGE = `<code-review-mode>
+[CODE REVIEW MODE ACTIVATED]
+Perform a comprehensive code review of the relevant changes or target area. Focus on correctness, maintainability, edge cases, regressions, and test adequacy before recommending changes.
+</code-review-mode>
+
+---
+`;
+
+const SECURITY_REVIEW_MESSAGE = `<security-review-mode>
+[SECURITY REVIEW MODE ACTIVATED]
+Perform a focused security review of the relevant changes or target area. Check trust boundaries, auth/authz, data exposure, input validation, command/file access, secrets handling, and escalation risks before recommending changes.
+</security-review-mode>
+
+---
+`;
+
 // Extract prompt from various JSON structures
 function extractPrompt(input) {
   try {
@@ -69,6 +105,15 @@ function extractPrompt(input) {
 }
 
 // Sanitize text to prevent false positives from code blocks, XML tags, URLs, and file paths
+const ANTI_SLOP_EXPLICIT_PATTERN = /\b(ai[\s-]?slop|anti[\s-]?slop|deslop|de[\s-]?slop)\b/i;
+const ANTI_SLOP_ACTION_PATTERN = /\b(clean(?:\s*up)?|cleanup|refactor|simplify|dedupe|de-duplicate|prune)\b/i;
+const ANTI_SLOP_SMELL_PATTERN = /\b(slop|duplicate(?:d|s)?|duplication|dead\s+code|unused\s+code|over[\s-]?abstract(?:ion|ed)?|wrapper\s+layers?|boundary\s+violations?|needless\s+abstractions?|unnecessary\s+abstractions?|ai[\s-]?generated|generated\s+code|tech\s+debt)\b/i;
+
+function isAntiSlopCleanupRequest(text) {
+  return ANTI_SLOP_EXPLICIT_PATTERN.test(text) ||
+    (ANTI_SLOP_ACTION_PATTERN.test(text) && ANTI_SLOP_SMELL_PATTERN.test(text));
+}
+
 function sanitizeForKeywordDetection(text) {
   return text
     // 1. Strip XML-style tag blocks: <tag-name ...>...</tag-name> (multi-line, greedy on tag name)
@@ -229,8 +274,8 @@ function resolveConflicts(matches) {
   // Team keyword detection removed — team is now explicit-only via /team skill.
 
   // Sort by priority order
-const priorityOrder = ['cancel','ralph','autopilot','ultrawork',
-    'pipeline','ccg','ralplan','plan','tdd','research','ultrathink','deepsearch','analyze'];
+  const priorityOrder = ['cancel','ralph','autopilot','ultrawork',
+    'ccg','ralplan','deep-interview','ai-slop-cleaner','tdd','code-review','security-review','ultrathink','deepsearch','analyze'];
   resolved.sort((a, b) => priorityOrder.indexOf(a.name) - priorityOrder.indexOf(b.name));
 
   return resolved;
@@ -337,10 +382,6 @@ async function main() {
       matches.push({ name: 'ultrawork', args: '' });
     }
 
-    // Pipeline keywords
-    if (/\bagent\s+pipeline\b/i.test(cleanPrompt) || /\bchain\s+agents\b/i.test(cleanPrompt)) {
-      matches.push({ name: 'pipeline', args: '' });
-    }
 
     // CCG keywords (Claude-Codex-Gemini tri-model orchestration)
     if (/\b(ccg|claude-codex-gemini)\b/i.test(cleanPrompt)) {
@@ -352,12 +393,33 @@ async function main() {
       matches.push({ name: 'ralplan', args: '' });
     }
 
+    // Deep interview keywords
+    if (/\b(deep[\s-]interview|ouroboros)\b/i.test(cleanPrompt)) {
+      matches.push({ name: 'deep-interview', args: '' });
+    }
+
+    // AI slop cleanup keywords
+    if (isAntiSlopCleanupRequest(cleanPrompt)) {
+      matches.push({ name: 'ai-slop-cleaner', args: '' });
+    }
+
     // TDD keywords
     if (/\b(tdd)\b/i.test(cleanPrompt) ||
-        /\btest\s+first\b/i.test(cleanPrompt)) {
+        /\btest\s+first\b/i.test(cleanPrompt) ||
+        /\bred\s+green\b/i.test(cleanPrompt)) {
       matches.push({ name: 'tdd', args: '' });
     }
 
+    // Code review keywords
+    if (/\b(code\s+review|review\s+code)\b/i.test(cleanPrompt)) {
+      matches.push({ name: 'code-review', args: '' });
+    }
+
+    // Security review keywords
+    if (/\b(security\s+review|review\s+security)\b/i.test(cleanPrompt)) {
+      matches.push({ name: 'security-review', args: '' });
+    }
+
     // Ultrathink keywords
     if (/\b(ultrathink)\b/i.test(cleanPrompt)) {
       matches.push({ name: 'ultrathink', args: '' });
@@ -396,7 +458,7 @@ async function main() {
 
     // Handle cancel specially - clear states and emit
     if (resolved.length > 0 && resolved[0].name === 'cancel') {
-      clearStateFiles(directory, ['ralph', 'autopilot', 'ultrawork', 'pipeline']);
+      clearStateFiles(directory, ['ralph', 'autopilot', 'ultrawork']);
       console.log(JSON.stringify(createHookOutput(createSkillInvocation('cancel', prompt))));
       return;
     }
@@ -415,27 +477,33 @@ async function main() {
       activateState(directory, prompt, 'ultrawork', sessionId);
     }
 
-    // Handle ultrathink specially - prepend message instead of skill invocation
-    const ultrathinkIndex = resolved.findIndex(m => m.name === 'ultrathink');
-    if (ultrathinkIndex !== -1) {
-      // Remove ultrathink from skill list
-      resolved.splice(ultrathinkIndex, 1);
-
-      // If ultrathink was the only match, emit message
-      if (resolved.length === 0) {
-        console.log(JSON.stringify(createHookOutput(ULTRATHINK_MESSAGE)));
-        return;
+    const additionalContextParts = [];
+    for (const [keywordName, message] of [
+      ['ultrathink', ULTRATHINK_MESSAGE],
+      ['analyze', ANALYZE_MESSAGE],
+      ['tdd', TDD_MESSAGE],
+      ['code-review', CODE_REVIEW_MESSAGE],
+      ['security-review', SECURITY_REVIEW_MESSAGE],
+    ]) {
+      const index = resolved.findIndex(m => m.name === keywordName);
+      if (index !== -1) {
+        resolved.splice(index, 1);
+        additionalContextParts.push(message);
       }
+    }
 
-      // Otherwise, prepend ultrathink message to skill invocation
-      const skillMessage = createMultiSkillInvocation(resolved, prompt);
-      console.log(JSON.stringify(createHookOutput(ULTRATHINK_MESSAGE + skillMessage)));
+    if (resolved.length === 0 && additionalContextParts.length > 0) {
+      console.log(JSON.stringify(createHookOutput(additionalContextParts.join(''))));
       return;
     }
 
-    const skillMatches = resolved;
-    if (skillMatches.length > 0) {
-      console.log(JSON.stringify(createHookOutput(createMultiSkillInvocation(skillMatches, prompt))));
+    if (resolved.length > 0) {
+      additionalContextParts.push(createMultiSkillInvocation(resolved, prompt));
+    }
+
+    if (additionalContextParts.length > 0) {
+      console.log(JSON.stringify(createHookOutput(additionalContextParts.join(''))));
+      return;
     }
   } catch (error) {
     // On any error, allow continuation

package/templates/hooks/persistent-mode.mjs

@@ -132,6 +132,29 @@ Do NOT skip this step. Do NOT move on without fixing the error.
  * from causing the stop hook to malfunction in new sessions.
  */
 const STALE_STATE_THRESHOLD_MS = 2 * 60 * 60 * 1000; // 2 hours
+const TEAM_TERMINAL_PHASES = new Set([
+  "completed",
+  "complete",
+  "failed",
+  "cancelled",
+  "canceled",
+  "aborted",
+  "terminated",
+  "done",
+]);
+const TEAM_ACTIVE_PHASES = new Set([
+  "team-plan",
+  "team-prd",
+  "team-exec",
+  "team-verify",
+  "team-fix",
+  "planning",
+  "executing",
+  "verify",
+  "verification",
+  "fix",
+  "fixing",
+]);
 
 /**
  * Check if a state is stale based on its timestamps.
@@ -153,6 +176,23 @@ function isStaleState(state) {
   return age > STALE_STATE_THRESHOLD_MS;
 }
 
+function normalizeTeamPhase(state) {
+  if (!state || typeof state !== "object") return null;
+
+  const rawPhase = state.current_phase ?? state.phase ?? state.stage;
+  if (typeof rawPhase !== "string") return null;
+
+  const phase = rawPhase.trim().toLowerCase();
+  if (!phase || TEAM_TERMINAL_PHASES.has(phase)) return null;
+  return TEAM_ACTIVE_PHASES.has(phase) ? phase : null;
+}
+
+function getSafeReinforcementCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0
+    ? Math.floor(value)
+    : 0;
+}
+
 /**
  * Check if a skill active state is stale based on its per-skill TTL.
  * Unlike mode states (which use the global 2-hour threshold), skill states
@@ -803,10 +843,9 @@ async function main() {
         ? team.state.session_id === sessionId
         : !team.state.session_id || team.state.session_id === sessionId;
       if (sessionMatches) {
-        const phase = team.state.current_phase || "executing";
-        const terminalPhases = ["completed", "complete", "failed", "cancelled"];
-        if (!terminalPhases.includes(phase)) {
-          const newCount = (team.state.reinforcement_count || 0) + 1;
+        const phase = normalizeTeamPhase(team.state);
+        if (phase) {
+          const newCount = getSafeReinforcementCount(team.state.reinforcement_count) + 1;
           if (newCount <= 20) {
             const toolError = readLastToolError(stateDir);
             const errorGuidance = getToolErrorRetryGuidance(toolError);

package/templates/hooks/pre-tool-use.mjs

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 /**
  * OMC Pre-Tool-Use Hook (Node.js)
- * Enforces delegation by warning when orchestrator attempts direct source file edits
+ * Enforces delegation by warning when orchestrator attempts direct source file edits.
+ * Also activates skill-active state for Stop hook protection (issue #1033).
  */
 
 import * as path from 'path';
 import { dirname } from 'path';
+import { existsSync, mkdirSync, writeFileSync, renameSync } from 'fs';
 import { fileURLToPath, pathToFileURL } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -14,6 +16,105 @@ const __dirname = dirname(__filename);
 // Dynamic import for the shared stdin module
 const { readStdin } = await import(pathToFileURL(path.join(__dirname, 'lib', 'stdin.mjs')).href);
 
+// ---------------------------------------------------------------------------
+// Skill Active State (issue #1033)
+// Writes skill-active-state.json so the persistent-mode Stop hook can prevent
+// premature session termination while a skill is executing.
+// ---------------------------------------------------------------------------
+
+/**
+ * Skill protection levels: none/light/medium/heavy.
+ * - 'none': Already has dedicated mode state (ralph, autopilot) or instant/read-only
+ * - 'light': Quick agent shortcuts (3 reinforcements, 5 min TTL)
+ * - 'medium': Review/planning skills that run multiple agents (5 reinforcements, 15 min TTL)
+ * - 'heavy': Long-running skills (10 reinforcements, 30 min TTL)
+ */
+const PROTECTION_CONFIGS = {
+  none:   { maxReinforcements: 0,  staleTtlMs: 0 },
+  light:  { maxReinforcements: 3,  staleTtlMs: 5 * 60 * 1000 },
+  medium: { maxReinforcements: 5,  staleTtlMs: 15 * 60 * 1000 },
+  heavy:  { maxReinforcements: 10, staleTtlMs: 30 * 60 * 1000 },
+};
+
+const SKILL_PROTECTION = {
+  // Already have mode state → no protection needed
+  autopilot: 'none', ralph: 'none', ultrawork: 'none', team: 'none',
+  'omc-teams': 'none', ultraqa: 'none', cancel: 'none',
+  // Instant / read-only → no protection needed
+  trace: 'none', hud: 'none', 'omc-doctor': 'none', 'omc-help': 'none',
+  'learn-about-omc': 'none', note: 'none',
+  // Light protection (3 reinforcements)
+  tdd: 'light', 'build-fix': 'light', analyze: 'light', skill: 'light',
+  'configure-notifications': 'light',
+  // Medium protection (5 reinforcements)
+  'code-review': 'medium', 'security-review': 'medium', plan: 'medium',
+  ralplan: 'medium', review: 'medium', 'external-context': 'medium',
+  sciomc: 'medium', learner: 'medium', 'omc-setup': 'medium',
+  'mcp-setup': 'medium', 'project-session-manager': 'medium',
+  'writer-memory': 'medium', 'ralph-init': 'medium', ccg: 'medium',
+  // Heavy protection (10 reinforcements)
+  deepinit: 'heavy',
+};
+
+function getSkillProtection(skillName) {
+  const normalized = (skillName || '').toLowerCase().replace(/^oh-my-claudecode:/, '');
+  return SKILL_PROTECTION[normalized] || 'light';
+}
+
+function getInvokedSkillName(toolInput) {
+  if (!toolInput || typeof toolInput !== 'object') return null;
+  const rawSkill = toolInput.skill || toolInput.skill_name || toolInput.skillName || toolInput.command || null;
+  if (typeof rawSkill !== 'string' || !rawSkill.trim()) return null;
+  const normalized = rawSkill.trim();
+  return normalized.includes(':') ? normalized.split(':').at(-1).toLowerCase() : normalized.toLowerCase();
+}
+
+const SESSION_ID_ALLOWLIST = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/;
+
+function writeSkillActiveState(directory, skillName, sessionId) {
+  const protection = getSkillProtection(skillName);
+  if (protection === 'none') return;
+
+  const config = PROTECTION_CONFIGS[protection];
+  const now = new Date().toISOString();
+  const normalized = (skillName || '').toLowerCase().replace(/^oh-my-claudecode:/, '');
+
+  const state = {
+    active: true,
+    skill_name: normalized,
+    session_id: sessionId || undefined,
+    started_at: now,
+    last_checked_at: now,
+    reinforcement_count: 0,
+    max_reinforcements: config.maxReinforcements,
+    stale_ttl_ms: config.staleTtlMs,
+  };
+
+  const stateDir = path.join(directory, '.omc', 'state');
+
+  // Write to session-scoped path when sessionId is available (must match persistent-mode.mjs reads)
+  const safeSessionId = sessionId && SESSION_ID_ALLOWLIST.test(sessionId) ? sessionId : '';
+  const targetDir = safeSessionId
+    ? path.join(stateDir, 'sessions', safeSessionId)
+    : stateDir;
+  const targetPath = path.join(targetDir, 'skill-active-state.json');
+
+  try {
+    if (!existsSync(targetDir)) {
+      mkdirSync(targetDir, { recursive: true });
+    }
+    const tmpPath = targetPath + '.tmp';
+    writeFileSync(tmpPath, JSON.stringify(state, null, 2), { mode: 0o600 });
+    renameSync(tmpPath, targetPath);
+  } catch {
+    // Best-effort; don't fail the hook
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Delegation enforcement
+// ---------------------------------------------------------------------------
+
 // Allowed path patterns (no warning)
 // Paths are normalized to forward slashes before matching
 const ALLOWED_PATH_PATTERNS = [
@@ -193,6 +294,19 @@ async function main() {
     return;
   }
 
+  // Activate skill state when Skill tool is invoked (issue #1033)
+  // Writes skill-active-state.json so the persistent-mode Stop hook can
+  // prevent premature session termination while a skill is executing.
+  if (toolName === 'Skill' || toolName === 'skill') {
+    const directory = data.cwd || data.directory || process.cwd();
+    const sessionId = data.sessionId || data.session_id || data.sessionid || '';
+    const toolInput = data.tool_input || data.toolInput || {};
+    const skillName = getInvokedSkillName(toolInput);
+    if (skillName) {
+      writeSkillActiveState(directory, skillName, sessionId);
+    }
+  }
+
   // Only check Edit and Write tools
   if (!['Edit', 'Write', 'edit', 'write'].includes(toolName)) {
     console.log(JSON.stringify({ continue: true, suppressOutput: true }));

package/templates/hooks/session-start.mjs

@@ -200,7 +200,7 @@ async function main() {
     for (let i = 1; i <= 4; i++) {
       const candidate = join(__dirname, ...Array(i).fill('..'), 'package.json');
       const pkg = readJsonFile(candidate);
-      if (pkg?.name === 'claudecode-omc' && pkg?.version) {
+      if ((pkg?.name === 'claudecode-omc' || pkg?.name === 'oh-my-claude-sisyphus' || pkg?.name === 'oh-my-claudecode') && pkg?.version) {
         currentVersion = pkg.version;
         break;
       }