fix: CI failures — os.readlink crash, skills.json index, dir_sync manifest + status check

- base.py: fix OSError in sync_skills_dir() — os.readlink() was called before
  is_symlink() check; restructured to guard correctly
- collect.py: restore save_skills() for index (metadata only, no body) so
  apc skill list and existing tests still work
- manifest.py: add record_dir_sync() + dir_sync field in schema
- sync_helpers.py: call manifest.record_dir_sync() after sync_skills_dir() succeeds
- status.py: check dir_sync symlink integrity for exclusive-dir tools
- test_docker_integration.py: seed ~/.apc/skills/ instead of inline skills.json body;
  update test_out_of_sync to break dir symlink for exclusive-dir tools

Author: forge-fz2000

src/appliers/base.py

@@ -163,8 +163,10 @@ def sync_skills_dir(self) -> bool:
         skill_dir = self.SKILL_DIR
 
         # Already correctly symlinked — nothing to do
-        link_target = Path(os.readlink(skill_dir)).resolve()
-        if skill_dir.is_symlink() and link_target == skills_source.resolve():
+        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

src/appliers/manifest.py

@@ -57,10 +57,19 @@ 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,
+            "synced_at": _now_iso(),
+        }
+
     @property
     def is_first_sync(self) -> bool:
         """True when no manifest existed on disk before this run."""

src/collect.py

@@ -12,10 +12,13 @@
 from cache import (
     load_mcp_servers,
     load_memory,
+    load_skills,
     merge_mcp_servers,
     merge_memory,
+    merge_skills,
     save_mcp_servers,
     save_memory,
+    save_skills,
 )
 from extractors import detect_installed_tools, get_extractor
 from frontmatter_parser import render_frontmatter
@@ -175,9 +178,18 @@ def collect(tools, no_memory, yes):
 
     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_mcp_servers(merged_mcp)
     save_memory(merged_memory)
+    save_skills(merged_index)
 
     cache_summary_table(
         len(new_skills), len(merged_mcp), len(merged_memory), title="Local Cache Updated"

src/status.py

@@ -3,6 +3,7 @@
 No login required. No network calls.
 """
 
+import os
 from pathlib import Path
 
 import click
@@ -46,6 +47,14 @@ def _tool_sync_status(name: str) -> str:
         if fp := info_dict.get("link_path"):
             recorded_paths.append(fp)
 
+    # Dir-level symlink check: verify the skills dir still points to ~/.apc/skills/
+    if dir_sync := manifest._data.get("dir_sync"):
+        skill_dir = Path(dir_sync.get("skill_dir", ""))
+        target = Path(dir_sync.get("target", ""))
+        # Symlink must exist and still resolve to the canonical source
+        if not skill_dir.is_symlink() or Path(os.readlink(skill_dir)).resolve() != target.resolve():
+            return "out of sync"
+
     # memory is a flat dict {file_path, checksum, ...}, not a dict-of-dicts.
     if fp := manifest._data.get("memory", {}).get("file_path"):
         recorded_paths.append(fp)

src/sync_helpers.py

@@ -92,6 +92,7 @@ def sync_skills(tool_list: List[str]) -> Tuple[int, int]:
 
             if applier.sync_skills_dir():
                 # Dir-level symlink established — entire ~/.apc/skills/ is live
+                manifest.record_dir_sync(str(applier.SKILL_DIR), str(skills_dir))
                 total_dir += 1
                 success(f"{tool_name}: skills dir symlinked → ~/.apc/skills/")
             elif installed_skills:
@@ -202,6 +203,7 @@ def sync_all(tool_list: List[str], no_memory: bool = False, override_mcp: bool =
 
             # Establish skill link (dir-level or per-skill depending on tool)
             if applier.sync_skills_dir():
+                manifest.record_dir_sync(str(applier.SKILL_DIR), str(skills_dir))
                 s, lk = 1, 0  # dir symlink counts as 1
             else:
                 s = 0

tests/test_docker_integration.py

@@ -406,29 +406,27 @@ def test_out_of_sync_when_skill_deleted(
         mcp_key,
         supports_skills,
     ):
-        """Deleting a synced skill file causes 'out of sync' for that tool."""
+        """Removing a synced skill link/file causes 'out of sync' for that tool.
+
+        Skills now live in ~/.apc/skills/ (source of truth).
+        - SKILL_DIR_EXCLUSIVE tools (claude-code, openclaw): their skills dir is a
+          single symlink → ~/.apc/skills/. Out-of-sync = symlink removed/broken.
+        - Per-skill tools (cursor): individual link_path entries in the manifest.
+          Out-of-sync = linked file deleted.
+        """
         monkeypatch.setenv("HOME", str(tmp_path))
         monkeypatch.chdir(tmp_path)
         for d in seed_dirs:
             (tmp_path / d).mkdir(parents=True, exist_ok=True)
 
-        # Seed isolated cache then sync — appliers are lazy so all writes go to tmp_path
+        # Seed ~/.apc/skills/test-skill/SKILL.md — the canonical source
+        skills_source = tmp_path / ".apc" / "skills" / "test-skill"
+        skills_source.mkdir(parents=True, exist_ok=True)
+        (skills_source / "SKILL.md").write_text("# Test\nTest skill body.", encoding="utf-8")
+
         cache_dir = tmp_path / ".apc" / "cache"
         cache_dir.mkdir(parents=True, exist_ok=True)
-        (cache_dir / "skills.json").write_text(
-            json.dumps(
-                [
-                    {
-                        "name": "test-skill",
-                        "description": "A test skill",
-                        "body": "Test skill body.",
-                        "tags": ["test"],
-                        "version": "1.0.0",
-                    }
-                ]
-            ),
-            encoding="utf-8",
-        )
+        (cache_dir / "skills.json").write_text("[]", encoding="utf-8")
         (cache_dir / "mcp_servers.json").write_text("[]", encoding="utf-8")
         (cache_dir / "memory.json").write_text("[]", encoding="utf-8")
         runner.invoke(cli, ["sync", "--tools", detected_name, "--yes", "--no-memory"])
@@ -439,14 +437,23 @@ def test_out_of_sync_when_skill_deleted(
             f"{detected_name}: expected synced before delete, got:\n{r1.output}"
         )
 
-        # Find and delete a skill file recorded by the manifest
+        # Break the skill link/symlink to trigger out-of-sync
         manifest_path = tmp_path / ".apc" / "manifests" / f"{applier_tool_name}.json"
         manifest_data = json.loads(manifest_path.read_text())
-        skill_paths = [
-            v["file_path"] for v in manifest_data.get("skills", {}).values() if "file_path" in v
-        ]
-        assert skill_paths, f"no skill file_paths in manifest for {detected_name}"
-        Path(skill_paths[0]).unlink()
+
+        if manifest_data.get("dir_sync"):
+            # Exclusive-dir tool: remove the dir-level symlink
+            skill_dir = Path(manifest_data["dir_sync"]["skill_dir"])
+            skill_dir.unlink()
+        else:
+            # Per-skill tool: delete a linked skill file
+            link_paths = [
+                v["link_path"]
+                for v in manifest_data.get("linked_skills", {}).values()
+                if "link_path" in v
+            ]
+            assert link_paths, f"no link_paths in manifest for {detected_name}"
+            Path(link_paths[0]).unlink()
 
         r2 = runner.invoke(cli, ["status"])
         assert "out of sync" in r2.output.lower(), (