feat: Add arbitrary directory project storage with registry system

This major update replaces the fixed `generations/` directory with support
for storing projects in any directory on the filesystem. Projects are now
tracked via a cross-platform registry system.

## New Features

### Project Registry (`registry.py`)
- Cross-platform registry storing project name-to-path mappings
- Platform-specific config locations:
  - Windows: %APPDATA%\autonomous-coder\projects.json
  - macOS: ~/Library/Application Support/autonomous-coder/projects.json
  - Linux: ~/.config/autonomous-coder/projects.json
- POSIX path format for cross-platform compatibility
- File locking for concurrent access safety (fcntl/msvcrt)
- Atomic writes via temp file + rename to prevent corruption
- Fixed Windows file locking issue with tempfile.mkstemp()

### Filesystem Browser API (`server/routers/filesystem.py`)
- REST endpoints for browsing directories server-side
- Cross-platform support with blocked system paths:
  - Windows: C:\Windows, Program Files, ProgramData, etc.
  - macOS: /System, /Library, /private, etc.
  - Linux: /etc, /var, /usr, /bin, etc.
- Universal blocked paths: .ssh, .aws, .gnupg, .docker, etc.
- Hidden file detection (Unix dot-prefix + Windows attributes)
- UNC path blocking for security
- Windows drive enumeration via ctypes
- Directory creation with validation
- Added `has_children` field to DirectoryEntry schema

### UI Folder Browser (`ui/src/components/FolderBrowser.tsx`)
- React component for selecting project directories
- Breadcrumb navigation with clickable segments
- Windows drive selector
- New folder creation inline
- Fixed text visibility with explicit color values

## Updated Components

### Server Routers
- `projects.py`: Uses registry instead of fixed generations/ directory
- `agent.py`: Uses registry for project path lookups
- `features.py`: Uses registry for database path resolution
- `spec_creation.py`: Uses registry for WebSocket project resolution

### Process Manager (`server/services/process_manager.py`)
- Fixed sandbox issue: subprocess now uses project_dir as cwd
- This allows the Claude SDK sandbox to access external project directories

### Schemas (`server/schemas.py`)
- Added `has_children` to DirectoryEntry
- Added `in_progress` to ProjectStats
- Added path field to ProjectSummary and ProjectDetail

### UI Components
- `NewProjectModal.tsx`: Multi-step wizard with folder selection
- Added clarifying text about subfolder creation
- Fixed text color visibility issues

### API Client (`ui/src/lib/api.ts`)
- Added filesystem API functions (listDirectory, createDirectory)
- Fixed Windows path splitting for directory creation

### Documentation
- Updated CLAUDE.md with registry system details
- Updated command examples for absolute paths

## Security Improvements
- Blocked `.` and `..` in directory names to prevent traversal
- Added path blocking check in project creation
- UNC path blocking throughout filesystem API

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

server/services/process_manager.py

@@ -56,6 +56,7 @@ class AgentProcessManager:
     def __init__(
         self,
         project_name: str,
+        project_dir: Path,
         root_dir: Path,
     ):
         """
@@ -63,9 +64,11 @@ class AgentProcessManager:
 
         Args:
             project_name: Name of the project
+            project_dir: Absolute path to the project directory
             root_dir: Root directory of the autonomous-coding-ui project
         """
         self.project_name = project_name
+        self.project_dir = project_dir
         self.root_dir = root_dir
         self.process: subprocess.Popen | None = None
         self._status: Literal["stopped", "running", "paused", "crashed"] = "stopped"
@@ -77,8 +80,8 @@ class AgentProcessManager:
         self._status_callbacks: Set[Callable[[str], Awaitable[None]]] = set()
         self._callbacks_lock = threading.Lock()
 
-        # Lock file to prevent multiple instances
-        self.lock_file = self.root_dir / "generations" / project_name / ".agent.lock"
+        # Lock file to prevent multiple instances (stored in project directory)
+        self.lock_file = self.project_dir / ".agent.lock"
 
     @property
     def status(self) -> Literal["stopped", "running", "paused", "crashed"]:
@@ -224,21 +227,22 @@ class AgentProcessManager:
         if not self._check_lock():
             return False, "Another agent instance is already running for this project"
 
-        # Build command
+        # Build command - pass absolute path to project directory
         cmd = [
             sys.executable,
             str(self.root_dir / "autonomous_agent_demo.py"),
             "--project-dir",
-            self.project_name,
+            str(self.project_dir.resolve()),
         ]
 
         try:
             # Start subprocess with piped stdout/stderr
+            # Use project_dir as cwd so Claude SDK sandbox allows access to project files
             self.process = subprocess.Popen(
                 cmd,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT,
-                cwd=str(self.root_dir),
+                cwd=str(self.project_dir),
             )
 
             self._create_lock()
@@ -379,11 +383,17 @@ _managers: dict[str, AgentProcessManager] = {}
 _managers_lock = threading.Lock()
 
 
-def get_manager(project_name: str, root_dir: Path) -> AgentProcessManager:
-    """Get or create a process manager for a project (thread-safe)."""
+def get_manager(project_name: str, project_dir: Path, root_dir: Path) -> AgentProcessManager:
+    """Get or create a process manager for a project (thread-safe).
+
+    Args:
+        project_name: Name of the project
+        project_dir: Absolute path to the project directory
+        root_dir: Root directory of the autonomous-coding-ui project
+    """
     with _managers_lock:
         if project_name not in _managers:
-            _managers[project_name] = AgentProcessManager(project_name, root_dir)
+            _managers[project_name] = AgentProcessManager(project_name, project_dir, root_dir)
         return _managers[project_name]