FZ2000
diff --git a/‎src/appliers/base.py‎
Lines changed: 70 additions & 0 deletions b/‎src/appliers/base.py‎
Lines changed: 70 additions & 0 deletions
diff --git a/‎src/appliers/copilot.py‎
Lines changed: 73 additions & 0 deletions b/‎src/appliers/copilot.py‎
Lines changed: 73 additions & 0 deletions
diff --git a/‎src/appliers/cursor.py‎
Lines changed: 2 additions & 0 deletions b/‎src/appliers/cursor.py‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎src/appliers/gemini.py‎
Lines changed: 9 additions & 0 deletions b/‎src/appliers/gemini.py‎
Lines changed: 9 additions & 0 deletions
diff --git a/‎src/appliers/manifest.py‎
Lines changed: 22 additions & 0 deletions b/‎src/appliers/manifest.py‎
Lines changed: 22 additions & 0 deletions
diff --git a/‎src/appliers/windsurf.py‎
Lines changed: 78 additions & 0 deletions b/‎src/appliers/windsurf.py‎
Lines changed: 78 additions & 0 deletions
diff --git a/‎src/collect.py‎
Lines changed: 23 additions & 4 deletions b/‎src/collect.py‎
Lines changed: 23 additions & 4 deletions
@@ -64,6 +64,7 @@ class BaseApplier(ABC):
     # Subclasses that support skills should set this to their skill directory
     # and the target name used in frontmatter filtering.
     SKILL_DIR: Optional[Path] = None
+    SYNC_METHOD: str = "dir-symlink"  # override in injection/per-file tools
     TOOL_NAME: str = ""
 
     # Subclasses that support LLM-based memory sync should override this
@@ -140,6 +141,75 @@ def link_skills(self, skills: List[Dict], source_dir: Path, manifest: ToolManife
 
         return count
 
+    def sync_skills_dir(self) -> bool:
+        """Establish a dir-level symlink: SKILL_DIR → ~/.apc/skills/.
+
+        Only applies when SKILL_DIR is set on the applier.
+        After this runs once, any future `apc install` is immediately live in
+        this tool without re-running sync.
+
+        Returns True if the symlink was established, False if not applicable.
+        """
+        from skills import get_skills_dir
+
+        if self.SKILL_DIR is None:
+            return False
+
+        skills_source = get_skills_dir()
+        skill_dir = self.SKILL_DIR
+
+        # Already correctly symlinked — nothing to do
+        already_linked = skill_dir.is_symlink() and (
+            Path(os.readlink(skill_dir)).resolve() == skills_source.resolve()
+        )
+        if already_linked:
+            return True
+
+        # Remove whatever is there now
+        if skill_dir.is_symlink():
+            skill_dir.unlink()
+        elif skill_dir.exists():
+            shutil.rmtree(skill_dir)
+
+        # Ensure parent exists, then symlink
+        skill_dir.parent.mkdir(parents=True, exist_ok=True)
+        os.symlink(skills_source, skill_dir)
+        return True
+
+    def apply_installed_skill(self, name: str) -> bool:
+        """Propagate a newly installed skill to this tool (called by apc install).
+
+        Dir-symlink tools: no-op — the symlink already makes the skill live.
+        Override in tools that need per-skill injection (Windsurf, Copilot).
+        Returns True if an action was taken, False if no-op.
+        """
+        return False  # dir-symlink tools need no action
+
+    def remove_installed_skill(self, name: str) -> bool:
+        """Clean up after a skill is uninstalled from ~/.apc/skills/.
+
+        Dir-symlink tools: no-op — the skill dir vanishes automatically.
+        Override in tools that maintain per-skill state (Windsurf, Copilot).
+        Returns True if an action was taken, False if no-op.
+        """
+        return False  # dir-symlink tools need no cleanup
+
+    def unsync_skills(self) -> bool:
+        """Undo the skill sync for this tool.
+
+        Dir-symlink tools: remove the symlink, recreate an empty dir.
+        Override in tools that use injection or per-file symlinks.
+        Returns True if anything was undone.
+        """
+        skill_dir = self.SKILL_DIR
+        if skill_dir is None:
+            return False
+        if skill_dir.is_symlink():
+            skill_dir.unlink()
+            skill_dir.mkdir(parents=True, exist_ok=True)
+            return True
+        return False
+
     @abstractmethod
     def apply_mcp_servers(
         self,
 
@@ -18,6 +18,11 @@ def _copilot_instructions_dir() -> Path:
     return Path.cwd() / ".github" / "instructions"
 
 
+def _copilot_global_instructions_dir() -> Path:
+    """User-global instructions dir — applies across all projects via VS Code."""
+    return Path.home() / ".github" / "instructions"
+
+
 def _vscode_mcp_json() -> Path:
     return Path.cwd() / ".vscode" / "mcp.json"
 
@@ -87,6 +92,7 @@ def _vscode_mcp_json() -> Path:
 
 class CopilotApplier(BaseApplier):
     TOOL_NAME = "github-copilot"
+    SYNC_METHOD = "per-file-symlink"
     MEMORY_SCHEMA = COPILOT_MEMORY_SCHEMA
 
     @property  # type: ignore[override]
@@ -96,6 +102,73 @@ def MEMORY_ALLOWED_BASE(self) -> "Path":  # noqa: N802
         # calling process later changes directory (#42).
         return Path.cwd().resolve()
 
+    def _global_instructions_dir(self) -> Path:
+        return _copilot_global_instructions_dir()
+
+    def sync_skills_dir(self) -> bool:  # type: ignore[override]
+        """Create per-skill .instructions.md symlinks in ~/.github/instructions/.
+
+        Copilot reads each <name>.instructions.md in the instructions dir.
+        We symlink: ~/.github/instructions/<name>.instructions.md →
+                    ~/.apc/skills/<name>/SKILL.md
+        so each skill's content is served as a Copilot instruction.
+        """
+        from skills import get_skills_dir
+
+        instr_dir = self._global_instructions_dir()
+        instr_dir.mkdir(parents=True, exist_ok=True)
+        skills_dir = get_skills_dir()
+
+        if not skills_dir.exists():
+            return True  # nothing to link yet; will populate on first apc install
+
+        for skill_path in skills_dir.iterdir():
+            skill_md = skill_path / "SKILL.md"
+            if not skill_md.exists():
+                continue
+            self._link_skill(skill_path.name, skill_md, instr_dir)
+
+        return True
+
+    def apply_installed_skill(self, name: str) -> bool:  # type: ignore[override]
+        """Create a symlink for a newly installed skill."""
+        from skills import get_skills_dir
+
+        skill_md = get_skills_dir() / name / "SKILL.md"
+        if not skill_md.exists():
+            return False
+        instr_dir = self._global_instructions_dir()
+        instr_dir.mkdir(parents=True, exist_ok=True)
+        self._link_skill(name, skill_md, instr_dir)
+        return True
+
+    def remove_installed_skill(self, name: str) -> bool:  # type: ignore[override]
+        """Remove the dangling .instructions.md symlink for an uninstalled skill."""
+        link = self._global_instructions_dir() / f"{name}.instructions.md"
+        if link.is_symlink():
+            link.unlink()
+            return True
+        return False
+
+    def unsync_skills(self) -> bool:  # type: ignore[override]
+        """Remove all apc-managed .instructions.md symlinks from ~/.github/instructions/."""
+        instr_dir = self._global_instructions_dir()
+        if not instr_dir.exists():
+            return False
+        removed = 0
+        for link in instr_dir.glob("*.instructions.md"):
+            if link.is_symlink():
+                link.unlink()
+                removed += 1
+        return removed > 0
+
+    @staticmethod
+    def _link_skill(name: str, skill_md: Path, instr_dir: Path) -> None:
+        link_path = instr_dir / f"{name}.instructions.md"
+        if link_path.is_symlink() or link_path.exists():
+            link_path.unlink()
+        os.symlink(skill_md.resolve(), link_path)
+
     def apply_skills(self, skills: List[Dict], manifest: ToolManifest) -> int:
         count = 0
         instructions = _copilot_instructions()
 
@@ -76,6 +76,8 @@ def _cursor_mcp_json() -> Path:
 
 class CursorApplier(BaseApplier):
     TOOL_NAME = "cursor"
+    # ~/.cursor/rules/ → ~/.apc/skills/ symlink (dir-level sync, same as all tools).
+    # Skills appear as <name>/SKILL.md subdirs; .mdc per-file format superseded.
     MEMORY_SCHEMA = CURSOR_MEMORY_SCHEMA
 
     @property  # type: ignore[override]
 
@@ -65,6 +65,10 @@ def _gemini_dir() -> Path:
     return Path.home() / ".gemini"
 
 
+def _gemini_skills_dir() -> Path:
+    return Path.home() / ".gemini" / "skills"
+
+
 def _gemini_settings() -> Path:
     return Path.home() / ".gemini/settings.json"
 
@@ -75,6 +79,11 @@ def _gemini_md() -> Path:
 
 class GeminiApplier(BaseApplier):
     TOOL_NAME = "gemini-cli"
+
+    @property
+    def SKILL_DIR(self) -> Path:  # type: ignore[override]
+        return _gemini_skills_dir()
+
     MEMORY_SCHEMA = GEMINI_MEMORY_SCHEMA
 
     @property  # type: ignore[override]
 
@@ -57,10 +57,32 @@ def _empty(self) -> dict:
             "last_sync_at": None,
             "skills": {},
             "linked_skills": {},
+            "dir_sync": None,
             "mcp_servers": {},
             "memory": {},
         }
 
+    def record_dir_sync(self, skill_dir: str, target: str) -> None:
+        """Record a dir-level symlink: skill_dir → target (~/.apc/skills/)."""
+        self._data["dir_sync"] = {
+            "skill_dir": skill_dir,
+            "target": target,
+            "sync_method": "dir-symlink",
+            "synced_at": _now_iso(),
+        }
+
+    def record_tool_sync(self, sync_method: str) -> None:
+        """Record a tool-specific sync (injection or per-file symlinks)."""
+        self._data["dir_sync"] = {
+            "sync_method": sync_method,
+            "synced_at": _now_iso(),
+        }
+
+    @property
+    def sync_method(self) -> str | None:
+        """Return the sync method recorded for this tool, or None if never synced."""
+        return (self._data.get("dir_sync") or {}).get("sync_method")
+
     @property
     def is_first_sync(self) -> bool:
         """True when no manifest existed on disk before this run."""
 
@@ -91,12 +91,90 @@ def _windsurf_global_rules() -> Path:
 
 class WindsurfApplier(BaseApplier):
     TOOL_NAME = "windsurf"
+    SYNC_METHOD = "injection"
     MEMORY_SCHEMA = WINDSURF_MEMORY_SCHEMA
 
     @property  # type: ignore[override]
     def MEMORY_ALLOWED_BASE(self) -> "Path":  # noqa: N802
         return _windsurf_dir()
 
+    _APC_SKILLS_HEADER = "<!-- apc-skills-start -->"
+    _APC_SKILLS_FOOTER = "<!-- apc-skills-end -->"
+
+    def _skills_section(self) -> str:
+        """Build the APC-managed skills block for global_rules.md."""
+        from skills import get_skills_dir
+
+        skills_dir = get_skills_dir()
+        lines = [
+            self._APC_SKILLS_HEADER,
+            "",
+            "## APC Skills",
+            "",
+            "The following skills are managed by apc. Each provides specialised",
+            "instructions — refer to the skill name when you need that capability.",
+            "",
+        ]
+        if skills_dir.exists():
+            for skill_path in sorted(skills_dir.iterdir()):
+                skill_md = skill_path / "SKILL.md"
+                if skill_md.exists():
+                    lines.append(f"- **{skill_path.name}**: {skill_md}")
+        lines += ["", self._APC_SKILLS_FOOTER]
+        return "\n".join(lines)
+
+    def _write_skills_to_global_rules(self) -> None:
+        """Inject (or update) the APC skills block in global_rules.md."""
+        rules_path = _windsurf_global_rules()
+        rules_path.parent.mkdir(parents=True, exist_ok=True)
+        existing = rules_path.read_text(encoding="utf-8") if rules_path.exists() else ""
+
+        block = self._skills_section()
+
+        if self._APC_SKILLS_HEADER in existing:
+            # Replace existing block
+            start = existing.index(self._APC_SKILLS_HEADER)
+            end = existing.index(self._APC_SKILLS_FOOTER) + len(self._APC_SKILLS_FOOTER)
+            updated = existing[:start] + block + existing[end:]
+        else:
+            # Append block
+            updated = existing.rstrip("\n") + "\n\n" + block + "\n"
+
+        rules_path.write_text(updated, encoding="utf-8")
+
+    def sync_skills_dir(self) -> bool:  # type: ignore[override]
+        """Inject the APC skills section into global_rules.md (no dir symlink)."""
+        self._write_skills_to_global_rules()
+        return True
+
+    def apply_installed_skill(self, name: str) -> bool:  # type: ignore[override]
+        """Regenerate the APC skills block when a new skill is installed."""
+        self._write_skills_to_global_rules()
+        return True
+
+    def remove_installed_skill(self, name: str) -> bool:  # type: ignore[override]
+        """Regenerate the APC skills block after a skill is uninstalled.
+
+        The deleted skill is already gone from ~/.apc/skills/ at this point,
+        so _write_skills_to_global_rules() will naturally omit it.
+        """
+        self._write_skills_to_global_rules()
+        return True
+
+    def unsync_skills(self) -> bool:  # type: ignore[override]
+        """Remove the APC skills section from global_rules.md."""
+        rules_path = _windsurf_global_rules()
+        if not rules_path.exists():
+            return False
+        content = rules_path.read_text(encoding="utf-8")
+        if self._APC_SKILLS_HEADER not in content:
+            return False
+        start = content.index(self._APC_SKILLS_HEADER)
+        end = content.index(self._APC_SKILLS_FOOTER) + len(self._APC_SKILLS_FOOTER)
+        updated = (content[:start] + content[end:]).strip("\n") + "\n"
+        rules_path.write_text(updated, encoding="utf-8")
+        return True
+
     def apply_skills(self, skills: List[Dict], manifest: ToolManifest) -> int:
         return 0
 
 
@@ -21,7 +21,9 @@
     save_skills,
 )
 from extractors import detect_installed_tools, get_extractor
+from frontmatter_parser import render_frontmatter
 from secrets_manager import detect_and_redact, store_secrets_batch
+from skills import save_skill_file
 from ui import (
     cache_summary_table,
     display_memory_files,
@@ -198,16 +200,33 @@ def collect(tools, no_memory, dry_run, yes):
         info("\n[dry-run] No files written.")
         return
 
-    # Merge into existing cache (upsert, never delete)
-    merged_skills = merge_skills(load_skills(), new_skills)
+    # Write collected skills to ~/.apc/skills/<name>/SKILL.md (source of truth)
+    # Skills are never stored inline in the cache — ~/.apc/skills/ is canonical.
+    for skill in new_skills:
+        name = skill.get("name", "unnamed")
+        metadata = {k: skill[k] for k in ("name", "description", "tags", "version") if skill.get(k)}
+        raw_content = render_frontmatter(metadata, skill.get("body", ""))
+        try:
+            save_skill_file(name, raw_content)
+        except ValueError as exc:
+            warning(f"Skipping skill {name!r}: {exc}")
+
     merged_mcp = merge_mcp_servers(load_mcp_servers(), new_mcp_servers)
     merged_memory = merge_memory(load_memory(), selected_memory)
+    # Keep skills.json as a metadata index (name, description, tags — no body)
+    # so `apc skill list` and other commands can enumerate skills without
+    # reading every SKILL.md. Body lives in ~/.apc/skills/<name>/SKILL.md.
+    skill_index = [
+        {k: s[k] for k in ("name", "description", "tags", "version", "source_tool") if k in s}
+        for s in new_skills
+    ]
+    merged_index = merge_skills(load_skills(), skill_index)
 
-    save_skills(merged_skills)
     save_mcp_servers(merged_mcp)
     save_memory(merged_memory)
+    save_skills(merged_index)
 
     cache_summary_table(
-        len(merged_skills), len(merged_mcp), len(merged_memory), title="Local Cache Updated"
+        len(new_skills), len(merged_mcp), len(merged_memory), title="Local Cache Updated"
     )
     success("Collection complete.")