agent-rules-sync 1.4.0__tar.gz → 1.4.4__tar.gz

{agent_rules_sync-1.4.0 → agent_rules_sync-1.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-rules-sync
-Version: 1.4.0
+Version: 1.4.4
 Summary: Synchronize rules and skills across AI coding assistants (Claude Code, Cursor, Gemini, OpenCode, Codex)
 Author: Agent Rules Sync Contributors
 License: MIT
@@ -81,7 +81,8 @@ Monitored locations:
 | Agent | Path |
 |-------|------|
 | Claude Code | `~/.claude/CLAUDE.md` |
-| Cursor | `~/.cursor/rules/global.mdc` |
+| Cursor | `~/.cursor/rules/global.mdc` (merged **output**); also reads every `*.md` / `*.mdc` in the **same** `~/.cursor/rules/` dir (subfolders except `imported/`). Strip YAML frontmatter before parsing. |
+| Cursor (legacy) | `~/.cursorrules` plus `<repo>/.cursorrules` for each path in `repo_paths.json` — same body as `global.mdc`; Cursor still loads these ([docs](https://cursor.com/docs/rules)) |
 | Gemini Antigravity | `~/.gemini/GEMINI.md` |
 | OpenCode | `~/.config/opencode/AGENTS.md` |
 | Codex | `~/.codex/AGENTS.md` |
@@ -131,6 +132,7 @@ Add repos to sync rules, skills, and settings into:
 
 Each repo gets:
 - `<repo>/CLAUDE.md` — synced from global rules
+- `<repo>/.cursorrules` — legacy Cursor rules file; mirrored from the same content as `global.mdc` (optional; Cursor prefers `.cursor/rules/`)
 - `<repo>/.claude/skills/` — synced from master skills
 - `<repo>/.claude/settings.json` — portable settings (auto-generated)
 - `<repo>/.claude/hooks/` — hook scripts (copied from `~/.claude/hooks/`)

{agent_rules_sync-1.4.0 → agent_rules_sync-1.4.4}/README.md

@@ -53,7 +53,8 @@ Monitored locations:
 | Agent | Path |
 |-------|------|
 | Claude Code | `~/.claude/CLAUDE.md` |
-| Cursor | `~/.cursor/rules/global.mdc` |
+| Cursor | `~/.cursor/rules/global.mdc` (merged **output**); also reads every `*.md` / `*.mdc` in the **same** `~/.cursor/rules/` dir (subfolders except `imported/`). Strip YAML frontmatter before parsing. |
+| Cursor (legacy) | `~/.cursorrules` plus `<repo>/.cursorrules` for each path in `repo_paths.json` — same body as `global.mdc`; Cursor still loads these ([docs](https://cursor.com/docs/rules)) |
 | Gemini Antigravity | `~/.gemini/GEMINI.md` |
 | OpenCode | `~/.config/opencode/AGENTS.md` |
 | Codex | `~/.codex/AGENTS.md` |
@@ -103,6 +104,7 @@ Add repos to sync rules, skills, and settings into:
 
 Each repo gets:
 - `<repo>/CLAUDE.md` — synced from global rules
+- `<repo>/.cursorrules` — legacy Cursor rules file; mirrored from the same content as `global.mdc` (optional; Cursor prefers `.cursor/rules/`)
 - `<repo>/.claude/skills/` — synced from master skills
 - `<repo>/.claude/settings.json` — portable settings (auto-generated)
 - `<repo>/.claude/hooks/` — hook scripts (copied from `~/.claude/hooks/`)

agent_rules_sync-1.4.4/agent_guardian.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+Agent Guardian - macOS watchdog for agent-rules-sync.
+Monitors the daemon and shows a popup if it's down or erroring.
+"""
+
+import os
+import sys
+import time
+import subprocess
+from pathlib import Path
+from datetime import datetime
+
+class AgentGuardian:
+    def __init__(self):
+        self.config_dir = Path.home() / ".config" / "agent-rules-sync"
+        self.pid_file = self.config_dir / "daemon.pid"
+        self.log_file = self.config_dir / "daemon.log"
+        self.last_error_count = self._get_error_count()
+        self.last_popup_time = 0
+        self.popup_cooldown = 300 # 5 minutes
+
+    def _get_error_count(self):
+        if not self.log_file.exists():
+            return 0
+        try:
+            content = self.log_file.read_text()
+            return content.count("ERROR:")
+        except Exception:
+            return 0
+
+    def is_daemon_running(self):
+        if not self.pid_file.exists():
+            return False
+        try:
+            pid = int(self.pid_file.read_text().strip())
+            # Check if process exists
+            os.kill(pid, 0)
+            return True
+        except (OSError, ValueError):
+            return False
+
+    def show_popup(self, message):
+        now = time.time()
+        if now - self.last_popup_time < self.popup_cooldown:
+            return
+
+        self.last_popup_time = now
+        
+        applescript = f'''
+        set result to display dialog "{message}" with title "Agent Sync Guardian" buttons {{"Inspect", "Restart", "Dismiss"}} default button "Restart" with icon caution
+        return button returned of result
+        '''
+        
+        try:
+            result = subprocess.check_output(['osascript', '-e', applescript]).decode('utf-8').strip()
+            
+            if result == "Inspect":
+                subprocess.run(['open', str(self.log_file)])
+            elif result == "Restart":
+                self.restart_daemon()
+        except subprocess.CalledProcessError:
+            # User clicked cancel or closed dialog
+            pass
+
+    def restart_daemon(self):
+        # Use the agent-sync command to stop and start
+        try:
+            subprocess.run(['agent-sync', 'stop'], capture_output=True)
+            time.sleep(1)
+            subprocess.run(['agent-sync'], capture_output=True)
+            # Notify success
+            subprocess.run(['osascript', '-e', 'display notification "Agent Sync Daemon restarted successfully." with title "Agent Sync Guardian"'])
+        except Exception as e:
+            subprocess.run(['osascript', '-e', f'display notification "Failed to restart daemon: {e}" with title "Agent Sync Guardian"'])
+
+    def run(self):
+        print(f"Guardian started at {datetime.now()}")
+        while True:
+            time.sleep(10) # Check every 10 seconds
+            
+            # Check if running
+            if not self.is_daemon_running():
+                self.show_popup("Agent Sync Daemon is NOT running.")
+                continue
+
+            # Check for new errors
+            current_errors = self._get_error_count()
+            if current_errors > self.last_error_count:
+                new_errors = current_errors - self.last_error_count
+                self.last_error_count = current_errors
+                self.show_popup(f"Agent Sync Daemon detected {new_errors} new errors.")
+
+if __name__ == "__main__":
+    if sys.platform != "darwin":
+        print("Guardian is only supported on macOS.")
+        sys.exit(1)
+        
+    guardian = AgentGuardian()
+    guardian.run()

{agent_rules_sync-1.4.0 → agent_rules_sync-1.4.4}/agent_rules_sync.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-rules-sync
-Version: 1.4.0
+Version: 1.4.4
 Summary: Synchronize rules and skills across AI coding assistants (Claude Code, Cursor, Gemini, OpenCode, Codex)
 Author: Agent Rules Sync Contributors
 License: MIT
@@ -81,7 +81,8 @@ Monitored locations:
 | Agent | Path |
 |-------|------|
 | Claude Code | `~/.claude/CLAUDE.md` |
-| Cursor | `~/.cursor/rules/global.mdc` |
+| Cursor | `~/.cursor/rules/global.mdc` (merged **output**); also reads every `*.md` / `*.mdc` in the **same** `~/.cursor/rules/` dir (subfolders except `imported/`). Strip YAML frontmatter before parsing. |
+| Cursor (legacy) | `~/.cursorrules` plus `<repo>/.cursorrules` for each path in `repo_paths.json` — same body as `global.mdc`; Cursor still loads these ([docs](https://cursor.com/docs/rules)) |
 | Gemini Antigravity | `~/.gemini/GEMINI.md` |
 | OpenCode | `~/.config/opencode/AGENTS.md` |
 | Codex | `~/.codex/AGENTS.md` |
@@ -131,6 +132,7 @@ Add repos to sync rules, skills, and settings into:
 
 Each repo gets:
 - `<repo>/CLAUDE.md` — synced from global rules
+- `<repo>/.cursorrules` — legacy Cursor rules file; mirrored from the same content as `global.mdc` (optional; Cursor prefers `.cursor/rules/`)
 - `<repo>/.claude/skills/` — synced from master skills
 - `<repo>/.claude/settings.json` — portable settings (auto-generated)
 - `<repo>/.claude/hooks/` — hook scripts (copied from `~/.claude/hooks/`)

{agent_rules_sync-1.4.0 → agent_rules_sync-1.4.4}/agent_rules_sync.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 LICENSE
 README.md
+agent_guardian.py
 agent_rules_sync.py
 agent_settings_sync.py
 agent_skills_sync.py

{agent_rules_sync-1.4.0 → agent_rules_sync-1.4.4}/agent_rules_sync.egg-info/top_level.txt

@@ -1,3 +1,4 @@
+agent_guardian
 agent_rules_sync
 agent_settings_sync
 agent_skills_sync

{agent_rules_sync-1.4.0 → agent_rules_sync-1.4.4}/agent_rules_sync.py

@@ -9,7 +9,8 @@ Simple usage:
 
 Edit your rules in any location:
     ~/.claude/CLAUDE.md
-    ~/.cursor/rules/global.mdc
+    ~/.cursor/rules/*.md and *.mdc (merged; canonical write is global.mdc)
+    ~/.cursorrules (legacy; mirrored from global.mdc, still supported by Cursor in project roots)
     ~/.gemini/GEMINI.md
     ~/.config/opencode/AGENTS.md
 
@@ -56,9 +57,6 @@ class AgentRulesSync:
         self.pid_file = self.config_dir / "daemon.pid"
         self.watch_flag_file = self.config_dir / "watching"
 
-        # State file to track previous sync (for detecting deletions)
-        self.state_file = self.config_dir / "sync_state.txt"
-
         # Stop event for graceful Windows daemon shutdown
         self.stop_event = threading.Event()
 
@@ -81,12 +79,12 @@ class AgentRulesSync:
             "cursor": {
                 "name": "Cursor",
                 "path": Path.home() / ".cursor" / "rules" / "global.mdc",
-                "description": "Cursor global rules",
+                "description": "Cursor global rules (canonical output; all ~/.cursor/rules/*.md|.mdc merged in)",
             },
             "gemini": {
-                "name": "Gemini Antigravity",
+                "name": "Gemini",
                 "path": Path.home() / ".gemini" / "GEMINI.md",
-                "description": "Gemini Antigravity global rules",
+                "description": "Gemini CLI / Antigravity global rules",
             },
             "opencode": {
                 "name": "OpenCode",
@@ -124,6 +122,11 @@ class AgentRulesSync:
         # Uses the same repo_paths.json as agent_skills_sync.
         self._load_repo_agent_paths()
 
+    @property
+    def state_file(self):
+        """Previous sync’s shared bullets; always under the active config_dir."""
+        return self.config_dir / "sync_state.txt"
+
     def _load_repo_agent_paths(self):
         """Add configured repos' CLAUDE.md as rules sync targets."""
         import json
@@ -144,6 +147,174 @@ class AgentRulesSync:
         except Exception:
             pass
 
+    def _list_repo_roots(self):
+        """Resolved repo directories from repo_paths.json (same entries as repo CLAUDE.md targets)."""
+        import json
+        repo_paths_file = self.config_dir / "repo_paths.json"
+        if not repo_paths_file.exists():
+            return []
+        try:
+            repo_paths = json.loads(repo_paths_file.read_text())
+        except Exception:
+            return []
+        roots = []
+        for repo_path in repo_paths:
+            repo = Path(repo_path).expanduser().resolve()
+            if repo.is_dir():
+                roots.append(repo)
+        return roots
+
+    def _cursorrules_legacy_paths(self):
+        """
+        Legacy `.cursorrules` paths Cursor may still load (project root; deprecated vs `.cursor/rules`).
+        We treat them like extra Cursor surfaces: same markdown shape as global.mdc
+        (# Shared Rules + ## Cursor Specific bullets).
+        """
+        paths = [Path.home() / ".cursorrules"]
+        paths.extend(repo / ".cursorrules" for repo in self._list_repo_roots())
+        return paths
+
+    def _cursorrules_backup_slug(self, cr_path: Path) -> str:
+        """Distinct backup filename prefix per legacy .cursorrules path."""
+        try:
+            home_cr = (Path.home() / ".cursorrules").resolve()
+            if cr_path.resolve() == home_cr:
+                return "cursorrules_home"
+        except Exception:
+            pass
+        return f"cursorrules_repo_{cr_path.parent.name}"
+
+    def _merge_cursorrules_legacy_into_cursor(self, master_agent_rules, all_shared_rules):
+        """Merge shared + Cursor-specific bullets from legacy `.cursorrules` files into the cursor agent."""
+        if not self._cursor_layout_is_canonical():
+            return
+        for cr_path in self._cursorrules_legacy_paths():
+            if not cr_path.exists():
+                continue
+            try:
+                text = cr_path.read_text(encoding="utf-8", errors="replace")
+            except Exception:
+                continue
+            all_shared_rules.update(self._extract_shared_rules(text))
+            if "cursor" in master_agent_rules:
+                master_agent_rules["cursor"].update(
+                    self._extract_agent_rules(text, "cursor")
+                )
+
+    def _mirror_cursorrules_legacy_files(self, content: str):
+        """
+        Write the same Cursor payload as global.mdc to legacy paths so `.cursorrules` keeps working.
+        See: https://cursor.com/docs/rules — `.cursor/rules` is preferred; `.cursorrules` remains supported.
+        """
+        if not self._cursor_layout_is_canonical():
+            return
+        for cr_path in self._cursorrules_legacy_paths():
+            try:
+                cr_path.parent.mkdir(parents=True, exist_ok=True)
+                if cr_path.exists():
+                    backup_path = self._backup_file(cr_path, self._cursorrules_backup_slug(cr_path))
+                    if backup_path:
+                        self._log_message(f"Backed up {cr_path}: {backup_path.name}")
+                with open(cr_path, "w", encoding="utf-8") as f:
+                    f.write(content)
+            except Exception as e:
+                self._log_error(f"Error writing legacy .cursorrules {cr_path}: {e}")
+
+    def _cursorrules_watch_pairs(self):
+        """(hash_key, path) for watch loops."""
+        if not self._cursor_layout_is_canonical():
+            return []
+        return [(f"cursorrules:{i}", p) for i, p in enumerate(self._cursorrules_legacy_paths())]
+
+    def _cursor_primary_path(self) -> Path:
+        """File we rewrite with the merged Cursor payload (usually ~/.cursor/rules/global.mdc)."""
+        return self.agents["cursor"]["path"]
+
+    def _cursor_layout_is_canonical(self) -> bool:
+        """True when the Cursor target lives under ~/.cursor/rules/ (daemon/tests use real layout)."""
+        primary = self._cursor_primary_path()
+        try:
+            rules_dir = primary.parent
+        except Exception:
+            return False
+        return rules_dir.name == "rules" and rules_dir.parent.name == ".cursor"
+
+    def _cursor_all_rule_paths(self):
+        """
+        Cursor rule files: same directory as global.mdc when it lives under .../.cursor/rules/
+        (Cursor layout). Otherwise only the primary path (e.g. tests use a flat temp dir).
+        Skips .../imported/ subtrees. Always includes the primary path.
+        """
+        primary = self._cursor_primary_path()
+        rules_dir = primary.parent
+        found = set()
+        try:
+            found.add(primary.resolve())
+        except Exception:
+            found.add(primary)
+
+        looks_like_cursor_rules_dir = (
+            rules_dir.name == "rules"
+            and rules_dir.parent.name == ".cursor"
+        )
+        if looks_like_cursor_rules_dir and rules_dir.is_dir():
+            for pattern in ("*.md", "*.mdc"):
+                for p in rules_dir.rglob(pattern):
+                    if "imported" in p.parts:
+                        continue
+                    try:
+                        found.add(p.resolve())
+                    except Exception:
+                        found.add(p)
+        return sorted(found)
+
+    def _strip_cursor_rule_frontmatter(self, content: str) -> str:
+        """Strip leading YAML frontmatter from .mdc/.md rule bodies before parsing."""
+        stripped = content.lstrip("\ufeff")
+        if not stripped.startswith("---"):
+            return content
+        lines = stripped.splitlines()
+        if not lines or lines[0].strip() != "---":
+            return content
+        for i in range(1, len(lines)):
+            if lines[i].strip() == "---":
+                return "\n".join(lines[i + 1 :]).lstrip("\n")
+        return content
+
+    def _read_cursor_rule_body(self, path: Path) -> str:
+        raw = path.read_text(encoding="utf-8", errors="replace")
+        return self._strip_cursor_rule_frontmatter(raw)
+
+    def _merge_cursor_rule_files(self, master_agent_rules, all_shared_rules):
+        """Union shared and Cursor-specific bullets from every ~/.cursor/rules/*.md|.mdc file."""
+        if "cursor" not in master_agent_rules:
+            return
+        for p in self._cursor_all_rule_paths():
+            if not p.exists():
+                continue
+            try:
+                agent_content = self._read_cursor_rule_body(p)
+            except Exception:
+                continue
+            all_shared_rules.update(self._extract_shared_rules(agent_content))
+            master_agent_rules["cursor"].update(
+                self._extract_agent_rules(agent_content, "cursor")
+            )
+
+    def _cursor_shared_rule_present(self, rule: str) -> bool:
+        """True if the canonical Cursor file still lists this bullet under # Shared Rules."""
+        p = self._cursor_primary_path()
+        if not p.exists():
+            return False
+        try:
+            agent_content = self._read_cursor_rule_body(p)
+            return rule in self._extract_shared_rules(agent_content)
+        except Exception:
+            return False
+
+    def _cursor_watch_pairs(self):
+        return [(f"cursor:{i}", p) for i, p in enumerate(self._cursor_all_rule_paths())]
+
     def _get_file_hash(self, filepath):
         """Calculate SHA256 hash of a file."""
         if not filepath.exists():
@@ -285,6 +456,19 @@ class AgentRulesSync:
         - Subtract any rules that were in previous state but removed from ANY file
         """
         try:
+            # Tests (and future callers) may point config_dir at an isolated directory after
+            # __init__; reload config + sub-syncers so we never use another dir's sync_state,
+            # sync_config.json, or skills paths.
+            self.sync_config = load_config(self.config_dir)
+            if self.skills_sync.config_dir.resolve() != self.config_dir.resolve():
+                self.skills_sync = AgentSkillsSync(config_dir=self.config_dir)
+            if self.settings_sync.config_dir.resolve() != self.config_dir.resolve():
+                self.settings_sync = AgentSettingsSync(config_dir=self.config_dir)
+            expect_backup = self.config_dir / "backups"
+            if self.backup_dir.resolve() != expect_backup.resolve():
+                self.backup_dir = expect_backup
+                self.backup_dir.mkdir(parents=True, exist_ok=True)
+
             self._ensure_master_exists()
             self._migrate_from_old_version()
 
@@ -304,6 +488,8 @@ class AgentRulesSync:
             all_shared_rules = set(master_shared)
 
             for agent_id, config in self.agents.items():
+                if agent_id == "cursor":
+                    continue
                 agent_path = config["path"]
                 if agent_path.exists():
                     try:
@@ -320,6 +506,9 @@ class AgentRulesSync:
                     except Exception:
                         pass
 
+            self._merge_cursor_rule_files(master_agent_rules, all_shared_rules)
+            self._merge_cursorrules_legacy_into_cursor(master_agent_rules, all_shared_rules)
+
             # Step 4: Detect deletions
             # If we have previous state, remove rules that were deleted from ANY file
             if previous_shared is not None:
@@ -328,25 +517,16 @@ class AgentRulesSync:
                 self._log_message(f"Checking deletions: {len(previous_shared)} in prev, {len(master_shared)} in master, {len(all_shared_rules)} in union")
 
                 for rule in previous_shared:
-                    # Check if rule was deleted from master
+                    # Master intentionally trimmed (hidden RULES.md) always wins.
                     if rule not in master_shared:
                         rules_to_delete.add(rule)
                         self._log_message(f"Deletion detected from master: {rule[:50]}...")
                         continue
-
-                    # Check if rule was deleted from any agent
-                    for agent_id, config in self.agents.items():
-                        if config["path"].exists():
-                            try:
-                                with open(config["path"], 'r') as f:
-                                    agent_content = f.read()
-                                agent_shared = self._extract_shared_rules(agent_content)
-                                if rule not in agent_shared:
-                                    rules_to_delete.add(rule)
-                                    self._log_message(f"Deletion detected from {agent_id}: {rule[:50]}...")
-                                    break
-                            except Exception:
-                                pass
+                    # Gone from everywhere we merged — do not require each agent to list every
+                    # bullet mid-sync (Cursor may not have received Claude's row yet).
+                    if rule not in all_shared_rules:
+                        rules_to_delete.add(rule)
+                        self._log_message(f"Deletion detected (absent after merge): {rule[:50]}...")
 
                 # Remove deleted rules
                 if rules_to_delete:
@@ -397,6 +577,8 @@ class AgentRulesSync:
                         )
                         with open(agent_path, 'w') as f:
                             f.write(content)
+                        if agent_id == "cursor":
+                            self._mirror_cursorrules_legacy_files(content)
                     except Exception as e:
                         self._log_error(f"Error syncing {agent_id}: {e}")
 
@@ -450,7 +632,13 @@ class AgentRulesSync:
         file_hashes = {}
         file_hashes["master"] = self._get_file_hash(self.master_file)
         for agent_id, config in self.agents.items():
+            if agent_id == "cursor":
+                for key, p in self._cursor_watch_pairs():
+                    file_hashes[key] = self._get_file_hash(p)
+                continue
             file_hashes[agent_id] = self._get_file_hash(config["path"])
+        for key, p in self._cursorrules_watch_pairs():
+            file_hashes[key] = self._get_file_hash(p)
 
         # Store initial hashes for skills and settings
         skill_hashes = self.skills_sync.get_watch_paths_and_hashes()
@@ -477,11 +665,24 @@ class AgentRulesSync:
                     file_hashes["master"] = master_hash
 
                 for agent_id, config in self.agents.items():
+                    if agent_id == "cursor":
+                        for key, p in self._cursor_watch_pairs():
+                            current_hash = self._get_file_hash(p)
+                            if current_hash != file_hashes.get(key):
+                                changed = True
+                                file_hashes[key] = current_hash
+                        continue
                     current_hash = self._get_file_hash(config["path"])
                     if current_hash != file_hashes[agent_id]:
                         changed = True
                         file_hashes[agent_id] = current_hash
 
+                for key, p in self._cursorrules_watch_pairs():
+                    current_hash = self._get_file_hash(p)
+                    if current_hash != file_hashes.get(key):
+                        changed = True
+                        file_hashes[key] = current_hash
+
                 # Check if any skills changed
                 if self.skills_sync.skills_changed(skill_hashes):
                     changed = True
@@ -531,6 +732,11 @@ class AgentRulesSync:
         print(f"   Hash: {master_hash[:12] if master_hash else 'N/A'}...")
         print()
 
+        # Read master file once
+        with open(self.master_file, 'r') as f:
+            master_content = f.read()
+        master_shared = self._extract_shared_rules(master_content)
+        
         # Agent status
         for agent_id, config in self.agents.items():
             agent_path = config["path"]
@@ -540,10 +746,22 @@ class AgentRulesSync:
             print(f"   Path: {agent_path}")
 
             if agent_path.exists():
-                agent_hash = self._get_file_hash(agent_path)
-                in_sync = agent_hash == master_hash
-                status = "✓ In sync" if in_sync else "⚠️  Out of sync"
-                print(f"   Status: {status}")
+                try:
+                    with open(agent_path, 'r') as f:
+                        agent_content = f.read()
+                    
+                    agent_shared = self._extract_shared_rules(agent_content)
+                    agent_specific = self._extract_agent_rules(agent_content, agent_id)
+                    
+                    master_specific = self._extract_agent_rules(master_content, agent_id)
+                    
+                    in_sync = (agent_shared == master_shared and 
+                              agent_specific == master_specific)
+                    
+                    status = "✓ In sync" if in_sync else "⚠️  Out of sync"
+                    print(f"   Status: {status}")
+                except Exception as e:
+                    print(f"   Status: ⚠️  Error reading: {e}")
             else:
                 print(f"   Status: ⚠️  Not found")
 
@@ -636,7 +854,13 @@ class AgentRulesSync:
                 file_hashes = {}
                 file_hashes["master"] = self._get_file_hash(self.master_file)
                 for agent_id, config in self.agents.items():
+                    if agent_id == "cursor":
+                        for key, p in self._cursor_watch_pairs():
+                            file_hashes[key] = self._get_file_hash(p)
+                        continue
                     file_hashes[agent_id] = self._get_file_hash(config["path"])
+                for key, p in self._cursorrules_watch_pairs():
+                    file_hashes[key] = self._get_file_hash(p)
                 skill_hashes = self.skills_sync.get_watch_paths_and_hashes()
                 settings_hashes = self.settings_sync.get_watch_hashes()
 
@@ -655,11 +879,24 @@ class AgentRulesSync:
                         file_hashes["master"] = master_hash
 
                     for agent_id, config in self.agents.items():
+                        if agent_id == "cursor":
+                            for key, p in self._cursor_watch_pairs():
+                                current_hash = self._get_file_hash(p)
+                                if current_hash != file_hashes.get(key):
+                                    changed = True
+                                    file_hashes[key] = current_hash
+                            continue
                         current_hash = self._get_file_hash(config["path"])
                         if current_hash != file_hashes[agent_id]:
                             changed = True
                             file_hashes[agent_id] = current_hash
 
+                    for key, p in self._cursorrules_watch_pairs():
+                        current_hash = self._get_file_hash(p)
+                        if current_hash != file_hashes.get(key):
+                            changed = True
+                            file_hashes[key] = current_hash
+
                     if self.skills_sync.skills_changed(skill_hashes):
                         changed = True
                         skill_hashes = self.skills_sync.get_watch_paths_and_hashes()
@@ -713,7 +950,7 @@ class AgentRulesSync:
 
 
 SYNC_SCOPES = ["rules", "skills", "settings", "all"]
-COMMANDS = ["sync", "setup", "status", "stop", "watch", "daemon"]
+COMMANDS = ["sync", "delete-skill", "setup", "status", "stop", "watch", "daemon", "guardian"]
 
 
 def _run_sync(syncer, scopes):
@@ -762,6 +999,7 @@ Sync scope examples:
   agent-sync sync skills             Sync only skills directories
   agent-sync sync settings           Sync only .claude/settings.json + hooks
   agent-sync sync rules skills       Sync rules and skills
+  agent-sync delete-skill <name>     Delete a skill from master and all frameworks
         """
     )
 
@@ -770,12 +1008,27 @@ Sync scope examples:
                         help='Command to run (default: daemon)')
     parser.add_argument('scopes', nargs='*',
                         metavar='SCOPE',
-                        help=f'Scopes for sync command: {", ".join(SYNC_SCOPES)}')
+                        help=f'Scopes for sync command: {", ".join(SYNC_SCOPES)}. For delete-skill: the skill name to delete.')
 
     args = parser.parse_args()
     syncer = AgentRulesSync()
 
-    if args.command == 'sync':
+    if args.command == 'delete-skill':
+        if not args.scopes:
+            print("✗ Usage: agent-sync delete-skill <skill-name>")
+            sys.exit(1)
+        skill_name = args.scopes[0]
+        print(f"Deleting skill '{skill_name}' from all locations...")
+        result = syncer.skills_sync.delete_skill(
+            skill_name, backup=True, log_callback=print
+        )
+        if result["deleted"]:
+            print(f"\n✓ Deleted from {len(result['deleted'])} location(s).")
+        else:
+            print(f"✗ Skill '{skill_name}' not found in any location.")
+            sys.exit(1)
+
+    elif args.command == 'sync':
         scopes = args.scopes if args.scopes else ['all']
         # Validate scopes
         invalid = [s for s in scopes if s not in SYNC_SCOPES]
@@ -801,6 +1054,18 @@ Sync scope examples:
     elif args.command == 'stop':
         syncer.daemon_stop()
 
+    elif args.command == 'guardian':
+        if sys.platform != "darwin":
+            print("❌ Guardian is only supported on macOS.")
+            sys.exit(1)
+        try:
+            from agent_guardian import AgentGuardian
+            guardian = AgentGuardian()
+            guardian.run()
+        except ImportError:
+            print("❌ agent_guardian.py not found.")
+            sys.exit(1)
+
     else:  # daemon (default)
         if syncer.pid_file.exists():
             try: