fix(worktree): symlink node_modules to worktrees for TypeScript support

.husky/pre-commit

@@ -2,7 +2,7 @@
 
 # Preserve git worktree context - prevent HEAD corruption in worktrees
 if [ -f ".git" ]; then
-  WORKTREE_GIT_DIR=$(cat .git | sed 's/gitdir: //')
+  WORKTREE_GIT_DIR=$(sed 's/^gitdir: //' .git)
   if [ -n "$WORKTREE_GIT_DIR" ]; then
     export GIT_DIR="$WORKTREE_GIT_DIR"
     export GIT_WORK_TREE="$(pwd)"
@@ -170,45 +170,83 @@ fi
 # Check if there are staged files in apps/frontend
 if git diff --cached --name-only | grep -q "^apps/frontend/"; then
   echo "Frontend changes detected, running frontend checks..."
-  # Use subshell to isolate directory changes and prevent worktree corruption
-  (
-    cd apps/frontend
 
-    # Run lint-staged (handles staged .ts/.tsx files)
-    npm exec lint-staged
-    if [ $? -ne 0 ]; then
-      echo "lint-staged failed. Please fix linting errors before committing."
-      exit 1
-    fi
+  # Detect if we're in a worktree and check if dependencies are available
+  IS_WORKTREE=false
+  DEPS_AVAILABLE=true
 
-    # Run TypeScript type check
-    echo "Running type check..."
-    npm run typecheck
-    if [ $? -ne 0 ]; then
-      echo "Type check failed. Please fix TypeScript errors before committing."
-      exit 1
-    fi
+  if [ -f ".git" ]; then
+    # .git is a file (not directory) in worktrees
+    IS_WORKTREE=true
+    echo "Detected git worktree environment"
+  fi
 
-    # Run linting
-    echo "Running lint..."
-    npm run lint
-    if [ $? -ne 0 ]; then
-      echo "Lint failed. Run 'npm run lint:fix' to auto-fix issues."
+  # Check if node_modules has actual dependencies by looking for a known package
+  # @lydell/node-pty is required for terminal code and is a common source of TypeScript errors
+  # It may be in root node_modules (hoisted) or apps/frontend/node_modules
+  # Note: -d follows symlinks automatically, so this works for both real dirs and symlinks
+  # We check for the full package path (@lydell/node-pty) rather than just the namespace
+  # for precise detection - ensures the actual dependency is installed, not just any @lydell package
+  if [ ! -d "node_modules/@lydell/node-pty" ] && [ ! -d "apps/frontend/node_modules/@lydell/node-pty" ]; then
+    DEPS_AVAILABLE=false
+  fi
+
+  if [ "$DEPS_AVAILABLE" = false ]; then
+    if [ "$IS_WORKTREE" = true ]; then
+      # In worktree without dependencies - warn but allow commit
+      echo ""
+      echo "⚠️  WARNING: node_modules not available in this worktree."
+      echo "   TypeScript and lint checks will be skipped."
+      echo "   This is expected for auto-claude worktrees."
+      echo "   Full validation will occur when PR is created/merged."
+      echo ""
+    else
+      # Main repo without dependencies - this is an error
+      echo "Error: node_modules not found. Run 'npm install' first."
       exit 1
     fi
+  else
+    # Dependencies available - run full frontend checks
+    # Use subshell to isolate directory changes and prevent worktree corruption
+    (
+      cd apps/frontend
+
+      # Run lint-staged (handles staged .ts/.tsx files)
+      npm exec lint-staged
+      if [ $? -ne 0 ]; then
+        echo "lint-staged failed. Please fix linting errors before committing."
+        exit 1
+      fi
+
+      # Run TypeScript type check
+      echo "Running type check..."
+      npm run typecheck
+      if [ $? -ne 0 ]; then
+        echo "Type check failed. Please fix TypeScript errors before committing."
+        exit 1
+      fi
+
+      # Run linting
+      echo "Running lint..."
+      npm run lint
+      if [ $? -ne 0 ]; then
+        echo "Lint failed. Run 'npm run lint:fix' to auto-fix issues."
+        exit 1
+      fi
 
-    # Check for vulnerabilities (only high severity)
-    echo "Checking for vulnerabilities..."
-    npm audit --audit-level=high
+      # Check for vulnerabilities (only high severity)
+      echo "Checking for vulnerabilities..."
+      npm audit --audit-level=high
+      if [ $? -ne 0 ]; then
+        echo "High severity vulnerabilities found. Run 'npm audit fix' to resolve."
+        exit 1
+      fi
+    )
     if [ $? -ne 0 ]; then
-      echo "High severity vulnerabilities found. Run 'npm audit fix' to resolve."
       exit 1
     fi
-  )
-  if [ $? -ne 0 ]; then
-    exit 1
+    echo "Frontend checks passed!"
   fi
-  echo "Frontend checks passed!"
 fi
 
 echo "All pre-commit checks passed!"

apps/backend/core/workspace/setup.py

@@ -7,7 +7,9 @@
 """
 
 import json
+import os
 import shutil
+import subprocess
 import sys
 from pathlib import Path
 
@@ -181,6 +183,106 @@ def copy_env_files_to_worktree(project_dir: Path, worktree_path: Path) -> list[s
     return copied
 
 
+def symlink_node_modules_to_worktree(
+    project_dir: Path, worktree_path: Path
+) -> list[str]:
+    """
+    Symlink node_modules directories from project root to worktree.
+
+    This ensures the worktree has access to dependencies for TypeScript checks
+    and other tooling without requiring a separate npm install.
+
+    Works with npm workspace hoisting where dependencies are hoisted to root
+    and workspace-specific dependencies remain in nested node_modules.
+
+    Args:
+        project_dir: The main project directory
+        worktree_path: Path to the worktree
+
+    Returns:
+        List of symlinked paths (relative to worktree)
+    """
+    symlinked = []
+
+    # Node modules locations to symlink for TypeScript and tooling support.
+    # These are the standard locations for this monorepo structure.
+    #
+    # Design rationale:
+    # - Hardcoded paths are intentional for simplicity and reliability
+    # - Dynamic discovery (reading workspaces from package.json) would add complexity
+    #   and potential failure points without significant benefit
+    # - This monorepo uses npm workspaces with hoisting, so dependencies are primarily
+    #   in root node_modules with workspace-specific deps in apps/frontend/node_modules
+    #
+    # To add new workspace locations:
+    # 1. Add (source_rel, target_rel) tuple below
+    # 2. Update the parallel TypeScript implementation in
+    #    apps/frontend/src/main/ipc-handlers/terminal/worktree-handlers.ts
+    # 3. Update the pre-commit hook check in .husky/pre-commit if needed
+    node_modules_locations = [
+        ("node_modules", "node_modules"),
+        ("apps/frontend/node_modules", "apps/frontend/node_modules"),
+    ]
+
+    for source_rel, target_rel in node_modules_locations:
+        source_path = project_dir / source_rel
+        target_path = worktree_path / target_rel
+
+        # Skip if source doesn't exist
+        if not source_path.exists():
+            debug(MODULE, f"Skipping {source_rel} - source does not exist")
+            continue
+
+        # Skip if target already exists (don't overwrite existing node_modules)
+        if target_path.exists():
+            debug(MODULE, f"Skipping {target_rel} - target already exists")
+            continue
+
+        # Also skip if target is a symlink (even if broken - exists() returns False for broken symlinks)
+        if target_path.is_symlink():
+            debug(
+                MODULE,
+                f"Skipping {target_rel} - symlink already exists (possibly broken)",
+            )
+            continue
+
+        # Ensure parent directory exists
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            if sys.platform == "win32":
+                # On Windows, use junctions instead of symlinks (no admin rights required)
+                # Junctions require absolute paths
+                result = subprocess.run(
+                    ["cmd", "/c", "mklink", "/J", str(target_path), str(source_path)],
+                    capture_output=True,
+                    text=True,
+                )
+                if result.returncode != 0:
+                    raise OSError(result.stderr or "mklink /J failed")
+            else:
+                # On macOS/Linux, use relative symlinks for portability
+                relative_source = os.path.relpath(source_path, target_path.parent)
+                os.symlink(relative_source, target_path)
+            symlinked.append(target_rel)
+            debug(MODULE, f"Symlinked {target_rel} -> {source_path}")
+        except OSError as e:
+            # Symlink/junction creation can fail on some systems (e.g., FAT32 filesystem)
+            # Log warning but don't fail - worktree is still usable, just without
+            # TypeScript checking
+            debug_warning(
+                MODULE,
+                f"Could not symlink {target_rel}: {e}. TypeScript checks may fail.",
+            )
+            # Warn user - pre-commit hooks may fail without dependencies
+            print_status(
+                f"Warning: Could not link {target_rel} - TypeScript checks may fail",
+                "warning",
+            )
+
+    return symlinked
+
+
 def copy_spec_to_worktree(
     source_spec_dir: Path,
     worktree_path: Path,
@@ -268,6 +370,14 @@ def setup_workspace(
             f"Environment files copied: {', '.join(copied_env_files)}", "success"
         )
 
+    # Symlink node_modules to worktree for TypeScript and tooling support
+    # This allows pre-commit hooks to run typecheck without npm install in worktree
+    symlinked_modules = symlink_node_modules_to_worktree(
+        project_dir, worktree_info.path
+    )
+    if symlinked_modules:
+        print_status(f"Dependencies linked: {', '.join(symlinked_modules)}", "success")
+
     # Copy security configuration files if they exist
     # Note: Unlike env files, security files always overwrite to ensure
     # the worktree uses the same security rules as the main project.

apps/frontend/src/main/__tests__/ipc-handlers.test.ts

@@ -80,6 +80,18 @@ vi.mock("electron-log/main.js", () => ({
   },
 }));
 
+// Mock cli-tool-manager to avoid blocking tool detection on Windows
+vi.mock("../cli-tool-manager", () => ({
+  getToolInfo: vi.fn(() => ({ found: false, path: null, source: "mock" })),
+  getToolPath: vi.fn((tool: string) => tool),
+  deriveGitBashPath: vi.fn(() => null),
+  clearCache: vi.fn(),
+  clearToolCache: vi.fn(),
+  configureTools: vi.fn(),
+  preWarmToolCache: vi.fn(() => Promise.resolve()),
+  getToolPathAsync: vi.fn((tool: string) => Promise.resolve(tool)),
+}));
+
 // Mock modules before importing
 vi.mock("electron", () => {
   const mockIpcMain = new (class extends EventEmitter {

apps/frontend/src/main/agent/agent-process.test.ts

@@ -111,6 +111,18 @@ vi.mock('electron', () => ({
   }
 }));
 
+// Mock cli-tool-manager to avoid blocking tool detection on Windows
+vi.mock('../cli-tool-manager', () => ({
+  getToolInfo: vi.fn(() => ({ found: false, path: null, source: 'mock' })),
+  deriveGitBashPath: vi.fn(() => null),
+  clearCache: vi.fn()
+}));
+
+// Mock env-utils to avoid blocking environment augmentation
+vi.mock('../env-utils', () => ({
+  getAugmentedEnv: vi.fn(() => ({ ...process.env }))
+}));
+
 // Mock fs.existsSync for getAutoBuildSourcePath path validation
 vi.mock('fs', async (importOriginal) => {
   const actual = await importOriginal<typeof import('fs')>();