JayantDevkar
diff --git a/‎api/db/indexer.py‎
Lines changed: 12 additions & 13 deletions b/‎api/db/indexer.py‎
Lines changed: 12 additions & 13 deletions
diff --git a/‎api/models/history.py‎
Lines changed: 16 additions & 7 deletions b/‎api/models/history.py‎
Lines changed: 16 additions & 7 deletions
diff --git a/‎api/models/plugin.py‎
Lines changed: 9 additions & 9 deletions b/‎api/models/plugin.py‎
Lines changed: 9 additions & 9 deletions
diff --git a/‎api/models/project.py‎
Lines changed: 51 additions & 10 deletions b/‎api/models/project.py‎
Lines changed: 51 additions & 10 deletions
diff --git a/‎api/routers/agent_analytics.py‎
Lines changed: 6 additions & 7 deletions b/‎api/routers/agent_analytics.py‎
Lines changed: 6 additions & 7 deletions
diff --git a/‎api/routers/history.py‎
Lines changed: 4 additions & 6 deletions b/‎api/routers/history.py‎
Lines changed: 4 additions & 6 deletions
diff --git a/‎api/routers/plugins.py‎
Lines changed: 5 additions & 7 deletions b/‎api/routers/plugins.py‎
Lines changed: 5 additions & 7 deletions
@@ -21,6 +21,8 @@
 from pathlib import Path
 from typing import Optional
 
+from utils import is_encoded_project_dir
+
 # Ensure api/ is on the import path (needed when called from background thread)
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
@@ -91,7 +93,7 @@ def sync_all_projects(conn: sqlite3.Connection) -> dict:
 
         # First pass: normal projects
         for encoded_dir in projects_dir.iterdir():
-            if not encoded_dir.is_dir() or not encoded_dir.name.startswith("-"):
+            if not encoded_dir.is_dir() or not is_encoded_project_dir(encoded_dir.name):
                 continue
             if is_worktree_project(encoded_dir.name):
                 worktree_dirs.append(encoded_dir)
@@ -576,10 +578,11 @@ def _detect_project_path(session, encoded_name: str) -> Optional[str]:
     # Fallback: Decode from encoded name (lossy for paths with hyphens).
     # Only use the decoded path if it actually exists on disk, to avoid
     # storing wrong paths (e.g. "claude-karma" → "claude/karma").
-    if encoded_name.startswith("-"):
-        decoded = "/" + encoded_name[1:].replace("-", "/")
-        if Path(decoded).is_dir():
-            return decoded
+    from models.project import Project
+
+    decoded = Project.decode_path(encoded_name)
+    if Path(decoded).is_dir():
+        return decoded
 
     # Don't store a bad path — let _update_project_summaries resolve it
     # from sibling sessions that have working directory data.
@@ -687,23 +690,19 @@ def _resolve_project_path(encoded_name: str, candidate_paths: list) -> str:
     """
     from pathlib import Path
 
+    from models.project import Project
+
     if not candidate_paths:
         # Last resort: decode from encoded name (lossy for hyphenated paths)
-        if encoded_name.startswith("-"):
-            return "/" + encoded_name[1:].replace("-", "/")
-        return encoded_name
+        return Project.decode_path(encoded_name)
 
     # Find all paths whose encoding matches the encoded_name
     # (multiple paths can match due to lossy encoding: / and - both become -)
     matches = []
     for path in candidate_paths:
         if not path:
             continue
-        if path.startswith("/"):
-            encoded = "-" + path[1:].replace("/", "-")
-        else:
-            encoded = path.replace("/", "-")
-        if encoded == encoded_name:
+        if Project.encode_path(path) == encoded_name:
             matches.append(path)
 
     if matches:
 
@@ -97,16 +97,25 @@ def prompt_count(self) -> int:
 
 
 def encode_path(path: str) -> str:
-    """Encode a path to Claude's format: /Users/me/repo -> -Users-me-repo"""
-    if path.startswith("/"):
-        return "-" + path[1:].replace("/", "-")
-    return path.replace("/", "-")
+    """Encode a path to Claude's format.
+
+    Delegates to the canonical Project.encode_path() which handles
+    both Unix and Windows paths correctly.
+
+    Unix:    /Users/me/repo  -> -Users-me-repo
+    Windows: C:\\Code\\Tools -> C--Code-Tools
+    """
+    from models.project import Project
+
+    return Project.encode_path(path)
 
 
 def get_project_name(path: str) -> str:
     """Extract a readable project name from a full path."""
-    # Get last 2 path components for context
-    parts = path.rstrip("/").split("/")
+    # Normalize Windows backslashes before splitting so C:\Users\me\repo
+    # produces "me/repo" instead of the raw backslash string.
+    # Mac/Linux paths are unchanged (no backslashes to normalize).
+    parts = path.replace("\\", "/").rstrip("/").split("/")
     if len(parts) >= 2:
         return "/".join(parts[-2:])
     return parts[-1] if parts else path
@@ -139,7 +148,7 @@ def parse_history_file(history_path: Path) -> list[HistoryEntry]:
     if not history_path.exists():
         return entries
 
-    with open(history_path, "r") as f:
+    with open(history_path, "r", encoding="utf-8", errors="replace") as f:
         for line in f:
             line = line.strip()
             if not line:
 
@@ -229,7 +229,7 @@ def from_path(cls, path: Path) -> Optional["InstalledPlugins"]:
             return None
 
         try:
-            with open(path, "r", encoding="utf-8") as f:
+            with open(path, "r", encoding="utf-8", errors="replace") as f:
                 data = json.load(f)
 
             # Parse datetime strings in nested structures
@@ -356,7 +356,7 @@ def read_plugin_manifest(cache_path: Path) -> dict:
         return {}
 
 
-def _resolve_manifest_dirs(
+def resolve_manifest_dirs(
     cache_path: Path, manifest: dict, key: str, defaults: list[str]
 ) -> list[Path]:
     """
@@ -449,22 +449,22 @@ def scan_plugin_capabilities(plugin_name: str) -> dict:
     manifest = read_plugin_manifest(cache_path)
 
     # Scan agents directories (default + manifest custom paths)
-    for agents_dir in _resolve_manifest_dirs(cache_path, manifest, "agents", ["agents"]):
+    for agents_dir in resolve_manifest_dirs(cache_path, manifest, "agents", ["agents"]):
         for f in agents_dir.glob("*.md"):
             if f.stem not in result["agents"]:
                 result["agents"].append(f.stem)
 
     # Scan skills directories first (recursive for SKILL.md)
     # Skills take priority over commands when both exist (skills have richer structure)
-    for skills_dir in _resolve_manifest_dirs(cache_path, manifest, "skills", ["skills"]):
+    for skills_dir in resolve_manifest_dirs(cache_path, manifest, "skills", ["skills"]):
         for f in skills_dir.rglob("SKILL.md"):
             skill_name = f.parent.name
             if skill_name not in result["skills"]:
                 result["skills"].append(skill_name)
 
     # Scan commands directories — skip entries already found as skills
     skills_set = set(result["skills"])
-    for commands_dir in _resolve_manifest_dirs(cache_path, manifest, "commands", ["commands"]):
+    for commands_dir in resolve_manifest_dirs(cache_path, manifest, "commands", ["commands"]):
         for f in commands_dir.glob("*.md"):
             if f.stem not in skills_set and f.stem not in result["commands"]:
                 result["commands"].append(f.stem)
@@ -486,7 +486,7 @@ def scan_plugin_capabilities(plugin_name: str) -> dict:
     mcp_config = cache_path / ".mcp.json"
     if mcp_config.exists():
         try:
-            with open(mcp_config, "r") as f:
+            with open(mcp_config, "r", encoding="utf-8", errors="replace") as f:
                 mcp_data = json.load(f)
                 server_keys = []
                 if "mcpServers" in mcp_data:
@@ -547,7 +547,7 @@ def read_command_contents(plugin_name: str) -> list[dict]:
     manifest = read_plugin_manifest(cache_path)
 
     # Scan skills directories for SKILL.md files
-    for skills_dir in _resolve_manifest_dirs(cache_path, manifest, "skills", ["skills"]):
+    for skills_dir in resolve_manifest_dirs(cache_path, manifest, "skills", ["skills"]):
         for f in sorted(skills_dir.rglob("SKILL.md")):
             name = f.parent.name
             if name not in seen_names:
@@ -560,7 +560,7 @@ def read_command_contents(plugin_name: str) -> list[dict]:
                     result.append({"name": name, "content": None})
 
     # Scan commands directories for .md files
-    for commands_dir in _resolve_manifest_dirs(cache_path, manifest, "commands", ["commands"]):
+    for commands_dir in resolve_manifest_dirs(cache_path, manifest, "commands", ["commands"]):
         for f in sorted(commands_dir.glob("*.md")):
             if f.stem not in seen_names:
                 seen_names.add(f.stem)
@@ -591,7 +591,7 @@ def get_plugin_description(plugin_name: str) -> Optional[str]:
     plugin_json = cache_path / "plugin.json"
     if plugin_json.exists():
         try:
-            with open(plugin_json, "r") as f:
+            with open(plugin_json, "r", encoding="utf-8", errors="replace") as f:
                 data = json.load(f)
                 return data.get("description")
         except Exception as e:
 
@@ -6,6 +6,7 @@
 
 from __future__ import annotations
 
+import re
 from functools import cached_property
 from pathlib import Path
 from typing import TYPE_CHECKING, List, Optional, Union
@@ -62,6 +63,25 @@ def get_cached_jsonl_count(project_dir: Path) -> int:
 PathLike = Union[str, Path]
 
 
+def _is_absolute_path(path: str) -> bool:
+    """Check if a path is absolute, recognizing both Unix and Windows formats.
+
+    Unlike Path.is_absolute(), this works cross-platform: a Windows path like
+    'C:\\Users\\test' is recognized as absolute even when running on macOS/Linux.
+    This is important for reading session data synced from other operating systems.
+    """
+    # Unix absolute path
+    if path.startswith("/"):
+        return True
+    # Windows absolute path: drive letter followed by colon and separator
+    if re.match(r"^[A-Za-z]:[/\\]", path):
+        return True
+    # Windows UNC path
+    if path.startswith("\\\\") or path.startswith("//"):
+        return True
+    return False
+
+
 class Project(BaseModel):
     """
     Represents a Claude Code project directory under ~/.claude/projects/.
@@ -89,24 +109,35 @@ def encode_path(path: PathLike) -> str:
         """
         Encode a project path to Claude's directory name format.
 
+        Unix:    /Users/me/repo  -> -Users-me-repo   (leading / -> leading -)
+        Windows: C:\\Code\\Tools -> C--Code-Tools     (colon -> dash, backslash -> dash)
+
         Args:
             path: Absolute project path
 
         Returns:
-            Encoded directory name (e.g., -Users-me-repo)
+            Encoded directory name (e.g., -Users-me-repo or C--Code-Tools)
         """
         p = str(path)
-        # Claude's encoding: replace '/' with '-' (leading '/' becomes leading '-')
+        # Normalise Windows backslashes
         p = p.replace("\\", "/")
         if p.startswith("/"):
+            # Unix absolute path: strip leading slash, prepend dash
             p = p[1:]
-        return "-" + p.replace("/", "-")
+            return "-" + p.replace("/", "-")
+        else:
+            # Windows absolute path like C:/Code/Tools
+            # Claude Code encodes colon and slash both as dash -> C--Code-Tools
+            return p.replace(":", "-").replace("/", "-")
 
     @staticmethod
     def decode_path(encoded: str) -> str:
         """
         Decode a Claude directory name back to original path.
 
+        Unix:    -Users-me-repo  -> /Users/me/repo
+        Windows: C--Code-Tools   -> C:/Code/Tools
+
         Note: This is lossy if the original path contained '-' characters.
         Use _extract_real_path_from_sessions() for accurate path recovery.
 
@@ -116,10 +147,20 @@ def decode_path(encoded: str) -> str:
         Returns:
             Decoded absolute path (may be incorrect if original had dashes)
         """
-        e = encoded
-        if e.startswith("-"):
-            e = e[1:]
-        return "/" + e.replace("-", "/")
+        if encoded.startswith("-"):
+            # Unix encoded path: -Users-me-repo -> /Users/me/repo
+            return "/" + encoded[1:].replace("-", "/")
+
+        # Windows encoded path: C--Code-Tools -> C:/Code/Tools
+        # Pattern: single drive letter followed by --
+        win_match = re.match(r"^([A-Za-z])--(.*)", encoded)
+        if win_match:
+            drive = win_match.group(1).upper()
+            rest = win_match.group(2).replace("-", "/")
+            return f"{drive}:/{rest}"
+
+        # Fallback: treat as Unix-style without leading slash
+        return "/" + encoded.replace("-", "/")
 
     @staticmethod
     def _extract_real_path_from_sessions(project_dir: Path) -> Optional[str]:
@@ -157,9 +198,9 @@ def _extract_real_path_from_sessions(project_dir: Path) -> Optional[str]:
                         try:
                             data = json.loads(line.strip())
                             cwd = data.get("cwd")
-                            # Validate cwd is an absolute path
-                            if cwd and Path(cwd).is_absolute():
-                                return cwd
+                            if cwd and _is_absolute_path(cwd):
+                                # Normalize Windows backslashes to forward slashes
+                                return cwd.replace("\\", "/")
                         except json.JSONDecodeError:
                             continue
             except (OSError, PermissionError, UnicodeDecodeError):
 
@@ -22,6 +22,7 @@
     AgentUsageListResponse,
     AgentUsageSummary,
 )
+from utils import is_encoded_project_dir
 
 logger = logging.getLogger(__name__)
 
@@ -83,14 +84,12 @@ def _get_all_project_agent_names() -> frozenset[str]:
     for encoded_dir in projects_dir.iterdir():
         if not encoded_dir.is_dir() or encoded_dir.name.startswith("."):
             continue
-        # Decode: leading "-" → "/", all "-" → "/"
-        decoded_path = (
-            "/" + encoded_dir.name[1:].replace("-", "/")
-            if encoded_dir.name.startswith("-")
-            else None
-        )
-        if not decoded_path:
+        if not is_encoded_project_dir(encoded_dir.name):
             continue
+        # Decode to real project path using Project model
+        from models.project import Project
+
+        decoded_path = Project.decode_path(encoded_dir.name)
         project_dir = Path(decoded_path)
         if not project_dir.is_dir():
             continue
 
@@ -244,12 +244,10 @@ async def get_project_archived_prompts(
 
     if not archived_projects:
         # Return empty response rather than 404 - project may just have no archived prompts
-        # Decode the path to get project name
-        project_path = (
-            "/" + encoded_name[1:].replace("-", "/")
-            if encoded_name.startswith("-")
-            else encoded_name.replace("-", "/")
-        )
+        # Decode the path using Project model (handles both Unix and Windows)
+        from models.project import Project
+
+        project_path = Project.decode_path(encoded_name)
         return ProjectArchivedResponse(
             project_name=get_project_name(project_path),
             project_path=project_path,
 
@@ -26,10 +26,10 @@
     load_installed_plugins,
 )
 from models.plugin import (
-    _resolve_manifest_dirs,
     get_plugin_description,
     read_command_contents,
     read_plugin_manifest,
+    resolve_manifest_dirs,
     scan_plugin_capabilities,
 )
 from schemas import (
@@ -1232,7 +1232,7 @@ def list_plugin_skills(plugin_name: str, request: Request) -> list[SkillItem]:
     seen_names: set[str] = set()
 
     # Scan skills directories for SKILL.md files
-    for skills_dir in _resolve_manifest_dirs(install_path, manifest, "skills", ["skills"]):
+    for skills_dir in resolve_manifest_dirs(install_path, manifest, "skills", ["skills"]):
         try:
             for skill_md in sorted(
                 skills_dir.rglob("SKILL.md"), key=lambda p: p.parent.name.lower()
@@ -1258,7 +1258,7 @@ def list_plugin_skills(plugin_name: str, request: Request) -> list[SkillItem]:
             logger.error(f"Failed to scan skills directory {skills_dir}: {e}")
 
     # Scan commands directories for .md files
-    for commands_dir in _resolve_manifest_dirs(install_path, manifest, "commands", ["commands"]):
+    for commands_dir in resolve_manifest_dirs(install_path, manifest, "commands", ["commands"]):
         try:
             for entry in sorted(commands_dir.iterdir(), key=lambda p: p.name.lower()):
                 if entry.name.startswith(".") or not entry.is_file():
@@ -1350,7 +1350,7 @@ def get_plugin_skill_content(
     target_file = None
 
     # Search skills directories for SKILL.md (path is skill name)
-    for skills_dir in _resolve_manifest_dirs(install_path, manifest, "skills", ["skills"]):
+    for skills_dir in resolve_manifest_dirs(install_path, manifest, "skills", ["skills"]):
         candidate = (skills_dir / clean_path / "SKILL.md").resolve()
         try:
             candidate.relative_to(skills_dir.resolve())
@@ -1362,9 +1362,7 @@ def get_plugin_skill_content(
 
     # Search commands directories for .md file
     if target_file is None:
-        for commands_dir in _resolve_manifest_dirs(
-            install_path, manifest, "commands", ["commands"]
-        ):
+        for commands_dir in resolve_manifest_dirs(install_path, manifest, "commands", ["commands"]):
             candidate = (commands_dir / clean_path).resolve()
             try:
                 candidate.relative_to(commands_dir.resolve())