Merge pull request #703 from AutoMaker-Org/fix/false-positive-auth-warning

fix: Check Claude Code CLI auth before showing warning

SECURITY_TODO.md

@@ -1,300 +0,0 @@
-# Security Audit Findings - v0.13.0rc Branch
-
-**Date:** $(date)  
-**Audit Type:** Git diff security review against v0.13.0rc branch  
-**Status:** ⚠️ Security vulnerabilities found - requires fixes before release
-
-## Executive Summary
-
-No intentionally malicious code was detected in the changes. However, several **critical security vulnerabilities** were identified that could allow command injection attacks. These must be fixed before release.
-
----
-
-## 🔴 Critical Security Issues
-
-### 1. Command Injection in Merge Handler
-
-**File:** `apps/server/src/routes/worktree/routes/merge.ts`  
-**Lines:** 43, 54, 65-66, 93  
-**Severity:** CRITICAL
-
-**Issue:**
-User-controlled inputs (`branchName`, `mergeTo`, `options?.message`) are directly interpolated into shell commands without validation, allowing command injection attacks.
-
-**Vulnerable Code:**
-
-```typescript
-// Line 43 - branchName not validated
-await execAsync(`git rev-parse --verify ${branchName}`, { cwd: projectPath });
-
-// Line 54 - mergeTo not validated
-await execAsync(`git rev-parse --verify ${mergeTo}`, { cwd: projectPath });
-
-// Lines 65-66 - branchName and message not validated
-const mergeCmd = options?.squash
-  ? `git merge --squash ${branchName}`
-  : `git merge ${branchName} -m "${options?.message || `Merge ${branchName} into ${mergeTo}`}"`;
-
-// Line 93 - message not sanitized
-await execAsync(`git commit -m "${options?.message || `Merge ${branchName} (squash)`}"`, {
-  cwd: projectPath,
-});
-```
-
-**Attack Vector:**
-An attacker could inject shell commands via branch names or commit messages:
-
-- Branch name: `main; rm -rf /`
-- Commit message: `"; malicious_command; "`
-
-**Fix Required:**
-
-1. Validate `branchName` and `mergeTo` using `isValidBranchName()` before use
-2. Sanitize commit messages or use `execGitCommand` with proper escaping
-3. Replace `execAsync` template literals with `execGitCommand` array-based calls
-
-**Note:** `isValidBranchName` is imported but only used AFTER deletion (line 119), not before execAsync calls.
-
----
-
-### 2. Command Injection in Push Handler
-
-**File:** `apps/server/src/routes/worktree/routes/push.ts`  
-**Lines:** 44, 49  
-**Severity:** CRITICAL
-
-**Issue:**
-User-controlled `remote` parameter and `branchName` are directly interpolated into shell commands without validation.
-
-**Vulnerable Code:**
-
-```typescript
-// Line 38 - remote defaults to 'origin' but not validated
-const targetRemote = remote || 'origin';
-
-// Lines 44, 49 - targetRemote and branchName not validated
-await execAsync(`git push -u ${targetRemote} ${branchName} ${forceFlag}`, {
-  cwd: worktreePath,
-});
-await execAsync(`git push --set-upstream ${targetRemote} ${branchName} ${forceFlag}`, {
-  cwd: worktreePath,
-});
-```
-
-**Attack Vector:**
-An attacker could inject commands via the remote name:
-
-- Remote: `origin; malicious_command; #`
-
-**Fix Required:**
-
-1. Validate `targetRemote` parameter (alphanumeric + `-`, `_` only)
-2. Validate `branchName` before use (even though it comes from git output)
-3. Use `execGitCommand` with array arguments instead of template literals
-
----
-
-### 3. Unsafe Environment Variable Export in Shell Script
-
-**File:** `start-automaker.sh`  
-**Lines:** 5068, 5085  
-**Severity:** CRITICAL
-
-**Issue:**
-Unsafe parsing and export of `.env` file contents using `xargs` without proper handling of special characters.
-
-**Vulnerable Code:**
-
-```bash
-export $(grep -v '^#' .env | xargs)
-```
-
-**Attack Vector:**
-If `.env` file contains malicious content with spaces, special characters, or code, it could be executed:
-
-- `.env` entry: `VAR="value; malicious_command"`
-- Could lead to code execution during startup
-
-**Fix Required:**
-Replace with safer parsing method:
-
-```bash
-# Safer approach
-set -a
-source <(grep -v '^#' .env | sed 's/^/export /')
-set +a
-
-# Or even safer - validate each line
-while IFS= read -r line; do
-  [[ "$line" =~ ^[[:space:]]*# ]] && continue
-  [[ -z "$line" ]] && continue
-  if [[ "$line" =~ ^([A-Za-z_][A-Za-z0-9_]*)=(.*)$ ]]; then
-    export "${BASH_REMATCH[1]}"="${BASH_REMATCH[2]}"
-  fi
-done < .env
-```
-
----
-
-## 🟡 Moderate Security Concerns
-
-### 4. Inconsistent Use of Secure Command Execution
-
-**Issue:**
-The codebase has `execGitCommand()` function available (which uses array arguments and is safer), but it's not consistently used. Some places still use `execAsync` with template literals.
-
-**Files Affected:**
-
-- `apps/server/src/routes/worktree/routes/merge.ts`
-- `apps/server/src/routes/worktree/routes/push.ts`
-
-**Recommendation:**
-
-- Audit all `execAsync` calls with template literals
-- Replace with `execGitCommand` where possible
-- Document when `execAsync` is acceptable (only with fully validated inputs)
-
----
-
-### 5. Missing Input Validation
-
-**Issues:**
-
-1. `targetRemote` in `push.ts` defaults to 'origin' but isn't validated
-2. Commit messages in `merge.ts` aren't sanitized before use in shell commands
-3. `worktreePath` validation relies on middleware but should be double-checked
-
-**Recommendation:**
-
-- Add validation functions for remote names
-- Sanitize commit messages (remove shell metacharacters)
-- Add defensive validation even when middleware exists
-
----
-
-## ✅ Positive Security Findings
-
-1. **No Hardcoded Credentials:** No API keys, passwords, or tokens found in the diff
-2. **No Data Exfiltration:** No suspicious network requests or data transmission patterns
-3. **No Backdoors:** No hidden functionality or unauthorized access patterns detected
-4. **Safe Command Execution:** `execGitCommand` function properly uses array arguments in some places
-5. **Environment Variable Handling:** `init-script-service.ts` properly sanitizes environment variables (lines 194-220)
-
----
-
-## 📋 Action Items
-
-### Immediate (Before Release)
-
-- [ ] **Fix command injection in `merge.ts`**
-  - [ ] Validate `branchName` with `isValidBranchName()` before line 43
-  - [ ] Validate `mergeTo` with `isValidBranchName()` before line 54
-  - [ ] Sanitize commit messages or use `execGitCommand` for merge commands
-  - [ ] Replace `execAsync` template literals with `execGitCommand` array calls
-
-- [ ] **Fix command injection in `push.ts`**
-  - [ ] Add validation function for remote names
-  - [ ] Validate `targetRemote` before use
-  - [ ] Validate `branchName` before use (defensive programming)
-  - [ ] Replace `execAsync` template literals with `execGitCommand`
-
-- [ ] **Fix shell script security issue**
-  - [ ] Replace unsafe `export $(grep ... | xargs)` with safer parsing
-  - [ ] Add validation for `.env` file contents
-  - [ ] Test with edge cases (spaces, special chars, quotes)
-
-### Short-term (Next Sprint)
-
-- [ ] **Audit all `execAsync` calls**
-  - [ ] Create inventory of all `execAsync` calls with template literals
-  - [ ] Replace with `execGitCommand` where possible
-  - [ ] Document exceptions and why they're safe
-
-- [ ] **Add input validation utilities**
-  - [ ] Create `isValidRemoteName()` function
-  - [ ] Create `sanitizeCommitMessage()` function
-  - [ ] Add validation for all user-controlled inputs
-
-- [ ] **Security testing**
-  - [ ] Add unit tests for command injection prevention
-  - [ ] Add integration tests with malicious inputs
-  - [ ] Test shell script with malicious `.env` files
-
-### Long-term (Security Hardening)
-
-- [ ] **Code review process**
-  - [ ] Add security checklist for PR reviews
-  - [ ] Require security review for shell command execution changes
-  - [ ] Add automated security scanning
-
-- [ ] **Documentation**
-  - [ ] Document secure coding practices for shell commands
-  - [ ] Create security guidelines for contributors
-  - [ ] Add security section to CONTRIBUTING.md
-
----
-
-## 🔍 Testing Recommendations
-
-### Command Injection Tests
-
-```typescript
-// Test cases for merge.ts
-describe('merge handler security', () => {
-  it('should reject branch names with shell metacharacters', () => {
-    // Test: branchName = "main; rm -rf /"
-    // Expected: Validation error, command not executed
-  });
-
-  it('should sanitize commit messages', () => {
-    // Test: message = '"; malicious_command; "'
-    // Expected: Sanitized or rejected
-  });
-});
-
-// Test cases for push.ts
-describe('push handler security', () => {
-  it('should reject remote names with shell metacharacters', () => {
-    // Test: remote = "origin; malicious_command; #"
-    // Expected: Validation error, command not executed
-  });
-});
-```
-
-### Shell Script Tests
-
-```bash
-# Test with malicious .env content
-echo 'VAR="value; echo PWNED"' > test.env
-# Expected: Should not execute the command
-
-# Test with spaces in values
-echo 'VAR="value with spaces"' > test.env
-# Expected: Should handle correctly
-
-# Test with special characters
-echo 'VAR="value\$with\$dollars"' > test.env
-# Expected: Should handle correctly
-```
-
----
-
-## 📚 References
-
-- [OWASP Command Injection](https://owasp.org/www-community/attacks/Command_Injection)
-- [Node.js Child Process Security](https://nodejs.org/api/child_process.html#child_process_security_concerns)
-- [Shell Script Security Best Practices](https://mywiki.wooledge.org/BashGuide/Practices)
-
----
-
-## Notes
-
-- All findings are based on code diff analysis
-- No runtime testing was performed
-- Assumes attacker has access to API endpoints (authenticated or unauthenticated)
-- Fixes should be tested thoroughly before deployment
-
----
-
-**Last Updated:** $(date)  
-**Next Review:** After fixes are implemented

TODO.md

@@ -1,25 +0,0 @@
-# Bugs
-
-- Setting the default model does not seem like it works.
-
-# Performance (completed)
-
-- [x] Graph performance mode for large graphs (compact nodes/edges + visible-only rendering)
-- [x] Render containment on heavy scroll regions (kanban columns, chat history)
-- [x] Reduce blur/shadow effects when lists get large
-- [x] React Query tuning for heavy datasets (less refetch on focus/reconnect)
-- [x] DnD/list rendering optimizations (virtualized kanban + memoized card sections)
-
-# UX
-
-- Consolidate all models to a single place in the settings instead of having AI profiles and all this other stuff
-- Simplify the create feature modal. It should just be one page. I don't need nessa tabs and all these nested buttons. It's too complex.
-- added to do's list checkbox directly into the card so as it's going through if there's any to do items we can see those update live
-- When the feature is done, I want to see a summary of the LLM. That's the first thing I should see when I double click the card.
-- I went away to mass edit all my features. For example, when I created a new project, it added auto testing on every single feature card. Now I have to manually go through one by one and change those. Have a way to mass edit those, the configuration of all them.
-- Double check and debug if there's memory leaks. It seems like the memory of automaker grows like 3 gigabytes. It's 5gb right now and I'm running three different cursor cli features implementing at the same time.
-- Typing in the text area of the plan mode was super laggy.
-- When I have a bunch of features running at the same time, it seems like I cannot edit the features in the backlog. Like they don't persist their file changes and I think this is because of the secure FS file has an internal queue to prevent hitting that file open write limit. We may have to reconsider refactoring away from file system and do Postgres or SQLite or something.
-- modals are not scrollable if height of the screen is small enough
-- and the Agent Runner add an archival button for the new sessions.
-- investigate a potential issue with the feature cards not refreshing. I see a lock icon on the feature card But it doesn't go away until I open the card and edit it and I turn the testing mode off. I think there's like a refresh sync issue.

apps/server/src/index.ts

@@ -16,7 +16,7 @@ import { createServer } from 'http';
 import dotenv from 'dotenv';
 
 import { createEventEmitter, type EventEmitter } from './lib/events.js';
-import { initAllowedPaths } from '@automaker/platform';
+import { initAllowedPaths, getClaudeAuthIndicators } from '@automaker/platform';
 import { createLogger, setLogLevel, LogLevel } from '@automaker/utils';
 
 const logger = createLogger('Server');
@@ -117,15 +117,44 @@ export function isRequestLoggingEnabled(): boolean {
 // Width for log box content (excluding borders)
 const BOX_CONTENT_WIDTH = 67;
 
-// Check for required environment variables
-const hasAnthropicKey = !!process.env.ANTHROPIC_API_KEY;
+// Check for Claude authentication (async - runs in background)
+// The Claude Agent SDK can use either ANTHROPIC_API_KEY or Claude Code CLI authentication
+(async () => {
+  const hasAnthropicKey = !!process.env.ANTHROPIC_API_KEY;
 
-if (!hasAnthropicKey) {
+  if (hasAnthropicKey) {
+    logger.info('✓ ANTHROPIC_API_KEY detected');
+    return;
+  }
+
+  // Check for Claude Code CLI authentication
+  try {
+    const indicators = await getClaudeAuthIndicators();
+    const hasCliAuth =
+      indicators.hasStatsCacheWithActivity ||
+      (indicators.hasSettingsFile && indicators.hasProjectsSessions) ||
+      (indicators.hasCredentialsFile &&
+        (indicators.credentials?.hasOAuthToken || indicators.credentials?.hasApiKey));
+
+    if (hasCliAuth) {
+      logger.info('✓ Claude Code CLI authentication detected');
+      return;
+    }
+  } catch (error) {
+    // Ignore errors checking CLI auth - will fall through to warning
+    logger.warn('Error checking for Claude Code CLI authentication:', error);
+  }
+
+  // No authentication found - show warning
   const wHeader = '⚠️  WARNING: No Claude authentication configured'.padEnd(BOX_CONTENT_WIDTH);
   const w1 = 'The Claude Agent SDK requires authentication to function.'.padEnd(BOX_CONTENT_WIDTH);
-  const w2 = 'Set your Anthropic API key:'.padEnd(BOX_CONTENT_WIDTH);
-  const w3 = '  export ANTHROPIC_API_KEY="sk-ant-..."'.padEnd(BOX_CONTENT_WIDTH);
-  const w4 = 'Or use the setup wizard in Settings to configure authentication.'.padEnd(
+  const w2 = 'Options:'.padEnd(BOX_CONTENT_WIDTH);
+  const w3 = '1. Install Claude Code CLI and authenticate with subscription'.padEnd(
+    BOX_CONTENT_WIDTH
+  );
+  const w4 = '2. Set your Anthropic API key:'.padEnd(BOX_CONTENT_WIDTH);
+  const w5 = '   export ANTHROPIC_API_KEY="sk-ant-..."'.padEnd(BOX_CONTENT_WIDTH);
+  const w6 = '3. Use the setup wizard in Settings to configure authentication.'.padEnd(
     BOX_CONTENT_WIDTH
   );
 
@@ -138,14 +167,13 @@ if (!hasAnthropicKey) {
 ║                                                                     ║
 ║  ${w2}║
 ║  ${w3}║
-║                                                                     ║
 ║  ${w4}║
+║  ${w5}║
+║  ${w6}║
 ║                                                                     ║
 ╚═════════════════════════════════════════════════════════════════════╝
 `);
-} else {
-  logger.info('✓ ANTHROPIC_API_KEY detected');
-}
+})();
 
 // Initialize security
 initAllowedPaths();
@@ -326,7 +354,10 @@ app.get('/api/health/detailed', createDetailedHandler());
 app.use('/api/fs', createFsRoutes(events));
 app.use('/api/agent', createAgentRoutes(agentService, events));
 app.use('/api/sessions', createSessionsRoutes(agentService));
-app.use('/api/features', createFeaturesRoutes(featureLoader, settingsService, events));
+app.use(
+  '/api/features',
+  createFeaturesRoutes(featureLoader, settingsService, events, autoModeService)
+);
 app.use('/api/auto-mode', createAutoModeRoutes(autoModeService));
 app.use('/api/enhance-prompt', createEnhancePromptRoutes(settingsService));
 app.use('/api/worktree', createWorktreeRoutes(events, settingsService));
@@ -769,21 +800,36 @@ process.on('uncaughtException', (error: Error) => {
   process.exit(1);
 });
 
-// Graceful shutdown
-process.on('SIGTERM', () => {
-  logger.info('SIGTERM received, shutting down...');
+// Graceful shutdown timeout (30 seconds)
+const SHUTDOWN_TIMEOUT_MS = 30000;
+
+// Graceful shutdown helper
+const gracefulShutdown = async (signal: string) => {
+  logger.info(`${signal} received, shutting down...`);
+
+  // Set up a force-exit timeout to prevent hanging
+  const forceExitTimeout = setTimeout(() => {
+    logger.error(`Shutdown timed out after ${SHUTDOWN_TIMEOUT_MS}ms, forcing exit`);
+    process.exit(1);
+  }, SHUTDOWN_TIMEOUT_MS);
+
+  // Mark all running features as interrupted before shutdown
+  // This ensures they can be resumed when the server restarts
+  // Note: markAllRunningFeaturesInterrupted handles errors internally and never rejects
+  await autoModeService.markAllRunningFeaturesInterrupted(`${signal} signal received`);
+
   terminalService.cleanup();
   server.close(() => {
+    clearTimeout(forceExitTimeout);
     logger.info('Server closed');
     process.exit(0);
   });
+};
+
+process.on('SIGTERM', () => {
+  gracefulShutdown('SIGTERM');
 });
 
 process.on('SIGINT', () => {
-  logger.info('SIGINT received, shutting down...');
-  terminalService.cleanup();
-  server.close(() => {
-    logger.info('Server closed');
-    process.exit(0);
-  });
+  gracefulShutdown('SIGINT');
 });

apps/server/src/routes/features/index.ts

@@ -5,6 +5,7 @@
 import { Router } from 'express';
 import { FeatureLoader } from '../../services/feature-loader.js';
 import type { SettingsService } from '../../services/settings-service.js';
+import type { AutoModeService } from '../../services/auto-mode-service.js';
 import type { EventEmitter } from '../../lib/events.js';
 import { validatePathParams } from '../../middleware/validate-paths.js';
 import { createListHandler } from './routes/list.js';
@@ -22,11 +23,16 @@ import { createImportHandler, createConflictCheckHandler } from './routes/import
 export function createFeaturesRoutes(
   featureLoader: FeatureLoader,
   settingsService?: SettingsService,
-  events?: EventEmitter
+  events?: EventEmitter,
+  autoModeService?: AutoModeService
 ): Router {
   const router = Router();
 
-  router.post('/list', validatePathParams('projectPath'), createListHandler(featureLoader));
+  router.post(
+    '/list',
+    validatePathParams('projectPath'),
+    createListHandler(featureLoader, autoModeService)
+  );
   router.post('/get', validatePathParams('projectPath'), createGetHandler(featureLoader));
   router.post(
     '/create',

apps/server/src/routes/features/routes/list.ts

@@ -1,12 +1,19 @@
 /**
  * POST /list endpoint - List all features for a project
+ *
+ * Also performs orphan detection when a project is loaded to identify
+ * features whose branches no longer exist. This runs on every project load/switch.
  */
 
 import type { Request, Response } from 'express';
 import { FeatureLoader } from '../../../services/feature-loader.js';
+import type { AutoModeService } from '../../../services/auto-mode-service.js';
 import { getErrorMessage, logError } from '../common.js';
+import { createLogger } from '@automaker/utils';
 
-export function createListHandler(featureLoader: FeatureLoader) {
+const logger = createLogger('FeaturesListRoute');
+
+export function createListHandler(featureLoader: FeatureLoader, autoModeService?: AutoModeService) {
   return async (req: Request, res: Response): Promise<void> => {
     try {
       const { projectPath } = req.body as { projectPath: string };
@@ -17,6 +24,26 @@ export function createListHandler(featureLoader: FeatureLoader) {
       }
 
       const features = await featureLoader.getAll(projectPath);
+
+      // Run orphan detection in background when project is loaded
+      // This detects features whose branches no longer exist (e.g., after merge/delete)
+      // We don't await this to keep the list response fast
+      // Note: detectOrphanedFeatures handles errors internally and always resolves
+      if (autoModeService) {
+        autoModeService.detectOrphanedFeatures(projectPath).then((orphanedFeatures) => {
+          if (orphanedFeatures.length > 0) {
+            logger.info(
+              `[ProjectLoad] Detected ${orphanedFeatures.length} orphaned feature(s) in ${projectPath}`
+            );
+            for (const { feature, missingBranch } of orphanedFeatures) {
+              logger.info(
+                `[ProjectLoad] Orphaned: ${feature.title || feature.id} - branch "${missingBranch}" no longer exists`
+              );
+            }
+          }
+        });
+      }
+
       res.json({ success: true, features });
     } catch (error) {
       logError(error, 'List features failed');

apps/server/tests/unit/services/auto-mode-service.test.ts

@@ -315,4 +315,531 @@ describe('auto-mode-service.ts', () => {
       expect(duration).toBeLessThan(40);
     });
   });
+
+  describe('detectOrphanedFeatures', () => {
+    // Helper to mock featureLoader.getAll
+    const mockFeatureLoaderGetAll = (svc: AutoModeService, mockFn: ReturnType<typeof vi.fn>) => {
+      (svc as any).featureLoader = { getAll: mockFn };
+    };
+
+    // Helper to mock getExistingBranches
+    const mockGetExistingBranches = (svc: AutoModeService, branches: string[]) => {
+      (svc as any).getExistingBranches = vi.fn().mockResolvedValue(new Set(branches));
+    };
+
+    it('should return empty array when no features have branch names', async () => {
+      const getAllMock = vi.fn().mockResolvedValue([
+        { id: 'f1', title: 'Feature 1', description: 'desc', category: 'test' },
+        { id: 'f2', title: 'Feature 2', description: 'desc', category: 'test' },
+      ] satisfies Feature[]);
+      mockFeatureLoaderGetAll(service, getAllMock);
+      mockGetExistingBranches(service, ['main', 'develop']);
+
+      const result = await service.detectOrphanedFeatures('/test/project');
+
+      expect(result).toEqual([]);
+    });
+
+    it('should return empty array when all feature branches exist', async () => {
+      const getAllMock = vi.fn().mockResolvedValue([
+        {
+          id: 'f1',
+          title: 'Feature 1',
+          description: 'desc',
+          category: 'test',
+          branchName: 'feature-1',
+        },
+        {
+          id: 'f2',
+          title: 'Feature 2',
+          description: 'desc',
+          category: 'test',
+          branchName: 'feature-2',
+        },
+      ] satisfies Feature[]);
+      mockFeatureLoaderGetAll(service, getAllMock);
+      mockGetExistingBranches(service, ['main', 'feature-1', 'feature-2']);
+
+      const result = await service.detectOrphanedFeatures('/test/project');
+
+      expect(result).toEqual([]);
+    });
+
+    it('should detect orphaned features with missing branches', async () => {
+      const features: Feature[] = [
+        {
+          id: 'f1',
+          title: 'Feature 1',
+          description: 'desc',
+          category: 'test',
+          branchName: 'feature-1',
+        },
+        {
+          id: 'f2',
+          title: 'Feature 2',
+          description: 'desc',
+          category: 'test',
+          branchName: 'deleted-branch',
+        },
+        { id: 'f3', title: 'Feature 3', description: 'desc', category: 'test' }, // No branch
+      ];
+      const getAllMock = vi.fn().mockResolvedValue(features);
+      mockFeatureLoaderGetAll(service, getAllMock);
+      mockGetExistingBranches(service, ['main', 'feature-1']); // deleted-branch not in list
+
+      const result = await service.detectOrphanedFeatures('/test/project');
+
+      expect(result).toHaveLength(1);
+      expect(result[0].feature.id).toBe('f2');
+      expect(result[0].missingBranch).toBe('deleted-branch');
+    });
+
+    it('should detect multiple orphaned features', async () => {
+      const features: Feature[] = [
+        {
+          id: 'f1',
+          title: 'Feature 1',
+          description: 'desc',
+          category: 'test',
+          branchName: 'orphan-1',
+        },
+        {
+          id: 'f2',
+          title: 'Feature 2',
+          description: 'desc',
+          category: 'test',
+          branchName: 'orphan-2',
+        },
+        {
+          id: 'f3',
+          title: 'Feature 3',
+          description: 'desc',
+          category: 'test',
+          branchName: 'valid-branch',
+        },
+      ];
+      const getAllMock = vi.fn().mockResolvedValue(features);
+      mockFeatureLoaderGetAll(service, getAllMock);
+      mockGetExistingBranches(service, ['main', 'valid-branch']);
+
+      const result = await service.detectOrphanedFeatures('/test/project');
+
+      expect(result).toHaveLength(2);
+      expect(result.map((r) => r.feature.id)).toContain('f1');
+      expect(result.map((r) => r.feature.id)).toContain('f2');
+    });
+
+    it('should return empty array when getAll throws error', async () => {
+      const getAllMock = vi.fn().mockRejectedValue(new Error('Failed to load features'));
+      mockFeatureLoaderGetAll(service, getAllMock);
+
+      const result = await service.detectOrphanedFeatures('/test/project');
+
+      expect(result).toEqual([]);
+    });
+
+    it('should ignore empty branchName strings', async () => {
+      const features: Feature[] = [
+        { id: 'f1', title: 'Feature 1', description: 'desc', category: 'test', branchName: '' },
+        { id: 'f2', title: 'Feature 2', description: 'desc', category: 'test', branchName: '   ' },
+      ];
+      const getAllMock = vi.fn().mockResolvedValue(features);
+      mockFeatureLoaderGetAll(service, getAllMock);
+      mockGetExistingBranches(service, ['main']);
+
+      const result = await service.detectOrphanedFeatures('/test/project');
+
+      expect(result).toEqual([]);
+    });
+
+    it('should skip features whose branchName matches the primary branch', async () => {
+      const features: Feature[] = [
+        { id: 'f1', title: 'Feature 1', description: 'desc', category: 'test', branchName: 'main' },
+        {
+          id: 'f2',
+          title: 'Feature 2',
+          description: 'desc',
+          category: 'test',
+          branchName: 'orphaned',
+        },
+      ];
+      const getAllMock = vi.fn().mockResolvedValue(features);
+      mockFeatureLoaderGetAll(service, getAllMock);
+      mockGetExistingBranches(service, ['main', 'develop']);
+      // Mock getCurrentBranch to return 'main'
+      (service as any).getCurrentBranch = vi.fn().mockResolvedValue('main');
+
+      const result = await service.detectOrphanedFeatures('/test/project');
+
+      // Only f2 should be orphaned (orphaned branch doesn't exist)
+      expect(result).toHaveLength(1);
+      expect(result[0].feature.id).toBe('f2');
+    });
+  });
+
+  describe('markFeatureInterrupted', () => {
+    // Helper to mock updateFeatureStatus
+    const mockUpdateFeatureStatus = (svc: AutoModeService, mockFn: ReturnType<typeof vi.fn>) => {
+      (svc as any).updateFeatureStatus = mockFn;
+    };
+
+    // Helper to mock loadFeature
+    const mockLoadFeature = (svc: AutoModeService, mockFn: ReturnType<typeof vi.fn>) => {
+      (svc as any).loadFeature = mockFn;
+    };
+
+    it('should call updateFeatureStatus with interrupted status for non-pipeline features', async () => {
+      const loadMock = vi.fn().mockResolvedValue({ id: 'feature-123', status: 'in_progress' });
+      const updateMock = vi.fn().mockResolvedValue(undefined);
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await service.markFeatureInterrupted('/test/project', 'feature-123');
+
+      expect(updateMock).toHaveBeenCalledWith('/test/project', 'feature-123', 'interrupted');
+    });
+
+    it('should call updateFeatureStatus with reason when provided', async () => {
+      const loadMock = vi.fn().mockResolvedValue({ id: 'feature-123', status: 'in_progress' });
+      const updateMock = vi.fn().mockResolvedValue(undefined);
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await service.markFeatureInterrupted('/test/project', 'feature-123', 'server shutdown');
+
+      expect(updateMock).toHaveBeenCalledWith('/test/project', 'feature-123', 'interrupted');
+    });
+
+    it('should propagate errors from updateFeatureStatus', async () => {
+      const loadMock = vi.fn().mockResolvedValue({ id: 'feature-123', status: 'in_progress' });
+      const updateMock = vi.fn().mockRejectedValue(new Error('Update failed'));
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await expect(service.markFeatureInterrupted('/test/project', 'feature-123')).rejects.toThrow(
+        'Update failed'
+      );
+    });
+
+    it('should preserve pipeline_implementation status instead of marking as interrupted', async () => {
+      const loadMock = vi
+        .fn()
+        .mockResolvedValue({ id: 'feature-123', status: 'pipeline_implementation' });
+      const updateMock = vi.fn().mockResolvedValue(undefined);
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await service.markFeatureInterrupted('/test/project', 'feature-123', 'server shutdown');
+
+      // updateFeatureStatus should NOT be called for pipeline statuses
+      expect(updateMock).not.toHaveBeenCalled();
+    });
+
+    it('should preserve pipeline_testing status instead of marking as interrupted', async () => {
+      const loadMock = vi.fn().mockResolvedValue({ id: 'feature-123', status: 'pipeline_testing' });
+      const updateMock = vi.fn().mockResolvedValue(undefined);
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await service.markFeatureInterrupted('/test/project', 'feature-123');
+
+      expect(updateMock).not.toHaveBeenCalled();
+    });
+
+    it('should preserve pipeline_review status instead of marking as interrupted', async () => {
+      const loadMock = vi.fn().mockResolvedValue({ id: 'feature-123', status: 'pipeline_review' });
+      const updateMock = vi.fn().mockResolvedValue(undefined);
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await service.markFeatureInterrupted('/test/project', 'feature-123');
+
+      expect(updateMock).not.toHaveBeenCalled();
+    });
+
+    it('should mark feature as interrupted when loadFeature returns null', async () => {
+      const loadMock = vi.fn().mockResolvedValue(null);
+      const updateMock = vi.fn().mockResolvedValue(undefined);
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await service.markFeatureInterrupted('/test/project', 'feature-123');
+
+      expect(updateMock).toHaveBeenCalledWith('/test/project', 'feature-123', 'interrupted');
+    });
+
+    it('should mark feature as interrupted for pending status', async () => {
+      const loadMock = vi.fn().mockResolvedValue({ id: 'feature-123', status: 'pending' });
+      const updateMock = vi.fn().mockResolvedValue(undefined);
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await service.markFeatureInterrupted('/test/project', 'feature-123');
+
+      expect(updateMock).toHaveBeenCalledWith('/test/project', 'feature-123', 'interrupted');
+    });
+  });
+
+  describe('markAllRunningFeaturesInterrupted', () => {
+    // Helper to access private runningFeatures Map
+    const getRunningFeaturesMap = (svc: AutoModeService) =>
+      (svc as any).runningFeatures as Map<
+        string,
+        { featureId: string; projectPath: string; isAutoMode: boolean }
+      >;
+
+    // Helper to mock updateFeatureStatus
+    const mockUpdateFeatureStatus = (svc: AutoModeService, mockFn: ReturnType<typeof vi.fn>) => {
+      (svc as any).updateFeatureStatus = mockFn;
+    };
+
+    // Helper to mock loadFeature
+    const mockLoadFeature = (svc: AutoModeService, mockFn: ReturnType<typeof vi.fn>) => {
+      (svc as any).loadFeature = mockFn;
+    };
+
+    it('should do nothing when no features are running', async () => {
+      const updateMock = vi.fn().mockResolvedValue(undefined);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await service.markAllRunningFeaturesInterrupted();
+
+      expect(updateMock).not.toHaveBeenCalled();
+    });
+
+    it('should mark a single running feature as interrupted', async () => {
+      const runningFeaturesMap = getRunningFeaturesMap(service);
+      runningFeaturesMap.set('feature-1', {
+        featureId: 'feature-1',
+        projectPath: '/project/path',
+        isAutoMode: true,
+      });
+
+      const loadMock = vi.fn().mockResolvedValue({ id: 'feature-1', status: 'in_progress' });
+      const updateMock = vi.fn().mockResolvedValue(undefined);
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await service.markAllRunningFeaturesInterrupted();
+
+      expect(updateMock).toHaveBeenCalledWith('/project/path', 'feature-1', 'interrupted');
+    });
+
+    it('should mark multiple running features as interrupted', async () => {
+      const runningFeaturesMap = getRunningFeaturesMap(service);
+      runningFeaturesMap.set('feature-1', {
+        featureId: 'feature-1',
+        projectPath: '/project-a',
+        isAutoMode: true,
+      });
+      runningFeaturesMap.set('feature-2', {
+        featureId: 'feature-2',
+        projectPath: '/project-b',
+        isAutoMode: false,
+      });
+      runningFeaturesMap.set('feature-3', {
+        featureId: 'feature-3',
+        projectPath: '/project-a',
+        isAutoMode: true,
+      });
+
+      const loadMock = vi.fn().mockResolvedValue({ status: 'in_progress' });
+      const updateMock = vi.fn().mockResolvedValue(undefined);
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await service.markAllRunningFeaturesInterrupted();
+
+      expect(updateMock).toHaveBeenCalledTimes(3);
+      expect(updateMock).toHaveBeenCalledWith('/project-a', 'feature-1', 'interrupted');
+      expect(updateMock).toHaveBeenCalledWith('/project-b', 'feature-2', 'interrupted');
+      expect(updateMock).toHaveBeenCalledWith('/project-a', 'feature-3', 'interrupted');
+    });
+
+    it('should mark features in parallel', async () => {
+      const runningFeaturesMap = getRunningFeaturesMap(service);
+      for (let i = 1; i <= 5; i++) {
+        runningFeaturesMap.set(`feature-${i}`, {
+          featureId: `feature-${i}`,
+          projectPath: `/project-${i}`,
+          isAutoMode: true,
+        });
+      }
+
+      const loadMock = vi.fn().mockResolvedValue({ status: 'in_progress' });
+      const callOrder: string[] = [];
+      const updateMock = vi.fn().mockImplementation(async (_path: string, featureId: string) => {
+        callOrder.push(featureId);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      });
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      const startTime = Date.now();
+      await service.markAllRunningFeaturesInterrupted();
+      const duration = Date.now() - startTime;
+
+      expect(updateMock).toHaveBeenCalledTimes(5);
+      // If executed in parallel, total time should be ~10ms
+      // If sequential, it would be ~50ms (5 * 10ms)
+      expect(duration).toBeLessThan(40);
+    });
+
+    it('should continue marking other features when one fails', async () => {
+      const runningFeaturesMap = getRunningFeaturesMap(service);
+      runningFeaturesMap.set('feature-1', {
+        featureId: 'feature-1',
+        projectPath: '/project-a',
+        isAutoMode: true,
+      });
+      runningFeaturesMap.set('feature-2', {
+        featureId: 'feature-2',
+        projectPath: '/project-b',
+        isAutoMode: false,
+      });
+
+      const loadMock = vi.fn().mockResolvedValue({ status: 'in_progress' });
+      const updateMock = vi
+        .fn()
+        .mockResolvedValueOnce(undefined)
+        .mockRejectedValueOnce(new Error('Failed to update'));
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      // Should not throw even though one feature failed
+      await expect(service.markAllRunningFeaturesInterrupted()).resolves.not.toThrow();
+
+      expect(updateMock).toHaveBeenCalledTimes(2);
+    });
+
+    it('should use provided reason in logging', async () => {
+      const runningFeaturesMap = getRunningFeaturesMap(service);
+      runningFeaturesMap.set('feature-1', {
+        featureId: 'feature-1',
+        projectPath: '/project/path',
+        isAutoMode: true,
+      });
+
+      const loadMock = vi.fn().mockResolvedValue({ id: 'feature-1', status: 'in_progress' });
+      const updateMock = vi.fn().mockResolvedValue(undefined);
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await service.markAllRunningFeaturesInterrupted('manual stop');
+
+      expect(updateMock).toHaveBeenCalledWith('/project/path', 'feature-1', 'interrupted');
+    });
+
+    it('should use default reason when none provided', async () => {
+      const runningFeaturesMap = getRunningFeaturesMap(service);
+      runningFeaturesMap.set('feature-1', {
+        featureId: 'feature-1',
+        projectPath: '/project/path',
+        isAutoMode: true,
+      });
+
+      const loadMock = vi.fn().mockResolvedValue({ id: 'feature-1', status: 'in_progress' });
+      const updateMock = vi.fn().mockResolvedValue(undefined);
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await service.markAllRunningFeaturesInterrupted();
+
+      expect(updateMock).toHaveBeenCalledWith('/project/path', 'feature-1', 'interrupted');
+    });
+
+    it('should preserve pipeline statuses for running features', async () => {
+      const runningFeaturesMap = getRunningFeaturesMap(service);
+      runningFeaturesMap.set('feature-1', {
+        featureId: 'feature-1',
+        projectPath: '/project-a',
+        isAutoMode: true,
+      });
+      runningFeaturesMap.set('feature-2', {
+        featureId: 'feature-2',
+        projectPath: '/project-b',
+        isAutoMode: false,
+      });
+      runningFeaturesMap.set('feature-3', {
+        featureId: 'feature-3',
+        projectPath: '/project-c',
+        isAutoMode: true,
+      });
+
+      // feature-1 has in_progress (should be interrupted)
+      // feature-2 has pipeline_testing (should be preserved)
+      // feature-3 has pipeline_implementation (should be preserved)
+      const loadMock = vi
+        .fn()
+        .mockImplementation(async (_projectPath: string, featureId: string) => {
+          if (featureId === 'feature-1') return { id: 'feature-1', status: 'in_progress' };
+          if (featureId === 'feature-2') return { id: 'feature-2', status: 'pipeline_testing' };
+          if (featureId === 'feature-3')
+            return { id: 'feature-3', status: 'pipeline_implementation' };
+          return null;
+        });
+      const updateMock = vi.fn().mockResolvedValue(undefined);
+      mockLoadFeature(service, loadMock);
+      mockUpdateFeatureStatus(service, updateMock);
+
+      await service.markAllRunningFeaturesInterrupted();
+
+      // Only feature-1 should be marked as interrupted
+      expect(updateMock).toHaveBeenCalledTimes(1);
+      expect(updateMock).toHaveBeenCalledWith('/project-a', 'feature-1', 'interrupted');
+    });
+  });
+
+  describe('isFeatureRunning', () => {
+    // Helper to access private runningFeatures Map
+    const getRunningFeaturesMap = (svc: AutoModeService) =>
+      (svc as any).runningFeatures as Map<
+        string,
+        { featureId: string; projectPath: string; isAutoMode: boolean }
+      >;
+
+    it('should return false when no features are running', () => {
+      expect(service.isFeatureRunning('feature-123')).toBe(false);
+    });
+
+    it('should return true when the feature is running', () => {
+      const runningFeaturesMap = getRunningFeaturesMap(service);
+      runningFeaturesMap.set('feature-123', {
+        featureId: 'feature-123',
+        projectPath: '/project/path',
+        isAutoMode: true,
+      });
+
+      expect(service.isFeatureRunning('feature-123')).toBe(true);
+    });
+
+    it('should return false for non-running feature when others are running', () => {
+      const runningFeaturesMap = getRunningFeaturesMap(service);
+      runningFeaturesMap.set('feature-other', {
+        featureId: 'feature-other',
+        projectPath: '/project/path',
+        isAutoMode: true,
+      });
+
+      expect(service.isFeatureRunning('feature-123')).toBe(false);
+    });
+
+    it('should correctly track multiple running features', () => {
+      const runningFeaturesMap = getRunningFeaturesMap(service);
+      runningFeaturesMap.set('feature-1', {
+        featureId: 'feature-1',
+        projectPath: '/project-a',
+        isAutoMode: true,
+      });
+      runningFeaturesMap.set('feature-2', {
+        featureId: 'feature-2',
+        projectPath: '/project-b',
+        isAutoMode: false,
+      });
+
+      expect(service.isFeatureRunning('feature-1')).toBe(true);
+      expect(service.isFeatureRunning('feature-2')).toBe(true);
+      expect(service.isFeatureRunning('feature-3')).toBe(false);
+    });
+  });
 });

apps/server/tests/unit/services/auto-mode-task-parsing.test.ts

@@ -1,18 +1,11 @@
 import { describe, it, expect } from 'vitest';
+import type { ParsedTask } from '@automaker/types';
 
 /**
  * Test the task parsing logic by reimplementing the parsing functions
  * These mirror the logic in auto-mode-service.ts parseTasksFromSpec and parseTaskLine
  */
 
-interface ParsedTask {
-  id: string;
-  description: string;
-  filePath?: string;
-  phase?: string;
-  status: 'pending' | 'in_progress' | 'completed';
-}
-
 function parseTaskLine(line: string, currentPhase?: string): ParsedTask | null {
   // Match pattern: - [ ] T###: Description | File: path
   const taskMatch = line.match(/- \[ \] (T\d{3}):\s*([^|]+)(?:\|\s*File:\s*(.+))?$/);
@@ -342,4 +335,236 @@ Some other text
       expect(fullModeOutput).toContain('[SPEC_GENERATED]');
     });
   });
+
+  describe('detectSpecFallback - non-Claude model support', () => {
+    /**
+     * Reimplementation of detectSpecFallback for testing
+     * This mirrors the logic in auto-mode-service.ts for detecting specs
+     * when the [SPEC_GENERATED] marker is missing (common with non-Claude models)
+     */
+    function detectSpecFallback(text: string): boolean {
+      // Check for key structural elements of a spec
+      const hasTasksBlock = /```tasks[\s\S]*```/.test(text);
+      const hasTaskLines = /- \[ \] T\d{3}:/.test(text);
+
+      // Check for common spec sections (case-insensitive)
+      const hasAcceptanceCriteria = /acceptance criteria/i.test(text);
+      const hasTechnicalContext = /technical context/i.test(text);
+      const hasProblemStatement = /problem statement/i.test(text);
+      const hasUserStory = /user story/i.test(text);
+      // Additional patterns for different model outputs
+      const hasGoal = /\*\*Goal\*\*:/i.test(text);
+      const hasSolution = /\*\*Solution\*\*:/i.test(text);
+      const hasImplementation = /implementation\s*(plan|steps|approach)/i.test(text);
+      const hasOverview = /##\s*(overview|summary)/i.test(text);
+
+      // Spec is detected if we have task structure AND at least some spec content
+      const hasTaskStructure = hasTasksBlock || hasTaskLines;
+      const hasSpecContent =
+        hasAcceptanceCriteria ||
+        hasTechnicalContext ||
+        hasProblemStatement ||
+        hasUserStory ||
+        hasGoal ||
+        hasSolution ||
+        hasImplementation ||
+        hasOverview;
+
+      return hasTaskStructure && hasSpecContent;
+    }
+
+    it('should detect spec with tasks block and acceptance criteria', () => {
+      const content = `
+## Acceptance Criteria
+- GIVEN a user, WHEN they login, THEN they see the dashboard
+
+\`\`\`tasks
+- [ ] T001: Create login form | File: src/Login.tsx
+\`\`\`
+`;
+      expect(detectSpecFallback(content)).toBe(true);
+    });
+
+    it('should detect spec with task lines and problem statement', () => {
+      const content = `
+## Problem Statement
+Users cannot currently log in to the application.
+
+## Implementation Plan
+- [ ] T001: Add authentication endpoint
+- [ ] T002: Create login UI
+`;
+      expect(detectSpecFallback(content)).toBe(true);
+    });
+
+    it('should detect spec with Goal section (lite planning mode style)', () => {
+      const content = `
+**Goal**: Implement user authentication
+
+**Solution**: Use JWT tokens for session management
+
+- [ ] T001: Setup auth middleware
+- [ ] T002: Create token service
+`;
+      expect(detectSpecFallback(content)).toBe(true);
+    });
+
+    it('should detect spec with User Story format', () => {
+      const content = `
+## User Story
+As a user, I want to reset my password, so that I can regain access.
+
+## Technical Context
+This will modify the auth module.
+
+\`\`\`tasks
+- [ ] T001: Add reset endpoint
+\`\`\`
+`;
+      expect(detectSpecFallback(content)).toBe(true);
+    });
+
+    it('should detect spec with Overview section', () => {
+      const content = `
+## Overview
+This feature adds dark mode support.
+
+\`\`\`tasks
+- [ ] T001: Add theme toggle
+- [ ] T002: Update CSS variables
+\`\`\`
+`;
+      expect(detectSpecFallback(content)).toBe(true);
+    });
+
+    it('should detect spec with Summary section', () => {
+      const content = `
+## Summary
+Adding a new dashboard component.
+
+- [ ] T001: Create dashboard layout
+- [ ] T002: Add widgets
+`;
+      expect(detectSpecFallback(content)).toBe(true);
+    });
+
+    it('should detect spec with implementation plan', () => {
+      const content = `
+## Implementation Plan
+We will add the feature in two phases.
+
+- [ ] T001: Phase 1 setup
+- [ ] T002: Phase 2 implementation
+`;
+      expect(detectSpecFallback(content)).toBe(true);
+    });
+
+    it('should detect spec with implementation steps', () => {
+      const content = `
+## Implementation Steps
+Follow these steps:
+
+- [ ] T001: Step one
+- [ ] T002: Step two
+`;
+      expect(detectSpecFallback(content)).toBe(true);
+    });
+
+    it('should detect spec with implementation approach', () => {
+      const content = `
+## Implementation Approach
+We will use a modular approach.
+
+- [ ] T001: Create modules
+`;
+      expect(detectSpecFallback(content)).toBe(true);
+    });
+
+    it('should NOT detect spec without task structure', () => {
+      const content = `
+## Problem Statement
+Users cannot log in.
+
+## Acceptance Criteria
+- GIVEN a user, WHEN they try to login, THEN it works
+`;
+      expect(detectSpecFallback(content)).toBe(false);
+    });
+
+    it('should NOT detect spec without spec content sections', () => {
+      const content = `
+Here are some tasks:
+
+- [ ] T001: Do something
+- [ ] T002: Do another thing
+`;
+      expect(detectSpecFallback(content)).toBe(false);
+    });
+
+    it('should NOT detect random text as spec', () => {
+      const content = 'Just some random text without any structure';
+      expect(detectSpecFallback(content)).toBe(false);
+    });
+
+    it('should handle case-insensitive matching for spec sections', () => {
+      const content = `
+## ACCEPTANCE CRITERIA
+All caps section header
+
+- [ ] T001: Task
+`;
+      expect(detectSpecFallback(content)).toBe(true);
+
+      const content2 = `
+## acceptance criteria
+Lower case section header
+
+- [ ] T001: Task
+`;
+      expect(detectSpecFallback(content2)).toBe(true);
+    });
+
+    it('should detect OpenAI-style output without explicit marker', () => {
+      // Non-Claude models may format specs differently but still have the key elements
+      const openAIStyleOutput = `
+# Feature Specification: User Authentication
+
+**Goal**: Allow users to securely log into the application
+
+**Solution**: Implement JWT-based authentication with refresh tokens
+
+## Acceptance Criteria
+1. Users can log in with email and password
+2. Invalid credentials show error message
+3. Sessions persist across page refreshes
+
+## Implementation Tasks
+\`\`\`tasks
+- [ ] T001: Create auth service | File: src/services/auth.ts
+- [ ] T002: Build login component | File: src/components/Login.tsx
+- [ ] T003: Add protected routes | File: src/App.tsx
+\`\`\`
+`;
+      expect(detectSpecFallback(openAIStyleOutput)).toBe(true);
+    });
+
+    it('should detect Gemini-style output without explicit marker', () => {
+      const geminiStyleOutput = `
+## Overview
+
+This specification describes the implementation of a user profile page.
+
+## Technical Context
+- Framework: React
+- State: Redux
+
+## Tasks
+
+- [ ] T001: Create ProfilePage component
+- [ ] T002: Add profile API endpoint
+- [ ] T003: Style the profile page
+`;
+      expect(detectSpecFallback(geminiStyleOutput)).toBe(true);
+    });
+  });
 });

apps/ui/eslint.config.mjs

@@ -14,8 +14,13 @@ const eslintConfig = defineConfig([
         require: 'readonly',
         __dirname: 'readonly',
         __filename: 'readonly',
+        setTimeout: 'readonly',
+        clearTimeout: 'readonly',
       },
     },
+    rules: {
+      'no-unused-vars': ['warn', { argsIgnorePattern: '^_', caughtErrorsIgnorePattern: '^_' }],
+    },
   },
   {
     files: ['**/*.ts', '**/*.tsx'],
@@ -45,6 +50,8 @@ const eslintConfig = defineConfig([
         confirm: 'readonly',
         getComputedStyle: 'readonly',
         requestAnimationFrame: 'readonly',
+        cancelAnimationFrame: 'readonly',
+        alert: 'readonly',
         // DOM Element Types
         HTMLElement: 'readonly',
         HTMLInputElement: 'readonly',
@@ -56,6 +63,8 @@ const eslintConfig = defineConfig([
         HTMLParagraphElement: 'readonly',
         HTMLImageElement: 'readonly',
         Element: 'readonly',
+        SVGElement: 'readonly',
+        SVGSVGElement: 'readonly',
         // Event Types
         Event: 'readonly',
         KeyboardEvent: 'readonly',
@@ -64,14 +73,24 @@ const eslintConfig = defineConfig([
         CustomEvent: 'readonly',
         ClipboardEvent: 'readonly',
         WheelEvent: 'readonly',
+        MouseEvent: 'readonly',
+        UIEvent: 'readonly',
+        MediaQueryListEvent: 'readonly',
         DataTransfer: 'readonly',
         // Web APIs
         ResizeObserver: 'readonly',
         AbortSignal: 'readonly',
+        AbortController: 'readonly',
+        IntersectionObserver: 'readonly',
         Audio: 'readonly',
+        HTMLAudioElement: 'readonly',
         ScrollBehavior: 'readonly',
         URL: 'readonly',
         URLSearchParams: 'readonly',
+        XMLHttpRequest: 'readonly',
+        Response: 'readonly',
+        RequestInit: 'readonly',
+        RequestCache: 'readonly',
         // Timers
         setTimeout: 'readonly',
         setInterval: 'readonly',
@@ -90,6 +109,8 @@ const eslintConfig = defineConfig([
         Electron: 'readonly',
         // Console
         console: 'readonly',
+        // Vite defines
+        __APP_VERSION__: 'readonly',
       },
     },
     plugins: {
@@ -99,6 +120,13 @@ const eslintConfig = defineConfig([
       ...ts.configs.recommended.rules,
       '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }],
       '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/ban-ts-comment': [
+        'error',
+        {
+          'ts-nocheck': 'allow-with-description',
+          minimumDescriptionLength: 10,
+        },
+      ],
     },
   },
   globalIgnores([

apps/ui/package.json

@@ -170,6 +170,10 @@
         "from": "server-bundle/node_modules",
         "to": "server/node_modules"
       },
+      {
+        "from": "server-bundle/libs",
+        "to": "server/libs"
+      },
       {
         "from": "server-bundle/package.json",
         "to": "server/package.json"

apps/ui/scripts/kill-test-servers.mjs

@@ -29,7 +29,7 @@ async function killProcessOnPort(port) {
           try {
             await execAsync(`kill -9 ${pid}`);
             console.log(`[KillTestServers] Killed process ${pid}`);
-          } catch (error) {
+          } catch (_error) {
             // Process might have already exited
           }
         }
@@ -47,7 +47,7 @@ async function killProcessOnPort(port) {
       await new Promise((resolve) => setTimeout(resolve, 500));
       return;
     }
-  } catch (error) {
+  } catch (_error) {
     // No process on port, which is fine
   }
 }

apps/ui/src/app.tsx

@@ -7,6 +7,7 @@ import { useSettingsSync } from './hooks/use-settings-sync';
 import { useCursorStatusInit } from './hooks/use-cursor-status-init';
 import { useProviderAuthInit } from './hooks/use-provider-auth-init';
 import { useAppStore } from './store/app-store';
+import { TooltipProvider } from '@/components/ui/tooltip';
 import './styles/global.css';
 import './styles/theme-imports';
 import './styles/font-imports';
@@ -75,9 +76,9 @@ export default function App() {
   }, []);
 
   return (
-    <>
+    <TooltipProvider delayDuration={300}>
       <RouterProvider router={router} />
       {showSplash && !disableSplashScreen && <SplashScreen onComplete={handleSplashComplete} />}
-    </>
+    </TooltipProvider>
   );
 }

apps/ui/src/components/codex-usage-popover.tsx

@@ -68,7 +68,6 @@ export function CodexUsagePopover() {
   // Use React Query for data fetching with automatic polling
   const {
     data: codexUsage,
-    isLoading,
     isFetching,
     error: queryError,
     dataUpdatedAt,

apps/ui/src/components/dialogs/file-browser-dialog.tsx

@@ -40,8 +40,6 @@ interface FileBrowserDialogProps {
   initialPath?: string;
 }
 
-const MAX_RECENT_FOLDERS = 5;
-
 export function FileBrowserDialog({
   open,
   onOpenChange,

apps/ui/src/components/dialogs/new-project-modal.tsx

@@ -191,7 +191,7 @@ export function NewProjectModal({
 
   // Use platform-specific path separator
   const pathSep =
-    typeof window !== 'undefined' && (window as any).electronAPI
+    typeof window !== 'undefined' && window.electronAPI
       ? navigator.platform.indexOf('Win') !== -1
         ? '\\'
         : '/'

apps/ui/src/components/layout/project-switcher/components/edit-project-dialog.tsx

@@ -25,9 +25,9 @@ interface EditProjectDialogProps {
 export function EditProjectDialog({ project, open, onOpenChange }: EditProjectDialogProps) {
   const { setProjectName, setProjectIcon, setProjectCustomIcon } = useAppStore();
   const [name, setName] = useState(project.name);
-  const [icon, setIcon] = useState<string | null>((project as any).icon || null);
+  const [icon, setIcon] = useState<string | null>(project.icon || null);
   const [customIconPath, setCustomIconPath] = useState<string | null>(
-    (project as any).customIconPath || null
+    project.customIconPath || null
   );
   const [isUploadingIcon, setIsUploadingIcon] = useState(false);
   const fileInputRef = useRef<HTMLInputElement>(null);
@@ -36,10 +36,10 @@ export function EditProjectDialog({ project, open, onOpenChange }: EditProjectDi
     if (name.trim() !== project.name) {
       setProjectName(project.id, name.trim());
     }
-    if (icon !== (project as any).icon) {
+    if (icon !== project.icon) {
       setProjectIcon(project.id, icon);
     }
-    if (customIconPath !== (project as any).customIconPath) {
+    if (customIconPath !== project.customIconPath) {
       setProjectCustomIcon(project.id, customIconPath);
     }
     onOpenChange(false);

apps/ui/src/components/layout/project-switcher/components/notification-bell.tsx

@@ -3,7 +3,7 @@
  */
 
 import { useCallback } from 'react';
-import { Bell, Check, Trash2, ExternalLink } from 'lucide-react';
+import { Bell, Check, Trash2 } from 'lucide-react';
 import { useNavigate } from '@tanstack/react-router';
 import { useNotificationsStore } from '@/store/notifications-store';
 import { useLoadNotifications, useNotificationEvents } from '@/hooks/use-notification-events';

apps/ui/src/components/layout/project-switcher/components/project-context-menu.tsx

@@ -199,7 +199,6 @@ export function ProjectContextMenu({
   } = useAppStore();
   const [showRemoveDialog, setShowRemoveDialog] = useState(false);
   const [showThemeSubmenu, setShowThemeSubmenu] = useState(false);
-  const [removeConfirmed, setRemoveConfirmed] = useState(false);
   const themeSubmenuRef = useRef<HTMLDivElement>(null);
   const closeTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
@@ -331,7 +330,6 @@ export function ProjectContextMenu({
     toast.success('Project removed', {
       description: `${project.name} has been removed from your projects list`,
     });
-    setRemoveConfirmed(true);
   }, [moveProjectToTrash, project.id, project.name]);
 
   const handleDialogClose = useCallback(
@@ -340,8 +338,6 @@ export function ProjectContextMenu({
       // Close the context menu when dialog closes (whether confirmed or cancelled)
       // This prevents the context menu from reappearing after dialog interaction
       if (!isOpen) {
-        // Reset confirmation state
-        setRemoveConfirmed(false);
         // Always close the context menu when dialog closes
         onClose();
       }

apps/ui/src/components/layout/sidebar/components/sidebar-footer.tsx

@@ -5,7 +5,7 @@ import { formatShortcut } from '@/store/app-store';
 import { Activity, Settings, BookOpen, MessageSquare, ExternalLink } from 'lucide-react';
 import { useOSDetection } from '@/hooks/use-os-detection';
 import { getElectronAPI } from '@/lib/electron';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 
 function getOSAbbreviation(os: string): string {
   switch (os) {
@@ -72,68 +72,14 @@ export function SidebarFooter({
         <div className="flex flex-col items-center py-2 px-2 gap-1">
           {/* Running Agents */}
           {!hideRunningAgents && (
-            <TooltipProvider delayDuration={0}>
-              <Tooltip>
-                <TooltipTrigger asChild>
-                  <button
-                    onClick={() => navigate({ to: '/running-agents' })}
-                    className={cn(
-                      'relative flex items-center justify-center w-10 h-10 rounded-xl',
-                      'transition-all duration-200 ease-out titlebar-no-drag',
-                      isActiveRoute('running-agents')
-                        ? [
-                            'bg-gradient-to-r from-brand-500/20 via-brand-500/15 to-brand-600/10',
-                            'text-foreground border border-brand-500/30',
-                            'shadow-md shadow-brand-500/10',
-                          ]
-                        : [
-                            'text-muted-foreground hover:text-foreground',
-                            'hover:bg-accent/50 border border-transparent hover:border-border/40',
-                          ]
-                    )}
-                    data-testid="running-agents-link"
-                  >
-                    <Activity
-                      className={cn(
-                        'w-[18px] h-[18px]',
-                        isActiveRoute('running-agents') && 'text-brand-500'
-                      )}
-                    />
-                    {runningAgentsCount > 0 && (
-                      <span
-                        className={cn(
-                          'absolute -top-1 -right-1 flex items-center justify-center',
-                          'min-w-4 h-4 px-1 text-[9px] font-bold rounded-full',
-                          'bg-brand-500 text-white shadow-sm'
-                        )}
-                      >
-                        {runningAgentsCount > 99 ? '99' : runningAgentsCount}
-                      </span>
-                    )}
-                  </button>
-                </TooltipTrigger>
-                <TooltipContent side="right" sideOffset={8}>
-                  Running Agents
-                  {runningAgentsCount > 0 && (
-                    <span className="ml-2 px-1.5 py-0.5 bg-brand-500 text-white rounded-full text-[10px]">
-                      {runningAgentsCount}
-                    </span>
-                  )}
-                </TooltipContent>
-              </Tooltip>
-            </TooltipProvider>
-          )}
-
-          {/* Settings */}
-          <TooltipProvider delayDuration={0}>
             <Tooltip>
               <TooltipTrigger asChild>
                 <button
-                  onClick={() => navigate({ to: '/settings' })}
+                  onClick={() => navigate({ to: '/running-agents' })}
                   className={cn(
-                    'flex items-center justify-center w-10 h-10 rounded-xl',
+                    'relative flex items-center justify-center w-10 h-10 rounded-xl',
                     'transition-all duration-200 ease-out titlebar-no-drag',
-                    isActiveRoute('settings')
+                    isActiveRoute('running-agents')
                       ? [
                           'bg-gradient-to-r from-brand-500/20 via-brand-500/15 to-brand-600/10',
                           'text-foreground border border-brand-500/30',
@@ -144,72 +90,115 @@ export function SidebarFooter({
                           'hover:bg-accent/50 border border-transparent hover:border-border/40',
                         ]
                   )}
-                  data-testid="settings-button"
+                  data-testid="running-agents-link"
                 >
-                  <Settings
+                  <Activity
                     className={cn(
                       'w-[18px] h-[18px]',
-                      isActiveRoute('settings') && 'text-brand-500'
+                      isActiveRoute('running-agents') && 'text-brand-500'
                     )}
                   />
+                  {runningAgentsCount > 0 && (
+                    <span
+                      className={cn(
+                        'absolute -top-1 -right-1 flex items-center justify-center',
+                        'min-w-4 h-4 px-1 text-[9px] font-bold rounded-full',
+                        'bg-brand-500 text-white shadow-sm'
+                      )}
+                    >
+                      {runningAgentsCount > 99 ? '99' : runningAgentsCount}
+                    </span>
+                  )}
                 </button>
               </TooltipTrigger>
               <TooltipContent side="right" sideOffset={8}>
-                Global Settings
-                <span className="ml-2 px-1.5 py-0.5 bg-muted rounded text-[10px] font-mono text-muted-foreground">
-                  {formatShortcut(shortcuts.settings, true)}
-                </span>
+                Running Agents
+                {runningAgentsCount > 0 && (
+                  <span className="ml-2 px-1.5 py-0.5 bg-brand-500 text-white rounded-full text-[10px]">
+                    {runningAgentsCount}
+                  </span>
+                )}
               </TooltipContent>
             </Tooltip>
-          </TooltipProvider>
+          )}
+
+          {/* Settings */}
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <button
+                onClick={() => navigate({ to: '/settings' })}
+                className={cn(
+                  'flex items-center justify-center w-10 h-10 rounded-xl',
+                  'transition-all duration-200 ease-out titlebar-no-drag',
+                  isActiveRoute('settings')
+                    ? [
+                        'bg-gradient-to-r from-brand-500/20 via-brand-500/15 to-brand-600/10',
+                        'text-foreground border border-brand-500/30',
+                        'shadow-md shadow-brand-500/10',
+                      ]
+                    : [
+                        'text-muted-foreground hover:text-foreground',
+                        'hover:bg-accent/50 border border-transparent hover:border-border/40',
+                      ]
+                )}
+                data-testid="settings-button"
+              >
+                <Settings
+                  className={cn('w-[18px] h-[18px]', isActiveRoute('settings') && 'text-brand-500')}
+                />
+              </button>
+            </TooltipTrigger>
+            <TooltipContent side="right" sideOffset={8}>
+              Global Settings
+              <span className="ml-2 px-1.5 py-0.5 bg-muted rounded text-[10px] font-mono text-muted-foreground">
+                {formatShortcut(shortcuts.settings, true)}
+              </span>
+            </TooltipContent>
+          </Tooltip>
 
           {/* Documentation */}
           {!hideWiki && (
-            <TooltipProvider delayDuration={0}>
-              <Tooltip>
-                <TooltipTrigger asChild>
-                  <button
-                    onClick={handleWikiClick}
-                    className={cn(
-                      'flex items-center justify-center w-10 h-10 rounded-xl',
-                      'text-muted-foreground hover:text-foreground',
-                      'hover:bg-accent/50 border border-transparent hover:border-border/40',
-                      'transition-all duration-200 ease-out titlebar-no-drag'
-                    )}
-                    data-testid="documentation-button"
-                  >
-                    <BookOpen className="w-[18px] h-[18px]" />
-                  </button>
-                </TooltipTrigger>
-                <TooltipContent side="right" sideOffset={8}>
-                  Documentation
-                </TooltipContent>
-              </Tooltip>
-            </TooltipProvider>
-          )}
-
-          {/* Feedback */}
-          <TooltipProvider delayDuration={0}>
             <Tooltip>
               <TooltipTrigger asChild>
                 <button
-                  onClick={handleFeedbackClick}
+                  onClick={handleWikiClick}
                   className={cn(
                     'flex items-center justify-center w-10 h-10 rounded-xl',
                     'text-muted-foreground hover:text-foreground',
                     'hover:bg-accent/50 border border-transparent hover:border-border/40',
                     'transition-all duration-200 ease-out titlebar-no-drag'
                   )}
-                  data-testid="feedback-button"
+                  data-testid="documentation-button"
                 >
-                  <MessageSquare className="w-[18px] h-[18px]" />
+                  <BookOpen className="w-[18px] h-[18px]" />
                 </button>
               </TooltipTrigger>
               <TooltipContent side="right" sideOffset={8}>
-                Feedback
+                Documentation
               </TooltipContent>
             </Tooltip>
-          </TooltipProvider>
+          )}
+
+          {/* Feedback */}
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <button
+                onClick={handleFeedbackClick}
+                className={cn(
+                  'flex items-center justify-center w-10 h-10 rounded-xl',
+                  'text-muted-foreground hover:text-foreground',
+                  'hover:bg-accent/50 border border-transparent hover:border-border/40',
+                  'transition-all duration-200 ease-out titlebar-no-drag'
+                )}
+                data-testid="feedback-button"
+              >
+                <MessageSquare className="w-[18px] h-[18px]" />
+              </button>
+            </TooltipTrigger>
+            <TooltipContent side="right" sideOffset={8}>
+              Feedback
+            </TooltipContent>
+          </Tooltip>
         </div>
       </div>
     );

apps/ui/src/components/layout/sidebar/components/sidebar-header.tsx

@@ -15,7 +15,7 @@ import {
   DropdownMenuSeparator,
   DropdownMenuTrigger,
 } from '@/components/ui/dropdown-menu';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 
 interface SidebarHeaderProps {
   sidebarOpen: boolean;
@@ -92,78 +92,74 @@ export function SidebarHeader({
           isMac && isElectron() && 'pt-[10px]'
         )}
       >
-        <TooltipProvider delayDuration={0}>
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <button
-                onClick={handleLogoClick}
-                className="group flex flex-col items-center"
-                data-testid="logo-button"
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <button
+              onClick={handleLogoClick}
+              className="group flex flex-col items-center"
+              data-testid="logo-button"
+            >
+              <svg
+                xmlns="http://www.w3.org/2000/svg"
+                viewBox="0 0 256 256"
+                role="img"
+                aria-label="Automaker Logo"
+                className="size-8 group-hover:rotate-12 transition-transform duration-300 ease-out"
               >
-                <svg
-                  xmlns="http://www.w3.org/2000/svg"
-                  viewBox="0 0 256 256"
-                  role="img"
-                  aria-label="Automaker Logo"
-                  className="size-8 group-hover:rotate-12 transition-transform duration-300 ease-out"
-                >
-                  <defs>
-                    <linearGradient
-                      id="bg-collapsed"
-                      x1="0"
-                      y1="0"
-                      x2="256"
-                      y2="256"
-                      gradientUnits="userSpaceOnUse"
-                    >
-                      <stop offset="0%" style={{ stopColor: 'var(--brand-400)' }} />
-                      <stop offset="100%" style={{ stopColor: 'var(--brand-600)' }} />
-                    </linearGradient>
-                  </defs>
-                  <rect x="16" y="16" width="224" height="224" rx="56" fill="url(#bg-collapsed)" />
-                  <g
-                    fill="none"
-                    stroke="#FFFFFF"
-                    strokeWidth="20"
-                    strokeLinecap="round"
-                    strokeLinejoin="round"
+                <defs>
+                  <linearGradient
+                    id="bg-collapsed"
+                    x1="0"
+                    y1="0"
+                    x2="256"
+                    y2="256"
+                    gradientUnits="userSpaceOnUse"
                   >
-                    <path d="M92 92 L52 128 L92 164" />
-                    <path d="M144 72 L116 184" />
-                    <path d="M164 92 L204 128 L164 164" />
-                  </g>
-                </svg>
-              </button>
-            </TooltipTrigger>
-            <TooltipContent side="right" sideOffset={8}>
-              Go to Dashboard
-            </TooltipContent>
-          </Tooltip>
-        </TooltipProvider>
+                    <stop offset="0%" style={{ stopColor: 'var(--brand-400)' }} />
+                    <stop offset="100%" style={{ stopColor: 'var(--brand-600)' }} />
+                  </linearGradient>
+                </defs>
+                <rect x="16" y="16" width="224" height="224" rx="56" fill="url(#bg-collapsed)" />
+                <g
+                  fill="none"
+                  stroke="#FFFFFF"
+                  strokeWidth="20"
+                  strokeLinecap="round"
+                  strokeLinejoin="round"
+                >
+                  <path d="M92 92 L52 128 L92 164" />
+                  <path d="M144 72 L116 184" />
+                  <path d="M164 92 L204 128 L164 164" />
+                </g>
+              </svg>
+            </button>
+          </TooltipTrigger>
+          <TooltipContent side="right" sideOffset={8}>
+            Go to Dashboard
+          </TooltipContent>
+        </Tooltip>
 
         {/* Collapsed project icon with dropdown */}
         {currentProject && (
           <>
             <div className="w-full h-px bg-border/40 my-2" />
             <DropdownMenu open={dropdownOpen} onOpenChange={setDropdownOpen}>
-              <TooltipProvider delayDuration={0}>
-                <Tooltip>
-                  <TooltipTrigger asChild>
-                    <DropdownMenuTrigger asChild>
-                      <button
-                        onContextMenu={(e) => onProjectContextMenu(currentProject, e)}
-                        className="p-1 rounded-lg hover:bg-accent/50 transition-colors"
-                        data-testid="collapsed-project-button"
-                      >
-                        {renderProjectIcon(currentProject)}
-                      </button>
-                    </DropdownMenuTrigger>
-                  </TooltipTrigger>
-                  <TooltipContent side="right" sideOffset={8}>
-                    {currentProject.name}
-                  </TooltipContent>
-                </Tooltip>
-              </TooltipProvider>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <DropdownMenuTrigger asChild>
+                    <button
+                      onContextMenu={(e) => onProjectContextMenu(currentProject, e)}
+                      className="p-1 rounded-lg hover:bg-accent/50 transition-colors"
+                      data-testid="collapsed-project-button"
+                    >
+                      {renderProjectIcon(currentProject)}
+                    </button>
+                  </DropdownMenuTrigger>
+                </TooltipTrigger>
+                <TooltipContent side="right" sideOffset={8}>
+                  {currentProject.name}
+                </TooltipContent>
+              </Tooltip>
               <DropdownMenuContent
                 align="start"
                 side="right"

apps/ui/src/components/layout/sidebar/components/sidebar-navigation.tsx

@@ -13,7 +13,7 @@ import {
   DropdownMenuItem,
   DropdownMenuTrigger,
 } from '@/components/ui/dropdown-menu';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 
 // Map section labels to icons
 const sectionIcons: Record<string, React.ComponentType<{ className?: string }>> = {
@@ -158,27 +158,25 @@ export function SidebarNavigation({
             {/* Section icon with dropdown (collapsed sidebar) */}
             {section.label && !sidebarOpen && SectionIcon && section.collapsible && isCollapsed && (
               <DropdownMenu>
-                <TooltipProvider delayDuration={0}>
-                  <Tooltip>
-                    <TooltipTrigger asChild>
-                      <DropdownMenuTrigger asChild>
-                        <button
-                          className={cn(
-                            'group flex items-center justify-center w-full py-2 rounded-lg',
-                            'text-muted-foreground hover:text-foreground',
-                            'hover:bg-accent/50 border border-transparent hover:border-border/40',
-                            'transition-all duration-200 ease-out'
-                          )}
-                        >
-                          <SectionIcon className="w-[18px] h-[18px]" />
-                        </button>
-                      </DropdownMenuTrigger>
-                    </TooltipTrigger>
-                    <TooltipContent side="right" sideOffset={8}>
-                      {section.label}
-                    </TooltipContent>
-                  </Tooltip>
-                </TooltipProvider>
+                <Tooltip>
+                  <TooltipTrigger asChild>
+                    <DropdownMenuTrigger asChild>
+                      <button
+                        className={cn(
+                          'group flex items-center justify-center w-full py-2 rounded-lg',
+                          'text-muted-foreground hover:text-foreground',
+                          'hover:bg-accent/50 border border-transparent hover:border-border/40',
+                          'transition-all duration-200 ease-out'
+                        )}
+                      >
+                        <SectionIcon className="w-[18px] h-[18px]" />
+                      </button>
+                    </DropdownMenuTrigger>
+                  </TooltipTrigger>
+                  <TooltipContent side="right" sideOffset={8}>
+                    {section.label}
+                  </TooltipContent>
+                </Tooltip>
                 <DropdownMenuContent side="right" align="start" sideOffset={8} className="w-48">
                   {section.items.map((item) => {
                     const ItemIcon = item.icon;

apps/ui/src/components/shared/model-override-trigger.tsx

@@ -1,8 +1,4 @@
-import * as React from 'react';
-import { Settings2 } from 'lucide-react';
 import { cn } from '@/lib/utils';
-import { Button } from '@/components/ui/button';
-import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
 import { useAppStore } from '@/store/app-store';
 import type { ModelAlias, CursorModelId, PhaseModelKey, PhaseModelEntry } from '@automaker/types';
 import { PhaseModelSelector } from '@/components/views/settings-view/model-defaults/phase-model-selector';
@@ -74,12 +70,6 @@ export function ModelOverrideTrigger({
     lg: 'h-10 w-10',
   };
 
-  const iconSizes = {
-    sm: 'w-3.5 h-3.5',
-    md: 'w-4 h-4',
-    lg: 'w-5 h-5',
-  };
-
   // For icon variant, wrap PhaseModelSelector and hide text/chevron with CSS
   if (variant === 'icon') {
     return (

apps/ui/src/components/shared/use-model-override.ts

@@ -37,16 +37,6 @@ function normalizeEntry(entry: PhaseModelEntry | string): PhaseModelEntry {
   return entry;
 }
 
-/**
- * Extract model string from PhaseModelEntry or string
- */
-function extractModel(entry: PhaseModelEntry | string): ModelId {
-  if (typeof entry === 'string') {
-    return entry as ModelId;
-  }
-  return entry.model;
-}
-
 /**
  * Hook for managing model overrides per phase
  *

apps/ui/src/components/ui/collapsible.tsx

@@ -1,4 +1,3 @@
-import * as React from 'react';
 import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
 
 const Collapsible = CollapsiblePrimitive.Root;

apps/ui/src/components/ui/git-diff-panel.tsx

@@ -479,7 +479,7 @@ export function GitDiffPanel({
             <div className="flex flex-col items-center justify-center gap-2 py-8 text-muted-foreground">
               <AlertCircle className="w-5 h-5 text-amber-500" />
               <span className="text-sm">{error}</span>
-              <Button variant="ghost" size="sm" onClick={loadDiffs} className="mt-2">
+              <Button variant="ghost" size="sm" onClick={() => void loadDiffs()} className="mt-2">
                 <RefreshCw className="w-4 h-4 mr-2" />
                 Retry
               </Button>
@@ -550,7 +550,12 @@ export function GitDiffPanel({
                     >
                       Collapse All
                     </Button>
-                    <Button variant="ghost" size="sm" onClick={loadDiffs} className="text-xs h-7">
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={() => void loadDiffs()}
+                      className="text-xs h-7"
+                    >
                       <RefreshCw className="w-3 h-3 mr-1" />
                       Refresh
                     </Button>

apps/ui/src/components/ui/keyboard-map.tsx

@@ -7,7 +7,7 @@ import {
 } from '@/store/app-store';
 import type { KeyboardShortcuts } from '@/store/app-store';
 import { cn } from '@/lib/utils';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { Input } from '@/components/ui/input';
 import { Button } from '@/components/ui/button';
 import { CheckCircle2, X, RotateCcw, Edit2 } from 'lucide-react';
@@ -305,54 +305,52 @@ export function KeyboardMap({ onKeySelect, selectedKey, className }: KeyboardMap
   };
 
   return (
-    <TooltipProvider>
-      <div className={cn('space-y-4', className)} data-testid="keyboard-map">
-        {/* Legend */}
-        <div className="flex flex-wrap gap-4 justify-center text-xs">
-          {Object.entries(CATEGORY_COLORS).map(([key, colors]) => (
-            <div key={key} className="flex items-center gap-2">
-              <div className={cn('w-4 h-4 rounded border', colors.bg, colors.border)} />
-              <span className={colors.text}>{colors.label}</span>
-            </div>
-          ))}
-          <div className="flex items-center gap-2">
-            <div className="w-4 h-4 rounded bg-sidebar-accent/10 border border-sidebar-border" />
-            <span className="text-muted-foreground">Available</span>
-          </div>
-          <div className="flex items-center gap-2">
-            <div className="w-2 h-2 rounded-full bg-yellow-500" />
-            <span className="text-yellow-400">Modified</span>
+    <div className={cn('space-y-4', className)} data-testid="keyboard-map">
+      {/* Legend */}
+      <div className="flex flex-wrap gap-4 justify-center text-xs">
+        {Object.entries(CATEGORY_COLORS).map(([key, colors]) => (
+          <div key={key} className="flex items-center gap-2">
+            <div className={cn('w-4 h-4 rounded border', colors.bg, colors.border)} />
+            <span className={colors.text}>{colors.label}</span>
           </div>
+        ))}
+        <div className="flex items-center gap-2">
+          <div className="w-4 h-4 rounded bg-sidebar-accent/10 border border-sidebar-border" />
+          <span className="text-muted-foreground">Available</span>
         </div>
-
-        {/* Keyboard layout */}
-        <div className="flex flex-col items-center gap-1.5 p-4 rounded-xl bg-sidebar-accent/5 border border-sidebar-border">
-          {KEYBOARD_ROWS.map((row, rowIndex) => (
-            <div key={rowIndex} className="flex gap-1.5 justify-center">
-              {row.map(renderKey)}
-            </div>
-          ))}
-        </div>
-
-        {/* Stats */}
-        <div className="flex justify-center gap-6 text-xs text-muted-foreground">
-          <span>
-            <strong className="text-foreground">{Object.keys(keyboardShortcuts).length}</strong>{' '}
-            shortcuts configured
-          </span>
-          <span>
-            <strong className="text-foreground">{Object.keys(keyToShortcuts).length}</strong> keys
-            in use
-          </span>
-          <span>
-            <strong className="text-foreground">
-              {KEYBOARD_ROWS.flat().length - Object.keys(keyToShortcuts).length}
-            </strong>{' '}
-            keys available
-          </span>
+        <div className="flex items-center gap-2">
+          <div className="w-2 h-2 rounded-full bg-yellow-500" />
+          <span className="text-yellow-400">Modified</span>
         </div>
       </div>
-    </TooltipProvider>
+
+      {/* Keyboard layout */}
+      <div className="flex flex-col items-center gap-1.5 p-4 rounded-xl bg-sidebar-accent/5 border border-sidebar-border">
+        {KEYBOARD_ROWS.map((row, rowIndex) => (
+          <div key={rowIndex} className="flex gap-1.5 justify-center">
+            {row.map(renderKey)}
+          </div>
+        ))}
+      </div>
+
+      {/* Stats */}
+      <div className="flex justify-center gap-6 text-xs text-muted-foreground">
+        <span>
+          <strong className="text-foreground">{Object.keys(keyboardShortcuts).length}</strong>{' '}
+          shortcuts configured
+        </span>
+        <span>
+          <strong className="text-foreground">{Object.keys(keyToShortcuts).length}</strong> keys in
+          use
+        </span>
+        <span>
+          <strong className="text-foreground">
+            {KEYBOARD_ROWS.flat().length - Object.keys(keyToShortcuts).length}
+          </strong>{' '}
+          keys available
+        </span>
+      </div>
+    </div>
   );
 }
 
@@ -508,196 +506,194 @@ export function ShortcutReferencePanel({ editable = false }: ShortcutReferencePa
   };
 
   return (
-    <TooltipProvider>
-      <div className="space-y-4" data-testid="shortcut-reference-panel">
-        {editable && (
-          <div className="flex justify-end">
-            <Button
-              variant="outline"
-              size="sm"
-              onClick={() => resetKeyboardShortcuts()}
-              className="gap-2 text-xs"
-              data-testid="reset-all-shortcuts-button"
-            >
-              <RotateCcw className="w-3 h-3" />
-              Reset All to Defaults
-            </Button>
-          </div>
-        )}
-        {Object.entries(groupedShortcuts).map(([category, shortcuts]) => {
-          const colors = CATEGORY_COLORS[category as keyof typeof CATEGORY_COLORS];
-          return (
-            <div key={category} className="space-y-2">
-              <h4 className={cn('text-sm font-semibold', colors.text)}>{colors.label}</h4>
-              <div className="grid grid-cols-2 gap-2">
-                {shortcuts.map(({ key, label, value }) => {
-                  const isModified = mergedShortcuts[key] !== DEFAULT_KEYBOARD_SHORTCUTS[key];
-                  const isEditing = editingShortcut === key;
+    <div className="space-y-4" data-testid="shortcut-reference-panel">
+      {editable && (
+        <div className="flex justify-end">
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() => resetKeyboardShortcuts()}
+            className="gap-2 text-xs"
+            data-testid="reset-all-shortcuts-button"
+          >
+            <RotateCcw className="w-3 h-3" />
+            Reset All to Defaults
+          </Button>
+        </div>
+      )}
+      {Object.entries(groupedShortcuts).map(([category, shortcuts]) => {
+        const colors = CATEGORY_COLORS[category as keyof typeof CATEGORY_COLORS];
+        return (
+          <div key={category} className="space-y-2">
+            <h4 className={cn('text-sm font-semibold', colors.text)}>{colors.label}</h4>
+            <div className="grid grid-cols-2 gap-2">
+              {shortcuts.map(({ key, label, value }) => {
+                const isModified = mergedShortcuts[key] !== DEFAULT_KEYBOARD_SHORTCUTS[key];
+                const isEditing = editingShortcut === key;
 
-                  return (
-                    <div
-                      key={key}
-                      className={cn(
-                        'flex items-center justify-between p-2 rounded-lg bg-sidebar-accent/10 border transition-colors',
-                        isEditing ? 'border-brand-500' : 'border-sidebar-border',
-                        editable && !isEditing && 'hover:bg-sidebar-accent/20 cursor-pointer'
-                      )}
-                      onClick={() => editable && !isEditing && handleStartEdit(key)}
-                      data-testid={`shortcut-row-${key}`}
-                    >
-                      <span className="text-sm text-foreground">{label}</span>
-                      <div className="flex items-center gap-2">
-                        {isEditing ? (
-                          <div
-                            className="flex items-center gap-2"
-                            onClick={(e) => e.stopPropagation()}
-                          >
-                            {/* Modifier checkboxes */}
-                            <div className="flex items-center gap-1.5 text-xs">
-                              <div className="flex items-center gap-1">
-                                <Checkbox
-                                  id={`mod-cmd-${key}`}
-                                  checked={modifiers.cmdCtrl}
-                                  onCheckedChange={(checked) =>
-                                    handleModifierChange('cmdCtrl', !!checked, key)
-                                  }
-                                  className="h-3.5 w-3.5"
-                                />
-                                <Label
-                                  htmlFor={`mod-cmd-${key}`}
-                                  className="text-xs text-muted-foreground cursor-pointer"
-                                >
-                                  {isMac ? '⌘' : 'Ctrl'}
-                                </Label>
-                              </div>
-                              <div className="flex items-center gap-1">
-                                <Checkbox
-                                  id={`mod-alt-${key}`}
-                                  checked={modifiers.alt}
-                                  onCheckedChange={(checked) =>
-                                    handleModifierChange('alt', !!checked, key)
-                                  }
-                                  className="h-3.5 w-3.5"
-                                />
-                                <Label
-                                  htmlFor={`mod-alt-${key}`}
-                                  className="text-xs text-muted-foreground cursor-pointer"
-                                >
-                                  {isMac ? '⌥' : 'Alt'}
-                                </Label>
-                              </div>
-                              <div className="flex items-center gap-1">
-                                <Checkbox
-                                  id={`mod-shift-${key}`}
-                                  checked={modifiers.shift}
-                                  onCheckedChange={(checked) =>
-                                    handleModifierChange('shift', !!checked, key)
-                                  }
-                                  className="h-3.5 w-3.5"
-                                />
-                                <Label
-                                  htmlFor={`mod-shift-${key}`}
-                                  className="text-xs text-muted-foreground cursor-pointer"
-                                >
-                                  ⇧
-                                </Label>
-                              </div>
+                return (
+                  <div
+                    key={key}
+                    className={cn(
+                      'flex items-center justify-between p-2 rounded-lg bg-sidebar-accent/10 border transition-colors',
+                      isEditing ? 'border-brand-500' : 'border-sidebar-border',
+                      editable && !isEditing && 'hover:bg-sidebar-accent/20 cursor-pointer'
+                    )}
+                    onClick={() => editable && !isEditing && handleStartEdit(key)}
+                    data-testid={`shortcut-row-${key}`}
+                  >
+                    <span className="text-sm text-foreground">{label}</span>
+                    <div className="flex items-center gap-2">
+                      {isEditing ? (
+                        <div
+                          className="flex items-center gap-2"
+                          onClick={(e) => e.stopPropagation()}
+                        >
+                          {/* Modifier checkboxes */}
+                          <div className="flex items-center gap-1.5 text-xs">
+                            <div className="flex items-center gap-1">
+                              <Checkbox
+                                id={`mod-cmd-${key}`}
+                                checked={modifiers.cmdCtrl}
+                                onCheckedChange={(checked) =>
+                                  handleModifierChange('cmdCtrl', !!checked, key)
+                                }
+                                className="h-3.5 w-3.5"
+                              />
+                              <Label
+                                htmlFor={`mod-cmd-${key}`}
+                                className="text-xs text-muted-foreground cursor-pointer"
+                              >
+                                {isMac ? '⌘' : 'Ctrl'}
+                              </Label>
+                            </div>
+                            <div className="flex items-center gap-1">
+                              <Checkbox
+                                id={`mod-alt-${key}`}
+                                checked={modifiers.alt}
+                                onCheckedChange={(checked) =>
+                                  handleModifierChange('alt', !!checked, key)
+                                }
+                                className="h-3.5 w-3.5"
+                              />
+                              <Label
+                                htmlFor={`mod-alt-${key}`}
+                                className="text-xs text-muted-foreground cursor-pointer"
+                              >
+                                {isMac ? '⌥' : 'Alt'}
+                              </Label>
+                            </div>
+                            <div className="flex items-center gap-1">
+                              <Checkbox
+                                id={`mod-shift-${key}`}
+                                checked={modifiers.shift}
+                                onCheckedChange={(checked) =>
+                                  handleModifierChange('shift', !!checked, key)
+                                }
+                                className="h-3.5 w-3.5"
+                              />
+                              <Label
+                                htmlFor={`mod-shift-${key}`}
+                                className="text-xs text-muted-foreground cursor-pointer"
+                              >
+                                ⇧
+                              </Label>
                             </div>
-                            <span className="text-muted-foreground">+</span>
-                            <Input
-                              value={keyValue}
-                              onChange={(e) => handleKeyChange(e.target.value, key)}
-                              onKeyDown={handleKeyDown}
-                              className={cn(
-                                'w-12 h-7 text-center font-mono text-xs uppercase',
-                                shortcutError && 'border-red-500 focus-visible:ring-red-500'
-                              )}
-                              placeholder="Key"
-                              maxLength={1}
-                              autoFocus
-                              data-testid={`edit-shortcut-input-${key}`}
-                            />
-                            <Button
-                              size="sm"
-                              variant="ghost"
-                              className="h-7 w-7 p-0 hover:bg-green-500/20 hover:text-green-400"
-                              onClick={(e) => {
-                                e.stopPropagation();
-                                handleSaveShortcut();
-                              }}
-                              disabled={!!shortcutError || !keyValue}
-                              data-testid={`save-shortcut-${key}`}
-                            >
-                              <CheckCircle2 className="w-4 h-4" />
-                            </Button>
-                            <Button
-                              size="sm"
-                              variant="ghost"
-                              className="h-7 w-7 p-0 hover:bg-red-500/20 hover:text-red-400"
-                              onClick={(e) => {
-                                e.stopPropagation();
-                                handleCancelEdit();
-                              }}
-                              data-testid={`cancel-shortcut-${key}`}
-                            >
-                              <X className="w-4 h-4" />
-                            </Button>
                           </div>
-                        ) : (
-                          <>
-                            <kbd
-                              className={cn(
-                                'px-2 py-1 text-xs font-mono rounded border',
-                                colors.bg,
-                                colors.border,
-                                colors.text
-                              )}
-                            >
-                              {formatShortcut(value, true)}
-                            </kbd>
-                            {isModified && editable && (
-                              <Tooltip>
-                                <TooltipTrigger asChild>
-                                  <Button
-                                    size="sm"
-                                    variant="ghost"
-                                    className="h-6 w-6 p-0 hover:bg-yellow-500/20 hover:text-yellow-400"
-                                    onClick={(e) => {
-                                      e.stopPropagation();
-                                      handleResetShortcut(key);
-                                    }}
-                                    data-testid={`reset-shortcut-${key}`}
-                                  >
-                                    <RotateCcw className="w-3 h-3" />
-                                  </Button>
-                                </TooltipTrigger>
-                                <TooltipContent side="top">
-                                  Reset to default ({DEFAULT_KEYBOARD_SHORTCUTS[key]})
-                                </TooltipContent>
-                              </Tooltip>
+                          <span className="text-muted-foreground">+</span>
+                          <Input
+                            value={keyValue}
+                            onChange={(e) => handleKeyChange(e.target.value, key)}
+                            onKeyDown={handleKeyDown}
+                            className={cn(
+                              'w-12 h-7 text-center font-mono text-xs uppercase',
+                              shortcutError && 'border-red-500 focus-visible:ring-red-500'
                             )}
-                            {isModified && !editable && (
-                              <span className="w-2 h-2 rounded-full bg-yellow-500" />
+                            placeholder="Key"
+                            maxLength={1}
+                            autoFocus
+                            data-testid={`edit-shortcut-input-${key}`}
+                          />
+                          <Button
+                            size="sm"
+                            variant="ghost"
+                            className="h-7 w-7 p-0 hover:bg-green-500/20 hover:text-green-400"
+                            onClick={(e) => {
+                              e.stopPropagation();
+                              handleSaveShortcut();
+                            }}
+                            disabled={!!shortcutError || !keyValue}
+                            data-testid={`save-shortcut-${key}`}
+                          >
+                            <CheckCircle2 className="w-4 h-4" />
+                          </Button>
+                          <Button
+                            size="sm"
+                            variant="ghost"
+                            className="h-7 w-7 p-0 hover:bg-red-500/20 hover:text-red-400"
+                            onClick={(e) => {
+                              e.stopPropagation();
+                              handleCancelEdit();
+                            }}
+                            data-testid={`cancel-shortcut-${key}`}
+                          >
+                            <X className="w-4 h-4" />
+                          </Button>
+                        </div>
+                      ) : (
+                        <>
+                          <kbd
+                            className={cn(
+                              'px-2 py-1 text-xs font-mono rounded border',
+                              colors.bg,
+                              colors.border,
+                              colors.text
                             )}
-                            {editable && !isModified && (
-                              <Edit2 className="w-3 h-3 text-muted-foreground opacity-0 group-hover:opacity-100" />
-                            )}
-                          </>
-                        )}
-                      </div>
+                          >
+                            {formatShortcut(value, true)}
+                          </kbd>
+                          {isModified && editable && (
+                            <Tooltip>
+                              <TooltipTrigger asChild>
+                                <Button
+                                  size="sm"
+                                  variant="ghost"
+                                  className="h-6 w-6 p-0 hover:bg-yellow-500/20 hover:text-yellow-400"
+                                  onClick={(e) => {
+                                    e.stopPropagation();
+                                    handleResetShortcut(key);
+                                  }}
+                                  data-testid={`reset-shortcut-${key}`}
+                                >
+                                  <RotateCcw className="w-3 h-3" />
+                                </Button>
+                              </TooltipTrigger>
+                              <TooltipContent side="top">
+                                Reset to default ({DEFAULT_KEYBOARD_SHORTCUTS[key]})
+                              </TooltipContent>
+                            </Tooltip>
+                          )}
+                          {isModified && !editable && (
+                            <span className="w-2 h-2 rounded-full bg-yellow-500" />
+                          )}
+                          {editable && !isModified && (
+                            <Edit2 className="w-3 h-3 text-muted-foreground opacity-0 group-hover:opacity-100" />
+                          )}
+                        </>
+                      )}
                     </div>
-                  );
-                })}
-              </div>
-              {editingShortcut &&
-                shortcutError &&
-                SHORTCUT_CATEGORIES[editingShortcut] === category && (
-                  <p className="text-xs text-red-400 mt-1">{shortcutError}</p>
-                )}
+                  </div>
+                );
+              })}
             </div>
-          );
-        })}
-      </div>
-    </TooltipProvider>
+            {editingShortcut &&
+              shortcutError &&
+              SHORTCUT_CATEGORIES[editingShortcut] === category && (
+                <p className="text-xs text-red-400 mt-1">{shortcutError}</p>
+              )}
+          </div>
+        );
+      })}
+    </div>
   );
 }

apps/ui/src/components/ui/log-viewer.tsx

@@ -1,4 +1,4 @@
-import { useState, useMemo, useEffect, useRef } from 'react';
+import { useState, useMemo, useRef } from 'react';
 import {
   ChevronDown,
   ChevronRight,
@@ -21,7 +21,6 @@ import {
   X,
   Filter,
   Circle,
-  Play,
 } from 'lucide-react';
 import { Spinner } from '@/components/ui/spinner';
 import { cn } from '@/lib/utils';

apps/ui/src/components/ui/task-progress-panel.tsx

@@ -9,6 +9,7 @@ import { Check, Circle, ChevronDown, ChevronRight, FileCode } from 'lucide-react
 import { Spinner } from '@/components/ui/spinner';
 import { getElectronAPI } from '@/lib/electron';
 import type { AutoModeEvent } from '@/types/electron';
+import type { Feature, ParsedTask } from '@automaker/types';
 import { Badge } from '@/components/ui/badge';
 
 interface TaskInfo {
@@ -36,7 +37,7 @@ export function TaskProgressPanel({
   const [tasks, setTasks] = useState<TaskInfo[]>([]);
   const [isExpanded, setIsExpanded] = useState(defaultExpanded);
   const [isLoading, setIsLoading] = useState(true);
-  const [currentTaskId, setCurrentTaskId] = useState<string | null>(null);
+  const [, setCurrentTaskId] = useState<string | null>(null);
 
   // Load initial tasks from feature's planSpec
   const loadInitialTasks = useCallback(async () => {
@@ -53,26 +54,29 @@ export function TaskProgressPanel({
       }
 
       const result = await api.features.get(projectPath, featureId);
-      const feature: any = (result as any).feature;
+      const feature = (result as { success: boolean; feature?: Feature }).feature;
       if (result.success && feature?.planSpec?.tasks) {
-        const planSpec = feature.planSpec as any;
-        const planTasks = planSpec.tasks;
+        const planSpec = feature.planSpec;
+        const planTasks = planSpec.tasks; // Already guarded by the if condition above
         const currentId = planSpec.currentTaskId;
         const completedCount = planSpec.tasksCompleted || 0;
 
         // Convert planSpec tasks to TaskInfo with proper status
-        const initialTasks: TaskInfo[] = planTasks.map((t: any, index: number) => ({
-          id: t.id,
-          description: t.description,
-          filePath: t.filePath,
-          phase: t.phase,
-          status:
-            index < completedCount
-              ? ('completed' as const)
-              : t.id === currentId
-                ? ('in_progress' as const)
-                : ('pending' as const),
-        }));
+        // planTasks is guaranteed to be defined due to the if condition check
+        const initialTasks: TaskInfo[] = (planTasks as ParsedTask[]).map(
+          (t: ParsedTask, index: number) => ({
+            id: t.id,
+            description: t.description,
+            filePath: t.filePath,
+            phase: t.phase,
+            status:
+              index < completedCount
+                ? ('completed' as const)
+                : t.id === currentId
+                  ? ('in_progress' as const)
+                  : ('pending' as const),
+          })
+        );
 
         setTasks(initialTasks);
         setCurrentTaskId(currentId || null);
@@ -236,7 +240,7 @@ export function TaskProgressPanel({
             <div className="absolute left-[2.35rem] top-4 bottom-8 w-px bg-linear-to-b from-border/80 via-border/40 to-transparent" />
 
             <div className="space-y-5">
-              {tasks.map((task, index) => {
+              {tasks.map((task, _index) => {
                 const isActive = task.status === 'in_progress';
                 const isCompleted = task.status === 'completed';
                 const isPending = task.status === 'pending';

apps/ui/src/components/usage-popover.tsx

@@ -25,8 +25,6 @@ type UsageError = {
   message: string;
 };
 
-// Fixed refresh interval (45 seconds)
-const REFRESH_INTERVAL_SECONDS = 45;
 const CLAUDE_SESSION_WINDOW_HOURS = 5;
 
 // Helper to format reset time for Codex
@@ -229,15 +227,6 @@ export function UsagePopover() {
   // Calculate max percentage for header button
   const claudeSessionPercentage = claudeUsage?.sessionPercentage || 0;
 
-  const codexMaxPercentage = codexUsage?.rateLimits
-    ? Math.max(
-        codexUsage.rateLimits.primary?.usedPercent || 0,
-        codexUsage.rateLimits.secondary?.usedPercent || 0
-      )
-    : 0;
-
-  const isStale = activeTab === 'claude' ? isClaudeStale : isCodexStale;
-
   const getProgressBarColor = (percentage: number) => {
     if (percentage >= 80) return 'bg-red-500';
     if (percentage >= 50) return 'bg-yellow-500';

apps/ui/src/components/views/agent-tools-view.tsx

@@ -5,17 +5,7 @@ import { Card, CardContent, CardHeader, CardTitle, CardDescription } from '@/com
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
-import {
-  FileText,
-  FolderOpen,
-  Terminal,
-  CheckCircle,
-  XCircle,
-  Play,
-  File,
-  Pencil,
-  Wrench,
-} from 'lucide-react';
+import { Terminal, CheckCircle, XCircle, Play, File, Pencil, Wrench } from 'lucide-react';
 import { Spinner } from '@/components/ui/spinner';
 import { cn } from '@/lib/utils';
 import { getElectronAPI } from '@/lib/electron';
@@ -29,13 +19,6 @@ interface ToolResult {
   timestamp: Date;
 }
 
-interface ToolExecution {
-  tool: string;
-  input: string;
-  result: ToolResult | null;
-  isRunning: boolean;
-}
-
 export function AgentToolsView() {
   const { currentProject } = useAppStore();
   const api = getElectronAPI();

apps/ui/src/components/views/agent-view.tsx

@@ -63,7 +63,6 @@ export function AgentView() {
     sendMessage,
     clearHistory,
     stopExecution,
-    error: agentError,
     serverQueue,
     addToServerQueue,
     removeFromServerQueue,

apps/ui/src/components/views/analysis-view.tsx

@@ -1,7 +1,7 @@
 import { useCallback, useState } from 'react';
 import { createLogger } from '@automaker/utils/logger';
 import { useQueryClient } from '@tanstack/react-query';
-import { useAppStore, FileTreeNode, ProjectAnalysis } from '@/store/app-store';
+import { useAppStore, FileTreeNode, ProjectAnalysis, Feature } from '@/store/app-store';
 import { getElectronAPI } from '@/lib/electron';
 import { queryKeys } from '@/lib/query-keys';
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
@@ -640,14 +640,14 @@ ${Object.entries(projectAnalysis.filesByExtension)
       }
 
       for (const detectedFeature of detectedFeatures) {
-        await api.features.create(currentProject.path, {
+        const newFeature: Feature = {
           id: generateUUID(),
           category: detectedFeature.category,
           description: detectedFeature.description,
           status: 'backlog',
-          // Initialize with empty steps so the object satisfies the Feature type
           steps: [],
-        } as any);
+        };
+        await api.features.create(currentProject.path, newFeature);
       }
 
       // Invalidate React Query cache to sync UI

apps/ui/src/components/views/board-view.tsx

@@ -1,6 +1,6 @@
-// @ts-nocheck
-import { useEffect, useState, useCallback, useMemo, useRef } from 'react';
+import { useEffect, useState, useCallback, useMemo } from 'react';
 import { createLogger } from '@automaker/utils/logger';
+import type { PointerEvent as ReactPointerEvent } from 'react';
 import {
   DndContext,
   PointerSensor,
@@ -8,7 +8,8 @@ import {
   useSensors,
   rectIntersection,
   pointerWithin,
-  type PointerEvent as DndPointerEvent,
+  type CollisionDetection,
+  type Collision,
 } from '@dnd-kit/core';
 
 // Custom pointer sensor that ignores drag events from within dialogs
@@ -16,7 +17,7 @@ class DialogAwarePointerSensor extends PointerSensor {
   static activators = [
     {
       eventName: 'onPointerDown' as const,
-      handler: ({ nativeEvent: event }: { nativeEvent: DndPointerEvent }) => {
+      handler: ({ nativeEvent: event }: ReactPointerEvent) => {
         // Don't start drag if the event originated from inside a dialog
         if ((event.target as Element)?.closest?.('[role="dialog"]')) {
           return false;
@@ -29,16 +30,13 @@ class DialogAwarePointerSensor extends PointerSensor {
 import { useAppStore, Feature } from '@/store/app-store';
 import { getElectronAPI } from '@/lib/electron';
 import { getHttpApiClient } from '@/lib/http-api-client';
-import type { AutoModeEvent } from '@/types/electron';
-import type { ModelAlias, CursorModelId, BacklogPlanResult } from '@automaker/types';
+import type { BacklogPlanResult, FeatureStatusWithPipeline } from '@automaker/types';
 import { pathsEqual } from '@/lib/utils';
 import { toast } from 'sonner';
-import { getBlockingDependencies } from '@automaker/dependency-resolver';
 import { BoardBackgroundModal } from '@/components/dialogs/board-background-modal';
 import { Spinner } from '@/components/ui/spinner';
 import { useShallow } from 'zustand/react/shallow';
 import { useAutoMode } from '@/hooks/use-auto-mode';
-import { useKeyboardShortcutsConfig } from '@/hooks/use-keyboard-shortcuts';
 import { useWindowState } from '@/hooks/use-window-state';
 // Board-view specific imports
 import { BoardHeader } from './board-view/board-header';
@@ -97,8 +95,6 @@ const logger = createLogger('Board');
 export function BoardView() {
   const {
     currentProject,
-    maxConcurrency: legacyMaxConcurrency,
-    setMaxConcurrency: legacySetMaxConcurrency,
     defaultSkipTests,
     specCreatingForProject,
     setSpecCreatingForProject,
@@ -109,9 +105,6 @@ export function BoardView() {
     setCurrentWorktree,
     getWorktrees,
     setWorktrees,
-    useWorktrees,
-    enableDependencyBlocking,
-    skipVerificationInAutoMode,
     planUseSelectedWorktreeBranch,
     addFeatureUseSelectedWorktreeBranch,
     isPrimaryWorktreeBranch,
@@ -120,8 +113,6 @@ export function BoardView() {
   } = useAppStore(
     useShallow((state) => ({
       currentProject: state.currentProject,
-      maxConcurrency: state.maxConcurrency,
-      setMaxConcurrency: state.setMaxConcurrency,
       defaultSkipTests: state.defaultSkipTests,
       specCreatingForProject: state.specCreatingForProject,
       setSpecCreatingForProject: state.setSpecCreatingForProject,
@@ -132,9 +123,6 @@ export function BoardView() {
       setCurrentWorktree: state.setCurrentWorktree,
       getWorktrees: state.getWorktrees,
       setWorktrees: state.setWorktrees,
-      useWorktrees: state.useWorktrees,
-      enableDependencyBlocking: state.enableDependencyBlocking,
-      skipVerificationInAutoMode: state.skipVerificationInAutoMode,
       planUseSelectedWorktreeBranch: state.planUseSelectedWorktreeBranch,
       addFeatureUseSelectedWorktreeBranch: state.addFeatureUseSelectedWorktreeBranch,
       isPrimaryWorktreeBranch: state.isPrimaryWorktreeBranch,
@@ -151,12 +139,9 @@ export function BoardView() {
   // Subscribe to worktreePanelVisibleByProject to trigger re-renders when it changes
   const worktreePanelVisibleByProject = useAppStore((state) => state.worktreePanelVisibleByProject);
   // Subscribe to showInitScriptIndicatorByProject to trigger re-renders when it changes
-  const showInitScriptIndicatorByProject = useAppStore(
-    (state) => state.showInitScriptIndicatorByProject
-  );
+  useAppStore((state) => state.showInitScriptIndicatorByProject);
   const getShowInitScriptIndicator = useAppStore((state) => state.getShowInitScriptIndicator);
   const getDefaultDeleteBranch = useAppStore((state) => state.getDefaultDeleteBranch);
-  const shortcuts = useKeyboardShortcutsConfig();
   const {
     features: hookFeatures,
     isLoading,
@@ -187,13 +172,9 @@ export function BoardView() {
   const [showCreatePRDialog, setShowCreatePRDialog] = useState(false);
   const [showCreateBranchDialog, setShowCreateBranchDialog] = useState(false);
   const [showPullResolveConflictsDialog, setShowPullResolveConflictsDialog] = useState(false);
-  const [selectedWorktreeForAction, setSelectedWorktreeForAction] = useState<{
-    path: string;
-    branch: string;
-    isMain: boolean;
-    hasChanges?: boolean;
-    changedFilesCount?: number;
-  } | null>(null);
+  const [selectedWorktreeForAction, setSelectedWorktreeForAction] = useState<WorktreeInfo | null>(
+    null
+  );
   const [worktreeRefreshKey, setWorktreeRefreshKey] = useState(0);
 
   // Backlog plan dialog state
@@ -364,12 +345,12 @@ export function BoardView() {
   }, [currentProject, worktreeRefreshKey]);
 
   // Custom collision detection that prioritizes specific drop targets (cards, worktrees) over columns
-  const collisionDetectionStrategy = useCallback((args: any) => {
+  const collisionDetectionStrategy = useCallback((args: Parameters<CollisionDetection>[0]) => {
     const pointerCollisions = pointerWithin(args);
 
     // Priority 1: Specific drop targets (cards for dependency links, worktrees)
     // These need to be detected even if they are inside a column
-    const specificTargetCollisions = pointerCollisions.filter((collision: any) => {
+    const specificTargetCollisions = pointerCollisions.filter((collision: Collision) => {
       const id = String(collision.id);
       return id.startsWith('card-drop-') || id.startsWith('worktree-drop-');
     });
@@ -379,7 +360,7 @@ export function BoardView() {
     }
 
     // Priority 2: Columns
-    const columnCollisions = pointerCollisions.filter((collision: any) =>
+    const columnCollisions = pointerCollisions.filter((collision: Collision) =>
       COLUMNS.some((col) => col.id === collision.id)
     );
 
@@ -433,19 +414,29 @@ export function BoardView() {
 
   // Get the branch for the currently selected worktree
   // Find the worktree that matches the current selection, or use main worktree
-  const selectedWorktree = useMemo(() => {
+  const selectedWorktree = useMemo((): WorktreeInfo | undefined => {
+    let found;
     if (currentWorktreePath === null) {
       // Primary worktree selected - find the main worktree
-      return worktrees.find((w) => w.isMain);
+      found = worktrees.find((w) => w.isMain);
     } else {
       // Specific worktree selected - find it by path
-      return worktrees.find((w) => !w.isMain && pathsEqual(w.path, currentWorktreePath));
+      found = worktrees.find((w) => !w.isMain && pathsEqual(w.path, currentWorktreePath));
     }
+    if (!found) return undefined;
+    // Ensure all required WorktreeInfo fields are present
+    return {
+      ...found,
+      isCurrent:
+        found.isCurrent ??
+        (currentWorktreePath !== null ? pathsEqual(found.path, currentWorktreePath) : found.isMain),
+      hasWorktree: found.hasWorktree ?? true,
+    };
   }, [worktrees, currentWorktreePath]);
 
   // Auto mode hook - pass current worktree to get worktree-specific state
   // Must be after selectedWorktree is defined
-  const autoMode = useAutoMode(selectedWorktree ?? undefined);
+  const autoMode = useAutoMode(selectedWorktree);
   // Get runningTasks from the hook (scoped to current project/worktree)
   const runningAutoTasks = autoMode.runningTasks;
   // Get worktree-specific maxConcurrency from the hook
@@ -535,8 +526,6 @@ export function BoardView() {
     handleMoveBackToInProgress,
     handleOpenFollowUp,
     handleSendFollowUp,
-    handleCommitFeature,
-    handleMergeFeature,
     handleCompleteFeature,
     handleUnarchiveFeature,
     handleViewOutput,
@@ -976,28 +965,27 @@ export function BoardView() {
     const api = getElectronAPI();
     if (!api?.backlogPlan) return;
 
-    const unsubscribe = api.backlogPlan.onEvent(
-      (event: { type: string; result?: BacklogPlanResult; error?: string }) => {
-        if (event.type === 'backlog_plan_complete') {
-          setIsGeneratingPlan(false);
-          if (event.result && event.result.changes?.length > 0) {
-            setPendingBacklogPlan(event.result);
-            toast.success('Plan ready! Click to review.', {
-              duration: 10000,
-              action: {
-                label: 'Review',
-                onClick: () => setShowPlanDialog(true),
-              },
-            });
-          } else {
-            toast.info('No changes generated. Try again with a different prompt.');
-          }
-        } else if (event.type === 'backlog_plan_error') {
-          setIsGeneratingPlan(false);
-          toast.error(`Plan generation failed: ${event.error}`);
+    const unsubscribe = api.backlogPlan.onEvent((data: unknown) => {
+      const event = data as { type: string; result?: BacklogPlanResult; error?: string };
+      if (event.type === 'backlog_plan_complete') {
+        setIsGeneratingPlan(false);
+        if (event.result && event.result.changes?.length > 0) {
+          setPendingBacklogPlan(event.result);
+          toast.success('Plan ready! Click to review.', {
+            duration: 10000,
+            action: {
+              label: 'Review',
+              onClick: () => setShowPlanDialog(true),
+            },
+          });
+        } else {
+          toast.info('No changes generated. Try again with a different prompt.');
         }
+      } else if (event.type === 'backlog_plan_error') {
+        setIsGeneratingPlan(false);
+        toast.error(`Plan generation failed: ${event.error}`);
       }
-    );
+    });
 
     return unsubscribe;
   }, []);
@@ -1109,10 +1097,10 @@ export function BoardView() {
   // Build columnFeaturesMap for ListView
   // pipelineConfig is now from usePipelineConfig React Query hook at the top
   const columnFeaturesMap = useMemo(() => {
-    const columns = getColumnsWithPipeline(pipelineConfig);
+    const columns = getColumnsWithPipeline(pipelineConfig ?? null);
     const map: Record<string, typeof hookFeatures> = {};
     for (const column of columns) {
-      map[column.id] = getColumnFeatures(column.id as any);
+      map[column.id] = getColumnFeatures(column.id as FeatureStatusWithPipeline);
     }
     return map;
   }, [pipelineConfig, getColumnFeatures]);
@@ -1462,14 +1450,13 @@ export function BoardView() {
               onAddFeature={() => setShowAddDialog(true)}
               onShowCompletedModal={() => setShowCompletedModal(true)}
               completedCount={completedFeatures.length}
-              pipelineConfig={pipelineConfig}
+              pipelineConfig={pipelineConfig ?? null}
               onOpenPipelineSettings={() => setShowPipelineSettings(true)}
               isSelectionMode={isSelectionMode}
               selectionTarget={selectionTarget}
               selectedFeatureIds={selectedFeatureIds}
               onToggleFeatureSelection={toggleFeatureSelection}
               onToggleSelectionMode={toggleSelectionMode}
-              viewMode={viewMode}
               isDragging={activeFeature !== null}
               onAiSuggest={() => setShowPlanDialog(true)}
               className="transition-opacity duration-200"
@@ -1622,7 +1609,7 @@ export function BoardView() {
         open={showPipelineSettings}
         onClose={() => setShowPipelineSettings(false)}
         projectPath={currentProject.path}
-        pipelineConfig={pipelineConfig}
+        pipelineConfig={pipelineConfig ?? null}
         onSave={async (config) => {
           const api = getHttpApiClient();
           const result = await api.pipeline.saveConfig(currentProject.path, config);

apps/ui/src/components/views/board-view/board-controls.tsx

@@ -1,4 +1,4 @@
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { ImageIcon } from 'lucide-react';
 import { cn } from '@/lib/utils';
 
@@ -18,24 +18,22 @@ export function BoardControls({ isMounted, onShowBoardBackground }: BoardControl
   );
 
   return (
-    <TooltipProvider>
-      <div className="flex items-center gap-2">
-        {/* Board Background Button */}
-        <Tooltip>
-          <TooltipTrigger asChild>
-            <button
-              onClick={onShowBoardBackground}
-              className={buttonClass}
-              data-testid="board-background-button"
-            >
-              <ImageIcon className="w-4 h-4" />
-            </button>
-          </TooltipTrigger>
-          <TooltipContent>
-            <p>Board Background Settings</p>
-          </TooltipContent>
-        </Tooltip>
-      </div>
-    </TooltipProvider>
+    <div className="flex items-center gap-2">
+      {/* Board Background Button */}
+      <Tooltip>
+        <TooltipTrigger asChild>
+          <button
+            onClick={onShowBoardBackground}
+            className={buttonClass}
+            data-testid="board-background-button"
+          >
+            <ImageIcon className="w-4 h-4" />
+          </button>
+        </TooltipTrigger>
+        <TooltipContent>
+          <p>Board Background Settings</p>
+        </TooltipContent>
+      </Tooltip>
+    </div>
   );
 }

apps/ui/src/components/views/board-view/components/kanban-card/agent-info-panel.tsx

@@ -1,13 +1,7 @@
 import { memo, useEffect, useState, useMemo, useRef } from 'react';
-import { Feature, ThinkingLevel, ParsedTask } from '@/store/app-store';
-import type { ReasoningEffort } from '@automaker/types';
+import { Feature, ThinkingLevel, ReasoningEffort, ParsedTask } from '@/store/app-store';
 import { getProviderFromModel } from '@/lib/utils';
-import {
-  AgentTaskInfo,
-  parseAgentContext,
-  formatModelName,
-  DEFAULT_MODEL,
-} from '@/lib/agent-context-parser';
+import { parseAgentContext, formatModelName, DEFAULT_MODEL } from '@/lib/agent-context-parser';
 import { cn } from '@/lib/utils';
 import type { AutoModeEvent } from '@/types/electron';
 import { Brain, ListTodo, Sparkles, Expand, CheckCircle2, Circle, Wrench } from 'lucide-react';
@@ -295,7 +289,8 @@ export const AgentInfoPanel = memo(function AgentInfoPanel({
   // Agent Info Panel for non-backlog cards
   // Show panel if we have agentInfo OR planSpec.tasks (for spec/full mode)
   // Note: hasPlanSpecTasks is already defined above and includes freshPlanSpec
-  if (feature.status !== 'backlog' && (agentInfo || hasPlanSpecTasks)) {
+  // (The backlog case was already handled above and returned early)
+  if (agentInfo || hasPlanSpecTasks) {
     return (
       <>
         <div className="mb-3 space-y-2 overflow-hidden">

apps/ui/src/components/views/board-view/components/kanban-card/card-actions.tsx

@@ -1,4 +1,4 @@
-// @ts-nocheck
+// @ts-nocheck - optional callback prop typing with feature status narrowing
 import { memo } from 'react';
 import { Feature } from '@/store/app-store';
 import { Button } from '@/components/ui/button';
@@ -36,7 +36,7 @@ interface CardActionsProps {
 export const CardActions = memo(function CardActions({
   feature,
   isCurrentAutoTask,
-  hasContext,
+  hasContext: _hasContext,
   shortcutKey,
   isSelectionMode = false,
   onEdit,

apps/ui/src/components/views/board-view/components/kanban-card/card-badges.tsx

@@ -1,8 +1,8 @@
-// @ts-nocheck
+// @ts-nocheck - badge component prop variations with conditional rendering
 import { memo, useEffect, useMemo, useState } from 'react';
 import { Feature, useAppStore } from '@/store/app-store';
 import { cn } from '@/lib/utils';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { AlertCircle, Lock, Hand, Sparkles, SkipForward } from 'lucide-react';
 import { getBlockingDependencies } from '@automaker/dependency-resolver';
 import { useShallow } from 'zustand/react/shallow';
@@ -28,24 +28,22 @@ export const CardBadges = memo(function CardBadges({ feature }: CardBadgesProps)
   return (
     <div className="flex flex-wrap items-center gap-1.5 px-3 pt-1.5 min-h-[24px]">
       {/* Error badge */}
-      <TooltipProvider delayDuration={200}>
-        <Tooltip>
-          <TooltipTrigger asChild>
-            <div
-              className={cn(
-                uniformBadgeClass,
-                'bg-[var(--status-error-bg)] border-[var(--status-error)]/40 text-[var(--status-error)]'
-              )}
-              data-testid={`error-badge-${feature.id}`}
-            >
-              <AlertCircle className="w-3.5 h-3.5" />
-            </div>
-          </TooltipTrigger>
-          <TooltipContent side="bottom" className="text-xs max-w-[250px]">
-            <p>{feature.error}</p>
-          </TooltipContent>
-        </Tooltip>
-      </TooltipProvider>
+      <Tooltip>
+        <TooltipTrigger asChild>
+          <div
+            className={cn(
+              uniformBadgeClass,
+              'bg-[var(--status-error-bg)] border-[var(--status-error)]/40 text-[var(--status-error)]'
+            )}
+            data-testid={`error-badge-${feature.id}`}
+          >
+            <AlertCircle className="w-3.5 h-3.5" />
+          </div>
+        </TooltipTrigger>
+        <TooltipContent side="bottom" className="text-xs max-w-[250px]">
+          <p>{feature.error}</p>
+        </TooltipContent>
+      </Tooltip>
     </div>
   );
 });
@@ -100,13 +98,11 @@ export const PriorityBadges = memo(function PriorityBadges({
       return;
     }
 
-    // eslint-disable-next-line no-undef
     const interval = setInterval(() => {
       setCurrentTime(Date.now());
     }, 1000);
 
     return () => {
-      // eslint-disable-next-line no-undef
       clearInterval(interval);
     };
   }, [feature.justFinishedAt, feature.status, currentTime]);
@@ -138,147 +134,137 @@ export const PriorityBadges = memo(function PriorityBadges({
     <div className="absolute top-2 left-2 flex items-center gap-1">
       {/* Priority badge */}
       {feature.priority && (
-        <TooltipProvider delayDuration={200}>
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <div
-                className={cn(
-                  uniformBadgeClass,
-                  feature.priority === 1 &&
-                    'bg-[var(--status-error-bg)] border-[var(--status-error)]/40 text-[var(--status-error)]',
-                  feature.priority === 2 &&
-                    'bg-[var(--status-warning-bg)] border-[var(--status-warning)]/40 text-[var(--status-warning)]',
-                  feature.priority === 3 &&
-                    'bg-[var(--status-info-bg)] border-[var(--status-info)]/40 text-[var(--status-info)]'
-                )}
-                data-testid={`priority-badge-${feature.id}`}
-              >
-                <span className="font-bold text-xs">
-                  {feature.priority === 1 ? 'H' : feature.priority === 2 ? 'M' : 'L'}
-                </span>
-              </div>
-            </TooltipTrigger>
-            <TooltipContent side="bottom" className="text-xs">
-              <p>
-                {feature.priority === 1
-                  ? 'High Priority'
-                  : feature.priority === 2
-                    ? 'Medium Priority'
-                    : 'Low Priority'}
-              </p>
-            </TooltipContent>
-          </Tooltip>
-        </TooltipProvider>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <div
+              className={cn(
+                uniformBadgeClass,
+                feature.priority === 1 &&
+                  'bg-[var(--status-error-bg)] border-[var(--status-error)]/40 text-[var(--status-error)]',
+                feature.priority === 2 &&
+                  'bg-[var(--status-warning-bg)] border-[var(--status-warning)]/40 text-[var(--status-warning)]',
+                feature.priority === 3 &&
+                  'bg-[var(--status-info-bg)] border-[var(--status-info)]/40 text-[var(--status-info)]'
+              )}
+              data-testid={`priority-badge-${feature.id}`}
+            >
+              <span className="font-bold text-xs">
+                {feature.priority === 1 ? 'H' : feature.priority === 2 ? 'M' : 'L'}
+              </span>
+            </div>
+          </TooltipTrigger>
+          <TooltipContent side="bottom" className="text-xs">
+            <p>
+              {feature.priority === 1
+                ? 'High Priority'
+                : feature.priority === 2
+                  ? 'Medium Priority'
+                  : 'Low Priority'}
+            </p>
+          </TooltipContent>
+        </Tooltip>
       )}
 
       {/* Manual verification badge */}
       {showManualVerification && (
-        <TooltipProvider delayDuration={200}>
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <div
-                className={cn(
-                  uniformBadgeClass,
-                  'bg-[var(--status-warning-bg)] border-[var(--status-warning)]/40 text-[var(--status-warning)]'
-                )}
-                data-testid={`skip-tests-badge-${feature.id}`}
-              >
-                <Hand className="w-3.5 h-3.5" />
-              </div>
-            </TooltipTrigger>
-            <TooltipContent side="bottom" className="text-xs">
-              <p>Manual verification required</p>
-            </TooltipContent>
-          </Tooltip>
-        </TooltipProvider>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <div
+              className={cn(
+                uniformBadgeClass,
+                'bg-[var(--status-warning-bg)] border-[var(--status-warning)]/40 text-[var(--status-warning)]'
+              )}
+              data-testid={`skip-tests-badge-${feature.id}`}
+            >
+              <Hand className="w-3.5 h-3.5" />
+            </div>
+          </TooltipTrigger>
+          <TooltipContent side="bottom" className="text-xs">
+            <p>Manual verification required</p>
+          </TooltipContent>
+        </Tooltip>
       )}
 
       {/* Blocked badge */}
       {isBlocked && (
-        <TooltipProvider delayDuration={200}>
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <div
-                className={cn(
-                  uniformBadgeClass,
-                  'bg-orange-500/20 border-orange-500/50 text-orange-500'
-                )}
-                data-testid={`blocked-badge-${feature.id}`}
-              >
-                <Lock className="w-3.5 h-3.5" />
-              </div>
-            </TooltipTrigger>
-            <TooltipContent side="bottom" className="text-xs max-w-[250px]">
-              <p className="font-medium mb-1">
-                Blocked by {blockingDependencies.length} incomplete{' '}
-                {blockingDependencies.length === 1 ? 'dependency' : 'dependencies'}
-              </p>
-              <p className="text-muted-foreground">
-                {blockingDependencies
-                  .map((depId) => {
-                    const dep = features.find((f) => f.id === depId);
-                    return dep?.description || depId;
-                  })
-                  .join(', ')}
-              </p>
-            </TooltipContent>
-          </Tooltip>
-        </TooltipProvider>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <div
+              className={cn(
+                uniformBadgeClass,
+                'bg-orange-500/20 border-orange-500/50 text-orange-500'
+              )}
+              data-testid={`blocked-badge-${feature.id}`}
+            >
+              <Lock className="w-3.5 h-3.5" />
+            </div>
+          </TooltipTrigger>
+          <TooltipContent side="bottom" className="text-xs max-w-[250px]">
+            <p className="font-medium mb-1">
+              Blocked by {blockingDependencies.length} incomplete{' '}
+              {blockingDependencies.length === 1 ? 'dependency' : 'dependencies'}
+            </p>
+            <p className="text-muted-foreground">
+              {blockingDependencies
+                .map((depId) => {
+                  const dep = features.find((f) => f.id === depId);
+                  return dep?.description || depId;
+                })
+                .join(', ')}
+            </p>
+          </TooltipContent>
+        </Tooltip>
       )}
 
       {/* Just Finished badge */}
       {isJustFinished && (
-        <TooltipProvider delayDuration={200}>
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <div
-                className={cn(
-                  uniformBadgeClass,
-                  'bg-[var(--status-success-bg)] border-[var(--status-success)]/40 text-[var(--status-success)] animate-pulse'
-                )}
-                data-testid={`just-finished-badge-${feature.id}`}
-              >
-                <Sparkles className="w-3.5 h-3.5" />
-              </div>
-            </TooltipTrigger>
-            <TooltipContent side="bottom" className="text-xs">
-              <p>Agent just finished working on this feature</p>
-            </TooltipContent>
-          </Tooltip>
-        </TooltipProvider>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <div
+              className={cn(
+                uniformBadgeClass,
+                'bg-[var(--status-success-bg)] border-[var(--status-success)]/40 text-[var(--status-success)] animate-pulse'
+              )}
+              data-testid={`just-finished-badge-${feature.id}`}
+            >
+              <Sparkles className="w-3.5 h-3.5" />
+            </div>
+          </TooltipTrigger>
+          <TooltipContent side="bottom" className="text-xs">
+            <p>Agent just finished working on this feature</p>
+          </TooltipContent>
+        </Tooltip>
       )}
 
       {/* Pipeline exclusion badge */}
       {hasPipelineExclusions && (
-        <TooltipProvider delayDuration={200}>
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <div
-                className={cn(
-                  uniformBadgeClass,
-                  allPipelinesExcluded
-                    ? 'bg-violet-500/20 border-violet-500/50 text-violet-500'
-                    : 'bg-violet-500/10 border-violet-500/30 text-violet-400'
-                )}
-                data-testid={`pipeline-exclusion-badge-${feature.id}`}
-              >
-                <SkipForward className="w-3.5 h-3.5" />
-              </div>
-            </TooltipTrigger>
-            <TooltipContent side="bottom" className="text-xs max-w-[250px]">
-              <p className="font-medium mb-1">
-                {allPipelinesExcluded
-                  ? 'All pipelines skipped'
-                  : `${excludedStepCount} of ${totalPipelineSteps} pipeline${totalPipelineSteps !== 1 ? 's' : ''} skipped`}
-              </p>
-              <p className="text-muted-foreground">
-                {allPipelinesExcluded
-                  ? 'This feature will skip all custom pipeline steps'
-                  : 'Some custom pipeline steps will be skipped for this feature'}
-              </p>
-            </TooltipContent>
-          </Tooltip>
-        </TooltipProvider>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <div
+              className={cn(
+                uniformBadgeClass,
+                allPipelinesExcluded
+                  ? 'bg-violet-500/20 border-violet-500/50 text-violet-500'
+                  : 'bg-violet-500/10 border-violet-500/30 text-violet-400'
+              )}
+              data-testid={`pipeline-exclusion-badge-${feature.id}`}
+            >
+              <SkipForward className="w-3.5 h-3.5" />
+            </div>
+          </TooltipTrigger>
+          <TooltipContent side="bottom" className="text-xs max-w-[250px]">
+            <p className="font-medium mb-1">
+              {allPipelinesExcluded
+                ? 'All pipelines skipped'
+                : `${excludedStepCount} of ${totalPipelineSteps} pipeline${totalPipelineSteps !== 1 ? 's' : ''} skipped`}
+            </p>
+            <p className="text-muted-foreground">
+              {allPipelinesExcluded
+                ? 'This feature will skip all custom pipeline steps'
+                : 'Some custom pipeline steps will be skipped for this feature'}
+            </p>
+          </TooltipContent>
+        </Tooltip>
       )}
     </div>
   );

apps/ui/src/components/views/board-view/components/kanban-card/card-content-sections.tsx

@@ -1,4 +1,4 @@
-// @ts-nocheck
+// @ts-nocheck - content section prop typing with feature data extraction
 import { memo } from 'react';
 import { Feature } from '@/store/app-store';
 import { GitBranch, GitPullRequest, ExternalLink } from 'lucide-react';

apps/ui/src/components/views/board-view/components/kanban-card/card-header.tsx

@@ -1,4 +1,4 @@
-// @ts-nocheck
+// @ts-nocheck - header component props with optional handlers and status variants
 import { memo, useState } from 'react';
 import { Feature } from '@/store/app-store';
 import { cn } from '@/lib/utils';

apps/ui/src/components/views/board-view/components/kanban-card/kanban-card.tsx

@@ -1,4 +1,4 @@
-// @ts-nocheck
+// @ts-nocheck - dnd-kit draggable/droppable ref combination type incompatibilities
 import React, { memo, useLayoutEffect, useState, useCallback } from 'react';
 import { useDraggable, useDroppable } from '@dnd-kit/core';
 import { cn } from '@/lib/utils';

apps/ui/src/components/views/board-view/components/kanban-card/summary-dialog.tsx

@@ -1,4 +1,4 @@
-// @ts-nocheck
+// @ts-nocheck - dialog state typing with feature summary extraction
 import { Feature } from '@/store/app-store';
 import { AgentTaskInfo } from '@/lib/agent-context-parser';
 import {

apps/ui/src/components/views/board-view/components/list-view/list-row.tsx

@@ -1,9 +1,7 @@
-// TODO: Remove @ts-nocheck after fixing BaseFeature's index signature issue
-// The `[key: string]: unknown` in BaseFeature causes property access type errors
-// @ts-nocheck
+// @ts-nocheck - BaseFeature index signature causes property access type errors
 import { memo, useCallback, useState, useEffect } from 'react';
 import { cn } from '@/lib/utils';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { AlertCircle, Lock, Hand, Sparkles, FileText } from 'lucide-react';
 import type { Feature } from '@/store/app-store';
 import { RowActions, type RowActionHandlers } from './row-actions';
@@ -149,29 +147,27 @@ const IndicatorBadges = memo(function IndicatorBadges({
 
   return (
     <div className="flex items-center gap-1 ml-2">
-      <TooltipProvider delayDuration={200}>
-        {badges.map((badge) => (
-          <Tooltip key={badge.key}>
-            <TooltipTrigger asChild>
-              <div
-                className={cn(
-                  'inline-flex items-center justify-center w-5 h-5 rounded border',
-                  badge.colorClass,
-                  badge.bgClass,
-                  badge.borderClass,
-                  badge.animate && 'animate-pulse'
-                )}
-                data-testid={`list-row-badge-${badge.key}`}
-              >
-                <badge.icon className="w-3 h-3" />
-              </div>
-            </TooltipTrigger>
-            <TooltipContent side="top" className="text-xs max-w-[250px]">
-              <p>{badge.tooltip}</p>
-            </TooltipContent>
-          </Tooltip>
-        ))}
-      </TooltipProvider>
+      {badges.map((badge) => (
+        <Tooltip key={badge.key}>
+          <TooltipTrigger asChild>
+            <div
+              className={cn(
+                'inline-flex items-center justify-center w-5 h-5 rounded border',
+                badge.colorClass,
+                badge.bgClass,
+                badge.borderClass,
+                badge.animate && 'animate-pulse'
+              )}
+              data-testid={`list-row-badge-${badge.key}`}
+            >
+              <badge.icon className="w-3 h-3" />
+            </div>
+          </TooltipTrigger>
+          <TooltipContent side="top" className="text-xs max-w-[250px]">
+            <p>{badge.tooltip}</p>
+          </TooltipContent>
+        </Tooltip>
+      ))}
     </div>
   );
 });

apps/ui/src/components/views/board-view/components/list-view/list-view.tsx

@@ -8,7 +8,7 @@ import type { PipelineConfig, FeatureStatusWithPipeline } from '@automaker/types
 import { ListHeader } from './list-header';
 import { ListRow, sortFeatures } from './list-row';
 import { createRowActionHandlers, type RowActionHandlers } from './row-actions';
-import { getStatusLabel, getStatusOrder } from './status-badge';
+import { getStatusOrder } from './status-badge';
 import { getColumnsWithPipeline } from '../../constants';
 import type { SortConfig, SortColumn } from '../../hooks/use-list-view-state';
 

apps/ui/src/components/views/board-view/dialogs/add-feature-dialog.tsx

@@ -1,6 +1,5 @@
-// @ts-nocheck
+// @ts-nocheck - feature data building with conditional fields and model type inference
 import { useState, useEffect, useRef } from 'react';
-import { createLogger } from '@automaker/utils/logger';
 import {
   Dialog,
   DialogContent,
@@ -27,18 +26,10 @@ import { useNavigate } from '@tanstack/react-router';
 import { toast } from 'sonner';
 import { cn } from '@/lib/utils';
 import { modelSupportsThinking } from '@/lib/utils';
-import {
-  useAppStore,
-  ModelAlias,
-  ThinkingLevel,
-  FeatureImage,
-  PlanningMode,
-  Feature,
-} from '@/store/app-store';
+import { useAppStore, ThinkingLevel, FeatureImage, PlanningMode, Feature } from '@/store/app-store';
 import type { ReasoningEffort, PhaseModelEntry, AgentModel } from '@automaker/types';
-import { supportsReasoningEffort, isClaudeModel } from '@automaker/types';
+import { supportsReasoningEffort } from '@automaker/types';
 import {
-  TestingTabContent,
   PrioritySelector,
   WorkModeSelector,
   PlanningModeSelect,
@@ -50,15 +41,13 @@ import {
 } from '../shared';
 import type { WorkMode } from '../shared';
 import { PhaseModelSelector } from '@/components/views/settings-view/model-defaults/phase-model-selector';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import {
   getAncestors,
   formatAncestorContextForPrompt,
   type AncestorContext,
 } from '@automaker/dependency-resolver';
 
-const logger = createLogger('AddFeatureDialog');
-
 /**
  * Determines the default work mode based on global settings and current worktree selection.
  *
@@ -179,9 +168,6 @@ export function AddFeatureDialog({
   // Model selection state
   const [modelEntry, setModelEntry] = useState<PhaseModelEntry>({ model: 'claude-opus' });
 
-  // Check if current model supports planning mode (Claude/Anthropic only)
-  const modelSupportsPlanningMode = isClaudeModel(modelEntry.model);
-
   // Planning mode state
   const [planningMode, setPlanningMode] = useState<PlanningMode>('skip');
   const [requirePlanApproval, setRequirePlanApproval] = useState(false);
@@ -270,6 +256,13 @@ export function AddFeatureDialog({
     allFeatures,
   ]);
 
+  // Clear requirePlanApproval when planning mode is skip or lite
+  useEffect(() => {
+    if (planningMode === 'skip' || planningMode === 'lite') {
+      setRequirePlanApproval(false);
+    }
+  }, [planningMode]);
+
   const handleModelChange = (entry: PhaseModelEntry) => {
     setModelEntry(entry);
   };
@@ -528,26 +521,24 @@ export function AddFeatureDialog({
                 <Cpu className="w-4 h-4 text-muted-foreground" />
                 <span>AI & Execution</span>
               </div>
-              <TooltipProvider>
-                <Tooltip>
-                  <TooltipTrigger asChild>
-                    <button
-                      type="button"
-                      onClick={() => {
-                        onOpenChange(false);
-                        navigate({ to: '/settings', search: { view: 'defaults' } });
-                      }}
-                      className="flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground transition-colors"
-                    >
-                      <Settings2 className="w-3.5 h-3.5" />
-                      <span>Edit Defaults</span>
-                    </button>
-                  </TooltipTrigger>
-                  <TooltipContent>
-                    <p>Change default model and planning settings for new features</p>
-                  </TooltipContent>
-                </Tooltip>
-              </TooltipProvider>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <button
+                    type="button"
+                    onClick={() => {
+                      onOpenChange(false);
+                      navigate({ to: '/settings', search: { view: 'defaults' } });
+                    }}
+                    className="flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground transition-colors"
+                  >
+                    <Settings2 className="w-3.5 h-3.5" />
+                    <span>Edit Defaults</span>
+                  </button>
+                </TooltipTrigger>
+                <TooltipContent>
+                  <p>Change default model and planning settings for new features</p>
+                </TooltipContent>
+              </Tooltip>
             </div>
 
             <div className="space-y-1.5">
@@ -562,41 +553,13 @@ export function AddFeatureDialog({
 
             <div className="grid gap-3 grid-cols-2">
               <div className="space-y-1.5">
-                <Label
-                  className={cn(
-                    'text-xs text-muted-foreground',
-                    !modelSupportsPlanningMode && 'opacity-50'
-                  )}
-                >
-                  Planning
-                </Label>
-                {modelSupportsPlanningMode ? (
-                  <PlanningModeSelect
-                    mode={planningMode}
-                    onModeChange={setPlanningMode}
-                    testIdPrefix="add-feature-planning"
-                    compact
-                  />
-                ) : (
-                  <TooltipProvider>
-                    <Tooltip>
-                      <TooltipTrigger asChild>
-                        <div>
-                          <PlanningModeSelect
-                            mode="skip"
-                            onModeChange={() => {}}
-                            testIdPrefix="add-feature-planning"
-                            compact
-                            disabled
-                          />
-                        </div>
-                      </TooltipTrigger>
-                      <TooltipContent>
-                        <p>Planning modes are only available for Claude Provider</p>
-                      </TooltipContent>
-                    </Tooltip>
-                  </TooltipProvider>
-                )}
+                <Label className="text-xs text-muted-foreground">Planning</Label>
+                <PlanningModeSelect
+                  mode={planningMode}
+                  onModeChange={setPlanningMode}
+                  testIdPrefix="add-feature-planning"
+                  compact
+                />
               </div>
               <div className="space-y-1.5">
                 <Label className="text-xs text-muted-foreground">Options</Label>
@@ -620,20 +583,14 @@ export function AddFeatureDialog({
                       id="add-feature-require-approval"
                       checked={requirePlanApproval}
                       onCheckedChange={(checked) => setRequirePlanApproval(!!checked)}
-                      disabled={
-                        !modelSupportsPlanningMode ||
-                        planningMode === 'skip' ||
-                        planningMode === 'lite'
-                      }
-                      data-testid="add-feature-require-approval-checkbox"
+                      disabled={planningMode === 'skip' || planningMode === 'lite'}
+                      data-testid="add-feature-planning-require-approval-checkbox"
                     />
                     <Label
                       htmlFor="add-feature-require-approval"
                       className={cn(
                         'text-xs font-normal',
-                        !modelSupportsPlanningMode ||
-                          planningMode === 'skip' ||
-                          planningMode === 'lite'
+                        planningMode === 'skip' || planningMode === 'lite'
                           ? 'cursor-not-allowed text-muted-foreground'
                           : 'cursor-pointer'
                       )}

apps/ui/src/components/views/board-view/dialogs/agent-output-modal.tsx

@@ -17,6 +17,7 @@ import { useAppStore } from '@/store/app-store';
 import { extractSummary } from '@/lib/log-parser';
 import { useAgentOutput } from '@/hooks/queries';
 import type { AutoModeEvent } from '@/types/electron';
+import type { BacklogPlanEvent } from '@automaker/types';
 
 interface AgentOutputModalProps {
   open: boolean;
@@ -48,18 +49,16 @@ export function AgentOutputModal({
   const isBacklogPlan = featureId.startsWith('backlog-plan:');
 
   // Resolve project path - prefer prop, fallback to window.__currentProject
-  const resolvedProjectPath = projectPathProp || (window as any).__currentProject?.path || '';
+  const resolvedProjectPath = projectPathProp || window.__currentProject?.path || '';
 
   // Track additional content from WebSocket events (appended to query data)
   const [streamedContent, setStreamedContent] = useState<string>('');
   const [viewMode, setViewMode] = useState<ViewMode | null>(null);
 
   // Use React Query for initial output loading
-  const { data: initialOutput = '', isLoading } = useAgentOutput(
-    resolvedProjectPath,
-    featureId,
-    open && !!resolvedProjectPath
-  );
+  const { data: initialOutput = '', isLoading } = useAgentOutput(resolvedProjectPath, featureId, {
+    enabled: open && !!resolvedProjectPath,
+  });
 
   // Reset streamed content when modal opens or featureId changes
   useEffect(() => {
@@ -262,7 +261,8 @@ export function AgentOutputModal({
     const api = getElectronAPI();
     if (!api?.backlogPlan) return;
 
-    const unsubscribe = api.backlogPlan.onEvent((event: any) => {
+    const unsubscribe = api.backlogPlan.onEvent((data: unknown) => {
+      const event = data as BacklogPlanEvent;
       if (!event?.type) return;
 
       let newContent = '';
@@ -282,7 +282,7 @@ export function AgentOutputModal({
       }
 
       if (newContent) {
-        setOutput((prev) => `${prev}${newContent}`);
+        setStreamedContent((prev) => prev + newContent);
       }
     });
 

apps/ui/src/components/views/board-view/dialogs/completed-features-modal.tsx

@@ -1,4 +1,4 @@
-// @ts-nocheck
+// @ts-nocheck - completed features filtering and grouping with status transitions
 import {
   Dialog,
   DialogContent,

apps/ui/src/components/views/board-view/dialogs/dependency-tree-dialog.tsx

@@ -1,4 +1,4 @@
-// @ts-nocheck
+// @ts-nocheck - dependency tree visualization with recursive feature relationships
 import { useState, useEffect } from 'react';
 import { Dialog, DialogContent, DialogHeader, DialogTitle } from '@/components/ui/dialog';
 import { Feature } from '@/store/app-store';

apps/ui/src/components/views/board-view/dialogs/edit-feature-dialog.tsx

@@ -1,6 +1,5 @@
-// @ts-nocheck
+// @ts-nocheck - form state management with partial feature updates and validation
 import { useState, useEffect } from 'react';
-import { createLogger } from '@automaker/utils/logger';
 import {
   Dialog,
   DialogContent,
@@ -26,11 +25,10 @@ import { GitBranch, Cpu, FolderKanban, Settings2 } from 'lucide-react';
 import { useNavigate } from '@tanstack/react-router';
 import { toast } from 'sonner';
 import { cn, modelSupportsThinking } from '@/lib/utils';
-import { Feature, ModelAlias, ThinkingLevel, useAppStore, PlanningMode } from '@/store/app-store';
+import { Feature, ModelAlias, ThinkingLevel, PlanningMode } from '@/store/app-store';
 import type { ReasoningEffort, PhaseModelEntry, DescriptionHistoryEntry } from '@automaker/types';
 import { migrateModelId } from '@automaker/types';
 import {
-  TestingTabContent,
   PrioritySelector,
   WorkModeSelector,
   PlanningModeSelect,
@@ -41,11 +39,9 @@ import {
 } from '../shared';
 import type { WorkMode } from '../shared';
 import { PhaseModelSelector } from '@/components/views/settings-view/model-defaults/phase-model-selector';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { DependencyTreeDialog } from './dependency-tree-dialog';
-import { isClaudeModel, supportsReasoningEffort } from '@automaker/types';
-
-const logger = createLogger('EditFeatureDialog');
+import { supportsReasoningEffort } from '@automaker/types';
 
 interface EditFeatureDialogProps {
   feature: Feature | null;
@@ -119,9 +115,6 @@ export function EditFeatureDialog({
     reasoningEffort: feature?.reasoningEffort || 'none',
   }));
 
-  // Check if current model supports planning mode (Claude/Anthropic only)
-  const modelSupportsPlanningMode = isClaudeModel(modelEntry.model);
-
   // Track the source of description changes for history
   const [descriptionChangeSource, setDescriptionChangeSource] = useState<
     { source: 'enhance'; mode: EnhancementMode } | 'edit' | null
@@ -194,6 +187,13 @@ export function EditFeatureDialog({
     }
   }, [feature, allFeatures]);
 
+  // Clear requirePlanApproval when planning mode is skip or lite
+  useEffect(() => {
+    if (planningMode === 'skip' || planningMode === 'lite') {
+      setRequirePlanApproval(false);
+    }
+  }, [planningMode]);
+
   const handleModelChange = (entry: PhaseModelEntry) => {
     setModelEntry(entry);
   };
@@ -420,26 +420,24 @@ export function EditFeatureDialog({
                 <Cpu className="w-4 h-4 text-muted-foreground" />
                 <span>AI & Execution</span>
               </div>
-              <TooltipProvider>
-                <Tooltip>
-                  <TooltipTrigger asChild>
-                    <button
-                      type="button"
-                      onClick={() => {
-                        onClose();
-                        navigate({ to: '/settings', search: { view: 'defaults' } });
-                      }}
-                      className="flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground transition-colors"
-                    >
-                      <Settings2 className="w-3.5 h-3.5" />
-                      <span>Edit Defaults</span>
-                    </button>
-                  </TooltipTrigger>
-                  <TooltipContent>
-                    <p>Change default model and planning settings for new features</p>
-                  </TooltipContent>
-                </Tooltip>
-              </TooltipProvider>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <button
+                    type="button"
+                    onClick={() => {
+                      onClose();
+                      navigate({ to: '/settings', search: { view: 'defaults' } });
+                    }}
+                    className="flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground transition-colors"
+                  >
+                    <Settings2 className="w-3.5 h-3.5" />
+                    <span>Edit Defaults</span>
+                  </button>
+                </TooltipTrigger>
+                <TooltipContent>
+                  <p>Change default model and planning settings for new features</p>
+                </TooltipContent>
+              </Tooltip>
             </div>
 
             <div className="space-y-1.5">
@@ -454,41 +452,13 @@ export function EditFeatureDialog({
 
             <div className="grid gap-3 grid-cols-2">
               <div className="space-y-1.5">
-                <Label
-                  className={cn(
-                    'text-xs text-muted-foreground',
-                    !modelSupportsPlanningMode && 'opacity-50'
-                  )}
-                >
-                  Planning
-                </Label>
-                {modelSupportsPlanningMode ? (
-                  <PlanningModeSelect
-                    mode={planningMode}
-                    onModeChange={setPlanningMode}
-                    testIdPrefix="edit-feature-planning"
-                    compact
-                  />
-                ) : (
-                  <TooltipProvider>
-                    <Tooltip>
-                      <TooltipTrigger asChild>
-                        <div>
-                          <PlanningModeSelect
-                            mode="skip"
-                            onModeChange={() => {}}
-                            testIdPrefix="edit-feature-planning"
-                            compact
-                            disabled
-                          />
-                        </div>
-                      </TooltipTrigger>
-                      <TooltipContent>
-                        <p>Planning modes are only available for Claude Provider</p>
-                      </TooltipContent>
-                    </Tooltip>
-                  </TooltipProvider>
-                )}
+                <Label className="text-xs text-muted-foreground">Planning</Label>
+                <PlanningModeSelect
+                  mode={planningMode}
+                  onModeChange={setPlanningMode}
+                  testIdPrefix="edit-feature-planning"
+                  compact
+                />
               </div>
               <div className="space-y-1.5">
                 <Label className="text-xs text-muted-foreground">Options</Label>
@@ -514,20 +484,14 @@ export function EditFeatureDialog({
                       id="edit-feature-require-approval"
                       checked={requirePlanApproval}
                       onCheckedChange={(checked) => setRequirePlanApproval(!!checked)}
-                      disabled={
-                        !modelSupportsPlanningMode ||
-                        planningMode === 'skip' ||
-                        planningMode === 'lite'
-                      }
+                      disabled={planningMode === 'skip' || planningMode === 'lite'}
                       data-testid="edit-feature-require-approval-checkbox"
                     />
                     <Label
                       htmlFor="edit-feature-require-approval"
                       className={cn(
                         'text-xs font-normal',
-                        !modelSupportsPlanningMode ||
-                          planningMode === 'skip' ||
-                          planningMode === 'lite'
+                        planningMode === 'skip' || planningMode === 'lite'
                           ? 'cursor-not-allowed text-muted-foreground'
                           : 'cursor-pointer'
                       )}

apps/ui/src/components/views/board-view/dialogs/follow-up-dialog.tsx

@@ -1,5 +1,3 @@
-import { useState } from 'react';
-import { createLogger } from '@automaker/utils/logger';
 import {
   Dialog,
   DialogContent,
@@ -18,14 +16,7 @@ import {
 } from '@/components/ui/description-image-dropzone';
 import { MessageSquare } from 'lucide-react';
 import { Feature } from '@/store/app-store';
-import {
-  EnhanceWithAI,
-  EnhancementHistoryButton,
-  type EnhancementMode,
-  type BaseHistoryEntry,
-} from '../shared';
-
-const logger = createLogger('FollowUpDialog');
+import { EnhanceWithAI, EnhancementHistoryButton, type BaseHistoryEntry } from '../shared';
 
 /**
  * A single entry in the follow-up prompt history

apps/ui/src/components/views/board-view/dialogs/mass-edit-dialog.tsx

@@ -11,7 +11,6 @@ import { Button } from '@/components/ui/button';
 import { Checkbox } from '@/components/ui/checkbox';
 import { Label } from '@/components/ui/label';
 import { AlertCircle } from 'lucide-react';
-import { modelSupportsThinking } from '@/lib/utils';
 import { Feature, ModelAlias, ThinkingLevel, PlanningMode } from '@/store/app-store';
 import {
   TestingTabContent,
@@ -22,9 +21,8 @@ import {
 } from '../shared';
 import type { WorkMode } from '../shared';
 import { PhaseModelSelector } from '@/components/views/settings-view/model-defaults/phase-model-selector';
-import { isCursorModel, isClaudeModel, type PhaseModelEntry } from '@automaker/types';
+import type { PhaseModelEntry } from '@automaker/types';
 import { cn } from '@/lib/utils';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
 
 interface MassEditDialogProps {
   open: boolean;
@@ -199,6 +197,13 @@ export function MassEditDialog({
     }
   }, [open, selectedFeatures]);
 
+  // Clear requirePlanApproval when planning mode is skip or lite
+  useEffect(() => {
+    if (planningMode === 'skip' || planningMode === 'lite') {
+      setRequirePlanApproval(false);
+    }
+  }, [planningMode]);
+
   const handleApply = async () => {
     const updates: Partial<Feature> = {};
 
@@ -234,9 +239,6 @@ export function MassEditDialog({
   };
 
   const hasAnyApply = Object.values(applyState).some(Boolean);
-  const isCurrentModelCursor = isCursorModel(model);
-  const modelAllowsThinking = !isCurrentModelCursor && modelSupportsThinking(model);
-  const modelSupportsPlanningMode = isClaudeModel(model);
 
   return (
     <Dialog open={open} onOpenChange={(open) => !open && onClose()}>
@@ -276,64 +278,30 @@ export function MassEditDialog({
           <div className="border-t border-border" />
 
           {/* Planning Mode */}
-          {modelSupportsPlanningMode ? (
-            <FieldWrapper
-              label="Planning Mode"
-              isMixed={mixedValues.planningMode || mixedValues.requirePlanApproval}
-              willApply={applyState.planningMode || applyState.requirePlanApproval}
-              onApplyChange={(apply) =>
-                setApplyState((prev) => ({
-                  ...prev,
-                  planningMode: apply,
-                  requirePlanApproval: apply,
-                }))
-              }
-            >
-              <PlanningModeSelect
-                mode={planningMode}
-                onModeChange={(newMode) => {
-                  setPlanningMode(newMode);
-                  // Auto-suggest approval based on mode, but user can override
-                  setRequirePlanApproval(newMode === 'spec' || newMode === 'full');
-                }}
-                requireApproval={requirePlanApproval}
-                onRequireApprovalChange={setRequirePlanApproval}
-                testIdPrefix="mass-edit-planning"
-              />
-            </FieldWrapper>
-          ) : (
-            <TooltipProvider>
-              <Tooltip>
-                <TooltipTrigger asChild>
-                  <div
-                    className={cn(
-                      'p-3 rounded-lg border transition-colors border-border bg-muted/20 opacity-50 cursor-not-allowed'
-                    )}
-                  >
-                    <div className="flex items-center justify-between mb-3">
-                      <div className="flex items-center gap-2">
-                        <Checkbox checked={false} disabled className="opacity-50" />
-                        <Label className="text-sm font-medium text-muted-foreground">
-                          Planning Mode
-                        </Label>
-                      </div>
-                    </div>
-                    <div className="opacity-50 pointer-events-none">
-                      <PlanningModeSelect
-                        mode="skip"
-                        onModeChange={() => {}}
-                        testIdPrefix="mass-edit-planning"
-                        disabled
-                      />
-                    </div>
-                  </div>
-                </TooltipTrigger>
-                <TooltipContent>
-                  <p>Planning modes are only available for Claude Provider</p>
-                </TooltipContent>
-              </Tooltip>
-            </TooltipProvider>
-          )}
+          <FieldWrapper
+            label="Planning Mode"
+            isMixed={mixedValues.planningMode || mixedValues.requirePlanApproval}
+            willApply={applyState.planningMode || applyState.requirePlanApproval}
+            onApplyChange={(apply) =>
+              setApplyState((prev) => ({
+                ...prev,
+                planningMode: apply,
+                requirePlanApproval: apply,
+              }))
+            }
+          >
+            <PlanningModeSelect
+              mode={planningMode}
+              onModeChange={(newMode) => {
+                setPlanningMode(newMode);
+                // Auto-suggest approval based on mode, but user can override
+                setRequirePlanApproval(newMode === 'spec' || newMode === 'full');
+              }}
+              requireApproval={requirePlanApproval}
+              onRequireApprovalChange={setRequirePlanApproval}
+              testIdPrefix="mass-edit-planning"
+            />
+          </FieldWrapper>
 
           {/* Priority */}
           <FieldWrapper

apps/ui/src/components/views/board-view/dialogs/pull-resolve-conflicts-dialog.tsx

@@ -23,14 +23,7 @@ import { getHttpApiClient } from '@/lib/http-api-client';
 import { toast } from 'sonner';
 import { GitMerge, RefreshCw, AlertTriangle } from 'lucide-react';
 import { Spinner } from '@/components/ui/spinner';
-
-interface WorktreeInfo {
-  path: string;
-  branch: string;
-  isMain: boolean;
-  hasChanges?: boolean;
-  changedFilesCount?: number;
-}
+import type { WorktreeInfo } from '../worktree-panel/types';
 
 interface RemoteBranch {
   name: string;
@@ -49,7 +42,7 @@ interface PullResolveConflictsDialogProps {
   open: boolean;
   onOpenChange: (open: boolean) => void;
   worktree: WorktreeInfo | null;
-  onConfirm: (worktree: WorktreeInfo, remoteBranch: string) => void;
+  onConfirm: (worktree: WorktreeInfo, remoteBranch: string) => void | Promise<void>;
 }
 
 export function PullResolveConflictsDialog({

apps/ui/src/components/views/board-view/hooks/use-board-actions.ts

@@ -1,4 +1,4 @@
-// @ts-nocheck
+// @ts-nocheck - feature update logic with partial updates and image/file handling
 import { useCallback } from 'react';
 import {
   Feature,

apps/ui/src/components/views/board-view/hooks/use-board-column-features.ts

@@ -1,4 +1,4 @@
-// @ts-nocheck
+// @ts-nocheck - column filtering logic with dependency resolution and status mapping
 import { useMemo, useCallback } from 'react';
 import { Feature, useAppStore } from '@/store/app-store';
 import {
@@ -51,7 +51,6 @@ export function useBoardColumnFeatures({
 
     // Determine the effective worktree path and branch for filtering
     // If currentWorktreePath is null, we're on the main worktree
-    const effectiveWorktreePath = currentWorktreePath || projectPath;
     // Use the branch name from the selected worktree
     // If we're selecting main (currentWorktreePath is null), currentWorktreeBranch
     // should contain the main branch's actual name, defaulting to "main"

apps/ui/src/components/views/board-view/hooks/use-board-drag-drop.ts

@@ -23,7 +23,7 @@ interface UseBoardDragDropProps {
 
 export function useBoardDragDrop({
   features,
-  currentProject,
+  currentProject: _currentProject,
   runningAutoTasks,
   persistFeatureUpdate,
   handleStartImplementation,
@@ -128,10 +128,9 @@ export function useBoardDragDrop({
           const targetBranch = worktreeData.branch;
           const currentBranch = draggedFeature.branchName;
 
-          // For main worktree, set branchName to null to indicate it should use main
-          // (must use null not undefined so it serializes to JSON for the API call)
+          // For main worktree, set branchName to undefined to indicate it should use main
           // For other worktrees, set branchName to the target branch
-          const newBranchName = worktreeData.isMain ? null : targetBranch;
+          const newBranchName: string | undefined = worktreeData.isMain ? undefined : targetBranch;
 
           // If already on the same branch, nothing to do
           // For main worktree: feature with null/undefined branchName is already on main

apps/ui/src/components/views/board-view/hooks/use-board-effects.ts

@@ -1,15 +1,16 @@
 import { useEffect, useRef } from 'react';
 import { getElectronAPI } from '@/lib/electron';
 import { createLogger } from '@automaker/utils/logger';
+import type { Feature } from '@/store/app-store';
 
 const logger = createLogger('BoardEffects');
 
 interface UseBoardEffectsProps {
-  currentProject: { path: string; id: string } | null;
+  currentProject: { path: string; id: string; name?: string } | null;
   specCreatingForProject: string | null;
   setSpecCreatingForProject: (path: string | null) => void;
   checkContextExists: (featureId: string) => Promise<boolean>;
-  features: any[];
+  features: Feature[];
   isLoading: boolean;
   featuresWithContext: Set<string>;
   setFeaturesWithContext: (set: Set<string>) => void;
@@ -33,10 +34,10 @@ export function useBoardEffects({
   // Make current project available globally for modal
   useEffect(() => {
     if (currentProject) {
-      (window as any).__currentProject = currentProject;
+      window.__currentProject = currentProject;
     }
     return () => {
-      (window as any).__currentProject = null;
+      window.__currentProject = null;
     };
   }, [currentProject]);
 

apps/ui/src/components/views/board-view/hooks/use-board-features.ts

@@ -185,8 +185,8 @@ export function useBoardFeatures({ currentProject }: UseBoardFeaturesProps) {
     features,
     isLoading,
     persistedCategories,
-    loadFeatures: () => {
-      queryClient.invalidateQueries({
+    loadFeatures: async () => {
+      await queryClient.invalidateQueries({
         queryKey: queryKeys.features.all(currentProject?.path ?? ''),
       });
     },

apps/ui/src/components/views/board-view/hooks/use-board-persistence.ts

@@ -1,5 +1,6 @@
 import { useCallback } from 'react';
 import { useQueryClient } from '@tanstack/react-query';
+import type { Feature as ApiFeature } from '@automaker/types';
 import { Feature } from '@/store/app-store';
 import { getElectronAPI } from '@/lib/electron';
 import { useAppStore } from '@/store/app-store';
@@ -48,14 +49,14 @@ export function useBoardPersistence({ currentProject }: UseBoardPersistenceProps
           feature: result.feature,
         });
         if (result.success && result.feature) {
-          const updatedFeature = result.feature;
-          updateFeature(updatedFeature.id, updatedFeature);
+          const updatedFeature = result.feature as Feature;
+          updateFeature(updatedFeature.id, updatedFeature as Partial<Feature>);
           queryClient.setQueryData<Feature[]>(
             queryKeys.features.all(currentProject.path),
             (features) => {
               if (!features) return features;
               return features.map((feature) =>
-                feature.id === updatedFeature.id ? updatedFeature : feature
+                feature.id === updatedFeature.id ? { ...feature, ...updatedFeature } : feature
               );
             }
           );
@@ -85,9 +86,9 @@ export function useBoardPersistence({ currentProject }: UseBoardPersistenceProps
           return;
         }
 
-        const result = await api.features.create(currentProject.path, feature);
+        const result = await api.features.create(currentProject.path, feature as ApiFeature);
         if (result.success && result.feature) {
-          updateFeature(result.feature.id, result.feature);
+          updateFeature(result.feature.id, result.feature as Partial<Feature>);
           // Invalidate React Query cache to sync UI
           queryClient.invalidateQueries({
             queryKey: queryKeys.features.all(currentProject.path),

apps/ui/src/components/views/board-view/kanban-board.tsx

@@ -6,6 +6,7 @@ import {
   useEffect,
   type RefObject,
   type ReactNode,
+  type UIEvent,
 } from 'react';
 import { DragOverlay } from '@dnd-kit/core';
 import { SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable';
@@ -13,7 +14,7 @@ import { Button } from '@/components/ui/button';
 import { KanbanColumn, KanbanCard, EmptyStateCard } from './components';
 import { Feature, useAppStore, formatShortcut } from '@/store/app-store';
 import { Archive, Settings2, CheckSquare, GripVertical, Plus, CheckCircle2 } from 'lucide-react';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { useResponsiveKanban } from '@/hooks/use-responsive-kanban';
 import { getColumnsWithPipeline, type ColumnId } from './constants';
 import type { PipelineConfig } from '@automaker/types';
@@ -79,7 +80,7 @@ const REDUCED_CARD_OPACITY_PERCENT = 85;
 type VirtualListItem = { id: string };
 
 interface VirtualListState<Item extends VirtualListItem> {
-  contentRef: RefObject<HTMLDivElement>;
+  contentRef: RefObject<HTMLDivElement | null>;
   onScroll: (event: UIEvent<HTMLDivElement>) => void;
   itemIds: string[];
   visibleItems: Item[];
@@ -358,49 +359,47 @@ export function KanbanBoard({
                   contentClassName="perf-contain"
                   headerAction={
                     column.id === 'verified' ? (
-                      <TooltipProvider>
-                        <div className="flex items-center gap-1">
-                          {columnFeatures.length > 0 && (
-                            <Tooltip>
-                              <TooltipTrigger asChild>
-                                <Button
-                                  variant="ghost"
-                                  size="sm"
-                                  className="h-6 w-6 p-0"
-                                  onClick={onArchiveAllVerified}
-                                  data-testid="archive-all-verified-button"
-                                >
-                                  <CheckCircle2 className="w-3.5 h-3.5" />
-                                </Button>
-                              </TooltipTrigger>
-                              <TooltipContent>
-                                <p>Complete All</p>
-                              </TooltipContent>
-                            </Tooltip>
-                          )}
+                      <div className="flex items-center gap-1">
+                        {columnFeatures.length > 0 && (
                           <Tooltip>
                             <TooltipTrigger asChild>
                               <Button
                                 variant="ghost"
                                 size="sm"
-                                className="h-6 w-6 p-0 relative"
-                                onClick={onShowCompletedModal}
-                                data-testid="completed-features-button"
+                                className="h-6 w-6 p-0"
+                                onClick={onArchiveAllVerified}
+                                data-testid="archive-all-verified-button"
                               >
-                                <Archive className="w-3.5 h-3.5 text-muted-foreground" />
-                                {completedCount > 0 && (
-                                  <span className="absolute -top-1 -right-1 bg-brand-500 text-white text-[8px] font-bold rounded-full w-3.5 h-3.5 flex items-center justify-center">
-                                    {completedCount > 99 ? '99+' : completedCount}
-                                  </span>
-                                )}
+                                <CheckCircle2 className="w-3.5 h-3.5" />
                               </Button>
                             </TooltipTrigger>
                             <TooltipContent>
-                              <p>Completed Features ({completedCount})</p>
+                              <p>Complete All</p>
                             </TooltipContent>
                           </Tooltip>
-                        </div>
-                      </TooltipProvider>
+                        )}
+                        <Tooltip>
+                          <TooltipTrigger asChild>
+                            <Button
+                              variant="ghost"
+                              size="sm"
+                              className="h-6 w-6 p-0 relative"
+                              onClick={onShowCompletedModal}
+                              data-testid="completed-features-button"
+                            >
+                              <Archive className="w-3.5 h-3.5 text-muted-foreground" />
+                              {completedCount > 0 && (
+                                <span className="absolute -top-1 -right-1 bg-brand-500 text-white text-[8px] font-bold rounded-full w-3.5 h-3.5 flex items-center justify-center">
+                                  {completedCount > 99 ? '99+' : completedCount}
+                                </span>
+                              )}
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>
+                            <p>Completed Features ({completedCount})</p>
+                          </TooltipContent>
+                        </Tooltip>
+                      </div>
                     ) : column.id === 'backlog' ? (
                       <div className="flex items-center gap-1">
                         <Button

apps/ui/src/components/views/board-view/shared/model-constants.ts

@@ -1,4 +1,3 @@
-import type { ModelAlias } from '@/store/app-store';
 import type { ModelProvider, ThinkingLevel, ReasoningEffort } from '@automaker/types';
 import {
   CURSOR_MODEL_MAP,

apps/ui/src/components/views/board-view/shared/model-selector.tsx

@@ -1,14 +1,12 @@
-// @ts-nocheck
 import { Label } from '@/components/ui/label';
 import { Badge } from '@/components/ui/badge';
 import { Brain, AlertTriangle } from 'lucide-react';
 import { AnthropicIcon, CursorIcon, OpenAIIcon } from '@/components/ui/provider-icon';
 import { cn } from '@/lib/utils';
-import type { ModelAlias } from '@/store/app-store';
 import { useAppStore } from '@/store/app-store';
 import { useSetupStore } from '@/store/setup-store';
-import { getModelProvider, PROVIDER_PREFIXES, stripProviderPrefix } from '@automaker/types';
-import type { ModelProvider } from '@automaker/types';
+import { getModelProvider } from '@automaker/types';
+import type { ModelProvider, CursorModelId } from '@automaker/types';
 import { CLAUDE_MODELS, CURSOR_MODELS, ModelOption } from './model-constants';
 import { useEffect } from 'react';
 import { Spinner } from '@/components/ui/spinner';
@@ -41,6 +39,7 @@ export function ModelSelector({
   const isCursorAvailable = cursorCliStatus?.installed && cursorCliStatus?.auth?.authenticated;
 
   // Check if Codex CLI is available
+  // @ts-expect-error - codexCliStatus uses CliStatus type but should use CodexCliStatus which has auth
   const isCodexAvailable = codexCliStatus?.installed && codexCliStatus?.auth?.authenticated;
 
   // Fetch Codex models on mount
@@ -76,8 +75,8 @@ export function ModelSelector({
     // Check both the full ID (for GPT models) and the unprefixed version (for non-GPT models)
     const unprefixedId = model.id.startsWith('cursor-') ? model.id.slice(7) : model.id;
     return (
-      enabledCursorModels.includes(model.id as any) ||
-      enabledCursorModels.includes(unprefixedId as any)
+      enabledCursorModels.includes(model.id as CursorModelId) ||
+      enabledCursorModels.includes(unprefixedId as CursorModelId)
     );
   });
 

apps/ui/src/components/views/board-view/worktree-panel/components/dev-server-logs-panel.tsx

@@ -12,7 +12,6 @@ import {
   GitBranch,
 } from 'lucide-react';
 import { Spinner } from '@/components/ui/spinner';
-import { cn } from '@/lib/utils';
 import { XtermLogViewer, type XtermLogViewerRef } from '@/components/ui/xterm-log-viewer';
 import { useDevServerLogs } from '../hooks/use-dev-server-logs';
 import type { WorktreeInfo } from '../types';

apps/ui/src/components/views/board-view/worktree-panel/components/tooltip-wrapper.tsx

@@ -1,5 +1,5 @@
 import type { ReactElement, ReactNode } from 'react';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 
 interface TooltipWrapperProps {
   /** The element to wrap with a tooltip */
@@ -29,16 +29,14 @@ export function TooltipWrapper({
   }
 
   return (
-    <TooltipProvider>
-      <Tooltip>
-        <TooltipTrigger asChild>
-          {/* The div wrapper is necessary for tooltips to work on disabled elements */}
-          <div>{children}</div>
-        </TooltipTrigger>
-        <TooltipContent side={side}>
-          <p>{tooltipContent}</p>
-        </TooltipContent>
-      </Tooltip>
-    </TooltipProvider>
+    <Tooltip>
+      <TooltipTrigger asChild>
+        {/* The div wrapper is necessary for tooltips to work on disabled elements */}
+        <div>{children}</div>
+      </TooltipTrigger>
+      <TooltipContent side={side}>
+        <p>{tooltipContent}</p>
+      </TooltipContent>
+    </Tooltip>
   );
 }

apps/ui/src/components/views/board-view/worktree-panel/components/worktree-actions-dropdown.tsx

@@ -161,7 +161,7 @@ export function WorktreeActionsDropdown({
     : null;
 
   // Get available terminals for the "Open In Terminal" submenu
-  const { terminals, hasExternalTerminals } = useAvailableTerminals();
+  const { terminals } = useAvailableTerminals();
 
   // Use shared hook for effective default terminal (null = integrated terminal)
   const effectiveDefaultTerminal = useEffectiveDefaultTerminal(terminals);

apps/ui/src/components/views/board-view/worktree-panel/components/worktree-dropdown-item.tsx

@@ -1,5 +1,5 @@
 import { DropdownMenuItem } from '@/components/ui/dropdown-menu';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { Check, CircleDot, Globe, GitPullRequest, FlaskConical } from 'lucide-react';
 import { Spinner } from '@/components/ui/spinner';
 import { cn } from '@/lib/utils';
@@ -101,14 +101,12 @@ export function WorktreeDropdownItem({
 
         {/* Branch name with optional tooltip */}
         {isBranchNameTruncated ? (
-          <TooltipProvider>
-            <Tooltip>
-              <TooltipTrigger asChild>{branchNameElement}</TooltipTrigger>
-              <TooltipContent>
-                <p className="font-mono text-xs">{worktree.branch}</p>
-              </TooltipContent>
-            </Tooltip>
-          </TooltipProvider>
+          <Tooltip>
+            <TooltipTrigger asChild>{branchNameElement}</TooltipTrigger>
+            <TooltipContent>
+              <p className="font-mono text-xs">{worktree.branch}</p>
+            </TooltipContent>
+          </Tooltip>
         ) : (
           branchNameElement
         )}

apps/ui/src/components/views/board-view/worktree-panel/components/worktree-dropdown.tsx

@@ -8,7 +8,7 @@ import {
   DropdownMenuTrigger,
   DropdownMenuGroup,
 } from '@/components/ui/dropdown-menu';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import {
   GitBranch,
   ChevronDown,
@@ -335,14 +335,12 @@ export function WorktreeDropdown({
   const dropdownTrigger = <DropdownMenuTrigger asChild>{triggerButton}</DropdownMenuTrigger>;
 
   const triggerWithTooltip = isBranchNameTruncated ? (
-    <TooltipProvider>
-      <Tooltip>
-        <TooltipTrigger asChild>{dropdownTrigger}</TooltipTrigger>
-        <TooltipContent>
-          <p className="font-mono text-xs">{displayBranch}</p>
-        </TooltipContent>
-      </Tooltip>
-    </TooltipProvider>
+    <Tooltip>
+      <TooltipTrigger asChild>{dropdownTrigger}</TooltipTrigger>
+      <TooltipContent>
+        <p className="font-mono text-xs">{displayBranch}</p>
+      </TooltipContent>
+    </Tooltip>
   ) : (
     dropdownTrigger
   );

apps/ui/src/components/views/board-view/worktree-panel/components/worktree-tab.tsx

@@ -3,7 +3,7 @@ import { Button } from '@/components/ui/button';
 import { Globe, CircleDot, GitPullRequest } from 'lucide-react';
 import { Spinner } from '@/components/ui/spinner';
 import { cn } from '@/lib/utils';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { useDroppable } from '@dnd-kit/core';
 import type {
   WorktreeInfo,
@@ -271,29 +271,27 @@ export function WorktreeTab({
               </span>
             )}
             {hasChanges && (
-              <TooltipProvider>
-                <Tooltip>
-                  <TooltipTrigger asChild>
-                    <span
-                      className={cn(
-                        'inline-flex items-center justify-center h-4 min-w-[1rem] px-1 text-[10px] font-medium rounded border',
-                        isSelected
-                          ? 'bg-amber-500 text-amber-950 border-amber-400'
-                          : 'bg-amber-500/20 text-amber-600 dark:text-amber-400 border-amber-500/30'
-                      )}
-                    >
-                      <CircleDot className="w-2.5 h-2.5 mr-0.5" />
-                      {changedFilesCount ?? '!'}
-                    </span>
-                  </TooltipTrigger>
-                  <TooltipContent>
-                    <p>
-                      {changedFilesCount ?? 'Some'} uncommitted file
-                      {changedFilesCount !== 1 ? 's' : ''}
-                    </p>
-                  </TooltipContent>
-                </Tooltip>
-              </TooltipProvider>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <span
+                    className={cn(
+                      'inline-flex items-center justify-center h-4 min-w-[1rem] px-1 text-[10px] font-medium rounded border',
+                      isSelected
+                        ? 'bg-amber-500 text-amber-950 border-amber-400'
+                        : 'bg-amber-500/20 text-amber-600 dark:text-amber-400 border-amber-500/30'
+                    )}
+                  >
+                    <CircleDot className="w-2.5 h-2.5 mr-0.5" />
+                    {changedFilesCount ?? '!'}
+                  </span>
+                </TooltipTrigger>
+                <TooltipContent>
+                  <p>
+                    {changedFilesCount ?? 'Some'} uncommitted file
+                    {changedFilesCount !== 1 ? 's' : ''}
+                  </p>
+                </TooltipContent>
+              </Tooltip>
             )}
             {prBadge}
           </Button>
@@ -340,78 +338,72 @@ export function WorktreeTab({
             </span>
           )}
           {hasChanges && (
-            <TooltipProvider>
-              <Tooltip>
-                <TooltipTrigger asChild>
-                  <span
-                    className={cn(
-                      'inline-flex items-center justify-center h-4 min-w-[1rem] px-1 text-[10px] font-medium rounded border',
-                      isSelected
-                        ? 'bg-amber-500 text-amber-950 border-amber-400'
-                        : 'bg-amber-500/20 text-amber-600 dark:text-amber-400 border-amber-500/30'
-                    )}
-                  >
-                    <CircleDot className="w-2.5 h-2.5 mr-0.5" />
-                    {changedFilesCount ?? '!'}
-                  </span>
-                </TooltipTrigger>
-                <TooltipContent>
-                  <p>
-                    {changedFilesCount ?? 'Some'} uncommitted file
-                    {changedFilesCount !== 1 ? 's' : ''}
-                  </p>
-                </TooltipContent>
-              </Tooltip>
-            </TooltipProvider>
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <span
+                  className={cn(
+                    'inline-flex items-center justify-center h-4 min-w-[1rem] px-1 text-[10px] font-medium rounded border',
+                    isSelected
+                      ? 'bg-amber-500 text-amber-950 border-amber-400'
+                      : 'bg-amber-500/20 text-amber-600 dark:text-amber-400 border-amber-500/30'
+                  )}
+                >
+                  <CircleDot className="w-2.5 h-2.5 mr-0.5" />
+                  {changedFilesCount ?? '!'}
+                </span>
+              </TooltipTrigger>
+              <TooltipContent>
+                <p>
+                  {changedFilesCount ?? 'Some'} uncommitted file
+                  {changedFilesCount !== 1 ? 's' : ''}
+                </p>
+              </TooltipContent>
+            </Tooltip>
           )}
           {prBadge}
         </Button>
       )}
 
       {isDevServerRunning && (
-        <TooltipProvider>
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <Button
-                variant={isSelected ? 'default' : 'outline'}
-                size="sm"
-                className={cn(
-                  'h-7 w-7 p-0 rounded-none border-r-0',
-                  isSelected && 'bg-primary text-primary-foreground',
-                  !isSelected && 'bg-secondary/50 hover:bg-secondary',
-                  'text-green-500'
-                )}
-                onClick={() => onOpenDevServerUrl(worktree)}
-                aria-label={`Open dev server on port ${devServerInfo?.port} in browser`}
-              >
-                <Globe className="w-3 h-3" aria-hidden="true" />
-              </Button>
-            </TooltipTrigger>
-            <TooltipContent>
-              <p>Open dev server (:{devServerInfo?.port})</p>
-            </TooltipContent>
-          </Tooltip>
-        </TooltipProvider>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button
+              variant={isSelected ? 'default' : 'outline'}
+              size="sm"
+              className={cn(
+                'h-7 w-7 p-0 rounded-none border-r-0',
+                isSelected && 'bg-primary text-primary-foreground',
+                !isSelected && 'bg-secondary/50 hover:bg-secondary',
+                'text-green-500'
+              )}
+              onClick={() => onOpenDevServerUrl(worktree)}
+              aria-label={`Open dev server on port ${devServerInfo?.port} in browser`}
+            >
+              <Globe className="w-3 h-3" aria-hidden="true" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent>
+            <p>Open dev server (:{devServerInfo?.port})</p>
+          </TooltipContent>
+        </Tooltip>
       )}
 
       {isAutoModeRunning && (
-        <TooltipProvider>
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <span
-                className={cn(
-                  'flex items-center justify-center h-7 px-1.5 rounded-none border-r-0',
-                  isSelected ? 'bg-primary text-primary-foreground' : 'bg-secondary/50'
-                )}
-              >
-                <span className="h-2 w-2 rounded-full bg-green-500 animate-pulse" />
-              </span>
-            </TooltipTrigger>
-            <TooltipContent>
-              <p>Auto Mode Running</p>
-            </TooltipContent>
-          </Tooltip>
-        </TooltipProvider>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <span
+              className={cn(
+                'flex items-center justify-center h-7 px-1.5 rounded-none border-r-0',
+                isSelected ? 'bg-primary text-primary-foreground' : 'bg-secondary/50'
+              )}
+            >
+              <span className="h-2 w-2 rounded-full bg-green-500 animate-pulse" />
+            </span>
+          </TooltipTrigger>
+          <TooltipContent>
+            <p>Auto Mode Running</p>
+          </TooltipContent>
+        </Tooltip>
       )}
 
       <WorktreeActionsDropdown

apps/ui/src/components/views/board-view/worktree-panel/hooks/use-available-editors.ts

@@ -26,6 +26,9 @@ export function useAvailableEditors() {
   const { mutate: refreshMutate, isPending: isRefreshing } = useMutation({
     mutationFn: async () => {
       const api = getElectronAPI();
+      if (!api.worktree) {
+        throw new Error('Worktree API not available');
+      }
       const result = await api.worktree.refreshEditors();
       if (!result.success) {
         throw new Error(result.error || 'Failed to refresh editors');

apps/ui/src/components/views/board-view/worktree-panel/worktree-panel.tsx

@@ -514,7 +514,7 @@ export function WorktreePanel({
         } else {
           toast.error(result.error || 'Failed to push changes');
         }
-      } catch (error) {
+      } catch {
         toast.error('Failed to push changes');
       }
     },

apps/ui/src/components/views/chat-history.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import type { UIEvent } from 'react';
-import { useAppStore } from '@/store/app-store';
+import { useAppStore, ChatSession } from '@/store/app-store';
 import { useShallow } from 'zustand/react/shallow';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
@@ -156,7 +156,7 @@ export function ChatHistory() {
     createChatSession();
   };
 
-  const handleSelectSession = (session: any) => {
+  const handleSelectSession = (session: ChatSession) => {
     setCurrentChatSession(session);
   };
 

apps/ui/src/components/views/code-view.tsx

@@ -4,7 +4,7 @@ import { useAppStore } from '@/store/app-store';
 import { getElectronAPI } from '@/lib/electron';
 import { Card, CardContent } from '@/components/ui/card';
 import { Button } from '@/components/ui/button';
-import { File, Folder, FolderOpen, ChevronRight, ChevronDown, Code } from 'lucide-react';
+import { File, Folder, FolderOpen, ChevronRight, ChevronDown, Code, RefreshCw } from 'lucide-react';
 import { Spinner } from '@/components/ui/spinner';
 import { cn } from '@/lib/utils';
 

apps/ui/src/components/views/context-view.tsx

@@ -103,12 +103,6 @@ export function ContextView() {
   // File input ref for import
   const fileInputRef = useRef<HTMLInputElement>(null);
 
-  // Get images directory path
-  const getImagesPath = useCallback(() => {
-    if (!currentProject) return null;
-    return `${currentProject.path}/.automaker/images`;
-  }, [currentProject]);
-
   // Keyboard shortcuts for this view
   const contextShortcuts: KeyboardShortcut[] = useMemo(
     () => [

apps/ui/src/components/views/github-issues-view.tsx

@@ -1,4 +1,4 @@
-// @ts-nocheck
+// @ts-nocheck - GitHub issues view with issue selection and feature creation flow
 import { useState, useCallback, useMemo } from 'react';
 import { createLogger } from '@automaker/utils/logger';
 import { CircleDot, RefreshCw, SearchX } from 'lucide-react';
@@ -43,9 +43,6 @@ export function GitHubIssuesView() {
   // Model override for validation
   const validationModelOverride = useModelOverride({ phase: 'validationModel' });
 
-  // Extract model string for API calls (backward compatibility)
-  const validationModelString = validationModelOverride.effectiveModel;
-
   const { openIssues, closedIssues, loading, refreshing, error, refresh } = useGithubIssues();
 
   const { validatingIssues, cachedValidations, handleValidateIssue, handleViewCachedValidation } =

apps/ui/src/components/views/github-issues-view/components/issue-detail-panel.tsx

@@ -86,8 +86,7 @@ export function IssueDetailPanel({
           {(() => {
             if (isValidating) {
               return (
-                <Button variant="default" size="sm" disabled>
-                  <Spinner size="sm" className="mr-1" />
+                <Button variant="default" size="sm" loading>
                   Validating...
                 </Button>
               );
@@ -334,16 +333,9 @@ export function IssueDetailPanel({
                       size="sm"
                       className="w-full"
                       onClick={loadMore}
-                      disabled={loadingMore}
+                      loading={loadingMore}
                     >
-                      {loadingMore ? (
-                        <>
-                          <Spinner size="sm" className="mr-2" />
-                          Loading...
-                        </>
-                      ) : (
-                        'Load More Comments'
-                      )}
+                      {loadingMore ? 'Loading...' : 'Load More Comments'}
                     </Button>
                   )}
                 </div>

apps/ui/src/components/views/github-issues-view/components/issues-list-header.tsx

@@ -1,7 +1,6 @@
 import { CircleDot, RefreshCw } from 'lucide-react';
 import { Button } from '@/components/ui/button';
 import { Spinner } from '@/components/ui/spinner';
-import { cn } from '@/lib/utils';
 import type { IssuesStateFilter } from '../types';
 import { IssuesFilterControls } from './issues-filter-controls';
 

apps/ui/src/components/views/github-issues-view/hooks/use-issue-validation.ts

@@ -1,4 +1,4 @@
-// @ts-nocheck
+// @ts-nocheck - GitHub issue validation with Electron API integration and async state
 import { useState, useEffect, useCallback, useRef } from 'react';
 import { createLogger } from '@automaker/utils/logger';
 import {
@@ -17,17 +17,6 @@ import { useValidateIssue, useMarkValidationViewed } from '@/hooks/mutations';
 
 const logger = createLogger('IssueValidation');
 
-/**
- * Extract model string from PhaseModelEntry or string (handles both formats)
- */
-function extractModel(entry: PhaseModelEntry | string | undefined): ModelId | undefined {
-  if (!entry) return undefined;
-  if (typeof entry === 'string') {
-    return entry as ModelId;
-  }
-  return entry.model;
-}
-
 interface UseIssueValidationOptions {
   selectedIssue: GitHubIssue | null;
   showValidationDialog: boolean;

apps/ui/src/components/views/graph-view-page.tsx

@@ -1,6 +1,5 @@
-// @ts-nocheck
 import { useState, useCallback, useMemo, useEffect } from 'react';
-import { useAppStore, Feature } from '@/store/app-store';
+import { useAppStore, Feature, FeatureImagePath } from '@/store/app-store';
 import { useShallow } from 'zustand/react/shallow';
 import { GraphView } from './graph-view';
 import {
@@ -9,12 +8,7 @@ import {
   AgentOutputModal,
   BacklogPlanDialog,
 } from './board-view/dialogs';
-import {
-  useBoardFeatures,
-  useBoardActions,
-  useBoardBackground,
-  useBoardPersistence,
-} from './board-view/hooks';
+import { useBoardFeatures, useBoardActions, useBoardPersistence } from './board-view/hooks';
 import { useWorktrees } from './board-view/worktree-panel/hooks';
 import { useAutoMode } from '@/hooks/use-auto-mode';
 import { pathsEqual } from '@/lib/utils';
@@ -155,33 +149,32 @@ export function GraphViewPage() {
       return;
     }
 
-    const unsubscribe = api.backlogPlan.onEvent(
-      (event: { type: string; result?: BacklogPlanResult; error?: string }) => {
-        logger.debug('Backlog plan event received', {
-          type: event.type,
-          hasResult: Boolean(event.result),
-          hasError: Boolean(event.error),
-        });
-        if (event.type === 'backlog_plan_complete') {
-          setIsGeneratingPlan(false);
-          if (event.result && event.result.changes?.length > 0) {
-            setPendingBacklogPlan(event.result);
-            toast.success('Plan ready! Click to review.', {
-              duration: 10000,
-              action: {
-                label: 'Review',
-                onClick: () => setShowPlanDialog(true),
-              },
-            });
-          } else {
-            toast.info('No changes generated. Try again with a different prompt.');
-          }
-        } else if (event.type === 'backlog_plan_error') {
-          setIsGeneratingPlan(false);
-          toast.error(`Plan generation failed: ${event.error}`);
+    const unsubscribe = api.backlogPlan.onEvent((data: unknown) => {
+      const event = data as { type: string; result?: BacklogPlanResult; error?: string };
+      logger.debug('Backlog plan event received', {
+        type: event.type,
+        hasResult: Boolean(event.result),
+        hasError: Boolean(event.error),
+      });
+      if (event.type === 'backlog_plan_complete') {
+        setIsGeneratingPlan(false);
+        if (event.result && event.result.changes?.length > 0) {
+          setPendingBacklogPlan(event.result);
+          toast.success('Plan ready! Click to review.', {
+            duration: 10000,
+            action: {
+              label: 'Review',
+              onClick: () => setShowPlanDialog(true),
+            },
+          });
+        } else {
+          toast.info('No changes generated. Try again with a different prompt.');
         }
+      } else if (event.type === 'backlog_plan_error') {
+        setIsGeneratingPlan(false);
+        toast.error(`Plan generation failed: ${event.error}`);
       }
-    );
+    });
 
     return unsubscribe;
   }, []);
@@ -217,7 +210,7 @@ export function GraphViewPage() {
     return hookFeatures.reduce(
       (counts, feature) => {
         if (feature.status !== 'completed') {
-          const branch = feature.branchName ?? 'main';
+          const branch = (feature.branchName as string | undefined) ?? 'main';
           counts[branch] = (counts[branch] || 0) + 1;
         }
         return counts;
@@ -241,8 +234,8 @@ export function GraphViewPage() {
   // Follow-up state (simplified for graph view)
   const [followUpFeature, setFollowUpFeature] = useState<Feature | null>(null);
   const [followUpPrompt, setFollowUpPrompt] = useState('');
-  const [followUpImagePaths, setFollowUpImagePaths] = useState<any[]>([]);
-  const [followUpPreviewMap, setFollowUpPreviewMap] = useState<Map<string, string>>(new Map());
+  const [followUpImagePaths, setFollowUpImagePaths] = useState<FeatureImagePath[]>([]);
+  const [, setFollowUpPreviewMap] = useState<Map<string, string>>(new Map());
 
   // In-progress features for shortcuts
   const inProgressFeaturesForShortcuts = useMemo(() => {

apps/ui/src/components/views/graph-view/components/graph-controls.tsx

@@ -1,16 +1,7 @@
 import { useReactFlow, Panel } from '@xyflow/react';
 import { Button } from '@/components/ui/button';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
-import {
-  ZoomIn,
-  ZoomOut,
-  Maximize2,
-  Lock,
-  Unlock,
-  GitBranch,
-  ArrowRight,
-  ArrowDown,
-} from 'lucide-react';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
+import { ZoomIn, ZoomOut, Maximize2, Lock, Unlock, ArrowRight, ArrowDown } from 'lucide-react';
 import { cn } from '@/lib/utils';
 
 interface GraphControlsProps {
@@ -30,109 +21,107 @@ export function GraphControls({
 
   return (
     <Panel position="bottom-left" className="flex flex-col gap-2">
-      <TooltipProvider delayDuration={200}>
-        <div
-          className="flex flex-col gap-1 p-1.5 rounded-lg backdrop-blur-sm border border-border shadow-lg text-popover-foreground"
-          style={{ backgroundColor: 'color-mix(in oklch, var(--popover) 90%, transparent)' }}
-        >
-          {/* Zoom controls */}
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <Button
-                variant="ghost"
-                size="sm"
-                className="h-8 w-8 p-0"
-                onClick={() => zoomIn({ duration: 200 })}
-              >
-                <ZoomIn className="w-4 h-4" />
-              </Button>
-            </TooltipTrigger>
-            <TooltipContent side="right">Zoom In</TooltipContent>
-          </Tooltip>
+      <div
+        className="flex flex-col gap-1 p-1.5 rounded-lg backdrop-blur-sm border border-border shadow-lg text-popover-foreground"
+        style={{ backgroundColor: 'color-mix(in oklch, var(--popover) 90%, transparent)' }}
+      >
+        {/* Zoom controls */}
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button
+              variant="ghost"
+              size="sm"
+              className="h-8 w-8 p-0"
+              onClick={() => zoomIn({ duration: 200 })}
+            >
+              <ZoomIn className="w-4 h-4" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">Zoom In</TooltipContent>
+        </Tooltip>
 
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <Button
-                variant="ghost"
-                size="sm"
-                className="h-8 w-8 p-0"
-                onClick={() => zoomOut({ duration: 200 })}
-              >
-                <ZoomOut className="w-4 h-4" />
-              </Button>
-            </TooltipTrigger>
-            <TooltipContent side="right">Zoom Out</TooltipContent>
-          </Tooltip>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button
+              variant="ghost"
+              size="sm"
+              className="h-8 w-8 p-0"
+              onClick={() => zoomOut({ duration: 200 })}
+            >
+              <ZoomOut className="w-4 h-4" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">Zoom Out</TooltipContent>
+        </Tooltip>
 
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <Button
-                variant="ghost"
-                size="sm"
-                className="h-8 w-8 p-0"
-                onClick={() => fitView({ padding: 0.2, duration: 300 })}
-              >
-                <Maximize2 className="w-4 h-4" />
-              </Button>
-            </TooltipTrigger>
-            <TooltipContent side="right">Fit View</TooltipContent>
-          </Tooltip>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button
+              variant="ghost"
+              size="sm"
+              className="h-8 w-8 p-0"
+              onClick={() => fitView({ padding: 0.2, duration: 300 })}
+            >
+              <Maximize2 className="w-4 h-4" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">Fit View</TooltipContent>
+        </Tooltip>
 
-          <div className="h-px bg-border my-1" />
+        <div className="h-px bg-border my-1" />
 
-          {/* Layout controls */}
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <Button
-                variant="ghost"
-                size="sm"
-                className={cn(
-                  'h-8 w-8 p-0',
-                  layoutDirection === 'LR' && 'bg-brand-500/20 text-brand-500'
-                )}
-                onClick={() => onRunLayout('LR')}
-              >
-                <ArrowRight className="w-4 h-4" />
-              </Button>
-            </TooltipTrigger>
-            <TooltipContent side="right">Horizontal Layout</TooltipContent>
-          </Tooltip>
+        {/* Layout controls */}
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button
+              variant="ghost"
+              size="sm"
+              className={cn(
+                'h-8 w-8 p-0',
+                layoutDirection === 'LR' && 'bg-brand-500/20 text-brand-500'
+              )}
+              onClick={() => onRunLayout('LR')}
+            >
+              <ArrowRight className="w-4 h-4" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">Horizontal Layout</TooltipContent>
+        </Tooltip>
 
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <Button
-                variant="ghost"
-                size="sm"
-                className={cn(
-                  'h-8 w-8 p-0',
-                  layoutDirection === 'TB' && 'bg-brand-500/20 text-brand-500'
-                )}
-                onClick={() => onRunLayout('TB')}
-              >
-                <ArrowDown className="w-4 h-4" />
-              </Button>
-            </TooltipTrigger>
-            <TooltipContent side="right">Vertical Layout</TooltipContent>
-          </Tooltip>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button
+              variant="ghost"
+              size="sm"
+              className={cn(
+                'h-8 w-8 p-0',
+                layoutDirection === 'TB' && 'bg-brand-500/20 text-brand-500'
+              )}
+              onClick={() => onRunLayout('TB')}
+            >
+              <ArrowDown className="w-4 h-4" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">Vertical Layout</TooltipContent>
+        </Tooltip>
 
-          <div className="h-px bg-border my-1" />
+        <div className="h-px bg-border my-1" />
 
-          {/* Lock toggle */}
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <Button
-                variant="ghost"
-                size="sm"
-                className={cn('h-8 w-8 p-0', isLocked && 'bg-brand-500/20 text-brand-500')}
-                onClick={onToggleLock}
-              >
-                {isLocked ? <Lock className="w-4 h-4" /> : <Unlock className="w-4 h-4" />}
-              </Button>
-            </TooltipTrigger>
-            <TooltipContent side="right">{isLocked ? 'Unlock Nodes' : 'Lock Nodes'}</TooltipContent>
-          </Tooltip>
-        </div>
-      </TooltipProvider>
+        {/* Lock toggle */}
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button
+              variant="ghost"
+              size="sm"
+              className={cn('h-8 w-8 p-0', isLocked && 'bg-brand-500/20 text-brand-500')}
+              onClick={onToggleLock}
+            >
+              {isLocked ? <Lock className="w-4 h-4" /> : <Unlock className="w-4 h-4" />}
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">{isLocked ? 'Unlock Nodes' : 'Lock Nodes'}</TooltipContent>
+        </Tooltip>
+      </div>
     </Panel>
   );
 }

apps/ui/src/components/views/graph-view/components/graph-filter-controls.tsx

@@ -4,7 +4,7 @@ import { Checkbox } from '@/components/ui/checkbox';
 import { Switch } from '@/components/ui/switch';
 import { Input } from '@/components/ui/input';
 import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import {
   Filter,
   X,
@@ -115,248 +115,252 @@ export function GraphFilterControls({
 
   return (
     <Panel position="top-left" className="flex items-center gap-2">
-      <TooltipProvider delayDuration={200}>
-        <div
-          className="flex items-center gap-2 p-2 rounded-lg backdrop-blur-sm border border-border shadow-lg text-popover-foreground"
-          style={{ backgroundColor: 'color-mix(in oklch, var(--popover) 90%, transparent)' }}
-        >
-          {/* Search Input */}
-          <div className="relative">
-            <Search className="absolute left-2 top-1/2 -translate-y-1/2 w-4 h-4 text-muted-foreground pointer-events-none" />
-            <Input
-              type="text"
-              placeholder="Search tasks..."
-              value={searchQuery}
-              onChange={(e) => onSearchQueryChange(e.target.value)}
-              className="h-8 w-48 pl-8 pr-8 text-sm bg-background/50"
-            />
-            {searchQuery && (
-              <button
-                onClick={() => onSearchQueryChange('')}
-                className="absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
-                aria-label="Clear search"
-              >
-                <X className="w-3.5 h-3.5" />
-              </button>
-            )}
-          </div>
-
-          {/* Divider */}
-          <div className="h-6 w-px bg-border" />
-
-          {/* Category Filter Dropdown */}
-          <Popover>
-            <Tooltip>
-              <TooltipTrigger asChild>
-                <PopoverTrigger asChild>
-                  <Button
-                    variant="ghost"
-                    size="sm"
-                    className={cn(
-                      'h-8 px-2 gap-1.5',
-                      selectedCategories.length > 0 && 'bg-brand-500/20 text-brand-500'
-                    )}
-                  >
-                    <Filter className="w-4 h-4" />
-                    <span className="text-xs max-w-[100px] truncate">{categoryButtonLabel}</span>
-                    <ChevronDown className="w-3 h-3 opacity-50" />
-                  </Button>
-                </PopoverTrigger>
-              </TooltipTrigger>
-              <TooltipContent>Filter by Category</TooltipContent>
-            </Tooltip>
-            <PopoverContent align="start" className="w-56 p-2">
-              <div className="space-y-2">
-                <div className="text-xs font-medium text-muted-foreground px-2 py-1">
-                  Categories
-                </div>
-
-                {/* Select All option */}
-                <div
-                  className="flex items-center gap-2 px-2 py-1.5 rounded hover:bg-accent cursor-pointer"
-                  onClick={handleSelectAllCategories}
-                >
-                  <Checkbox
-                    checked={
-                      selectedCategories.length === availableCategories.length &&
-                      availableCategories.length > 0
-                    }
-                    onCheckedChange={handleSelectAllCategories}
-                  />
-                  <span className="text-sm font-medium">
-                    {selectedCategories.length === availableCategories.length
-                      ? 'Deselect All'
-                      : 'Select All'}
-                  </span>
-                </div>
-
-                <div className="h-px bg-border" />
-
-                {/* Category list */}
-                <div className="max-h-48 overflow-y-auto space-y-0.5">
-                  {availableCategories.length === 0 ? (
-                    <div className="text-xs text-muted-foreground px-2 py-2">
-                      No categories available
-                    </div>
-                  ) : (
-                    availableCategories.map((category) => (
-                      <div
-                        key={category}
-                        className="flex items-center gap-2 px-2 py-1.5 rounded hover:bg-accent cursor-pointer"
-                        onClick={() => handleCategoryToggle(category)}
-                      >
-                        <Checkbox
-                          checked={selectedCategories.includes(category)}
-                          onCheckedChange={() => handleCategoryToggle(category)}
-                        />
-                        <span className="text-sm truncate">{category}</span>
-                      </div>
-                    ))
-                  )}
-                </div>
-              </div>
-            </PopoverContent>
-          </Popover>
-
-          {/* Status Filter Dropdown */}
-          <Popover>
-            <Tooltip>
-              <TooltipTrigger asChild>
-                <PopoverTrigger asChild>
-                  <Button
-                    variant="ghost"
-                    size="sm"
-                    className={cn(
-                      'h-8 px-2 gap-1.5',
-                      selectedStatuses.length > 0 && 'bg-brand-500/20 text-brand-500'
-                    )}
-                  >
-                    <CircleDot className="w-4 h-4" />
-                    <span className="text-xs max-w-[120px] truncate">{statusButtonLabel}</span>
-                    <ChevronDown className="w-3 h-3 opacity-50" />
-                  </Button>
-                </PopoverTrigger>
-              </TooltipTrigger>
-              <TooltipContent>Filter by Status</TooltipContent>
-            </Tooltip>
-            <PopoverContent align="start" className="w-56 p-2">
-              <div className="space-y-2">
-                <div className="text-xs font-medium text-muted-foreground px-2 py-1">Status</div>
-
-                {/* Select All option */}
-                <div
-                  className="flex items-center gap-2 px-2 py-1.5 rounded hover:bg-accent cursor-pointer"
-                  onClick={handleSelectAllStatuses}
-                >
-                  <Checkbox
-                    checked={selectedStatuses.length === STATUS_FILTER_OPTIONS.length}
-                    onCheckedChange={handleSelectAllStatuses}
-                  />
-                  <span className="text-sm font-medium">
-                    {selectedStatuses.length === STATUS_FILTER_OPTIONS.length
-                      ? 'Deselect All'
-                      : 'Select All'}
-                  </span>
-                </div>
-
-                <div className="h-px bg-border" />
-
-                {/* Status list */}
-                <div className="space-y-0.5">
-                  {STATUS_FILTER_OPTIONS.map((status) => {
-                    const config = statusDisplayConfig[status];
-                    const StatusIcon = config.icon;
-                    return (
-                      <div
-                        key={status}
-                        className="flex items-center gap-2 px-2 py-1.5 rounded hover:bg-accent cursor-pointer"
-                        onClick={() => handleStatusToggle(status)}
-                      >
-                        <Checkbox
-                          checked={selectedStatuses.includes(status)}
-                          onCheckedChange={() => handleStatusToggle(status)}
-                        />
-                        <StatusIcon className={cn('w-3.5 h-3.5', config.colorClass)} />
-                        <span className="text-sm">{config.label}</span>
-                      </div>
-                    );
-                  })}
-                </div>
-              </div>
-            </PopoverContent>
-          </Popover>
-
-          {/* Divider */}
-          <div className="h-6 w-px bg-border" />
-
-          {/* Positive/Negative Filter Toggle */}
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <div className="flex items-center gap-2">
-                <button
-                  onClick={() => onNegativeFilterChange(!isNegativeFilter)}
-                  aria-label={
-                    isNegativeFilter
-                      ? 'Switch to show matching nodes'
-                      : 'Switch to hide matching nodes'
-                  }
-                  aria-pressed={isNegativeFilter}
-                  className={cn(
-                    'flex items-center gap-1.5 px-2 py-1 rounded text-xs transition-colors',
-                    isNegativeFilter
-                      ? 'bg-orange-500/20 text-orange-500'
-                      : 'hover:bg-accent text-muted-foreground hover:text-foreground'
-                  )}
-                >
-                  {isNegativeFilter ? (
-                    <>
-                      <EyeOff className="w-3.5 h-3.5" />
-                      <span>Hide</span>
-                    </>
-                  ) : (
-                    <>
-                      <Eye className="w-3.5 h-3.5" />
-                      <span>Show</span>
-                    </>
-                  )}
-                </button>
-                <Switch
-                  checked={isNegativeFilter}
-                  onCheckedChange={onNegativeFilterChange}
-                  aria-label="Toggle between show and hide filter modes"
-                  className="h-5 w-9 data-[state=checked]:bg-orange-500"
-                />
-              </div>
-            </TooltipTrigger>
-            <TooltipContent>
-              {isNegativeFilter
-                ? 'Negative filter: Highlighting non-matching nodes'
-                : 'Positive filter: Highlighting matching nodes'}
-            </TooltipContent>
-          </Tooltip>
-
-          {/* Clear Filters Button - only show when filters are active */}
-          {hasActiveFilter && (
-            <>
-              <div className="h-6 w-px bg-border" />
-              <Tooltip>
-                <TooltipTrigger asChild>
-                  <Button
-                    variant="ghost"
-                    size="sm"
-                    className="h-8 w-8 p-0 text-muted-foreground hover:text-destructive"
-                    onClick={onClearFilters}
-                    aria-label="Clear all filters"
-                  >
-                    <X className="w-4 h-4" />
-                  </Button>
-                </TooltipTrigger>
-                <TooltipContent>Clear All Filters</TooltipContent>
-              </Tooltip>
-            </>
+      <div
+        className="flex items-center gap-2 p-2 rounded-lg backdrop-blur-sm border border-border shadow-lg text-popover-foreground"
+        style={{ backgroundColor: 'color-mix(in oklch, var(--popover) 90%, transparent)' }}
+      >
+        {/* Search Input */}
+        <div className="relative">
+          <Search className="absolute left-2 top-1/2 -translate-y-1/2 w-4 h-4 text-muted-foreground pointer-events-none" />
+          <Input
+            type="text"
+            placeholder="Search tasks..."
+            value={searchQuery}
+            onChange={(e) => onSearchQueryChange(e.target.value)}
+            className="h-8 w-48 pl-8 pr-8 text-sm bg-background/50"
+          />
+          {searchQuery && (
+            <button
+              onClick={() => onSearchQueryChange('')}
+              className="absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
+              aria-label="Clear search"
+            >
+              <X className="w-3.5 h-3.5" />
+            </button>
           )}
         </div>
-      </TooltipProvider>
+
+        {/* Divider */}
+        <div className="h-6 w-px bg-border" />
+
+        {/* Category Filter Dropdown */}
+        <Popover>
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <PopoverTrigger asChild>
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  className={cn(
+                    'h-8 px-2 gap-1.5',
+                    selectedCategories.length > 0 && 'bg-brand-500/20 text-brand-500'
+                  )}
+                >
+                  <Filter className="w-4 h-4" />
+                  <span className="text-xs max-w-[100px] truncate">{categoryButtonLabel}</span>
+                  <ChevronDown className="w-3 h-3 opacity-50" />
+                </Button>
+              </PopoverTrigger>
+            </TooltipTrigger>
+            <TooltipContent>Filter by Category</TooltipContent>
+          </Tooltip>
+          <PopoverContent
+            align="start"
+            className="w-56 p-2"
+            onOpenAutoFocus={(e) => e.preventDefault()}
+          >
+            <div className="space-y-2">
+              <div className="text-xs font-medium text-muted-foreground px-2 py-1">Categories</div>
+
+              {/* Select All option */}
+              <div
+                className="flex items-center gap-2 px-2 py-1.5 rounded hover:bg-accent cursor-pointer"
+                onClick={handleSelectAllCategories}
+              >
+                <Checkbox
+                  checked={
+                    selectedCategories.length === availableCategories.length &&
+                    availableCategories.length > 0
+                  }
+                  onCheckedChange={handleSelectAllCategories}
+                />
+                <span className="text-sm font-medium">
+                  {selectedCategories.length === availableCategories.length
+                    ? 'Deselect All'
+                    : 'Select All'}
+                </span>
+              </div>
+
+              <div className="h-px bg-border" />
+
+              {/* Category list */}
+              <div className="max-h-48 overflow-y-auto space-y-0.5">
+                {availableCategories.length === 0 ? (
+                  <div className="text-xs text-muted-foreground px-2 py-2">
+                    No categories available
+                  </div>
+                ) : (
+                  availableCategories.map((category) => (
+                    <div
+                      key={category}
+                      className="flex items-center gap-2 px-2 py-1.5 rounded hover:bg-accent cursor-pointer"
+                      onClick={() => handleCategoryToggle(category)}
+                    >
+                      <Checkbox
+                        checked={selectedCategories.includes(category)}
+                        onCheckedChange={() => handleCategoryToggle(category)}
+                      />
+                      <span className="text-sm truncate">{category}</span>
+                    </div>
+                  ))
+                )}
+              </div>
+            </div>
+          </PopoverContent>
+        </Popover>
+
+        {/* Status Filter Dropdown */}
+        <Popover>
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <PopoverTrigger asChild>
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  className={cn(
+                    'h-8 px-2 gap-1.5',
+                    selectedStatuses.length > 0 && 'bg-brand-500/20 text-brand-500'
+                  )}
+                >
+                  <CircleDot className="w-4 h-4" />
+                  <span className="text-xs max-w-[120px] truncate">{statusButtonLabel}</span>
+                  <ChevronDown className="w-3 h-3 opacity-50" />
+                </Button>
+              </PopoverTrigger>
+            </TooltipTrigger>
+            <TooltipContent>Filter by Status</TooltipContent>
+          </Tooltip>
+          <PopoverContent
+            align="start"
+            className="w-56 p-2"
+            onOpenAutoFocus={(e) => e.preventDefault()}
+          >
+            <div className="space-y-2">
+              <div className="text-xs font-medium text-muted-foreground px-2 py-1">Status</div>
+
+              {/* Select All option */}
+              <div
+                className="flex items-center gap-2 px-2 py-1.5 rounded hover:bg-accent cursor-pointer"
+                onClick={handleSelectAllStatuses}
+              >
+                <Checkbox
+                  checked={selectedStatuses.length === STATUS_FILTER_OPTIONS.length}
+                  onCheckedChange={handleSelectAllStatuses}
+                />
+                <span className="text-sm font-medium">
+                  {selectedStatuses.length === STATUS_FILTER_OPTIONS.length
+                    ? 'Deselect All'
+                    : 'Select All'}
+                </span>
+              </div>
+
+              <div className="h-px bg-border" />
+
+              {/* Status list */}
+              <div className="space-y-0.5">
+                {STATUS_FILTER_OPTIONS.map((status) => {
+                  const config = statusDisplayConfig[status];
+                  const StatusIcon = config.icon;
+                  return (
+                    <div
+                      key={status}
+                      className="flex items-center gap-2 px-2 py-1.5 rounded hover:bg-accent cursor-pointer"
+                      onClick={() => handleStatusToggle(status)}
+                    >
+                      <Checkbox
+                        checked={selectedStatuses.includes(status)}
+                        onCheckedChange={() => handleStatusToggle(status)}
+                      />
+                      <StatusIcon className={cn('w-3.5 h-3.5', config.colorClass)} />
+                      <span className="text-sm">{config.label}</span>
+                    </div>
+                  );
+                })}
+              </div>
+            </div>
+          </PopoverContent>
+        </Popover>
+
+        {/* Divider */}
+        <div className="h-6 w-px bg-border" />
+
+        {/* Positive/Negative Filter Toggle */}
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <div className="flex items-center gap-2">
+              <button
+                onClick={() => onNegativeFilterChange(!isNegativeFilter)}
+                aria-label={
+                  isNegativeFilter
+                    ? 'Switch to show matching nodes'
+                    : 'Switch to hide matching nodes'
+                }
+                aria-pressed={isNegativeFilter}
+                className={cn(
+                  'flex items-center gap-1.5 px-2 py-1 rounded text-xs transition-colors',
+                  isNegativeFilter
+                    ? 'bg-orange-500/20 text-orange-500'
+                    : 'hover:bg-accent text-muted-foreground hover:text-foreground'
+                )}
+              >
+                {isNegativeFilter ? (
+                  <>
+                    <EyeOff className="w-3.5 h-3.5" />
+                    <span>Hide</span>
+                  </>
+                ) : (
+                  <>
+                    <Eye className="w-3.5 h-3.5" />
+                    <span>Show</span>
+                  </>
+                )}
+              </button>
+              <Switch
+                checked={isNegativeFilter}
+                onCheckedChange={onNegativeFilterChange}
+                aria-label="Toggle between show and hide filter modes"
+                className="h-5 w-9 data-[state=checked]:bg-orange-500"
+              />
+            </div>
+          </TooltipTrigger>
+          <TooltipContent>
+            {isNegativeFilter
+              ? 'Negative filter: Highlighting non-matching nodes'
+              : 'Positive filter: Highlighting matching nodes'}
+          </TooltipContent>
+        </Tooltip>
+
+        {/* Clear Filters Button - only show when filters are active */}
+        {hasActiveFilter && (
+          <>
+            <div className="h-6 w-px bg-border" />
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  className="h-8 w-8 p-0 text-muted-foreground hover:text-destructive"
+                  onClick={onClearFilters}
+                  aria-label="Clear all filters"
+                >
+                  <X className="w-4 h-4" />
+                </Button>
+              </TooltipTrigger>
+              <TooltipContent>Clear All Filters</TooltipContent>
+            </Tooltip>
+          </>
+        )}
+      </div>
     </Panel>
   );
 }

apps/ui/src/components/views/graph-view/components/task-node.tsx

@@ -26,7 +26,7 @@ import {
   DropdownMenuItem,
   DropdownMenuTrigger,
 } from '@/components/ui/dropdown-menu';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 
 type TaskNodeProps = NodeProps & {
   data: TaskNodeData;
@@ -286,50 +286,44 @@ export const TaskNode = memo(function TaskNode({ data, selected }: TaskNodeProps
 
             {/* Blocked indicator */}
             {data.isBlocked && !data.error && data.status === 'backlog' && (
-              <TooltipProvider delayDuration={200}>
-                <Tooltip>
-                  <TooltipTrigger asChild>
-                    <div className="p-1 rounded bg-orange-500/20">
-                      <Lock className="w-3 h-3 text-orange-500" />
-                    </div>
-                  </TooltipTrigger>
-                  <TooltipContent side="top" className="text-xs max-w-[200px]">
-                    <p>Blocked by {data.blockingDependencies.length} dependencies</p>
-                  </TooltipContent>
-                </Tooltip>
-              </TooltipProvider>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <div className="p-1 rounded bg-orange-500/20">
+                    <Lock className="w-3 h-3 text-orange-500" />
+                  </div>
+                </TooltipTrigger>
+                <TooltipContent side="top" className="text-xs max-w-[200px]">
+                  <p>Blocked by {data.blockingDependencies.length} dependencies</p>
+                </TooltipContent>
+              </Tooltip>
             )}
 
             {/* Error indicator */}
             {data.error && (
-              <TooltipProvider delayDuration={200}>
-                <Tooltip>
-                  <TooltipTrigger asChild>
-                    <div className="p-1 rounded bg-[var(--status-error-bg)]">
-                      <AlertCircle className="w-3 h-3 text-[var(--status-error)]" />
-                    </div>
-                  </TooltipTrigger>
-                  <TooltipContent side="top" className="text-xs max-w-[250px]">
-                    <p>{data.error}</p>
-                  </TooltipContent>
-                </Tooltip>
-              </TooltipProvider>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <div className="p-1 rounded bg-[var(--status-error-bg)]">
+                    <AlertCircle className="w-3 h-3 text-[var(--status-error)]" />
+                  </div>
+                </TooltipTrigger>
+                <TooltipContent side="top" className="text-xs max-w-[250px]">
+                  <p>{data.error}</p>
+                </TooltipContent>
+              </Tooltip>
             )}
 
             {/* Stopped indicator - task is in_progress but not actively running */}
             {isStopped && (
-              <TooltipProvider delayDuration={200}>
-                <Tooltip>
-                  <TooltipTrigger asChild>
-                    <div className="p-1 rounded bg-[var(--status-warning-bg)]">
-                      <Pause className="w-3 h-3 text-[var(--status-warning)]" />
-                    </div>
-                  </TooltipTrigger>
-                  <TooltipContent side="top" className="text-xs max-w-[200px]">
-                    <p>Task paused - click menu to resume</p>
-                  </TooltipContent>
-                </Tooltip>
-              </TooltipProvider>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <div className="p-1 rounded bg-[var(--status-warning-bg)]">
+                    <Pause className="w-3 h-3 text-[var(--status-warning)]" />
+                  </div>
+                </TooltipTrigger>
+                <TooltipContent side="top" className="text-xs max-w-[200px]">
+                  <p>Task paused - click menu to resume</p>
+                </TooltipContent>
+              </Tooltip>
             )}
 
             {/* Actions dropdown */}

apps/ui/src/components/views/graph-view/graph-canvas.tsx

@@ -175,9 +175,7 @@ function GraphCanvasInner({
       mql.addEventListener('change', update);
       return () => mql.removeEventListener('change', update);
     }
-    // eslint-disable-next-line deprecation/deprecation
     mql.addListener(update);
-    // eslint-disable-next-line deprecation/deprecation
     return () => mql.removeListener(update);
   }, [effectiveTheme]);
 

apps/ui/src/components/views/graph-view/hooks/use-graph-layout.ts

@@ -1,6 +1,5 @@
 import { useCallback, useMemo, useRef } from 'react';
 import dagre from 'dagre';
-import { Node, Edge } from '@xyflow/react';
 import { TaskNode, DependencyEdge } from './use-graph-nodes';
 
 const NODE_WIDTH = 280;

apps/ui/src/components/views/graph-view/hooks/use-graph-nodes.ts

@@ -174,7 +174,7 @@ export function useGraphNodes({
               type: 'dependency',
               animated: enableEdgeAnimations && (isRunning || runningTaskIds.has(depId)),
               data: {
-                sourceStatus: sourceFeature.status,
+                sourceStatus: sourceFeature.status as Feature['status'],
                 targetStatus: feature.status,
                 isHighlighted: edgeIsHighlighted,
                 isDimmed: edgeIsDimmed,

apps/ui/src/components/views/interview-view.tsx

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { useState, useCallback, useRef, useEffect } from 'react';
 import { createLogger } from '@automaker/utils/logger';
 import { useAppStore, Feature } from '@/store/app-store';
@@ -324,7 +323,7 @@ export function InterviewView() {
       const api = getElectronAPI();
       // Use platform-specific path separator
       const pathSep =
-        typeof window !== 'undefined' && (window as any).electronAPI
+        typeof window !== 'undefined' && window.electronAPI
           ? navigator.platform.indexOf('Win') !== -1
             ? '\\'
             : '/'
@@ -349,8 +348,9 @@ export function InterviewView() {
         id: generateUUID(),
         category: 'Core',
         description: 'Initial project setup',
-        status: 'backlog' as const,
+        status: 'backlog',
         skipTests: true,
+        steps: [],
       };
 
       if (!api.features) {

apps/ui/src/components/views/notifications-view.tsx

@@ -2,13 +2,13 @@
  * Notifications View - Full page view for all notifications
  */
 
-import { useEffect, useCallback } from 'react';
+import { useCallback } from 'react';
 import { useAppStore } from '@/store/app-store';
 import { useNotificationsStore } from '@/store/notifications-store';
 import { useLoadNotifications, useNotificationEvents } from '@/hooks/use-notification-events';
 import { getHttpApiClient } from '@/lib/http-api-client';
 import { Button } from '@/components/ui/button';
-import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
+import { Card, CardContent, CardDescription, CardTitle } from '@/components/ui/card';
 import { Bell, Check, CheckCheck, Trash2, ExternalLink } from 'lucide-react';
 import { Spinner } from '@/components/ui/spinner';
 import { useNavigate } from '@tanstack/react-router';
@@ -42,8 +42,6 @@ export function NotificationsView() {
     unreadCount,
     isLoading,
     error,
-    setNotifications,
-    setUnreadCount,
     markAsRead,
     dismissNotification,
     markAllAsRead,

apps/ui/src/components/views/overview/recent-activity-feed.tsx

@@ -121,7 +121,7 @@ export function RecentActivityFeed({ activities, maxItems = 10 }: RecentActivity
     async (activity: RecentActivity) => {
       try {
         // Get project path from the activity (projectId is actually the path in our data model)
-        const projectPath = activity.projectPath || activity.projectId;
+        const projectPath = (activity.projectPath as string | undefined) || activity.projectId;
         const projectName = activity.projectName;
 
         const initResult = await initializeProject(projectPath);

apps/ui/src/components/views/overview/running-agents-panel.tsx

@@ -9,10 +9,8 @@ import { useNavigate } from '@tanstack/react-router';
 import { useAppStore } from '@/store/app-store';
 import { initializeProject } from '@/lib/project-init';
 import { toast } from 'sonner';
-import { cn } from '@/lib/utils';
 import type { ProjectStatus } from '@automaker/types';
 import { Bot, Activity, GitBranch, ArrowRight } from 'lucide-react';
-import { Button } from '@/components/ui/button';
 
 interface RunningAgentsPanelProps {
   projects: ProjectStatus[];

apps/ui/src/components/views/project-settings-view/commands-section.tsx

@@ -1,5 +1,4 @@
 import { useState, useEffect, useCallback, type KeyboardEvent } from 'react';
-import { Label } from '@/components/ui/label';
 import { Input } from '@/components/ui/input';
 import { Button } from '@/components/ui/button';
 import { Terminal, Save, RotateCcw, Info, X, Play, FlaskConical } from 'lucide-react';

apps/ui/src/components/views/project-settings-view/project-bulk-replace-dialog.tsx

@@ -168,7 +168,8 @@ export function ProjectBulkReplaceDialog({
     currentEntry: PhaseModelEntry
   ) => {
     const claudeAlias = getClaudeModelAlias(currentEntry);
-    const newEntry = findModelForClaudeAlias(selectedProviderConfig, claudeAlias, key);
+    const providerConfig: ClaudeCompatibleProvider | null = selectedProviderConfig ?? null;
+    const newEntry = findModelForClaudeAlias(providerConfig, claudeAlias, key);
 
     // Get display names
     const getCurrentDisplay = (): string => {

apps/ui/src/components/views/project-settings-view/project-identity-section.tsx

@@ -97,7 +97,7 @@ export function ProjectIdentitySection({ project }: ProjectIdentitySectionProps)
               description: result.error || 'Please try again.',
             });
           }
-        } catch (error) {
+        } catch {
           toast.error('Failed to upload icon', {
             description: 'Network error. Please try again.',
           });

apps/ui/src/components/views/project-settings-view/project-models-section.tsx

@@ -86,8 +86,6 @@ const MEMORY_TASKS: PhaseConfig[] = [
   },
 ];
 
-const ALL_PHASES = [...QUICK_TASKS, ...VALIDATION_TASKS, ...GENERATION_TASKS, ...MEMORY_TASKS];
-
 /**
  * Default feature model override section for per-project settings.
  */

apps/ui/src/components/views/running-agents-view.tsx

@@ -12,7 +12,6 @@ import { Spinner } from '@/components/ui/spinner';
 import { getElectronAPI, type RunningAgent } from '@/lib/electron';
 import { useAppStore } from '@/store/app-store';
 import { Button } from '@/components/ui/button';
-import { cn } from '@/lib/utils';
 import { useNavigate } from '@tanstack/react-router';
 import { AgentOutputModal } from './board-view/dialogs/agent-output-modal';
 import { useRunningAgents } from '@/hooks/queries';

apps/ui/src/components/views/settings-view.tsx

@@ -58,8 +58,6 @@ export function SettingsView() {
     setDefaultRequirePlanApproval,
     defaultFeatureModel,
     setDefaultFeatureModel,
-    autoLoadClaudeMd,
-    setAutoLoadClaudeMd,
     promptCustomization,
     setPromptCustomization,
     skipSandboxWarning,

apps/ui/src/components/views/settings-view/account/account-section.tsx

@@ -8,7 +8,7 @@ import {
   SelectTrigger,
   SelectValue,
 } from '@/components/ui/select';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { toast } from 'sonner';
 import { LogOut, User, Code2, RefreshCw } from 'lucide-react';
 import { Spinner } from '@/components/ui/spinner';
@@ -19,6 +19,7 @@ import { useAppStore } from '@/store/app-store';
 import {
   useAvailableEditors,
   useEffectiveDefaultEditor,
+  type EditorInfo,
 } from '@/components/views/board-view/worktree-panel/hooks/use-available-editors';
 import { getEditorIcon } from '@/components/icons/editor-icons';
 
@@ -36,7 +37,7 @@ export function AccountSection() {
 
   // Normalize Select value: if saved editor isn't found, show 'auto'
   const hasSavedEditor =
-    !!defaultEditorCommand && editors.some((e) => e.command === defaultEditorCommand);
+    !!defaultEditorCommand && editors.some((e: EditorInfo) => e.command === defaultEditorCommand);
   const selectValue = hasSavedEditor ? defaultEditorCommand : 'auto';
 
   // Get icon component for the effective editor
@@ -121,7 +122,7 @@ export function AccountSection() {
                     Auto-detect
                   </span>
                 </SelectItem>
-                {editors.map((editor) => {
+                {editors.map((editor: EditorInfo) => {
                   const Icon = getEditorIcon(editor.command);
                   return (
                     <SelectItem key={editor.command} value={editor.command}>
@@ -134,24 +135,22 @@ export function AccountSection() {
                 })}
               </SelectContent>
             </Select>
-            <TooltipProvider>
-              <Tooltip>
-                <TooltipTrigger asChild>
-                  <Button
-                    variant="ghost"
-                    size="icon"
-                    onClick={handleRefreshEditors}
-                    disabled={isRefreshing || isLoadingEditors}
-                    className="shrink-0 h-9 w-9"
-                  >
-                    {isRefreshing ? <Spinner size="sm" /> : <RefreshCw className="w-4 h-4" />}
-                  </Button>
-                </TooltipTrigger>
-                <TooltipContent>
-                  <p>Refresh available editors</p>
-                </TooltipContent>
-              </Tooltip>
-            </TooltipProvider>
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  onClick={handleRefreshEditors}
+                  disabled={isRefreshing || isLoadingEditors}
+                  className="shrink-0 h-9 w-9"
+                >
+                  {isRefreshing ? <Spinner size="sm" /> : <RefreshCw className="w-4 h-4" />}
+                </Button>
+              </TooltipTrigger>
+              <TooltipContent>
+                <p>Refresh available editors</p>
+              </TooltipContent>
+            </Tooltip>
           </div>
         </div>
 

apps/ui/src/components/views/settings-view/api-keys/api-keys-section.tsx

@@ -14,8 +14,7 @@ import { toast } from 'sonner';
 
 export function ApiKeysSection() {
   const { apiKeys, setApiKeys } = useAppStore();
-  const { claudeAuthStatus, setClaudeAuthStatus, codexAuthStatus, setCodexAuthStatus } =
-    useSetupStore();
+  const { claudeAuthStatus, setClaudeAuthStatus, setCodexAuthStatus } = useSetupStore();
   const [isDeletingAnthropicKey, setIsDeletingAnthropicKey] = useState(false);
   const [isDeletingOpenaiKey, setIsDeletingOpenaiKey] = useState(false);
 
@@ -45,7 +44,7 @@ export function ApiKeysSection() {
       } else {
         toast.error(result.error || 'Failed to delete API key');
       }
-    } catch (error) {
+    } catch {
       toast.error('Failed to delete API key');
     } finally {
       setIsDeletingAnthropicKey(false);
@@ -73,7 +72,7 @@ export function ApiKeysSection() {
       } else {
         toast.error(result.error || 'Failed to delete API key');
       }
-    } catch (error) {
+    } catch {
       toast.error('Failed to delete API key');
     } finally {
       setIsDeletingOpenaiKey(false);

apps/ui/src/components/views/settings-view/api-keys/hooks/use-api-key-management.ts

@@ -1,4 +1,4 @@
-// @ts-nocheck
+// @ts-nocheck - API key management state with validation and persistence
 import { useState, useEffect } from 'react';
 import { createLogger } from '@automaker/utils/logger';
 import { useAppStore } from '@/store/app-store';

apps/ui/src/components/views/settings-view/appearance/appearance-section.tsx

@@ -12,7 +12,6 @@ import { cn } from '@/lib/utils';
 import { useAppStore } from '@/store/app-store';
 import { FontSelector } from '@/components/shared';
 import type { Theme } from '../shared/types';
-import type { SidebarStyle } from '@automaker/types';
 
 interface AppearanceSectionProps {
   effectiveTheme: Theme;

apps/ui/src/components/views/settings-view/cli-status/claude-cli-status.tsx

@@ -89,7 +89,17 @@ export function ClaudeCliStatus({ status, authStatus, isChecking, onRefresh }: C
     setIsAuthenticating(true);
     try {
       const api = getElectronAPI();
-      const result = await api.setup.authClaude();
+      // Check if authClaude method exists on the API
+      const authClaude = (api.setup as Record<string, unknown> | undefined)?.authClaude as
+        | (() => Promise<{ success: boolean; error?: string }>)
+        | undefined;
+      if (!authClaude) {
+        toast.error('Authentication Failed', {
+          description: 'Claude authentication is not available',
+        });
+        return;
+      }
+      const result = await authClaude();
 
       if (result.success) {
         toast.success('Signed In', {
@@ -114,7 +124,17 @@ export function ClaudeCliStatus({ status, authStatus, isChecking, onRefresh }: C
     setIsDeauthenticating(true);
     try {
       const api = getElectronAPI();
-      const result = await api.setup.deauthClaude();
+      // Check if deauthClaude method exists on the API
+      const deauthClaude = (api.setup as Record<string, unknown> | undefined)?.deauthClaude as
+        | (() => Promise<{ success: boolean; error?: string }>)
+        | undefined;
+      if (!deauthClaude) {
+        toast.error('Sign Out Failed', {
+          description: 'Claude sign out is not available',
+        });
+        return;
+      }
+      const result = await deauthClaude();
 
       if (result.success) {
         toast.success('Signed Out', {

apps/ui/src/components/views/settings-view/cli-status/codex-cli-status.tsx

@@ -84,7 +84,17 @@ export function CodexCliStatus({ status, authStatus, isChecking, onRefresh }: Cl
     setIsAuthenticating(true);
     try {
       const api = getElectronAPI();
-      const result = await api.setup.authCodex();
+      // Check if authCodex method exists on the API
+      const authCodex = (api.setup as Record<string, unknown> | undefined)?.authCodex as
+        | (() => Promise<{ success: boolean; error?: string }>)
+        | undefined;
+      if (!authCodex) {
+        toast.error('Authentication Failed', {
+          description: 'Codex authentication is not available',
+        });
+        return;
+      }
+      const result = await authCodex();
 
       if (result.success) {
         toast.success('Signed In', {
@@ -109,7 +119,17 @@ export function CodexCliStatus({ status, authStatus, isChecking, onRefresh }: Cl
     setIsDeauthenticating(true);
     try {
       const api = getElectronAPI();
-      const result = await api.setup.deauthCodex();
+      // Check if deauthCodex method exists on the API
+      const deauthCodex = (api.setup as Record<string, unknown> | undefined)?.deauthCodex as
+        | (() => Promise<{ success: boolean; error?: string }>)
+        | undefined;
+      if (!deauthCodex) {
+        toast.error('Sign Out Failed', {
+          description: 'Codex sign out is not available',
+        });
+        return;
+      }
+      const result = await deauthCodex();
 
       if (result.success) {
         toast.success('Signed Out', {

apps/ui/src/components/views/settings-view/cli-status/cursor-cli-status.tsx

@@ -209,7 +209,17 @@ export function CursorCliStatus({ status, isChecking, onRefresh }: CursorCliStat
     setIsAuthenticating(true);
     try {
       const api = getElectronAPI();
-      const result = await api.setup.authCursor();
+      // Check if authCursor method exists on the API
+      const authCursor = (api?.setup as Record<string, unknown> | undefined)?.authCursor as
+        | (() => Promise<{ success: boolean; error?: string }>)
+        | undefined;
+      if (!authCursor) {
+        toast.error('Authentication Failed', {
+          description: 'Cursor authentication is not available',
+        });
+        return;
+      }
+      const result = await authCursor();
 
       if (result.success) {
         toast.success('Signed In', {
@@ -234,7 +244,17 @@ export function CursorCliStatus({ status, isChecking, onRefresh }: CursorCliStat
     setIsDeauthenticating(true);
     try {
       const api = getElectronAPI();
-      const result = await api.setup.deauthCursor();
+      // Check if deauthCursor method exists on the API
+      const deauthCursor = (api?.setup as Record<string, unknown> | undefined)?.deauthCursor as
+        | (() => Promise<{ success: boolean; error?: string }>)
+        | undefined;
+      if (!deauthCursor) {
+        toast.error('Sign Out Failed', {
+          description: 'Cursor sign out is not available',
+        });
+        return;
+      }
+      const result = await deauthCursor();
 
       if (result.success) {
         toast.success('Signed Out', {

apps/ui/src/components/views/settings-view/cli-status/gemini-cli-status.tsx

@@ -1,7 +1,7 @@
 import { Button } from '@/components/ui/button';
 import { SkeletonPulse } from '@/components/ui/skeleton';
 import { Spinner } from '@/components/ui/spinner';
-import { CheckCircle2, AlertCircle, RefreshCw, Key } from 'lucide-react';
+import { CheckCircle2, AlertCircle, RefreshCw } from 'lucide-react';
 import { cn } from '@/lib/utils';
 import type { CliStatus } from '../shared/types';
 import { GeminiIcon } from '@/components/ui/provider-icon';