Merge main into massive-terminal-upgrade

Resolves merge conflicts:
- apps/server/src/routes/terminal/common.ts: Keep randomBytes import, use @automaker/utils for createLogger
- apps/ui/eslint.config.mjs: Use main's explicit globals list with XMLHttpRequest and MediaQueryListEvent additions
- apps/ui/src/components/views/terminal-view.tsx: Keep our terminal improvements (killAllSessions, beforeunload, better error handling)
- apps/ui/src/config/terminal-themes.ts: Keep our search highlight colors for all themes
- apps/ui/src/store/app-store.ts: Keep our terminal settings persistence improvements (merge function)

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

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

libs/dependency-resolver/README.md

@@ -0,0 +1,188 @@
+# @automaker/dependency-resolver
+
+Feature dependency resolution using topological sorting.
+
+## Overview
+
+This package provides dependency resolution for AutoMaker features using Kahn's algorithm with priority-aware ordering. It ensures features are executed in the correct order based on their dependencies.
+
+## Installation
+
+```bash
+npm install @automaker/dependency-resolver
+```
+
+## Exports
+
+### Resolve Dependencies
+
+Order features based on dependencies and priorities.
+
+```typescript
+import { resolveDependencies } from '@automaker/dependency-resolver';
+import type { Feature } from '@automaker/types';
+
+const features: Feature[] = [
+  {
+    id: 'database',
+    category: 'backend',
+    description: 'Setup database',
+    priority: 1,
+  },
+  {
+    id: 'auth',
+    category: 'backend',
+    description: 'Add authentication',
+    dependencies: ['database'],
+    priority: 2,
+  },
+  {
+    id: 'api',
+    category: 'backend',
+    description: 'Create API endpoints',
+    dependencies: ['auth'],
+    priority: 3,
+  },
+];
+
+const result = resolveDependencies(features);
+
+console.log(result.orderedFeatures);
+// [database, auth, api]
+
+if (result.hasCycle) {
+  console.error('Circular dependency detected!');
+  console.error('Features in cycle:', result.cyclicFeatures);
+}
+```
+
+### Check Dependencies Satisfied
+
+Check if a feature's dependencies are satisfied.
+
+```typescript
+import { areDependenciesSatisfied } from '@automaker/dependency-resolver';
+
+const allFeatures: Feature[] = [
+  { id: 'database', status: 'completed', ... },
+  { id: 'auth', status: 'pending', dependencies: ['database'], ... }
+];
+
+const authFeature = allFeatures.find(f => f.id === 'auth');
+
+if (areDependenciesSatisfied(authFeature, allFeatures)) {
+  console.log('Auth feature is ready to execute');
+} else {
+  console.log('Waiting for dependencies');
+}
+```
+
+### Get Blocking Dependencies
+
+Get list of incomplete dependencies blocking a feature.
+
+```typescript
+import { getBlockingDependencies } from '@automaker/dependency-resolver';
+
+const blocking = getBlockingDependencies(feature, allFeatures);
+
+if (blocking.length > 0) {
+  console.log(`Feature blocked by: ${blocking.join(', ')}`);
+} else {
+  console.log('No blocking dependencies');
+}
+```
+
+## Usage Example
+
+```typescript
+import {
+  resolveDependencies,
+  areDependenciesSatisfied,
+  getBlockingDependencies,
+} from '@automaker/dependency-resolver';
+import type { Feature } from '@automaker/types';
+
+async function executeFeatures(features: Feature[]) {
+  // Resolve dependency order
+  const { orderedFeatures, hasCycle, cyclicFeatures } = resolveDependencies(features);
+
+  if (hasCycle) {
+    throw new Error(`Circular dependency: ${cyclicFeatures.join(' → ')}`);
+  }
+
+  // Execute in order
+  for (const feature of orderedFeatures) {
+    // Check if dependencies are satisfied
+    if (!areDependenciesSatisfied(feature, features)) {
+      const blocking = getBlockingDependencies(feature, features);
+      console.log(`Skipping ${feature.id}, blocked by: ${blocking.join(', ')}`);
+      continue;
+    }
+
+    // Execute feature
+    console.log(`Executing: ${feature.id}`);
+    await executeFeature(feature);
+
+    // Mark as completed
+    feature.status = 'completed';
+  }
+}
+```
+
+## Algorithm
+
+### Topological Sort (Kahn's Algorithm)
+
+1. Calculate in-degree for each feature (number of dependencies)
+2. Start with features that have no dependencies (in-degree = 0)
+3. Process features in priority order
+4. Remove processed features from dependency graph
+5. Repeat until all features processed or cycle detected
+
+### Priority Handling
+
+- Features with lower priority numbers execute first
+- When multiple features have same in-degree, priority determines order
+- Features without explicit priority default to lowest priority
+
+### Cycle Detection
+
+- Detects circular dependencies
+- Returns affected features in cycle
+- Prevents infinite loops in execution
+
+## Return Types
+
+### DependencyResolutionResult
+
+```typescript
+interface DependencyResolutionResult {
+  orderedFeatures: Feature[]; // Features in execution order
+  hasCycle: boolean; // True if circular dependency detected
+  cyclicFeatures: string[]; // Feature IDs involved in cycle
+}
+```
+
+## Edge Cases
+
+### Missing Dependencies
+
+Features with dependencies on non-existent features are treated as if the dependency is satisfied (allows flexibility).
+
+### Self-Dependencies
+
+Features depending on themselves are detected as cycles.
+
+### Empty Dependencies Array
+
+Treated same as no dependencies - feature is ready immediately.
+
+## Dependencies
+
+- `@automaker/types` - Feature type definition
+
+## Used By
+
+- `@automaker/server` - Auto-mode feature execution
+- `@automaker/ui` - Board view feature ordering