📝 Add docstrings to fix/pipeline-resume-edge-cases

Docstrings generation was requested by @casiusss.

* https://github.com/AutoMaker-Org/automaker/pull/344#issuecomment-3705368737

The following files were modified:

* `apps/ui/src/components/views/board-view/components/kanban-card/card-actions.tsx`
* `apps/ui/src/components/views/board-view/hooks/use-board-effects.ts`

.claude/commands/gh-issue.md

@@ -0,0 +1,74 @@
+# GitHub Issue Fix Command
+
+Fetch a GitHub issue by number, verify it's a real issue, and fix it if valid.
+
+## Usage
+
+This command accepts a GitHub issue number as input (e.g., `123`).
+
+## Instructions
+
+1. **Get the issue number from the user**
+   - The issue number should be provided as an argument to this command
+   - If no number is provided, ask the user for it
+
+2. **Fetch the GitHub issue**
+   - Determine the current project path (check if there's a current project context)
+   - Verify the project has a GitHub remote:
+     ```bash
+     git remote get-url origin
+     ```
+   - Fetch the issue details using GitHub CLI:
+     ```bash
+     gh issue view <ISSUE_NUMBER> --json number,title,state,author,createdAt,labels,url,body,assignees
+     ```
+   - If the command fails, report the error and stop
+
+3. **Verify the issue is real and valid**
+   - Check that the issue exists (not 404)
+   - Check the issue state:
+     - If **closed**: Inform the user and ask if they still want to proceed
+     - If **open**: Proceed with validation
+   - Review the issue content:
+     - Read the title and body to understand what needs to be fixed
+     - Check labels for context (bug, enhancement, etc.)
+     - Note any assignees or linked PRs
+
+4. **Validate the issue**
+   - Determine if this is a legitimate issue that needs fixing:
+     - Is the description clear and actionable?
+     - Does it describe a real problem or feature request?
+     - Are there any obvious signs it's spam or invalid?
+   - If the issue seems invalid or unclear:
+     - Report findings to the user
+     - Ask if they want to proceed anyway
+     - Stop if user confirms it's not valid
+
+5. **If the issue is valid, proceed to fix it**
+   - Analyze what needs to be done based on the issue description
+   - Check the current codebase state:
+     - Run relevant tests to see current behavior
+     - Check if the issue is already fixed
+     - Look for related code that might need changes
+   - Implement the fix:
+     - Make necessary code changes
+     - Update or add tests as needed
+     - Ensure the fix addresses the issue description
+   - Verify the fix:
+     - Run tests to ensure nothing broke
+     - If possible, manually verify the fix addresses the issue
+
+6. **Report summary**
+   - Issue number and title
+   - Issue state (open/closed)
+   - Whether the issue was validated as real
+   - What was fixed (if anything)
+   - Any tests that were updated or added
+   - Next steps (if any)
+
+## Error Handling
+
+- If GitHub CLI (`gh`) is not installed or authenticated, report error and stop
+- If the project doesn't have a GitHub remote, report error and stop
+- If the issue number doesn't exist, report error and stop
+- If the issue is unclear or invalid, report findings and ask user before proceeding

.claude/commands/release.md

@@ -0,0 +1,77 @@
+# Release Command
+
+Bump the package.json version (major, minor, or patch) and build the Electron app with the new version.
+
+## Usage
+
+This command accepts a version bump type as input:
+
+- `patch` - Bump patch version (0.1.0 -> 0.1.1)
+- `minor` - Bump minor version (0.1.0 -> 0.2.0)
+- `major` - Bump major version (0.1.0 -> 1.0.0)
+
+## Instructions
+
+1. **Get the bump type from the user**
+   - The bump type should be provided as an argument (patch, minor, or major)
+   - If no type is provided, ask the user which type they want
+
+2. **Bump the version**
+   - Run the version bump script:
+     ```bash
+     node apps/ui/scripts/bump-version.mjs <type>
+     ```
+   - This updates both `apps/ui/package.json` and `apps/server/package.json` with the new version (keeps them in sync)
+   - Verify the version was updated correctly by checking the output
+
+3. **Build the Electron app**
+   - Run the electron build:
+     ```bash
+     npm run build:electron --workspace=apps/ui
+     ```
+   - The build process automatically:
+     - Uses the version from `package.json` for artifact names (e.g., `Automaker-1.2.3-x64.zip`)
+     - Injects the version into the app via Vite's `__APP_VERSION__` constant
+     - Displays the version below the logo in the sidebar
+
+4. **Commit the version bump**
+   - Stage the updated package.json files:
+     ```bash
+     git add apps/ui/package.json apps/server/package.json
+     ```
+   - Commit with a release message:
+     ```bash
+     git commit -m "chore: release v<version>"
+     ```
+
+5. **Create and push the git tag**
+   - Create an annotated tag for the release:
+     ```bash
+     git tag -a v<version> -m "Release v<version>"
+     ```
+   - Push the commit and tag to remote:
+     ```bash
+     git push && git push --tags
+     ```
+
+6. **Verify the release**
+   - Check that the build completed successfully
+   - Confirm the version appears correctly in the built artifacts
+   - The version will be displayed in the app UI below the logo
+   - Verify the tag is visible on the remote repository
+
+## Version Centralization
+
+The version is centralized and synchronized in both `apps/ui/package.json` and `apps/server/package.json`:
+
+- **Electron builds**: Automatically read from `apps/ui/package.json` via electron-builder's `${version}` variable in `artifactName`
+- **App display**: Injected at build time via Vite's `define` config as `__APP_VERSION__` constant (defined in `apps/ui/vite.config.mts`)
+- **Server API**: Read from `apps/server/package.json` via `apps/server/src/lib/version.ts` utility (used in health check endpoints)
+- **Type safety**: Defined in `apps/ui/src/vite-env.d.ts` as `declare const __APP_VERSION__: string`
+
+This ensures consistency across:
+
+- Build artifact names (e.g., `Automaker-1.2.3-x64.zip`)
+- App UI display (shown as `v1.2.3` below the logo in `apps/ui/src/components/layout/sidebar/components/automaker-logo.tsx`)
+- Server health endpoints (`/` and `/detailed`)
+- Package metadata (both UI and server packages stay in sync)

.claude/commands/validate-build.md

@@ -0,0 +1,49 @@
+# Project Build and Fix Command
+
+Run all builds and intelligently fix any failures based on what changed.
+
+## Instructions
+
+1. **Run the build**
+
+   ```bash
+   npm run build
+   ```
+
+   This builds all packages and the UI application.
+
+2. **If the build succeeds**, report success and stop.
+
+3. **If the build fails**, analyze the failures:
+   - Note which build step failed and the error messages
+   - Check for TypeScript compilation errors, missing dependencies, or configuration issues
+   - Run `git diff main` to see what code has changed
+
+4. **Determine the nature of the failure**:
+   - **If the failure is due to intentional changes** (new features, refactoring, dependency updates):
+     - Fix any TypeScript type errors introduced by the changes
+     - Update build configuration if needed (e.g., tsconfig.json, vite.config.mts)
+     - Ensure all new dependencies are properly installed
+     - Fix import paths or module resolution issues
+
+   - **If the failure appears to be a regression** (broken imports, missing files, configuration errors):
+     - Fix the source code to restore the build
+     - Check for accidentally deleted files or broken references
+     - Verify build configuration files are correct
+
+5. **Common build issues to check**:
+   - **TypeScript errors**: Fix type mismatches, missing types, or incorrect imports
+   - **Missing dependencies**: Run `npm install` if packages are missing
+   - **Import/export errors**: Fix incorrect import paths or missing exports
+   - **Build configuration**: Check tsconfig.json, vite.config.mts, or other build configs
+   - **Package build order**: Ensure `build:packages` completes before building apps
+
+6. **How to decide if it's intentional vs regression**:
+   - Look at the git diff and commit messages
+   - If the change was deliberate and introduced new code that needs fixing → fix the new code
+   - If the change broke existing functionality that should still build → fix the regression
+   - When in doubt, ask the user
+
+7. **After making fixes**, re-run the build to verify everything compiles successfully.
+
+8. **Report summary** of what was fixed (TypeScript errors, configuration issues, missing dependencies, etc.).

.claude/commands/validate-tests.md

@@ -0,0 +1,36 @@
+# Project Test and Fix Command
+
+Run all tests and intelligently fix any failures based on what changed.
+
+## Instructions
+
+1. **Run all tests**
+
+   ```bash
+   npm run test:all
+   ```
+
+2. **If all tests pass**, report success and stop.
+
+3. **If any tests fail**, analyze the failures:
+   - Note which tests failed and their error messages
+   - Run `git diff main` to see what code has changed
+
+4. **Determine the nature of the change**:
+   - **If the logic change is intentional** (new feature, refactor, behavior change):
+     - Update the failing tests to match the new expected behavior
+     - The tests should reflect what the code NOW does correctly
+
+   - **If the logic change appears to be a bug** (regression, unintended side effect):
+     - Fix the source code to restore the expected behavior
+     - Do NOT modify the tests - they are catching a real bug
+
+5. **How to decide if it's a bug vs intentional change**:
+   - Look at the git diff and commit messages
+   - If the change was deliberate and the test expectations are now outdated → update tests
+   - If the change broke existing functionality that should still work → fix the code
+   - When in doubt, ask the user
+
+6. **After making fixes**, re-run the tests to verify everything passes.
+
+7. **Report summary** of what was fixed (tests updated vs code fixed).

.claude/settings.local.json

@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(dir \"C:\\Users\\Ben\\Desktop\\appdev\\git\\automaker\\apps\\app\\public\")"
-    ]
-  }
-}

.claude_settings.json

@@ -1,24 +0,0 @@
-{
-  "sandbox": {
-    "enabled": true,
-    "autoAllowBashIfSandboxed": true
-  },
-  "permissions": {
-    "defaultMode": "acceptEdits",
-    "allow": [
-      "Read(./**)",
-      "Write(./**)",
-      "Edit(./**)",
-      "Glob(./**)",
-      "Grep(./**)",
-      "Bash(*)",
-      "mcp__puppeteer__puppeteer_navigate",
-      "mcp__puppeteer__puppeteer_screenshot",
-      "mcp__puppeteer__puppeteer_click",
-      "mcp__puppeteer__puppeteer_fill",
-      "mcp__puppeteer__puppeteer_select",
-      "mcp__puppeteer__puppeteer_hover",
-      "mcp__puppeteer__puppeteer_evaluate"
-    ]
-  }
-}

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,117 @@
+name: Bug Report
+description: File a bug report to help us improve Automaker
+title: '[Bug]: '
+labels: ['bug']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to report a bug! Please fill out the form below with as much detail as possible.
+
+  - type: dropdown
+    id: operating-system
+    attributes:
+      label: Operating System
+      description: What operating system are you using?
+      options:
+        - macOS
+        - Windows
+        - Linux
+        - Other
+      default: 0
+    validations:
+      required: true
+
+  - type: dropdown
+    id: run-mode
+    attributes:
+      label: Run Mode
+      description: How are you running Automaker?
+      options:
+        - Electron (Desktop App)
+        - Web (Browser)
+        - Docker
+      default: 0
+    validations:
+      required: true
+
+  - type: input
+    id: app-version
+    attributes:
+      label: App Version
+      description: What version of Automaker are you using? (e.g., 0.1.0)
+      placeholder: '0.1.0'
+    validations:
+      required: true
+
+  - type: textarea
+    id: bug-description
+    attributes:
+      label: Bug Description
+      description: A clear and concise description of what the bug is.
+      placeholder: Describe the bug...
+    validations:
+      required: true
+
+  - type: textarea
+    id: steps-to-reproduce
+    attributes:
+      label: Steps to Reproduce
+      description: Steps to reproduce the behavior
+      placeholder: |
+        1. Go to '...'
+        2. Click on '...'
+        3. Scroll down to '...'
+        4. See error
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: Expected Behavior
+      description: A clear and concise description of what you expected to happen.
+      placeholder: What should have happened?
+    validations:
+      required: true
+
+  - type: textarea
+    id: actual-behavior
+    attributes:
+      label: Actual Behavior
+      description: A clear and concise description of what actually happened.
+      placeholder: What actually happened?
+    validations:
+      required: true
+
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots
+      description: If applicable, add screenshots to help explain your problem.
+      placeholder: Drag and drop screenshots here or paste image URLs
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant Logs
+      description: If applicable, paste relevant logs or error messages.
+      placeholder: Paste logs here...
+      render: shell
+
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      description: Add any other context about the problem here.
+      placeholder: Any additional information that might be helpful...
+
+  - type: checkboxes
+    id: terms
+    attributes:
+      label: Checklist
+      options:
+        - label: I have searched existing issues to ensure this bug hasn't been reported already
+          required: true
+        - label: I have provided all required information above
+          required: true

.github/actions/setup-project/action.yml

@@ -0,0 +1,71 @@
+name: 'Setup Project'
+description: 'Common setup steps for CI workflows - checkout, Node.js, dependencies, and native modules'
+
+inputs:
+  node-version:
+    description: 'Node.js version to use'
+    required: false
+    default: '22'
+  check-lockfile:
+    description: 'Run lockfile lint check for SSH URLs'
+    required: false
+    default: 'false'
+  rebuild-node-pty-path:
+    description: 'Working directory for node-pty rebuild (empty = root)'
+    required: false
+    default: ''
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ inputs.node-version }}
+        cache: 'npm'
+        cache-dependency-path: package-lock.json
+
+    - name: Check for SSH URLs in lockfile
+      if: inputs.check-lockfile == 'true'
+      shell: bash
+      run: npm run lint:lockfile
+
+    - name: Configure Git for HTTPS
+      shell: bash
+      # Convert SSH URLs to HTTPS for git dependencies (e.g., @electron/node-gyp)
+      # This is needed because SSH authentication isn't available in CI
+      run: git config --global url."https://github.com/".insteadOf "git@github.com:"
+
+    - name: Install dependencies
+      shell: bash
+      # Use npm install instead of npm ci to correctly resolve platform-specific
+      # optional dependencies (e.g., @tailwindcss/oxide, lightningcss binaries)
+      # Skip scripts to avoid electron-builder install-app-deps which uses too much memory
+      run: npm install --ignore-scripts
+
+    - name: Install Linux native bindings
+      shell: bash
+      # Workaround for npm optional dependencies bug (npm/cli#4828)
+      # Explicitly install Linux bindings needed for build tools
+      run: |
+        npm install --no-save --force --ignore-scripts \
+          @rollup/rollup-linux-x64-gnu@4.53.3 \
+          @tailwindcss/oxide-linux-x64-gnu@4.1.17
+
+    - name: Build shared packages
+      shell: bash
+      # Build shared packages (types, utils, platform, etc.) before apps can use them
+      run: npm run build:packages
+
+    - name: Rebuild native modules (root)
+      if: inputs.rebuild-node-pty-path == ''
+      shell: bash
+      # Rebuild node-pty and other native modules for Electron
+      run: npm rebuild node-pty
+
+    - name: Rebuild native modules (workspace)
+      if: inputs.rebuild-node-pty-path != ''
+      shell: bash
+      # Rebuild node-pty and other native modules needed for server
+      run: npm rebuild node-pty
+      working-directory: ${{ inputs.rebuild-node-pty-path }}

.github/scripts/upload-to-r2.js

@@ -1,15 +1,11 @@
-const {
-  S3Client,
-  PutObjectCommand,
-  GetObjectCommand,
-} = require("@aws-sdk/client-s3");
-const fs = require("fs");
-const path = require("path");
-const https = require("https");
-const { pipeline } = require("stream/promises");
+const { S3Client, PutObjectCommand, GetObjectCommand } = require('@aws-sdk/client-s3');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { pipeline } = require('stream/promises');
 
 const s3Client = new S3Client({
-  region: "auto",
+  region: 'auto',
   endpoint: process.env.R2_ENDPOINT,
   credentials: {
     accessKeyId: process.env.R2_ACCESS_KEY_ID,
@@ -28,14 +24,14 @@ async function fetchExistingReleases() {
     const response = await s3Client.send(
       new GetObjectCommand({
         Bucket: BUCKET,
-        Key: "releases.json",
+        Key: 'releases.json',
       })
     );
     const body = await response.Body.transformToString();
     return JSON.parse(body);
   } catch (error) {
-    if (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404) {
-      console.log("No existing releases.json found, creating new one");
+    if (error.name === 'NoSuchKey' || error.$metadata?.httpStatusCode === 404) {
+      console.log('No existing releases.json found, creating new one');
       return { latestVersion: null, releases: [] };
     }
     throw error;
@@ -85,7 +81,7 @@ async function checkUrlAccessible(url, maxRetries = 10, initialDelay = 1000) {
               resolve({
                 accessible: false,
                 statusCode,
-                error: "Redirect without location header",
+                error: 'Redirect without location header',
               });
               return;
             }
@@ -93,18 +89,16 @@ async function checkUrlAccessible(url, maxRetries = 10, initialDelay = 1000) {
             return https
               .get(redirectUrl, { timeout: 10000 }, (redirectResponse) => {
                 const redirectStatus = redirectResponse.statusCode;
-                const contentType =
-                  redirectResponse.headers["content-type"] || "";
+                const contentType = redirectResponse.headers['content-type'] || '';
                 // Check if it's actually a file (zip/tar.gz) and not HTML
                 const isFile =
-                  contentType.includes("application/zip") ||
-                  contentType.includes("application/gzip") ||
-                  contentType.includes("application/x-gzip") ||
-                  contentType.includes("application/x-tar") ||
-                  redirectUrl.includes(".zip") ||
-                  redirectUrl.includes(".tar.gz");
-                const isGood =
-                  redirectStatus >= 200 && redirectStatus < 300 && isFile;
+                  contentType.includes('application/zip') ||
+                  contentType.includes('application/gzip') ||
+                  contentType.includes('application/x-gzip') ||
+                  contentType.includes('application/x-tar') ||
+                  redirectUrl.includes('.zip') ||
+                  redirectUrl.includes('.tar.gz');
+                const isGood = redirectStatus >= 200 && redirectStatus < 300 && isFile;
                 redirectResponse.destroy();
                 resolve({
                   accessible: isGood,
@@ -113,38 +107,38 @@ async function checkUrlAccessible(url, maxRetries = 10, initialDelay = 1000) {
                   contentType,
                 });
               })
-              .on("error", (error) => {
+              .on('error', (error) => {
                 resolve({
                   accessible: false,
                   statusCode,
                   error: error.message,
                 });
               })
-              .on("timeout", function () {
+              .on('timeout', function () {
                 this.destroy();
                 resolve({
                   accessible: false,
                   statusCode,
-                  error: "Timeout following redirect",
+                  error: 'Timeout following redirect',
                 });
               });
           }
 
           // Check if status is good (200-299 range) and it's actually a file
-          const contentType = response.headers["content-type"] || "";
+          const contentType = response.headers['content-type'] || '';
           const isFile =
-            contentType.includes("application/zip") ||
-            contentType.includes("application/gzip") ||
-            contentType.includes("application/x-gzip") ||
-            contentType.includes("application/x-tar") ||
-            url.includes(".zip") ||
-            url.includes(".tar.gz");
+            contentType.includes('application/zip') ||
+            contentType.includes('application/gzip') ||
+            contentType.includes('application/x-gzip') ||
+            contentType.includes('application/x-tar') ||
+            url.includes('.zip') ||
+            url.includes('.tar.gz');
           const isGood = statusCode >= 200 && statusCode < 300 && isFile;
           response.destroy();
           resolve({ accessible: isGood, statusCode, contentType });
         });
 
-        request.on("error", (error) => {
+        request.on('error', (error) => {
           resolve({
             accessible: false,
             statusCode: null,
@@ -152,12 +146,12 @@ async function checkUrlAccessible(url, maxRetries = 10, initialDelay = 1000) {
           });
         });
 
-        request.on("timeout", () => {
+        request.on('timeout', () => {
           request.destroy();
           resolve({
             accessible: false,
             statusCode: null,
-            error: "Request timeout",
+            error: 'Request timeout',
           });
         });
       });
@@ -168,22 +162,14 @@ async function checkUrlAccessible(url, maxRetries = 10, initialDelay = 1000) {
             `✓ URL ${url} is now accessible after ${attempt} retries (status: ${result.statusCode})`
           );
         } else {
-          console.log(
-            `✓ URL ${url} is accessible (status: ${result.statusCode})`
-          );
+          console.log(`✓ URL ${url} is accessible (status: ${result.statusCode})`);
         }
         return result.finalUrl || url; // Return the final URL (after redirects) if available
       } else {
-        const errorMsg = result.error ? ` - ${result.error}` : "";
-        const statusMsg = result.statusCode
-          ? ` (status: ${result.statusCode})`
-          : "";
-        const contentTypeMsg = result.contentType
-          ? ` [content-type: ${result.contentType}]`
-          : "";
-        console.log(
-          `✗ URL ${url} not accessible${statusMsg}${contentTypeMsg}${errorMsg}`
-        );
+        const errorMsg = result.error ? ` - ${result.error}` : '';
+        const statusMsg = result.statusCode ? ` (status: ${result.statusCode})` : '';
+        const contentTypeMsg = result.contentType ? ` [content-type: ${result.contentType}]` : '';
+        console.log(`✗ URL ${url} not accessible${statusMsg}${contentTypeMsg}${errorMsg}`);
       }
     } catch (error) {
       console.log(`✗ URL ${url} check failed: ${error.message}`);
@@ -191,9 +177,7 @@ async function checkUrlAccessible(url, maxRetries = 10, initialDelay = 1000) {
 
     if (attempt < maxRetries - 1) {
       const delay = initialDelay * Math.pow(2, attempt);
-      console.log(
-        `  Retrying in ${delay}ms... (attempt ${attempt + 1}/${maxRetries})`
-      );
+      console.log(`  Retrying in ${delay}ms... (attempt ${attempt + 1}/${maxRetries})`);
       await new Promise((resolve) => setTimeout(resolve, delay));
     }
   }
@@ -207,12 +191,7 @@ async function downloadFromGitHub(url, outputPath) {
       const statusCode = response.statusCode;
 
       // Follow redirects (all redirect types)
-      if (
-        statusCode === 301 ||
-        statusCode === 302 ||
-        statusCode === 307 ||
-        statusCode === 308
-      ) {
+      if (statusCode === 301 || statusCode === 302 || statusCode === 307 || statusCode === 308) {
         const redirectUrl = response.headers.location;
         response.destroy();
         if (!redirectUrl) {
@@ -220,39 +199,33 @@ async function downloadFromGitHub(url, outputPath) {
           return;
         }
         // Resolve relative redirects
-        const finalRedirectUrl = redirectUrl.startsWith("http")
+        const finalRedirectUrl = redirectUrl.startsWith('http')
           ? redirectUrl
           : new URL(redirectUrl, url).href;
         console.log(`  Following redirect: ${finalRedirectUrl}`);
-        return downloadFromGitHub(finalRedirectUrl, outputPath)
-          .then(resolve)
-          .catch(reject);
+        return downloadFromGitHub(finalRedirectUrl, outputPath).then(resolve).catch(reject);
       }
 
       if (statusCode !== 200) {
         response.destroy();
-        reject(
-          new Error(
-            `Failed to download ${url}: ${statusCode} ${response.statusMessage}`
-          )
-        );
+        reject(new Error(`Failed to download ${url}: ${statusCode} ${response.statusMessage}`));
         return;
       }
 
       const fileStream = fs.createWriteStream(outputPath);
       response.pipe(fileStream);
-      fileStream.on("finish", () => {
+      fileStream.on('finish', () => {
         fileStream.close();
         resolve();
       });
-      fileStream.on("error", (error) => {
+      fileStream.on('error', (error) => {
         response.destroy();
         reject(error);
       });
     });
 
-    request.on("error", reject);
-    request.on("timeout", () => {
+    request.on('error', reject);
+    request.on('timeout', () => {
       request.destroy();
       reject(new Error(`Request timeout for ${url}`));
     });
@@ -260,8 +233,8 @@ async function downloadFromGitHub(url, outputPath) {
 }
 
 async function main() {
-  const artifactsDir = "artifacts";
-  const tempDir = path.join(artifactsDir, "temp");
+  const artifactsDir = 'artifacts';
+  const tempDir = path.join(artifactsDir, 'temp');
 
   // Create temp directory for downloaded GitHub archives
   if (!fs.existsSync(tempDir)) {
@@ -292,40 +265,30 @@ async function main() {
 
   // Find all artifacts
   const artifacts = {
-    windows: findArtifacts(path.join(artifactsDir, "windows-builds"), /\.exe$/),
-    macos: findArtifacts(path.join(artifactsDir, "macos-builds"), /-x64\.dmg$/),
-    macosArm: findArtifacts(
-      path.join(artifactsDir, "macos-builds"),
-      /-arm64\.dmg$/
-    ),
-    linux: findArtifacts(
-      path.join(artifactsDir, "linux-builds"),
-      /\.AppImage$/
-    ),
+    windows: findArtifacts(path.join(artifactsDir, 'windows-builds'), /\.exe$/),
+    macos: findArtifacts(path.join(artifactsDir, 'macos-builds'), /-x64\.dmg$/),
+    macosArm: findArtifacts(path.join(artifactsDir, 'macos-builds'), /-arm64\.dmg$/),
+    linux: findArtifacts(path.join(artifactsDir, 'linux-builds'), /\.AppImage$/),
     sourceZip: [sourceZipPath],
     sourceTarGz: [sourceTarGzPath],
   };
 
-  console.log("Found artifacts:");
+  console.log('Found artifacts:');
   for (const [platform, files] of Object.entries(artifacts)) {
     console.log(
-      `  ${platform}: ${
-        files.length > 0
-          ? files.map((f) => path.basename(f)).join(", ")
-          : "none"
-      }`
+      `  ${platform}: ${files.length > 0 ? files.map((f) => path.basename(f)).join(', ') : 'none'}`
     );
   }
 
   // Upload each artifact to R2
   const assets = {};
   const contentTypes = {
-    windows: "application/x-msdownload",
-    macos: "application/x-apple-diskimage",
-    macosArm: "application/x-apple-diskimage",
-    linux: "application/x-executable",
-    sourceZip: "application/zip",
-    sourceTarGz: "application/gzip",
+    windows: 'application/x-msdownload',
+    macos: 'application/x-apple-diskimage',
+    macosArm: 'application/x-apple-diskimage',
+    linux: 'application/x-executable',
+    sourceZip: 'application/zip',
+    sourceTarGz: 'application/gzip',
   };
 
   for (const [platform, files] of Object.entries(artifacts)) {
@@ -345,11 +308,11 @@ async function main() {
       filename,
       size,
       arch:
-        platform === "macosArm"
-          ? "arm64"
-          : platform === "sourceZip" || platform === "sourceTarGz"
-          ? "source"
-          : "x64",
+        platform === 'macosArm'
+          ? 'arm64'
+          : platform === 'sourceZip' || platform === 'sourceTarGz'
+            ? 'source'
+            : 'x64',
     };
   }
 
@@ -364,9 +327,7 @@ async function main() {
   };
 
   // Remove existing entry for this version if re-running
-  releasesData.releases = releasesData.releases.filter(
-    (r) => r.version !== VERSION
-  );
+  releasesData.releases = releasesData.releases.filter((r) => r.version !== VERSION);
 
   // Prepend new release
   releasesData.releases.unshift(newRelease);
@@ -376,19 +337,19 @@ async function main() {
   await s3Client.send(
     new PutObjectCommand({
       Bucket: BUCKET,
-      Key: "releases.json",
+      Key: 'releases.json',
       Body: JSON.stringify(releasesData, null, 2),
-      ContentType: "application/json",
-      CacheControl: "public, max-age=60",
+      ContentType: 'application/json',
+      CacheControl: 'public, max-age=60',
     })
   );
 
-  console.log("Successfully updated releases.json");
+  console.log('Successfully updated releases.json');
   console.log(`Latest version: ${VERSION}`);
   console.log(`Total releases: ${releasesData.releases.length}`);
 }
 
 main().catch((err) => {
-  console.error("Failed to upload to R2:", err);
+  console.error('Failed to upload to R2:', err);
   process.exit(1);
 });

.github/workflows/claude.yml

@@ -0,0 +1,49 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+      actions: read # Required for Claude to read CI results on PRs
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+
+          # This is an optional setting that allows Claude to read CI results on PRs
+          additional_permissions: |
+            actions: read
+
+          # Optional: Give a custom prompt to Claude. If this is not specified, Claude will perform the instructions specified in the comment that tagged it.
+          # prompt: 'Update the pull request description to include a summary of changes.'
+
+          # Optional: Add claude_args to customize behavior and configuration
+          # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
+          # or https://code.claude.com/docs/en/cli-reference for available options
+          # claude_args: '--allowed-tools Bash(gh pr:*)'

.github/workflows/e2e-tests.yml

@@ -3,7 +3,7 @@ name: E2E Tests
 on:
   pull_request:
     branches:
-      - "*"
+      - '*'
   push:
     branches:
       - main
@@ -18,34 +18,15 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
+      - name: Setup project
+        uses: ./.github/actions/setup-project
         with:
-          node-version: "22"
-          cache: "npm"
-          cache-dependency-path: package-lock.json
-
-      - name: Configure Git for HTTPS
-        # Convert SSH URLs to HTTPS for git dependencies (e.g., @electron/node-gyp)
-        # This is needed because SSH authentication isn't available in CI
-        run: git config --global url."https://github.com/".insteadOf "git@github.com:"
-
-      - name: Install dependencies
-        # Use npm install instead of npm ci to correctly resolve platform-specific
-        # optional dependencies (e.g., @tailwindcss/oxide, lightningcss binaries)
-        run: npm install
-
-      - name: Install Linux native bindings
-        # Workaround for npm optional dependencies bug (npm/cli#4828)
-        # Explicitly install Linux bindings needed for build tools
-        run: |
-          npm install --no-save --force \
-            @rollup/rollup-linux-x64-gnu@4.53.3 \
-            @tailwindcss/oxide-linux-x64-gnu@4.1.17
+          check-lockfile: 'true'
+          rebuild-node-pty-path: 'apps/server'
 
       - name: Install Playwright browsers
         run: npx playwright install --with-deps chromium
-        working-directory: apps/app
+        working-directory: apps/ui
 
       - name: Build server
         run: npm run build --workspace=apps/server
@@ -71,20 +52,20 @@ jobs:
           exit 1
 
       - name: Run E2E tests
-        # Playwright automatically starts the Next.js frontend via webServer config
-        # (see apps/app/playwright.config.ts) - no need to start it manually
-        run: npm run test --workspace=apps/app
+        # Playwright automatically starts the Vite frontend via webServer config
+        # (see apps/ui/playwright.config.ts) - no need to start it manually
+        run: npm run test --workspace=apps/ui
         env:
           CI: true
-          NEXT_PUBLIC_SERVER_URL: http://localhost:3008
-          NEXT_PUBLIC_SKIP_SETUP: "true"
+          VITE_SERVER_URL: http://localhost:3008
+          VITE_SKIP_SETUP: 'true'
 
       - name: Upload Playwright report
         uses: actions/upload-artifact@v4
         if: always()
         with:
           name: playwright-report
-          path: apps/app/playwright-report/
+          path: apps/ui/playwright-report/
           retention-days: 7
 
       - name: Upload test results
@@ -92,5 +73,5 @@ jobs:
         if: failure()
         with:
           name: test-results
-          path: apps/app/test-results/
+          path: apps/ui/test-results/
           retention-days: 7

.github/workflows/format-check.yml

@@ -0,0 +1,31 @@
+name: Format Check
+
+on:
+  pull_request:
+    branches:
+      - '*'
+  push:
+    branches:
+      - main
+      - master
+
+jobs:
+  format:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'npm'
+          cache-dependency-path: package-lock.json
+
+      - name: Install dependencies
+        run: npm install --ignore-scripts
+
+      - name: Check formatting
+        run: npm run format:check

.github/workflows/pr-check.yml

@@ -3,7 +3,7 @@ name: PR Build Check
 on:
   pull_request:
     branches:
-      - "*"
+      - '*'
   push:
     branches:
       - main
@@ -17,30 +17,10 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
+      - name: Setup project
+        uses: ./.github/actions/setup-project
         with:
-          node-version: "22"
-          cache: "npm"
-          cache-dependency-path: package-lock.json
+          check-lockfile: 'true'
 
-      - name: Configure Git for HTTPS
-        # Convert SSH URLs to HTTPS for git dependencies (e.g., @electron/node-gyp)
-        # This is needed because SSH authentication isn't available in CI
-        run: git config --global url."https://github.com/".insteadOf "git@github.com:"
-
-      - name: Install dependencies
-        # Use npm install instead of npm ci to correctly resolve platform-specific
-        # optional dependencies (e.g., @tailwindcss/oxide, lightningcss binaries)
-        run: npm install
-
-      - name: Install Linux native bindings
-        # Workaround for npm optional dependencies bug (npm/cli#4828)
-        # Explicitly install Linux bindings needed for build tools
-        run: |
-          npm install --no-save --force \
-            @rollup/rollup-linux-x64-gnu@4.53.3 \
-            @tailwindcss/oxide-linux-x64-gnu@4.1.17
-
-      - name: Run build:electron
-        run: npm run build:electron
+      - name: Run build:electron (dir only - faster CI)
+        run: npm run build:electron:dir

.github/workflows/release.yml

@@ -1,180 +1,111 @@
-name: Build and Release Electron App
+name: Release Build
 
 on:
-  push:
-    tags:
-      - "v*.*.*" # Triggers on version tags like v1.0.0
-  workflow_dispatch: # Allows manual triggering
-    inputs:
-      version:
-        description: "Version to release (e.g., v1.0.0)"
-        required: true
-        default: "v0.1.0"
+  release:
+    types: [published]
 
 jobs:
-  build-and-release:
+  build:
     strategy:
-      fail-fast: false
       matrix:
-        include:
-          - os: macos-latest
-            name: macOS
-            artifact-name: macos-builds
-          - os: windows-latest
-            name: Windows
-            artifact-name: windows-builds
-          - os: ubuntu-latest
-            name: Linux
-            artifact-name: linux-builds
-
+        os: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
 
-    permissions:
-      contents: write
-
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "22"
-          cache: "npm"
-          cache-dependency-path: package-lock.json
-
-      - name: Configure Git for HTTPS
-        # Convert SSH URLs to HTTPS for git dependencies (e.g., @electron/node-gyp)
-        # This is needed because SSH authentication isn't available in CI
-        run: git config --global url."https://github.com/".insteadOf "git@github.com:"
-
-      - name: Install dependencies
-        # Use npm install instead of npm ci to correctly resolve platform-specific
-        # optional dependencies (e.g., @tailwindcss/oxide, lightningcss binaries)
-        run: npm install
-
-      - name: Install Linux native bindings
-        # Workaround for npm optional dependencies bug (npm/cli#4828)
-        # Only needed on Linux - macOS and Windows get their bindings automatically
-        if: matrix.os == 'ubuntu-latest'
-        run: |
-          npm install --no-save --force \
-            @rollup/rollup-linux-x64-gnu@4.53.3 \
-            @tailwindcss/oxide-linux-x64-gnu@4.1.17
-
-      - name: Extract and set version
+      - name: Extract version from tag
         id: version
         shell: bash
         run: |
-          VERSION_TAG="${{ github.event.inputs.version || github.ref_name }}"
-          # Remove 'v' prefix if present (e.g., v1.0.0 -> 1.0.0)
-          VERSION="${VERSION_TAG#v}"
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-          echo "Extracted version: $VERSION from tag: $VERSION_TAG"
-          # Update the app's package.json version
-          cd apps/app
-          npm version $VERSION --no-git-tag-version
-          cd ../..
-          echo "Updated apps/app/package.json to version $VERSION"
+          # Remove 'v' prefix if present (e.g., "v1.2.3" -> "1.2.3")
+          VERSION="${{ github.event.release.tag_name }}"
+          VERSION="${VERSION#v}"
+          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+          echo "Extracted version: ${VERSION}"
 
-      - name: Build Electron App (macOS)
-        if: matrix.os == 'macos-latest'
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: npm run build:electron -- --mac --x64 --arm64
+      - name: Update package.json version
+        shell: bash
+        run: |
+          node apps/ui/scripts/update-version.mjs "${{ steps.version.outputs.version }}"
 
-      - name: Build Electron App (Windows)
-        if: matrix.os == 'windows-latest'
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: npm run build:electron -- --win --x64
-
-      - name: Build Electron App (Linux)
-        if: matrix.os == 'ubuntu-latest'
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: npm run build:electron -- --linux --x64
-
-      - name: Upload Release Assets
-        uses: softprops/action-gh-release@v1
+      - name: Setup project
+        uses: ./.github/actions/setup-project
         with:
-          tag_name: ${{ github.event.inputs.version || github.ref_name }}
-          files: |
-            apps/app/dist/*.exe
-            apps/app/dist/*.dmg
-            apps/app/dist/*.AppImage
-            apps/app/dist/*.zip
-            apps/app/dist/*.deb
-            apps/app/dist/*.rpm
-          draft: false
-          prerelease: false
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          check-lockfile: 'true'
 
-      - name: Upload macOS artifacts for R2
+      - name: Build Electron app (macOS)
+        if: matrix.os == 'macos-latest'
+        shell: bash
+        run: npm run build:electron:mac --workspace=apps/ui
+        env:
+          CSC_IDENTITY_AUTO_DISCOVERY: false
+
+      - name: Build Electron app (Windows)
+        if: matrix.os == 'windows-latest'
+        shell: bash
+        run: npm run build:electron:win --workspace=apps/ui
+
+      - name: Build Electron app (Linux)
+        if: matrix.os == 'ubuntu-latest'
+        shell: bash
+        run: npm run build:electron:linux --workspace=apps/ui
+
+      - name: Upload macOS artifacts
         if: matrix.os == 'macos-latest'
         uses: actions/upload-artifact@v4
         with:
-          name: ${{ matrix.artifact-name }}
-          path: apps/app/dist/*.dmg
-          retention-days: 1
+          name: macos-builds
+          path: apps/ui/release/*.{dmg,zip}
+          retention-days: 30
 
-      - name: Upload Windows artifacts for R2
+      - name: Upload Windows artifacts
         if: matrix.os == 'windows-latest'
         uses: actions/upload-artifact@v4
         with:
-          name: ${{ matrix.artifact-name }}
-          path: apps/app/dist/*.exe
-          retention-days: 1
+          name: windows-builds
+          path: apps/ui/release/*.exe
+          retention-days: 30
 
-      - name: Upload Linux artifacts for R2
+      - name: Upload Linux artifacts
         if: matrix.os == 'ubuntu-latest'
         uses: actions/upload-artifact@v4
         with:
-          name: ${{ matrix.artifact-name }}
-          path: apps/app/dist/*.AppImage
-          retention-days: 1
+          name: linux-builds
+          path: apps/ui/release/*.{AppImage,deb}
+          retention-days: 30
 
-  upload-to-r2:
-    needs: build-and-release
+  upload:
+    needs: build
     runs-on: ubuntu-latest
+    if: github.event.release.draft == false
 
     steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-
-      - name: Download all artifacts
+      - name: Download macOS artifacts
         uses: actions/download-artifact@v4
         with:
-          path: artifacts
+          name: macos-builds
+          path: artifacts/macos-builds
 
-      - name: Install AWS SDK
-        run: npm install @aws-sdk/client-s3
+      - name: Download Windows artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: windows-builds
+          path: artifacts/windows-builds
 
-      - name: Extract version
-        id: version
-        shell: bash
-        run: |
-          VERSION_TAG="${{ github.event.inputs.version || github.ref_name }}"
-          # Remove 'v' prefix if present (e.g., v1.0.0 -> 1.0.0)
-          VERSION="${VERSION_TAG#v}"
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-          echo "version_tag=$VERSION_TAG" >> $GITHUB_OUTPUT
-          echo "Extracted version: $VERSION from tag: $VERSION_TAG"
+      - name: Download Linux artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: linux-builds
+          path: artifacts/linux-builds
 
-      - name: Upload to R2 and update releases.json
+      - name: Upload to GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: |
+            artifacts/macos-builds/*
+            artifacts/windows-builds/*
+            artifacts/linux-builds/*
         env:
-          R2_ENDPOINT: ${{ secrets.R2_ENDPOINT }}
-          R2_ACCESS_KEY_ID: ${{ secrets.R2_ACCESS_KEY_ID }}
-          R2_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET_ACCESS_KEY }}
-          R2_BUCKET_NAME: ${{ secrets.R2_BUCKET_NAME }}
-          R2_PUBLIC_URL: ${{ secrets.R2_PUBLIC_URL }}
-          RELEASE_VERSION: ${{ steps.version.outputs.version }}
-          RELEASE_TAG: ${{ steps.version.outputs.version_tag }}
-          GITHUB_REPOSITORY: ${{ github.repository }}
-        run: node .github/scripts/upload-to-r2.js
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/security-audit.yml

@@ -0,0 +1,30 @@
+name: Security Audit
+
+on:
+  pull_request:
+    branches:
+      - '*'
+  push:
+    branches:
+      - main
+      - master
+  schedule:
+    # Run weekly on Mondays at 9 AM UTC
+    - cron: '0 9 * * 1'
+
+jobs:
+  audit:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup project
+        uses: ./.github/actions/setup-project
+        with:
+          check-lockfile: 'true'
+
+      - name: Run npm audit
+        run: npm audit --audit-level=moderate
+        continue-on-error: false

.github/workflows/test.yml

@@ -3,7 +3,7 @@ name: Test Suite
 on:
   pull_request:
     branches:
-      - "*"
+      - '*'
   push:
     branches:
       - main
@@ -17,30 +17,16 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
+      - name: Setup project
+        uses: ./.github/actions/setup-project
         with:
-          node-version: "22"
-          cache: "npm"
-          cache-dependency-path: package-lock.json
+          check-lockfile: 'true'
+          rebuild-node-pty-path: 'apps/server'
 
-      - name: Configure Git for HTTPS
-        # Convert SSH URLs to HTTPS for git dependencies (e.g., @electron/node-gyp)
-        # This is needed because SSH authentication isn't available in CI
-        run: git config --global url."https://github.com/".insteadOf "git@github.com:"
-
-      - name: Install dependencies
-        # Use npm install instead of npm ci to correctly resolve platform-specific
-        # optional dependencies (e.g., @tailwindcss/oxide, lightningcss binaries)
-        run: npm install
-
-      - name: Install Linux native bindings
-        # Workaround for npm optional dependencies bug (npm/cli#4828)
-        # Explicitly install Linux bindings needed for build tools
-        run: |
-          npm install --no-save --force \
-            @rollup/rollup-linux-x64-gnu@4.53.3 \
-            @tailwindcss/oxide-linux-x64-gnu@4.1.17
+      - name: Run package tests
+        run: npm run test:packages
+        env:
+          NODE_ENV: test
 
       - name: Run server tests with coverage
         run: npm run test:server:coverage

.gitignore

@@ -6,10 +6,81 @@ node_modules/
 
 # Build outputs
 dist/
+build/
+out/
 .next/
+.turbo/
+
+# Automaker
 .automaker/images/
 .automaker/
 /.automaker/*
 /.automaker/
 
-/logs
+.worktrees/
+
+/logs
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# OS-specific files
+.DS_Store
+.DS_Store?
+._*
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+
+# IDE/Editor configs
+.vscode/
+.idea/
+*.sublime-workspace
+*.sublime-project
+
+# Editor backup/temp files
+*~
+*.bak
+*.backup
+*.orig
+*.swp
+*.swo
+*.tmp
+*.temp
+
+# Local settings (user-specific)
+*.local.json
+
+# Application state/backup
+backup.json
+
+# Test artifacts
+test-results/
+coverage/
+.nyc_output/
+*.lcov
+playwright-report/
+blob-report/
+
+# Environment files (keep .example)
+.env
+.env.local
+.env.*.local
+!.env.example
+!.env.local.example
+
+# TypeScript
+*.tsbuildinfo
+
+# Misc
+*.pem
+
+docker-compose.override.yml
+.claude/docker-compose.override.yml
+
+pnpm-lock.yaml
+yarn.lock

.husky/pre-commit

@@ -0,0 +1 @@
+npx lint-staged

.nvmrc

@@ -0,0 +1,2 @@
+22
+

.prettierignore

@@ -0,0 +1,39 @@
+# Dependencies
+node_modules/
+
+# Build outputs
+dist/
+build/
+out/
+.next/
+.turbo/
+release/
+
+# Automaker
+.automaker/
+
+# Logs
+logs/
+*.log
+
+# Lock files
+package-lock.json
+pnpm-lock.yaml
+
+# Generated files
+*.min.js
+*.min.css
+
+# Test artifacts
+test-results/
+coverage/
+playwright-report/
+blob-report/
+
+# IDE/Editor
+.vscode/
+.idea/
+
+# Electron
+dist-electron/
+server-bundle/

.prettierrc

@@ -0,0 +1,10 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "trailingComma": "es5",
+  "printWidth": 100,
+  "bracketSpacing": true,
+  "arrowParens": "always",
+  "endOfLine": "lf"
+}

CLAUDE.md

@@ -0,0 +1,172 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Automaker is an autonomous AI development studio built as an npm workspace monorepo. It provides a Kanban-based workflow where AI agents (powered by Claude Agent SDK) implement features in isolated git worktrees.
+
+## Common Commands
+
+```bash
+# Development
+npm run dev                 # Interactive launcher (choose web or electron)
+npm run dev:web             # Web browser mode (localhost:3007)
+npm run dev:electron        # Desktop app mode
+npm run dev:electron:debug  # Desktop with DevTools open
+
+# Building
+npm run build               # Build web application
+npm run build:packages      # Build all shared packages (required before other builds)
+npm run build:electron      # Build desktop app for current platform
+npm run build:server        # Build server only
+
+# Testing
+npm run test                # E2E tests (Playwright, headless)
+npm run test:headed         # E2E tests with browser visible
+npm run test:server         # Server unit tests (Vitest)
+npm run test:packages       # All shared package tests
+npm run test:all            # All tests (packages + server)
+
+# Single test file
+npm run test:server -- tests/unit/specific.test.ts
+
+# Linting and formatting
+npm run lint                # ESLint
+npm run format              # Prettier write
+npm run format:check        # Prettier check
+```
+
+## Architecture
+
+### Monorepo Structure
+
+```
+automaker/
+├── apps/
+│   ├── ui/           # React + Vite + Electron frontend (port 3007)
+│   └── server/       # Express + WebSocket backend (port 3008)
+└── libs/             # Shared packages (@automaker/*)
+    ├── types/        # Core TypeScript definitions (no dependencies)
+    ├── utils/        # Logging, errors, image processing, context loading
+    ├── prompts/      # AI prompt templates
+    ├── platform/     # Path management, security, process spawning
+    ├── model-resolver/    # Claude model alias resolution
+    ├── dependency-resolver/  # Feature dependency ordering
+    └── git-utils/    # Git operations & worktree management
+```
+
+### Package Dependency Chain
+
+Packages can only depend on packages above them:
+
+```
+@automaker/types (no dependencies)
+    ↓
+@automaker/utils, @automaker/prompts, @automaker/platform, @automaker/model-resolver, @automaker/dependency-resolver
+    ↓
+@automaker/git-utils
+    ↓
+@automaker/server, @automaker/ui
+```
+
+### Key Technologies
+
+- **Frontend**: React 19, Vite 7, Electron 39, TanStack Router, Zustand 5, Tailwind CSS 4
+- **Backend**: Express 5, WebSocket (ws), Claude Agent SDK, node-pty
+- **Testing**: Playwright (E2E), Vitest (unit)
+
+### Server Architecture
+
+The server (`apps/server/src/`) follows a modular pattern:
+
+- `routes/` - Express route handlers organized by feature (agent, features, auto-mode, worktree, etc.)
+- `services/` - Business logic (AgentService, AutoModeService, FeatureLoader, TerminalService)
+- `providers/` - AI provider abstraction (currently Claude via Claude Agent SDK)
+- `lib/` - Utilities (events, auth, worktree metadata)
+
+### Frontend Architecture
+
+The UI (`apps/ui/src/`) uses:
+
+- `routes/` - TanStack Router file-based routing
+- `components/views/` - Main view components (board, settings, terminal, etc.)
+- `store/` - Zustand stores with persistence (app-store.ts, setup-store.ts)
+- `hooks/` - Custom React hooks
+- `lib/` - Utilities and API client
+
+## Data Storage
+
+### Per-Project Data (`.automaker/`)
+
+```
+.automaker/
+├── features/              # Feature JSON files and images
+│   └── {featureId}/
+│       ├── feature.json
+│       ├── agent-output.md
+│       └── images/
+├── context/               # Context files for AI agents (CLAUDE.md, etc.)
+├── settings.json          # Project-specific settings
+├── spec.md               # Project specification
+└── analysis.json         # Project structure analysis
+```
+
+### Global Data (`DATA_DIR`, default `./data`)
+
+```
+data/
+├── settings.json          # Global settings, profiles, shortcuts
+├── credentials.json       # API keys
+├── sessions-metadata.json # Chat session metadata
+└── agent-sessions/        # Conversation histories
+```
+
+## Import Conventions
+
+Always import from shared packages, never from old paths:
+
+```typescript
+// ✅ Correct
+import type { Feature, ExecuteOptions } from '@automaker/types';
+import { createLogger, classifyError } from '@automaker/utils';
+import { getEnhancementPrompt } from '@automaker/prompts';
+import { getFeatureDir, ensureAutomakerDir } from '@automaker/platform';
+import { resolveModelString } from '@automaker/model-resolver';
+import { resolveDependencies } from '@automaker/dependency-resolver';
+import { getGitRepositoryDiffs } from '@automaker/git-utils';
+
+// ❌ Never import from old paths
+import { Feature } from '../services/feature-loader'; // Wrong
+import { createLogger } from '../lib/logger'; // Wrong
+```
+
+## Key Patterns
+
+### Event-Driven Architecture
+
+All server operations emit events that stream to the frontend via WebSocket. Events are created using `createEventEmitter()` from `lib/events.ts`.
+
+### Git Worktree Isolation
+
+Each feature executes in an isolated git worktree, created via `@automaker/git-utils`. This protects the main branch during AI agent execution.
+
+### Context Files
+
+Project-specific rules are stored in `.automaker/context/` and automatically loaded into agent prompts via `loadContextFiles()` from `@automaker/utils`.
+
+### Model Resolution
+
+Use `resolveModelString()` from `@automaker/model-resolver` to convert model aliases:
+
+- `haiku` → `claude-haiku-4-5`
+- `sonnet` → `claude-sonnet-4-20250514`
+- `opus` → `claude-opus-4-5-20251101`
+
+## Environment Variables
+
+- `ANTHROPIC_API_KEY` - Anthropic API key (or use Claude Code CLI auth)
+- `PORT` - Server port (default: 3008)
+- `DATA_DIR` - Data storage directory (default: ./data)
+- `ALLOWED_ROOT_DIRECTORY` - Restrict file operations to specific directory
+- `AUTOMAKER_MOCK_AGENT=true` - Enable mock agent mode for CI testing

CONTRIBUTING.md

@@ -0,0 +1,685 @@
+# Contributing to Automaker
+
+Thank you for your interest in contributing to Automaker! We're excited to have you join our community of developers building the future of autonomous AI development.
+
+Automaker is an autonomous AI development studio that provides a Kanban-based workflow where AI agents implement features in isolated git worktrees. Whether you're fixing bugs, adding features, improving documentation, or suggesting ideas, your contributions help make this project better for everyone.
+
+This guide will help you get started with contributing to Automaker. Please take a moment to read through these guidelines to ensure a smooth contribution process.
+
+## Contribution License Agreement
+
+**Important:** By submitting, pushing, or contributing any code, documentation, pull requests, issues, or other materials to the Automaker project, you agree to assign all right, title, and interest in and to your contributions, including all copyrights, patents, and other intellectual property rights, to the Core Contributors of Automaker. This assignment is irrevocable and includes the right to use, modify, distribute, and monetize your contributions in any manner.
+
+**You understand and agree that you will have no right to receive any royalties, compensation, or other financial benefits from any revenue, income, or commercial use generated from your contributed code or any derivative works thereof.** All contributions are made without expectation of payment or financial return.
+
+For complete details on contribution terms and rights assignment, please review [Section 5 (CONTRIBUTIONS AND RIGHTS ASSIGNMENT) of the LICENSE](LICENSE#5-contributions-and-rights-assignment).
+
+## Table of Contents
+
+- [Contributing to Automaker](#contributing-to-automaker)
+  - [Table of Contents](#table-of-contents)
+  - [Getting Started](#getting-started)
+    - [Prerequisites](#prerequisites)
+    - [Fork and Clone](#fork-and-clone)
+    - [Development Setup](#development-setup)
+    - [Project Structure](#project-structure)
+  - [Pull Request Process](#pull-request-process)
+    - [Branch Naming Convention](#branch-naming-convention)
+    - [Commit Message Format](#commit-message-format)
+    - [Submitting a Pull Request](#submitting-a-pull-request)
+      - [1. Prepare Your Changes](#1-prepare-your-changes)
+      - [2. Run Pre-submission Checks](#2-run-pre-submission-checks)
+      - [3. Push Your Changes](#3-push-your-changes)
+      - [4. Open a Pull Request](#4-open-a-pull-request)
+      - [PR Requirements Checklist](#pr-requirements-checklist)
+    - [Review Process](#review-process)
+      - [What to Expect](#what-to-expect)
+      - [Review Focus Areas](#review-focus-areas)
+      - [Responding to Feedback](#responding-to-feedback)
+      - [Approval Criteria](#approval-criteria)
+      - [Getting Help](#getting-help)
+  - [Code Style Guidelines](#code-style-guidelines)
+  - [Testing Requirements](#testing-requirements)
+    - [Running Tests](#running-tests)
+    - [Test Frameworks](#test-frameworks)
+      - [End-to-End Tests (Playwright)](#end-to-end-tests-playwright)
+      - [Unit Tests (Vitest)](#unit-tests-vitest)
+    - [Writing Tests](#writing-tests)
+      - [When to Write Tests](#when-to-write-tests)
+    - [CI/CD Pipeline](#cicd-pipeline)
+      - [CI Checks](#ci-checks)
+      - [CI Testing Environment](#ci-testing-environment)
+      - [Viewing CI Results](#viewing-ci-results)
+      - [Common CI Failures](#common-ci-failures)
+    - [Coverage Requirements](#coverage-requirements)
+  - [Issue Reporting](#issue-reporting)
+    - [Bug Reports](#bug-reports)
+      - [Before Reporting](#before-reporting)
+      - [Bug Report Template](#bug-report-template)
+    - [Feature Requests](#feature-requests)
+      - [Before Requesting](#before-requesting)
+      - [Feature Request Template](#feature-request-template)
+    - [Security Issues](#security-issues)
+
+---
+
+## Getting Started
+
+### Prerequisites
+
+Before contributing to Automaker, ensure you have the following installed on your system:
+
+- **Node.js 18+** (tested with Node.js 22)
+  - Download from [nodejs.org](https://nodejs.org/)
+  - Verify installation: `node --version`
+- **npm** (comes with Node.js)
+  - Verify installation: `npm --version`
+- **Git** for version control
+  - Verify installation: `git --version`
+- **Claude Code CLI** or **Anthropic API Key** (for AI agent functionality)
+  - Required to run the AI development features
+
+**Optional but recommended:**
+
+- A code editor with TypeScript support (VS Code recommended)
+- GitHub CLI (`gh`) for easier PR management
+
+### Fork and Clone
+
+1. **Fork the repository** on GitHub
+   - Navigate to [https://github.com/AutoMaker-Org/automaker](https://github.com/AutoMaker-Org/automaker)
+   - Click the "Fork" button in the top-right corner
+   - This creates your own copy of the repository
+
+2. **Clone your fork locally**
+
+   ```bash
+   git clone https://github.com/YOUR_USERNAME/automaker.git
+   cd automaker
+   ```
+
+3. **Add the upstream remote** to keep your fork in sync
+
+   ```bash
+   git remote add upstream https://github.com/AutoMaker-Org/automaker.git
+   ```
+
+4. **Verify remotes**
+   ```bash
+   git remote -v
+   # Should show:
+   # origin    https://github.com/YOUR_USERNAME/automaker.git (fetch)
+   # origin    https://github.com/YOUR_USERNAME/automaker.git (push)
+   # upstream  https://github.com/AutoMaker-Org/automaker.git (fetch)
+   # upstream  https://github.com/AutoMaker-Org/automaker.git (push)
+   ```
+
+### Development Setup
+
+1. **Install dependencies**
+
+   ```bash
+   npm install
+   ```
+
+2. **Build shared packages** (required before running the app)
+
+   ```bash
+   npm run build:packages
+   ```
+
+3. **Start the development server**
+   ```bash
+   npm run dev          # Interactive launcher - choose mode
+   npm run dev:web      # Browser mode (web interface)
+   npm run dev:electron # Desktop app mode
+   ```
+
+**Common development commands:**
+
+| Command                  | Description                      |
+| ------------------------ | -------------------------------- |
+| `npm run dev`            | Interactive development launcher |
+| `npm run dev:web`        | Start in browser mode            |
+| `npm run dev:electron`   | Start desktop app                |
+| `npm run build`          | Build all packages and apps      |
+| `npm run build:packages` | Build shared packages only       |
+| `npm run lint`           | Run ESLint checks                |
+| `npm run format`         | Format code with Prettier        |
+| `npm run format:check`   | Check formatting without changes |
+| `npm run test`           | Run E2E tests (Playwright)       |
+| `npm run test:server`    | Run server unit tests            |
+| `npm run test:packages`  | Run package tests                |
+| `npm run test:all`       | Run all tests                    |
+
+### Project Structure
+
+Automaker is organized as an npm workspace monorepo:
+
+```
+automaker/
+├── apps/
+│   ├── ui/              # React + Vite + Electron frontend
+│   └── server/          # Express + WebSocket backend
+├── libs/
+│   ├── @automaker/types/            # Shared TypeScript types
+│   ├── @automaker/utils/            # Utility functions
+│   ├── @automaker/prompts/          # AI prompt templates
+│   ├── @automaker/platform/         # Platform abstractions
+│   ├── @automaker/model-resolver/   # AI model resolution
+│   ├── @automaker/dependency-resolver/ # Dependency management
+│   └── @automaker/git-utils/        # Git operations
+├── docs/                # Documentation
+└── package.json         # Root package configuration
+```
+
+**Key conventions:**
+
+- Always import from `@automaker/*` shared packages, never use relative paths to `libs/`
+- Frontend code lives in `apps/ui/`
+- Backend code lives in `apps/server/`
+- Shared logic should be in the appropriate `libs/` package
+
+---
+
+## Pull Request Process
+
+This section covers everything you need to know about contributing changes through pull requests, from creating your branch to getting your code merged.
+
+### Branch Naming Convention
+
+We use a consistent branch naming pattern to keep our repository organized:
+
+```
+<type>/<description>
+```
+
+**Branch types:**
+
+| Type       | Purpose                  | Example                           |
+| ---------- | ------------------------ | --------------------------------- |
+| `feature`  | New functionality        | `feature/add-user-authentication` |
+| `fix`      | Bug fixes                | `fix/resolve-memory-leak`         |
+| `docs`     | Documentation changes    | `docs/update-contributing-guide`  |
+| `refactor` | Code restructuring       | `refactor/simplify-api-handlers`  |
+| `test`     | Adding or updating tests | `test/add-utils-unit-tests`       |
+| `chore`    | Maintenance tasks        | `chore/update-dependencies`       |
+
+**Guidelines:**
+
+- Use lowercase letters and hyphens (no underscores or spaces)
+- Keep descriptions short but descriptive
+- Include issue number when applicable: `feature/123-add-login`
+
+```bash
+# Create and checkout a new feature branch
+git checkout -b feature/add-dark-mode
+
+# Create a fix branch with issue reference
+git checkout -b fix/456-resolve-login-error
+```
+
+### Commit Message Format
+
+We follow the **Conventional Commits** style for clear, readable commit history:
+
+```
+<type>: <description>
+
+[optional body]
+```
+
+**Commit types:**
+
+| Type       | Purpose                     |
+| ---------- | --------------------------- |
+| `feat`     | New feature                 |
+| `fix`      | Bug fix                     |
+| `docs`     | Documentation only          |
+| `style`    | Formatting (no code change) |
+| `refactor` | Code restructuring          |
+| `test`     | Adding or updating tests    |
+| `chore`    | Maintenance tasks           |
+
+**Guidelines:**
+
+- Use **imperative mood** ("Add feature" not "Added feature")
+- Keep first line under **72 characters**
+- Capitalize the first letter after the type prefix
+- No period at the end of the subject line
+- Add a blank line before the body for detailed explanations
+
+**Examples:**
+
+```bash
+# Simple commit
+git commit -m "feat: Add user authentication flow"
+
+# Commit with body for more context
+git commit -m "fix: Resolve memory leak in WebSocket handler
+
+The connection cleanup was not being called when clients
+disconnected unexpectedly. Added proper cleanup in the
+error handler to prevent memory accumulation."
+
+# Documentation update
+git commit -m "docs: Update API documentation"
+
+# Refactoring
+git commit -m "refactor: Simplify state management logic"
+```
+
+### Submitting a Pull Request
+
+Follow these steps to submit your contribution:
+
+#### 1. Prepare Your Changes
+
+Ensure you've synced with the latest upstream changes:
+
+```bash
+# Fetch latest changes from upstream
+git fetch upstream
+
+# Rebase your branch on main (if needed)
+git rebase upstream/main
+```
+
+#### 2. Run Pre-submission Checks
+
+Before opening your PR, verify everything passes locally:
+
+```bash
+# Run all tests
+npm run test:all
+
+# Check formatting
+npm run format:check
+
+# Run linter
+npm run lint
+
+# Build to verify no compile errors
+npm run build
+```
+
+#### 3. Push Your Changes
+
+```bash
+# Push your branch to your fork
+git push origin feature/your-feature-name
+```
+
+#### 4. Open a Pull Request
+
+1. Go to your fork on GitHub
+2. Click "Compare & pull request" for your branch
+3. Ensure the base repository is `AutoMaker-Org/automaker` and base branch is `main`
+4. Fill out the PR template completely
+
+#### PR Requirements Checklist
+
+Your PR should include:
+
+- [ ] **Clear title** describing the change (use conventional commit format)
+- [ ] **Description** explaining what changed and why
+- [ ] **Link to related issue** (if applicable): `Closes #123` or `Fixes #456`
+- [ ] **All CI checks passing** (format, lint, build, tests)
+- [ ] **No merge conflicts** with main branch
+- [ ] **Tests included** for new functionality
+- [ ] **Documentation updated** if adding/changing public APIs
+
+**Example PR Description:**
+
+```markdown
+## Summary
+
+This PR adds dark mode support to the Automaker UI.
+
+- Implements theme toggle in settings panel
+- Adds CSS custom properties for theme colors
+- Persists theme preference to localStorage
+
+## Related Issue
+
+Closes #123
+
+## Testing
+
+- [x] Tested toggle functionality in Chrome and Firefox
+- [x] Verified theme persists across page reloads
+- [x] Checked accessibility contrast ratios
+
+## Screenshots
+
+[Include before/after screenshots for UI changes]
+```
+
+### Review Process
+
+All contributions go through code review to maintain quality:
+
+#### What to Expect
+
+1. **CI Checks Run First** - Automated checks (format, lint, build, tests) must pass before review
+2. **Maintainer Review** - The project maintainers will review your PR and decide whether to merge it
+3. **Feedback & Discussion** - The reviewer may ask questions or request changes
+4. **Iteration** - Make requested changes and push updates to the same branch
+5. **Approval & Merge** - Once approved and checks pass, your PR will be merged
+
+#### Review Focus Areas
+
+The reviewer checks for:
+
+- **Correctness** - Does the code work as intended?
+- **Clean Code** - Does it follow our [code style guidelines](#code-style-guidelines)?
+- **Test Coverage** - Are new features properly tested?
+- **Documentation** - Are public APIs documented?
+- **Breaking Changes** - Are any breaking changes discussed first?
+
+#### Responding to Feedback
+
+- Respond to **all** review comments, even if just to acknowledge
+- Ask questions if feedback is unclear
+- Push additional commits to address feedback (don't force-push during review)
+- Mark conversations as resolved once addressed
+
+#### Approval Criteria
+
+Your PR is ready to merge when:
+
+- ✅ All CI checks pass
+- ✅ The maintainer has approved the changes
+- ✅ All review comments are addressed
+- ✅ No unresolved merge conflicts
+
+#### Getting Help
+
+If your PR seems stuck:
+
+- Comment asking for status update (mention @webdevcody if needed)
+- Reach out on [Discord](https://discord.gg/jjem7aEDKU)
+- Make sure all checks are passing and you've responded to all feedback
+
+---
+
+## Code Style Guidelines
+
+Automaker uses automated tooling to enforce code style. Run `npm run format` to format code and `npm run lint` to check for issues. Pre-commit hooks automatically format staged files before committing.
+
+---
+
+## Testing Requirements
+
+Testing helps prevent regressions. Automaker uses **Playwright** for end-to-end testing and **Vitest** for unit tests.
+
+### Running Tests
+
+Use these commands to run tests locally:
+
+| Command                        | Description                           |
+| ------------------------------ | ------------------------------------- |
+| `npm run test`                 | Run E2E tests (Playwright)            |
+| `npm run test:server`          | Run server unit tests (Vitest)        |
+| `npm run test:packages`        | Run shared package tests              |
+| `npm run test:all`             | Run all tests                         |
+| `npm run test:server:coverage` | Run server tests with coverage report |
+
+**Before submitting a PR**, always run the full test suite:
+
+```bash
+npm run test:all
+```
+
+### Test Frameworks
+
+#### End-to-End Tests (Playwright)
+
+E2E tests verify the entire application works correctly from a user's perspective.
+
+- **Framework:** [Playwright](https://playwright.dev/)
+- **Location:** `e2e/` directory
+- **Test ports:** UI on port 3007, Server on port 3008
+
+**Running E2E tests:**
+
+```bash
+# Run all E2E tests
+npm run test
+
+# Run with headed browser (useful for debugging)
+npx playwright test --headed
+
+# Run a specific test file
+npm test --workspace=@automaker/ui -- tests/example.spec.ts
+```
+
+**E2E Test Guidelines:**
+
+- Write tests from a user's perspective
+- Use descriptive test names that explain the scenario
+- Clean up test data after each test
+- Use appropriate timeouts for async operations
+- Prefer `locator` over direct selectors for resilience
+
+#### Unit Tests (Vitest)
+
+Unit tests verify individual functions and modules work correctly in isolation.
+
+- **Framework:** [Vitest](https://vitest.dev/)
+- **Location:** In the `tests/` directory within each package (e.g., `apps/server/tests/`)
+
+**Running unit tests:**
+
+```bash
+# Run all server unit tests
+npm run test:server
+
+# Run with coverage report
+npm run test:server:coverage
+
+# Run package tests
+npm run test:packages
+
+# Run in watch mode during development
+npx vitest --watch
+```
+
+**Unit Test Guidelines:**
+
+- Keep tests small and focused on one behavior
+- Use descriptive test names: `it('should return null when user is not found')`
+- Follow the AAA pattern: Arrange, Act, Assert
+- Mock external dependencies to isolate the unit under test
+- Aim for meaningful coverage, not just line coverage
+
+### Writing Tests
+
+#### When to Write Tests
+
+- **New features:** All new features should include tests
+- **Bug fixes:** Add a test that reproduces the bug before fixing
+- **Refactoring:** Ensure existing tests pass after refactoring
+- **Public APIs:** All public APIs must have test coverage
+
+### CI/CD Pipeline
+
+Automaker uses **GitHub Actions** for continuous integration. Every pull request triggers automated checks.
+
+#### CI Checks
+
+The following checks must pass before your PR can be merged:
+
+| Check             | Description                                   |
+| ----------------- | --------------------------------------------- |
+| **Format**        | Verifies code is formatted with Prettier      |
+| **Build**         | Ensures the project compiles without errors   |
+| **Package Tests** | Runs tests for shared `@automaker/*` packages |
+| **Server Tests**  | Runs server unit tests with coverage          |
+
+#### CI Testing Environment
+
+For CI environments, Automaker supports a mock agent mode:
+
+```bash
+# Enable mock agent mode for CI testing
+AUTOMAKER_MOCK_AGENT=true npm run test
+```
+
+This allows tests to run without requiring a real Claude API connection.
+
+#### Viewing CI Results
+
+1. Go to your PR on GitHub
+2. Scroll to the "Checks" section at the bottom
+3. Click on any failed check to see detailed logs
+4. Fix issues locally and push updates
+
+#### Common CI Failures
+
+| Issue               | Solution                                      |
+| ------------------- | --------------------------------------------- |
+| Format check failed | Run `npm run format` locally                  |
+| Build failed        | Run `npm run build` and fix TypeScript errors |
+| Tests failed        | Run `npm run test:all` locally to reproduce   |
+| Coverage decreased  | Add tests for new code paths                  |
+
+### Coverage Requirements
+
+While we don't enforce strict coverage percentages, we expect:
+
+- **New features:** Should include comprehensive tests
+- **Bug fixes:** Should include a regression test
+- **Critical paths:** Must have test coverage (authentication, data persistence, etc.)
+
+To view coverage reports locally:
+
+```bash
+npm run test:server:coverage
+```
+
+This generates an HTML report you can open in your browser to see which lines are covered.
+
+---
+
+## Issue Reporting
+
+Found a bug or have an idea for a new feature? We'd love to hear from you! This section explains how to report issues effectively.
+
+### Bug Reports
+
+When reporting a bug, please provide as much information as possible to help us understand and reproduce the issue.
+
+#### Before Reporting
+
+1. **Search existing issues** - Check if the bug has already been reported
+2. **Try the latest version** - Make sure you're running the latest version of Automaker
+3. **Reproduce the issue** - Verify you can consistently reproduce the bug
+
+#### Bug Report Template
+
+When creating a bug report, include:
+
+- **Title:** A clear, descriptive title summarizing the issue
+- **Environment:**
+  - Operating System and version
+  - Node.js version (`node --version`)
+  - Automaker version or commit hash
+- **Steps to Reproduce:** Numbered list of steps to reproduce the bug
+- **Expected Behavior:** What you expected to happen
+- **Actual Behavior:** What actually happened
+- **Logs/Screenshots:** Any relevant error messages, console output, or screenshots
+
+**Example Bug Report:**
+
+```markdown
+## Bug: WebSocket connection drops after 5 minutes of inactivity
+
+### Environment
+
+- OS: Windows 11
+- Node.js: 22.11.0
+- Automaker: commit abc1234
+
+### Steps to Reproduce
+
+1. Start the application with `npm run dev:web`
+2. Open the Kanban board
+3. Leave the browser tab open for 5+ minutes without interaction
+4. Try to move a card
+
+### Expected Behavior
+
+The card should move to the new column.
+
+### Actual Behavior
+
+The UI shows "Connection lost" and the card doesn't move.
+
+### Logs
+
+[WebSocket] Connection closed: 1006
+```
+
+### Feature Requests
+
+We welcome ideas for improving Automaker! Here's how to submit a feature request:
+
+#### Before Requesting
+
+1. **Check existing issues** - Your idea may already be proposed or in development
+2. **Consider scope** - Think about whether the feature fits Automaker's mission as an autonomous AI development studio
+
+#### Feature Request Template
+
+A good feature request includes:
+
+- **Title:** A brief, descriptive title
+- **Problem Statement:** What problem does this feature solve?
+- **Proposed Solution:** How do you envision this working?
+- **Alternatives Considered:** What other approaches did you consider?
+- **Additional Context:** Mockups, examples, or references that help explain your idea
+
+**Example Feature Request:**
+
+```markdown
+## Feature: Dark Mode Support
+
+### Problem Statement
+
+Working late at night, the bright UI causes eye strain and doesn't match
+my system's dark theme preference.
+
+### Proposed Solution
+
+Add a theme toggle in the settings panel that allows switching between
+light and dark modes. Ideally, it should also detect system preference.
+
+### Alternatives Considered
+
+- Browser extension to force dark mode (doesn't work well with custom styling)
+- Custom CSS override (breaks with updates)
+
+### Additional Context
+
+Similar to how VS Code handles themes - a dropdown in settings with
+immediate preview.
+```
+
+### Security Issues
+
+**Important:** If you discover a security vulnerability, please do NOT open a public issue. Instead:
+
+1. Join our [Discord server](https://discord.gg/jjem7aEDKU) and send a direct message to the user `@webdevcody`
+2. Include detailed steps to reproduce
+3. Allow time for us to address the issue before public disclosure
+
+We take security seriously and appreciate responsible disclosure.
+
+---
+
+For license and contribution terms, see the [LICENSE](LICENSE) file in the repository root and the [README.md](README.md#license) for more details.
+
+---
+
+Thank you for contributing to Automaker!

DISCLAIMER.md

@@ -30,6 +30,26 @@ Before running Automaker, we strongly recommend reviewing the source code yourse
 - **Virtual Machine**: Use a VM (such as VirtualBox, VMware, or Parallels) to create an isolated environment
 - **Cloud Development Environment**: Use a cloud-based development environment that provides isolation
 
+#### Running in Isolated Docker Container
+
+For maximum security, run Automaker in an isolated Docker container that **cannot access your laptop's files**:
+
+```bash
+# 1. Set your API key (bash/Linux/Mac - creates UTF-8 file)
+echo "ANTHROPIC_API_KEY=your-api-key-here" > .env
+
+# On Windows PowerShell, use instead:
+Set-Content -Path .env -Value "ANTHROPIC_API_KEY=your-api-key-here" -Encoding UTF8
+
+# 2. Build and run isolated container
+docker-compose up -d
+
+# 3. Access the UI at http://localhost:3007
+#    API at http://localhost:3008/api/health
+```
+
+The container uses only Docker-managed volumes and has no access to your host filesystem. See [docker-isolation.md](docs/docker-isolation.md) for full documentation.
+
 ### 3. Limit Access
 
 If you must run locally:

Dockerfile

@@ -0,0 +1,154 @@
+# Automaker Multi-Stage Dockerfile
+# Single Dockerfile for both server and UI builds
+# Usage:
+#   docker build --target server -t automaker-server .
+#   docker build --target ui -t automaker-ui .
+# Or use docker-compose which selects targets automatically
+
+# =============================================================================
+# BASE STAGE - Common setup for all builds (DRY: defined once, used by all)
+# =============================================================================
+FROM node:22-alpine AS base
+
+# Install build dependencies for native modules (node-pty)
+RUN apk add --no-cache python3 make g++
+
+WORKDIR /app
+
+# Copy root package files
+COPY package*.json ./
+
+# Copy all libs package.json files (centralized - add new libs here)
+COPY libs/types/package*.json ./libs/types/
+COPY libs/utils/package*.json ./libs/utils/
+COPY libs/prompts/package*.json ./libs/prompts/
+COPY libs/platform/package*.json ./libs/platform/
+COPY libs/model-resolver/package*.json ./libs/model-resolver/
+COPY libs/dependency-resolver/package*.json ./libs/dependency-resolver/
+COPY libs/git-utils/package*.json ./libs/git-utils/
+
+# Copy scripts (needed by npm workspace)
+COPY scripts ./scripts
+
+# =============================================================================
+# SERVER BUILD STAGE
+# =============================================================================
+FROM base AS server-builder
+
+# Copy server-specific package.json
+COPY apps/server/package*.json ./apps/server/
+
+# Install dependencies (--ignore-scripts to skip husky/prepare, then rebuild native modules)
+RUN npm ci --ignore-scripts && npm rebuild node-pty
+
+# Copy all source files
+COPY libs ./libs
+COPY apps/server ./apps/server
+
+# Build packages in dependency order, then build server
+RUN npm run build:packages && npm run build --workspace=apps/server
+
+# =============================================================================
+# SERVER PRODUCTION STAGE
+# =============================================================================
+FROM node:22-alpine AS server
+
+# Install git, curl, bash (for terminal), and GitHub CLI (pinned version, multi-arch)
+RUN apk add --no-cache git curl bash && \
+    GH_VERSION="2.63.2" && \
+    ARCH=$(uname -m) && \
+    case "$ARCH" in \
+        x86_64) GH_ARCH="amd64" ;; \
+        aarch64|arm64) GH_ARCH="arm64" ;; \
+        *) echo "Unsupported architecture: $ARCH" && exit 1 ;; \
+    esac && \
+    curl -L "https://github.com/cli/cli/releases/download/v${GH_VERSION}/gh_${GH_VERSION}_linux_${GH_ARCH}.tar.gz" -o gh.tar.gz && \
+    tar -xzf gh.tar.gz && \
+    mv gh_${GH_VERSION}_linux_${GH_ARCH}/bin/gh /usr/local/bin/gh && \
+    rm -rf gh.tar.gz gh_${GH_VERSION}_linux_${GH_ARCH}
+
+# Install Claude CLI globally
+RUN npm install -g @anthropic-ai/claude-code
+
+WORKDIR /app
+
+# Create non-root user
+RUN addgroup -g 1001 -S automaker && \
+    adduser -S automaker -u 1001
+
+# Copy root package.json (needed for workspace resolution)
+COPY --from=server-builder /app/package*.json ./
+
+# Copy built libs (workspace packages are symlinked in node_modules)
+COPY --from=server-builder /app/libs ./libs
+
+# Copy built server
+COPY --from=server-builder /app/apps/server/dist ./apps/server/dist
+COPY --from=server-builder /app/apps/server/package*.json ./apps/server/
+
+# Copy node_modules (includes symlinks to libs)
+COPY --from=server-builder /app/node_modules ./node_modules
+
+# Create data and projects directories
+RUN mkdir -p /data /projects && chown automaker:automaker /data /projects
+
+# Configure git for mounted volumes and authentication
+# Use --system so it's not overwritten by mounted user .gitconfig
+RUN git config --system --add safe.directory '*' && \
+    # Use gh as credential helper (works with GH_TOKEN env var)
+    git config --system credential.helper '!gh auth git-credential'
+
+# Switch to non-root user
+USER automaker
+
+# Environment variables
+ENV PORT=3008
+ENV DATA_DIR=/data
+
+# Expose port
+EXPOSE 3008
+
+# Health check (using curl since it's already installed, more reliable than busybox wget)
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:3008/api/health || exit 1
+
+# Start server
+CMD ["node", "apps/server/dist/index.js"]
+
+# =============================================================================
+# UI BUILD STAGE
+# =============================================================================
+FROM base AS ui-builder
+
+# Copy UI-specific package.json
+COPY apps/ui/package*.json ./apps/ui/
+
+# Install dependencies (--ignore-scripts to skip husky and build:packages in prepare script)
+RUN npm ci --ignore-scripts
+
+# Copy all source files
+COPY libs ./libs
+COPY apps/ui ./apps/ui
+
+# Build packages in dependency order, then build UI
+# VITE_SERVER_URL tells the UI where to find the API server
+# Use ARG to allow overriding at build time: --build-arg VITE_SERVER_URL=http://api.example.com
+ARG VITE_SERVER_URL=http://localhost:3008
+ENV VITE_SKIP_ELECTRON=true
+ENV VITE_SERVER_URL=${VITE_SERVER_URL}
+RUN npm run build:packages && npm run build --workspace=apps/ui
+
+# =============================================================================
+# UI PRODUCTION STAGE
+# =============================================================================
+FROM nginx:alpine AS ui
+
+# Copy built files
+COPY --from=ui-builder /app/apps/ui/dist /usr/share/nginx/html
+
+# Copy nginx config for SPA routing
+COPY apps/ui/nginx.conf /etc/nginx/conf.d/default.conf
+
+EXPOSE 80
+
+CMD ["nginx", "-g", "daemon off;"]

README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="apps/app/public/readme_logo.png" alt="Automaker Logo" height="80" />
+  <img src="apps/ui/public/readme_logo.svg" alt="Automaker Logo" height="80" />
 </p>
 
 > **[!TIP]**
@@ -8,7 +8,7 @@
 >
 > Automaker itself was built by a group of engineers using AI and agentic coding techniques to build features faster than ever. By leveraging tools like Cursor IDE and Claude Code CLI, the team orchestrated AI agents to implement complex functionality in days instead of weeks.
 >
-> **Learn how:** Master these same techniques and workflows in the [Agentic Jumpstart course](https://agenticjumpstart.com/?utm=automaker).
+> **Learn how:** Master these same techniques and workflows in the [Agentic Jumpstart course](https://agenticjumpstart.com/?utm=automaker-gh).
 
 # Automaker
 
@@ -19,7 +19,7 @@
 
 - [What Makes Automaker Different?](#what-makes-automaker-different)
   - [The Workflow](#the-workflow)
-  - [Powered by Claude Code](#powered-by-claude-code)
+  - [Powered by Claude Agent SDK](#powered-by-claude-agent-sdk)
   - [Why This Matters](#why-this-matters)
 - [Security Disclaimer](#security-disclaimer)
 - [Community & Support](#community--support)
@@ -28,22 +28,36 @@
   - [Quick Start](#quick-start)
 - [How to Run](#how-to-run)
   - [Development Mode](#development-mode)
-    - [Electron Desktop App (Recommended)](#electron-desktop-app-recommended)
-    - [Web Browser Mode](#web-browser-mode)
   - [Building for Production](#building-for-production)
-  - [Running Production Build](#running-production-build)
   - [Testing](#testing)
   - [Linting](#linting)
-  - [Authentication Options](#authentication-options)
-  - [Persistent Setup (Optional)](#persistent-setup-optional)
+  - [Environment Configuration](#environment-configuration)
+  - [Authentication Setup](#authentication-setup)
 - [Features](#features)
+  - [Core Workflow](#core-workflow)
+  - [AI & Planning](#ai--planning)
+  - [Project Management](#project-management)
+  - [Collaboration & Review](#collaboration--review)
+  - [Developer Tools](#developer-tools)
+  - [Advanced Features](#advanced-features)
 - [Tech Stack](#tech-stack)
+  - [Frontend](#frontend)
+  - [Backend](#backend)
+  - [Testing & Quality](#testing--quality)
+  - [Shared Libraries](#shared-libraries)
+- [Available Views](#available-views)
+- [Architecture](#architecture)
+  - [Monorepo Structure](#monorepo-structure)
+  - [How It Works](#how-it-works)
+  - [Key Architectural Patterns](#key-architectural-patterns)
+  - [Security & Isolation](#security--isolation)
+  - [Data Storage](#data-storage)
 - [Learn More](#learn-more)
 - [License](#license)
 
 </details>
 
-Automaker is an autonomous AI development studio that transforms how you build software. Instead of manually writing every line of code, you describe features on a Kanban board and watch as AI agents powered by Claude Code automatically implement them.
+Automaker is an autonomous AI development studio that transforms how you build software. Instead of manually writing every line of code, you describe features on a Kanban board and watch as AI agents powered by Claude Agent SDK automatically implement them. Built with React, Vite, Electron, and Express, Automaker provides a complete workflow for managing AI agents through a desktop application (or web browser), with features like real-time streaming, git worktree isolation, plan approval, and multi-agent task execution.
 
 ![Automaker UI](https://i.imgur.com/jdwKydM.png)
 
@@ -59,43 +73,27 @@ Traditional development tools help you write code. Automaker helps you **orchest
 4. **Review & Verify** - Review the changes, run tests, and approve when ready
 5. **Ship Faster** - Build entire applications in days, not weeks
 
-### Powered by Claude Code
+### Powered by Claude Agent SDK
 
-Automaker leverages the [Claude Agent SDK](https://docs.anthropic.com/en/docs/claude-code) to give AI agents full access to your codebase. Agents can read files, write code, execute commands, run tests, and make git commits—all while working in isolated git worktrees to keep your main branch safe.
+Automaker leverages the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk) to give AI agents full access to your codebase. Agents can read files, write code, execute commands, run tests, and make git commits—all while working in isolated git worktrees to keep your main branch safe. The SDK provides autonomous AI agents that can use tools, make decisions, and complete complex multi-step tasks without constant human intervention.
 
 ### Why This Matters
 
 The future of software development is **agentic coding**—where developers become architects directing AI agents rather than manual coders. Automaker puts this future in your hands today, letting you experience what it's like to build software 10x faster with AI agents handling the implementation while you focus on architecture and business logic.
 
----
-
-> **[!CAUTION]**
->
-> ## Security Disclaimer
->
-> **This software uses AI-powered tooling that has access to your operating system and can read, modify, and delete files. Use at your own risk.**
->
-> We have reviewed this codebase for security vulnerabilities, but you assume all risk when running this software. You should review the code yourself before running it.
->
-> **We do not recommend running Automaker directly on your local computer** due to the risk of AI agents having access to your entire file system. Please sandbox this application using Docker or a virtual machine.
->
-> **[Read the full disclaimer](../DISCLAIMER.md)**
-
----
-
 ## Community & Support
 
 Join the **Agentic Jumpstart** to connect with other builders exploring **agentic coding** and autonomous development workflows.
 
 In the Discord, you can:
+
 - 💬 Discuss agentic coding patterns and best practices
 - 🧠 Share ideas for AI-driven development workflows
 - 🛠️ Get help setting up or extending Automaker
 - 🚀 Show off projects built with AI agents
 - 🤝 Collaborate with other developers and contributors
 
-👉 **Join the Discord:**  
-https://discord.gg/jjem7aEDKU
+👉 **Join the Discord:** [Agentic Jumpstart Discord](https://discord.gg/jjem7aEDKU)
 
 ---
 
@@ -103,25 +101,49 @@ https://discord.gg/jjem7aEDKU
 
 ### Prerequisites
 
-- Node.js 18+
-- npm
-- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) installed and authenticated
+- **Node.js 18+** (tested with Node.js 22)
+- **npm** (comes with Node.js)
+- **Authentication** (choose one):
+  - **[Claude Code CLI](https://code.claude.com/docs/en/overview)** (recommended) - Install and authenticate, credentials used automatically
+  - **Anthropic API Key** - Direct API key for Claude Agent SDK ([get one here](https://console.anthropic.com/))
 
 ### Quick Start
 
 ```bash
-# 1. Clone the repo
+# 1. Clone the repository
 git clone https://github.com/AutoMaker-Org/automaker.git
 cd automaker
 
 # 2. Install dependencies
 npm install
 
-# 3. Run Automaker (pick your mode)
+# 3. Build shared packages (Now can be skipped npm install / run dev does it automaticly)
+npm run build:packages
+
+# 4. Set up authentication (skip if using Claude Code CLI)
+# If using Claude Code CLI: credentials are detected automatically
+# If using API key directly, choose one method:
+
+# Option A: Environment variable
+export ANTHROPIC_API_KEY="sk-ant-..."
+
+# Option B: Create .env file in project root
+echo "ANTHROPIC_API_KEY=sk-ant-..." > .env
+
+# 5. Start Automaker (interactive launcher)
 npm run dev
-# Then choose your run mode when prompted, or use specific commands below
+# Choose between:
+#   1. Web Application (browser at localhost:3007)
+#   2. Desktop Application (Electron - recommended)
 ```
 
+**Note:** The `npm run dev` command will:
+
+- Check for dependencies and install if needed
+- Install Playwright browsers for E2E tests
+- Kill any processes on ports 3007/3008
+- Present an interactive menu to choose your run mode
+
 ## How to Run
 
 ### Development Mode
@@ -159,31 +181,162 @@ npm run dev:web
 
 ### Building for Production
 
+#### Web Application
+
 ```bash
-# Build Next.js app
+# Build for web deployment (uses Vite)
 npm run build
 
-# Build Electron app for distribution
-npm run build:electron
-```
-
-### Running Production Build
-
-```bash
-# Start production Next.js server
+# Run production build
 npm run start
 ```
 
-### Testing
+#### Desktop Application
 
 ```bash
-# Run tests headless
-npm run test
+# Build for current platform (macOS/Windows/Linux)
+npm run build:electron
 
-# Run tests with browser visible
-npm run test:headed
+# Platform-specific builds
+npm run build:electron:mac     # macOS (DMG + ZIP, x64 + arm64)
+npm run build:electron:win     # Windows (NSIS installer, x64)
+npm run build:electron:linux   # Linux (AppImage + DEB, x64)
+
+# Output directory: apps/ui/release/
 ```
 
+#### Docker Deployment
+
+Docker provides the most secure way to run Automaker by isolating it from your host filesystem.
+
+```bash
+# Build and run with Docker Compose
+docker-compose up -d
+
+# Access UI at http://localhost:3007
+# API at http://localhost:3008
+
+# View logs
+docker-compose logs -f
+
+# Stop containers
+docker-compose down
+```
+
+##### Configuration
+
+Create a `.env` file in the project root if using API key authentication:
+
+```bash
+# Optional: Anthropic API key (not needed if using Claude CLI authentication)
+ANTHROPIC_API_KEY=sk-ant-...
+```
+
+**Note:** Most users authenticate via Claude CLI instead of API keys. See [Claude CLI Authentication](#claude-cli-authentication-optional) below.
+
+##### Working with Projects (Host Directory Access)
+
+By default, the container is isolated from your host filesystem. To work on projects from your host machine, create a `docker-compose.override.yml` file (gitignored):
+
+```yaml
+services:
+  server:
+    volumes:
+      # Mount your project directories
+      - /path/to/your/project:/projects/your-project
+```
+
+##### Claude CLI Authentication (Optional)
+
+To use Claude Code CLI authentication instead of an API key, mount your Claude CLI config directory:
+
+```yaml
+services:
+  server:
+    volumes:
+      # Linux/macOS
+      - ~/.claude:/home/automaker/.claude
+      # Windows
+      - C:/Users/YourName/.claude:/home/automaker/.claude
+```
+
+**Note:** The Claude CLI config must be writable (do not use `:ro` flag) as the CLI writes debug files.
+
+##### GitHub CLI Authentication (For Git Push/PR Operations)
+
+To enable git push and GitHub CLI operations inside the container:
+
+```yaml
+services:
+  server:
+    volumes:
+      # Mount GitHub CLI config
+      # Linux/macOS
+      - ~/.config/gh:/home/automaker/.config/gh
+      # Windows
+      - 'C:/Users/YourName/AppData/Roaming/GitHub CLI:/home/automaker/.config/gh'
+
+      # Mount git config for user identity (name, email)
+      - ~/.gitconfig:/home/automaker/.gitconfig:ro
+    environment:
+      # GitHub token (required on Windows where tokens are in Credential Manager)
+      # Get your token with: gh auth token
+      - GH_TOKEN=${GH_TOKEN}
+```
+
+Then add `GH_TOKEN` to your `.env` file:
+
+```bash
+GH_TOKEN=gho_your_github_token_here
+```
+
+##### Complete docker-compose.override.yml Example
+
+```yaml
+services:
+  server:
+    volumes:
+      # Your projects
+      - /path/to/project1:/projects/project1
+      - /path/to/project2:/projects/project2
+
+      # Authentication configs
+      - ~/.claude:/home/automaker/.claude
+      - ~/.config/gh:/home/automaker/.config/gh
+      - ~/.gitconfig:/home/automaker/.gitconfig:ro
+    environment:
+      - GH_TOKEN=${GH_TOKEN}
+```
+
+##### Architecture Support
+
+The Docker image supports both AMD64 and ARM64 architectures. The GitHub CLI and Claude CLI are automatically downloaded for the correct architecture during build.
+
+### Testing
+
+#### End-to-End Tests (Playwright)
+
+```bash
+npm run test            # Headless E2E tests
+npm run test:headed     # Browser visible E2E tests
+```
+
+#### Unit Tests (Vitest)
+
+```bash
+npm run test:server              # Server unit tests
+npm run test:server:coverage     # Server tests with coverage
+npm run test:packages            # All shared package tests
+npm run test:all                 # Packages + server tests
+```
+
+#### Test Configuration
+
+- E2E tests run on ports 3007 (UI) and 3008 (server)
+- Automatically starts test servers before running
+- Uses Chromium browser via Playwright
+- Mock agent mode available in CI with `AUTOMAKER_MOCK_AGENT=true`
+
 ### Linting
 
 ```bash
@@ -191,59 +344,300 @@ npm run test:headed
 npm run lint
 ```
 
-### Authentication Options
+### Environment Configuration
 
-Automaker supports multiple authentication methods (in order of priority):
+#### Authentication (if not using Claude Code CLI)
 
-| Method           | Environment Variable | Description                     |
-| ---------------- | -------------------- | ------------------------------- |
-| API Key (env)    | `ANTHROPIC_API_KEY`  | Anthropic API key               |
-| API Key (stored) | —                    | Anthropic API key stored in app |
+- `ANTHROPIC_API_KEY` - Your Anthropic API key for Claude Agent SDK (not needed if using Claude Code CLI)
 
-### Persistent Setup (Optional)
+#### Optional - Server
+
+- `PORT` - Server port (default: 3008)
+- `DATA_DIR` - Data storage directory (default: ./data)
+- `ENABLE_REQUEST_LOGGING` - HTTP request logging (default: true)
+
+#### Optional - Security
+
+- `AUTOMAKER_API_KEY` - Optional API authentication for the server
+- `ALLOWED_ROOT_DIRECTORY` - Restrict file operations to specific directory
+- `CORS_ORIGIN` - CORS policy (default: \*)
+
+#### Optional - Development
+
+- `VITE_SKIP_ELECTRON` - Skip Electron in dev mode
+- `OPEN_DEVTOOLS` - Auto-open DevTools in Electron
+
+### Authentication Setup
+
+#### Option 1: Claude Code CLI (Recommended)
+
+Install and authenticate the Claude Code CLI following the [official quickstart guide](https://code.claude.com/docs/en/quickstart).
+
+Once authenticated, Automaker will automatically detect and use your CLI credentials. No additional configuration needed!
+
+#### Option 2: Direct API Key
+
+If you prefer not to use the CLI, you can provide an Anthropic API key directly using one of these methods:
+
+##### 2a. Shell Configuration
 
 Add to your `~/.bashrc` or `~/.zshrc`:
 
 ```bash
-export ANTHROPIC_API_KEY="YOUR_API_KEY_HERE"
+export ANTHROPIC_API_KEY="sk-ant-..."
 ```
 
-Then restart your terminal or run `source ~/.bashrc`.
+Then restart your terminal or run `source ~/.bashrc` (or `source ~/.zshrc`).
+
+##### 2b. .env File
+
+Create a `.env` file in the project root (gitignored):
+
+```bash
+ANTHROPIC_API_KEY=sk-ant-...
+PORT=3008
+DATA_DIR=./data
+```
+
+##### 2c. In-App Storage
+
+The application can store your API key securely in the settings UI. The key is persisted in the `DATA_DIR` directory.
 
 ## Features
 
+### Core Workflow
+
 - 📋 **Kanban Board** - Visual drag-and-drop board to manage features through backlog, in progress, waiting approval, and verified stages
 - 🤖 **AI Agent Integration** - Automatic AI agent assignment to implement features when moved to "In Progress"
-- 🧠 **Multi-Model Support** - Choose from multiple AI models including Claude Opus, Sonnet, and more
-- 💭 **Extended Thinking** - Enable extended thinking modes for complex problem-solving
-- 📡 **Real-time Agent Output** - View live agent output, logs, and file diffs as features are being implemented
-- 🔍 **Project Analysis** - AI-powered project structure analysis to understand your codebase
-- 📁 **Context Management** - Add context files to help AI agents understand your project better
-- 💡 **Feature Suggestions** - AI-generated feature suggestions based on your project
-- 🖼️ **Image Support** - Attach images and screenshots to feature descriptions
-- ⚡ **Concurrent Processing** - Configure concurrency to process multiple features simultaneously
-- 🧪 **Test Integration** - Automatic test running and verification for implemented features
-- 🔀 **Git Integration** - View git diffs and track changes made by AI agents
-- 👤 **AI Profiles** - Create and manage different AI agent profiles for various tasks
-- 💬 **Chat History** - Keep track of conversations and interactions with AI agents
-- ⌨️ **Keyboard Shortcuts** - Efficient navigation and actions via keyboard shortcuts
-- 🎨 **Dark/Light Theme** - Beautiful UI with theme support
-- 🖥️ **Cross-Platform** - Desktop application built with Electron for Windows, macOS, and Linux
+- 🔀 **Git Worktree Isolation** - Each feature executes in isolated git worktrees to protect your main branch
+- 📡 **Real-time Streaming** - Watch AI agents work in real-time with live tool usage, progress updates, and task completion
+- 🔄 **Follow-up Instructions** - Send additional instructions to running agents without stopping them
+
+### AI & Planning
+
+- 🧠 **Multi-Model Support** - Choose from Claude Opus, Sonnet, and Haiku per feature
+- 💭 **Extended Thinking** - Enable thinking modes (none, medium, deep, ultra) for complex problem-solving
+- 📝 **Planning Modes** - Four planning levels: skip (direct implementation), lite (quick plan), spec (task breakdown), full (phased execution)
+- ✅ **Plan Approval** - Review and approve AI-generated plans before implementation begins
+- 📊 **Multi-Agent Task Execution** - Spec mode spawns dedicated agents per task for focused implementation
+
+### Project Management
+
+- 🔍 **Project Analysis** - AI-powered codebase analysis to understand your project structure
+- 💡 **Feature Suggestions** - AI-generated feature suggestions based on project analysis
+- 📁 **Context Management** - Add markdown, images, and documentation files that agents automatically reference
+- 🔗 **Dependency Blocking** - Features can depend on other features, enforcing execution order
+- 🌳 **Graph View** - Visualize feature dependencies with interactive graph visualization
+- 📋 **GitHub Integration** - Import issues, validate feasibility, and convert to tasks automatically
+
+### Collaboration & Review
+
+- 🧪 **Verification Workflow** - Features move to "Waiting Approval" for review and testing
+- 💬 **Agent Chat** - Interactive chat sessions with AI agents for exploratory work
+- 👤 **AI Profiles** - Create custom agent configurations with different prompts, models, and settings
+- 📜 **Session History** - Persistent chat sessions across restarts with full conversation history
+- 🔍 **Git Diff Viewer** - Review changes made by agents before approving
+
+### Developer Tools
+
+- 🖥️ **Integrated Terminal** - Full terminal access with tabs, splits, and persistent sessions
+- 🖼️ **Image Support** - Attach screenshots and diagrams to feature descriptions for visual context
+- ⚡ **Concurrent Execution** - Configure how many features can run simultaneously (default: 3)
+- ⌨️ **Keyboard Shortcuts** - Fully customizable shortcuts for navigation and actions
+- 🎨 **Theme System** - 25+ themes including Dark, Light, Dracula, Nord, Catppuccin, and more
+- 🖥️ **Cross-Platform** - Desktop app for macOS (x64, arm64), Windows (x64), and Linux (x64)
+- 🌐 **Web Mode** - Run in browser or as Electron desktop app
+
+### Advanced Features
+
+- 🔐 **Docker Isolation** - Security-focused Docker deployment with no host filesystem access
+- 🎯 **Worktree Management** - Create, switch, commit, and create PRs from worktrees
+- 📊 **Usage Tracking** - Monitor Claude API usage with detailed metrics
+- 🔊 **Audio Notifications** - Optional completion sounds (mutable in settings)
+- 💾 **Auto-save** - All work automatically persisted to `.automaker/` directory
 
 ## Tech Stack
 
-- [Next.js](https://nextjs.org) - React framework
-- [Electron](https://www.electronjs.org/) - Desktop application framework
-- [Tailwind CSS](https://tailwindcss.com/) - Styling
-- [Zustand](https://zustand-demo.pmnd.rs/) - State management
-- [dnd-kit](https://dndkit.com/) - Drag and drop functionality
+### Frontend
+
+- **React 19** - UI framework
+- **Vite 7** - Build tool and development server
+- **Electron 39** - Desktop application framework
+- **TypeScript 5.9** - Type safety
+- **TanStack Router** - File-based routing
+- **Zustand 5** - State management with persistence
+- **Tailwind CSS 4** - Utility-first styling with 25+ themes
+- **Radix UI** - Accessible component primitives
+- **dnd-kit** - Drag and drop for Kanban board
+- **@xyflow/react** - Graph visualization for dependencies
+- **xterm.js** - Integrated terminal emulator
+- **CodeMirror 6** - Code editor for XML/syntax highlighting
+- **Lucide Icons** - Icon library
+
+### Backend
+
+- **Node.js** - JavaScript runtime with ES modules
+- **Express 5** - HTTP server framework
+- **TypeScript 5.9** - Type safety
+- **Claude Agent SDK** - AI agent integration (@anthropic-ai/claude-agent-sdk)
+- **WebSocket (ws)** - Real-time event streaming
+- **node-pty** - PTY terminal sessions
+
+### Testing & Quality
+
+- **Playwright** - End-to-end testing
+- **Vitest** - Unit testing framework
+- **ESLint 9** - Code linting
+- **Prettier 3** - Code formatting
+- **Husky** - Git hooks for pre-commit formatting
+
+### Shared Libraries
+
+- **@automaker/types** - Shared TypeScript definitions
+- **@automaker/utils** - Logging, error handling, image processing
+- **@automaker/prompts** - AI prompt templates
+- **@automaker/platform** - Path management and security
+- **@automaker/model-resolver** - Claude model alias resolution
+- **@automaker/dependency-resolver** - Feature dependency ordering
+- **@automaker/git-utils** - Git operations and worktree management
+
+## Available Views
+
+Automaker provides several specialized views accessible via the sidebar or keyboard shortcuts:
+
+| View               | Shortcut | Description                                                                                      |
+| ------------------ | -------- | ------------------------------------------------------------------------------------------------ |
+| **Board**          | `K`      | Kanban board for managing feature workflow (Backlog → In Progress → Waiting Approval → Verified) |
+| **Agent**          | `A`      | Interactive chat sessions with AI agents for exploratory work and questions                      |
+| **Spec**           | `D`      | Project specification editor with AI-powered generation and feature suggestions                  |
+| **Context**        | `C`      | Manage context files (markdown, images) that AI agents automatically reference                   |
+| **Profiles**       | `M`      | Create and manage AI agent profiles with custom prompts and configurations                       |
+| **Settings**       | `S`      | Configure themes, shortcuts, defaults, authentication, and more                                  |
+| **Terminal**       | `T`      | Integrated terminal with tabs, splits, and persistent sessions                                   |
+| **GitHub Issues**  | -        | Import and validate GitHub issues, convert to tasks                                              |
+| **Running Agents** | -        | View all active agents across projects with status and progress                                  |
+
+### Keyboard Navigation
+
+All shortcuts are customizable in Settings. Default shortcuts:
+
+- **Navigation:** `K` (Board), `A` (Agent), `D` (Spec), `C` (Context), `S` (Settings), `M` (Profiles), `T` (Terminal)
+- **UI:** `` ` `` (Toggle sidebar)
+- **Actions:** `N` (New item in current view), `G` (Start next features), `O` (Open project), `P` (Project picker)
+- **Projects:** `Q`/`E` (Cycle previous/next project)
+
+## Architecture
+
+### Monorepo Structure
+
+Automaker is built as an npm workspace monorepo with two main applications and seven shared packages:
+
+```text
+automaker/
+├── apps/
+│   ├── ui/          # React + Vite + Electron frontend
+│   └── server/      # Express + WebSocket backend
+└── libs/            # Shared packages
+    ├── types/                  # Core TypeScript definitions
+    ├── utils/                  # Logging, errors, utilities
+    ├── prompts/                # AI prompt templates
+    ├── platform/               # Path management, security
+    ├── model-resolver/         # Claude model aliasing
+    ├── dependency-resolver/    # Feature dependency ordering
+    └── git-utils/              # Git operations & worktree management
+```
+
+### How It Works
+
+1. **Feature Definition** - Users create feature cards on the Kanban board with descriptions, images, and configuration
+2. **Git Worktree Creation** - When a feature starts, a git worktree is created for isolated development
+3. **Agent Execution** - Claude Agent SDK executes in the worktree with full file system and command access
+4. **Real-time Streaming** - Agent output streams via WebSocket to the frontend for live monitoring
+5. **Plan Approval** (optional) - For spec/full planning modes, agents generate plans that require user approval
+6. **Multi-Agent Tasks** (spec mode) - Each task in the spec gets a dedicated agent for focused implementation
+7. **Verification** - Features move to "Waiting Approval" where changes can be reviewed via git diff
+8. **Integration** - After approval, changes can be committed and PRs created from the worktree
+
+### Key Architectural Patterns
+
+- **Event-Driven Architecture** - All server operations emit events that stream to the frontend
+- **Provider Pattern** - Extensible AI provider system (currently Claude, designed for future providers)
+- **Service-Oriented Backend** - Modular services for agent management, features, terminals, settings
+- **State Management** - Zustand with persistence for frontend state across restarts
+- **File-Based Storage** - No database; features stored as JSON files in `.automaker/` directory
+
+### Security & Isolation
+
+- **Git Worktrees** - Each feature executes in an isolated git worktree, protecting your main branch
+- **Path Sandboxing** - Optional `ALLOWED_ROOT_DIRECTORY` restricts file access
+- **Docker Isolation** - Recommended deployment uses Docker with no host filesystem access
+- **Plan Approval** - Optional plan review before implementation prevents unwanted changes
+
+### Data Storage
+
+Automaker uses a file-based storage system (no database required):
+
+#### Per-Project Data
+
+Stored in `{projectPath}/.automaker/`:
+
+```text
+.automaker/
+├── features/              # Feature JSON files and images
+│   └── {featureId}/
+│       ├── feature.json   # Feature metadata
+│       ├── agent-output.md # AI agent output log
+│       └── images/        # Attached images
+├── context/               # Context files for AI agents
+├── settings.json          # Project-specific settings
+├── spec.md               # Project specification
+├── analysis.json         # Project structure analysis
+└── feature-suggestions.json # AI-generated suggestions
+```
+
+#### Global Data
+
+Stored in `DATA_DIR` (default `./data`):
+
+```text
+data/
+├── settings.json          # Global settings, profiles, shortcuts
+├── credentials.json       # API keys (encrypted)
+├── sessions-metadata.json # Chat session metadata
+└── agent-sessions/        # Conversation histories
+    └── {sessionId}.json
+```
+
+---
+
+> **[!CAUTION]**
+>
+> ## Security Disclaimer
+>
+> **This software uses AI-powered tooling that has access to your operating system and can read, modify, and delete files. Use at your own risk.**
+>
+> We have reviewed this codebase for security vulnerabilities, but you assume all risk when running this software. You should review the code yourself before running it.
+>
+> **We do not recommend running Automaker directly on your local computer** due to the risk of AI agents having access to your entire file system. Please sandbox this application using Docker or a virtual machine.
+>
+> **[Read the full disclaimer](./DISCLAIMER.md)**
+
+---
 
 ## Learn More
 
-To learn more about Next.js, take a look at the following resources:
+### Documentation
 
-- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
-- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
+- [Contributing Guide](./CONTRIBUTING.md) - How to contribute to Automaker
+- [Project Documentation](./docs/) - Architecture guides, patterns, and developer docs
+- [Docker Isolation Guide](./docs/docker-isolation.md) - Security-focused Docker deployment
+- [Shared Packages Guide](./docs/llm-shared-packages.md) - Using monorepo packages
+
+### Community
+
+Join the **Agentic Jumpstart** Discord to connect with other builders exploring **agentic coding**:
+
+👉 [Agentic Jumpstart Discord](https://discord.gg/jjem7aEDKU)
 
 ## License
 
@@ -252,19 +646,16 @@ This project is licensed under the **Automaker License Agreement**. See [LICENSE
 **Summary of Terms:**
 
 - **Allowed:**
-
   - **Build Anything:** You can clone and use Automaker locally or in your organization to build ANY product (commercial or free).
   - **Internal Use:** You can use it internally within your company (commercial or non-profit) without restriction.
   - **Modify:** You can modify the code for internal use within your organization (commercial or non-profit).
 
 - **Restricted (The "No Monetization of the Tool" Rule):**
-
   - **No Resale:** You cannot resell Automaker itself.
   - **No SaaS:** You cannot host Automaker as a service for others.
   - **No Monetizing Mods:** You cannot distribute modified versions of Automaker for money.
 
 - **Liability:**
-
   - **Use at Own Risk:** This tool uses AI. We are **NOT** responsible if it breaks your computer, deletes your files, or generates bad code. You assume all risk.
 
 - **Contributing:**

apps/app/electron/.eslintrc.js

@@ -1,5 +0,0 @@
-module.exports = {
-  rules: {
-    "@typescript-eslint/no-require-imports": "off",
-  },
-};

apps/app/electron/main.js

@@ -1,435 +0,0 @@
-/**
- * Simplified Electron main process
- *
- * This version spawns the backend server and uses HTTP API for most operations.
- * Only native features (dialogs, shell) use IPC.
- */
-
-const path = require("path");
-const { spawn } = require("child_process");
-const fs = require("fs");
-const http = require("http");
-const { app, BrowserWindow, ipcMain, dialog, shell } = require("electron");
-
-// Load environment variables from .env file (development only)
-if (!app.isPackaged) {
-  try {
-    require("dotenv").config({ path: path.join(__dirname, "../.env") });
-  } catch (error) {
-    console.warn("[Electron] dotenv not available:", error.message);
-  }
-}
-
-let mainWindow = null;
-let serverProcess = null;
-let staticServer = null;
-const SERVER_PORT = 3008;
-const STATIC_PORT = 3007;
-
-// Get icon path - works in both dev and production, cross-platform
-function getIconPath() {
-  // Different icon formats for different platforms
-  let iconFile;
-  if (process.platform === "win32") {
-    iconFile = "icon.ico";
-  } else if (process.platform === "darwin") {
-    iconFile = "logo_larger.png";
-  } else {
-    // Linux
-    iconFile = "logo_larger.png";
-  }
-
-  const iconPath = path.join(__dirname, "../public", iconFile);
-
-  // Verify the icon exists
-  if (!fs.existsSync(iconPath)) {
-    console.warn(`[Electron] Icon not found at: ${iconPath}`);
-    return null;
-  }
-
-  return iconPath;
-}
-
-/**
- * Start static file server for production builds
- */
-async function startStaticServer() {
-  const staticPath = path.join(__dirname, "../out");
-
-  staticServer = http.createServer((request, response) => {
-    // Parse the URL and remove query string
-    let filePath = path.join(staticPath, request.url.split("?")[0]);
-
-    // Default to index.html for directory requests
-    if (filePath.endsWith("/")) {
-      filePath = path.join(filePath, "index.html");
-    } else if (!path.extname(filePath)) {
-      filePath += ".html";
-    }
-
-    // Check if file exists
-    fs.stat(filePath, (err, stats) => {
-      if (err || !stats.isFile()) {
-        // Try index.html for SPA fallback
-        filePath = path.join(staticPath, "index.html");
-      }
-
-      // Read and serve the file
-      fs.readFile(filePath, (error, content) => {
-        if (error) {
-          response.writeHead(500);
-          response.end("Server Error");
-          return;
-        }
-
-        // Set content type based on file extension
-        const ext = path.extname(filePath);
-        const contentTypes = {
-          ".html": "text/html",
-          ".js": "application/javascript",
-          ".css": "text/css",
-          ".json": "application/json",
-          ".png": "image/png",
-          ".jpg": "image/jpeg",
-          ".gif": "image/gif",
-          ".svg": "image/svg+xml",
-          ".ico": "image/x-icon",
-          ".woff": "font/woff",
-          ".woff2": "font/woff2",
-          ".ttf": "font/ttf",
-          ".eot": "application/vnd.ms-fontobject",
-        };
-
-        response.writeHead(200, { "Content-Type": contentTypes[ext] || "application/octet-stream" });
-        response.end(content);
-      });
-    });
-  });
-
-  return new Promise((resolve, reject) => {
-    staticServer.listen(STATIC_PORT, (err) => {
-      if (err) {
-        reject(err);
-      } else {
-        console.log(`[Electron] Static server running at http://localhost:${STATIC_PORT}`);
-        resolve();
-      }
-    });
-  });
-}
-
-/**
- * Start the backend server
- */
-async function startServer() {
-  const isDev = !app.isPackaged;
-
-  // Server entry point - use tsx in dev, compiled version in production
-  let command, args, serverPath;
-  if (isDev) {
-    // In development, use tsx to run TypeScript directly
-    // Use node from PATH (process.execPath in Electron points to Electron, not Node.js)
-    // spawn() resolves "node" from PATH on all platforms (Windows, Linux, macOS)
-    command = "node";
-    serverPath = path.join(__dirname, "../../server/src/index.ts");
-
-    // Find tsx CLI - check server node_modules first, then root
-    const serverNodeModules = path.join(
-      __dirname,
-      "../../server/node_modules/tsx"
-    );
-    const rootNodeModules = path.join(__dirname, "../../../node_modules/tsx");
-
-    let tsxCliPath;
-    if (fs.existsSync(path.join(serverNodeModules, "dist/cli.mjs"))) {
-      tsxCliPath = path.join(serverNodeModules, "dist/cli.mjs");
-    } else if (fs.existsSync(path.join(rootNodeModules, "dist/cli.mjs"))) {
-      tsxCliPath = path.join(rootNodeModules, "dist/cli.mjs");
-    } else {
-      // Last resort: try require.resolve
-      try {
-        tsxCliPath = require.resolve("tsx/cli.mjs", {
-          paths: [path.join(__dirname, "../../server")],
-        });
-      } catch {
-        throw new Error(
-          "Could not find tsx. Please run 'npm install' in the server directory."
-        );
-      }
-    }
-
-    args = [tsxCliPath, "watch", serverPath];
-  } else {
-    // In production, use compiled JavaScript
-    command = "node";
-    serverPath = path.join(process.resourcesPath, "server", "index.js");
-    args = [serverPath];
-
-    // Verify server files exist
-    if (!fs.existsSync(serverPath)) {
-      throw new Error(`Server not found at: ${serverPath}`);
-    }
-  }
-
-  // Set environment variables for server
-  const serverNodeModules = app.isPackaged
-    ? path.join(process.resourcesPath, "server", "node_modules")
-    : path.join(__dirname, "../../server/node_modules");
-
-  // Set default workspace directory to user's Documents/Automaker
-  const defaultWorkspaceDir = path.join(app.getPath("documents"), "Automaker");
-
-  // Ensure workspace directory exists
-  if (!fs.existsSync(defaultWorkspaceDir)) {
-    try {
-      fs.mkdirSync(defaultWorkspaceDir, { recursive: true });
-      console.log("[Electron] Created workspace directory:", defaultWorkspaceDir);
-    } catch (error) {
-      console.error("[Electron] Failed to create workspace directory:", error);
-    }
-  }
-
-  const env = {
-    ...process.env,
-    PORT: SERVER_PORT.toString(),
-    DATA_DIR: app.getPath("userData"),
-    NODE_PATH: serverNodeModules,
-    WORKSPACE_DIR: process.env.WORKSPACE_DIR || defaultWorkspaceDir,
-  };
-
-  console.log("[Electron] Starting backend server...");
-  console.log("[Electron] Server path:", serverPath);
-  console.log("[Electron] NODE_PATH:", serverNodeModules);
-
-  serverProcess = spawn(command, args, {
-    cwd: path.dirname(serverPath),
-    env,
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-
-  serverProcess.stdout.on("data", (data) => {
-    console.log(`[Server] ${data.toString().trim()}`);
-  });
-
-  serverProcess.stderr.on("data", (data) => {
-    console.error(`[Server Error] ${data.toString().trim()}`);
-  });
-
-  serverProcess.on("close", (code) => {
-    console.log(`[Server] Process exited with code ${code}`);
-    serverProcess = null;
-  });
-
-  serverProcess.on("error", (err) => {
-    console.error(`[Server] Failed to start server process:`, err);
-    serverProcess = null;
-  });
-
-  // Wait for server to be ready
-  await waitForServer();
-}
-
-/**
- * Wait for server to be available
- */
-async function waitForServer(maxAttempts = 30) {
-  const http = require("http");
-
-  for (let i = 0; i < maxAttempts; i++) {
-    try {
-      await new Promise((resolve, reject) => {
-        const req = http.get(
-          `http://localhost:${SERVER_PORT}/api/health`,
-          (res) => {
-            if (res.statusCode === 200) {
-              resolve();
-            } else {
-              reject(new Error(`Status: ${res.statusCode}`));
-            }
-          }
-        );
-        req.on("error", reject);
-        req.setTimeout(1000, () => {
-          req.destroy();
-          reject(new Error("Timeout"));
-        });
-      });
-      console.log("[Electron] Server is ready");
-      return;
-    } catch {
-      await new Promise((r) => setTimeout(r, 500));
-    }
-  }
-
-  throw new Error("Server failed to start");
-}
-
-/**
- * Create the main window
- */
-function createWindow() {
-  const iconPath = getIconPath();
-  const windowOptions = {
-    width: 1400,
-    height: 900,
-    minWidth: 1024,
-    minHeight: 700,
-    webPreferences: {
-      preload: path.join(__dirname, "preload.js"),
-      contextIsolation: true,
-      nodeIntegration: false,
-    },
-    titleBarStyle: "hiddenInset",
-    backgroundColor: "#0a0a0a",
-  };
-
-  // Only set icon if it exists
-  if (iconPath) {
-    windowOptions.icon = iconPath;
-  }
-
-  mainWindow = new BrowserWindow(windowOptions);
-
-  // Load Next.js dev server in development or static server in production
-  const isDev = !app.isPackaged;
-  mainWindow.loadURL(`http://localhost:${STATIC_PORT}`);
-  if (isDev && process.env.OPEN_DEVTOOLS === "true") {
-    mainWindow.webContents.openDevTools();
-  }
-
-  mainWindow.on("closed", () => {
-    mainWindow = null;
-  });
-
-  // Handle external links - open in default browser
-  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
-    shell.openExternal(url);
-    return { action: "deny" };
-  });
-}
-
-// App lifecycle
-app.whenReady().then(async () => {
-  // Set app icon (dock icon on macOS)
-  if (process.platform === "darwin" && app.dock) {
-    const iconPath = getIconPath();
-    if (iconPath) {
-      try {
-        app.dock.setIcon(iconPath);
-      } catch (error) {
-        console.warn("[Electron] Failed to set dock icon:", error.message);
-      }
-    }
-  }
-
-  try {
-    // Start static file server in production
-    if (app.isPackaged) {
-      await startStaticServer();
-    }
-
-    // Start backend server
-    await startServer();
-
-    // Create window
-    createWindow();
-  } catch (error) {
-    console.error("[Electron] Failed to start:", error);
-    app.quit();
-  }
-
-  app.on("activate", () => {
-    if (BrowserWindow.getAllWindows().length === 0) {
-      createWindow();
-    }
-  });
-});
-
-app.on("window-all-closed", () => {
-  if (process.platform !== "darwin") {
-    app.quit();
-  }
-});
-
-app.on("before-quit", () => {
-  // Kill server process
-  if (serverProcess) {
-    console.log("[Electron] Stopping server...");
-    serverProcess.kill();
-    serverProcess = null;
-  }
-
-  // Close static server
-  if (staticServer) {
-    console.log("[Electron] Stopping static server...");
-    staticServer.close();
-    staticServer = null;
-  }
-});
-
-// ============================================
-// IPC Handlers - Only native features
-// ============================================
-
-// Native file dialogs
-ipcMain.handle("dialog:openDirectory", async () => {
-  const result = await dialog.showOpenDialog(mainWindow, {
-    properties: ["openDirectory", "createDirectory"],
-  });
-  return result;
-});
-
-ipcMain.handle("dialog:openFile", async (_, options = {}) => {
-  const result = await dialog.showOpenDialog(mainWindow, {
-    properties: ["openFile"],
-    ...options,
-  });
-  return result;
-});
-
-ipcMain.handle("dialog:saveFile", async (_, options = {}) => {
-  const result = await dialog.showSaveDialog(mainWindow, options);
-  return result;
-});
-
-// Shell operations
-ipcMain.handle("shell:openExternal", async (_, url) => {
-  try {
-    await shell.openExternal(url);
-    return { success: true };
-  } catch (error) {
-    return { success: false, error: error.message };
-  }
-});
-
-ipcMain.handle("shell:openPath", async (_, filePath) => {
-  try {
-    await shell.openPath(filePath);
-    return { success: true };
-  } catch (error) {
-    return { success: false, error: error.message };
-  }
-});
-
-// App info
-ipcMain.handle("app:getPath", async (_, name) => {
-  return app.getPath(name);
-});
-
-ipcMain.handle("app:getVersion", async () => {
-  return app.getVersion();
-});
-
-ipcMain.handle("app:isPackaged", async () => {
-  return app.isPackaged;
-});
-
-// Ping - for connection check
-ipcMain.handle("ping", async () => {
-  return "pong";
-});
-
-// Get server URL for HTTP client
-ipcMain.handle("server:getUrl", async () => {
-  return `http://localhost:${SERVER_PORT}`;
-});

apps/app/electron/preload.js

@@ -1,37 +0,0 @@
-/**
- * Simplified Electron preload script
- *
- * Only exposes native features (dialogs, shell) and server URL.
- * All other operations go through HTTP API.
- */
-
-const { contextBridge, ipcRenderer } = require("electron");
-
-// Expose minimal API for native features
-contextBridge.exposeInMainWorld("electronAPI", {
-  // Platform info
-  platform: process.platform,
-  isElectron: true,
-
-  // Connection check
-  ping: () => ipcRenderer.invoke("ping"),
-
-  // Get server URL for HTTP client
-  getServerUrl: () => ipcRenderer.invoke("server:getUrl"),
-
-  // Native dialogs - better UX than prompt()
-  openDirectory: () => ipcRenderer.invoke("dialog:openDirectory"),
-  openFile: (options) => ipcRenderer.invoke("dialog:openFile", options),
-  saveFile: (options) => ipcRenderer.invoke("dialog:saveFile", options),
-
-  // Shell operations
-  openExternalLink: (url) => ipcRenderer.invoke("shell:openExternal", url),
-  openPath: (filePath) => ipcRenderer.invoke("shell:openPath", filePath),
-
-  // App info
-  getPath: (name) => ipcRenderer.invoke("app:getPath", name),
-  getVersion: () => ipcRenderer.invoke("app:getVersion"),
-  isPackaged: () => ipcRenderer.invoke("app:isPackaged"),
-});
-
-console.log("[Preload] Electron API exposed (simplified mode)");

apps/app/eslint.config.mjs

@@ -1,20 +0,0 @@
-import { defineConfig, globalIgnores } from "eslint/config";
-import nextVitals from "eslint-config-next/core-web-vitals";
-import nextTs from "eslint-config-next/typescript";
-
-const eslintConfig = defineConfig([
-  ...nextVitals,
-  ...nextTs,
-  // Override default ignores of eslint-config-next.
-  globalIgnores([
-    // Default ignores of eslint-config-next:
-    ".next/**",
-    "out/**",
-    "build/**",
-    "next-env.d.ts",
-    // Electron files use CommonJS
-    "electron/**",
-  ]),
-]);
-
-export default eslintConfig;

apps/app/next.config.ts

@@ -1,7 +0,0 @@
-import type { NextConfig } from "next";
-
-const nextConfig: NextConfig = {
-  output: "export",
-};
-
-export default nextConfig;

apps/app/package.json

@@ -1,193 +0,0 @@
-{
-  "name": "@automaker/app",
-  "version": "0.1.0",
-  "description": "An autonomous AI development studio that helps you build software faster using AI-powered agents",
-  "homepage": "https://github.com/AutoMaker-Org/automaker",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/AutoMaker-Org/automaker.git"
-  },
-  "author": {
-    "name": "Cody Seibert",
-    "email": "webdevcody@gmail.com"
-  },
-  "private": true,
-  "license": "Unlicense",
-  "main": "electron/main.js",
-  "scripts": {
-    "dev": "next dev -p 3007",
-    "dev:web": "next dev -p 3007",
-    "dev:electron": "concurrently \"next dev -p 3007\" \"wait-on http://localhost:3007 && electron .\"",
-    "dev:electron:debug": "concurrently \"next dev -p 3007\" \"wait-on http://localhost:3007 && OPEN_DEVTOOLS=true electron .\"",
-    "build": "next build",
-    "build:electron": "node scripts/prepare-server.js && next build && electron-builder",
-    "build:electron:win": "node scripts/prepare-server.js && next build && electron-builder --win",
-    "build:electron:mac": "node scripts/prepare-server.js && next build && electron-builder --mac",
-    "build:electron:linux": "node scripts/prepare-server.js && next build && electron-builder --linux",
-    "postinstall": "electron-builder install-app-deps",
-    "start": "next start",
-    "lint": "eslint",
-    "pretest": "node scripts/setup-e2e-fixtures.js",
-    "test": "playwright test",
-    "test:headed": "playwright test --headed",
-    "dev:electron:wsl": "concurrently \"next dev -p 3007\" \"wait-on http://localhost:3007 && electron . --no-sandbox --disable-gpu\"",
-    "dev:electron:wsl:gpu": "concurrently \"next dev -p 3007\" \"wait-on http://localhost:3007 && MESA_D3D12_DEFAULT_ADAPTER_NAME=NVIDIA electron . --no-sandbox --disable-gpu-sandbox\""
-  },
-  "dependencies": {
-    "@codemirror/lang-xml": "^6.1.0",
-    "@codemirror/theme-one-dark": "^6.1.3",
-    "@dnd-kit/core": "^6.3.1",
-    "@dnd-kit/sortable": "^10.0.0",
-    "@dnd-kit/utilities": "^3.2.2",
-    "@lezer/highlight": "^1.2.3",
-    "@radix-ui/react-checkbox": "^1.3.3",
-    "@radix-ui/react-dialog": "^1.1.15",
-    "@radix-ui/react-dropdown-menu": "^2.1.16",
-    "@radix-ui/react-label": "^2.1.8",
-    "@radix-ui/react-popover": "^1.1.15",
-    "@radix-ui/react-slider": "^1.3.6",
-    "@radix-ui/react-slot": "^1.2.4",
-    "@radix-ui/react-tabs": "^1.1.13",
-    "@radix-ui/react-tooltip": "^1.2.8",
-    "@tanstack/react-query": "^5.90.12",
-    "@uiw/react-codemirror": "^4.25.4",
-    "@xterm/addon-fit": "^0.10.0",
-    "@xterm/addon-webgl": "^0.18.0",
-    "@xterm/xterm": "^5.5.0",
-    "class-variance-authority": "^0.7.1",
-    "clsx": "^2.1.1",
-    "cmdk": "^1.1.1",
-    "dotenv": "^17.2.3",
-    "geist": "^1.5.1",
-    "lucide-react": "^0.556.0",
-    "next": "^16.0.10",
-    "react": "19.2.0",
-    "react-dom": "19.2.0",
-    "react-markdown": "^10.1.0",
-    "react-resizable-panels": "^3.0.6",
-    "sonner": "^2.0.7",
-    "tailwind-merge": "^3.4.0",
-    "zustand": "^5.0.9"
-  },
-  "optionalDependencies": {
-    "lightningcss-darwin-arm64": "^1.29.2",
-    "lightningcss-darwin-x64": "^1.29.2",
-    "lightningcss-linux-arm-gnueabihf": "^1.29.2",
-    "lightningcss-linux-arm64-gnu": "^1.29.2",
-    "lightningcss-linux-arm64-musl": "^1.29.2",
-    "lightningcss-linux-x64-gnu": "^1.29.2",
-    "lightningcss-linux-x64-musl": "^1.29.2",
-    "lightningcss-win32-arm64-msvc": "^1.29.2",
-    "lightningcss-win32-x64-msvc": "^1.29.2"
-  },
-  "devDependencies": {
-    "@electron/rebuild": "^4.0.2",
-    "@playwright/test": "^1.57.0",
-    "@tailwindcss/postcss": "^4",
-    "@types/node": "^20",
-    "@types/react": "^19",
-    "@types/react-dom": "^19",
-    "concurrently": "^9.2.1",
-    "electron": "39.2.7",
-    "electron-builder": "^26.0.12",
-    "eslint": "^9",
-    "eslint-config-next": "16.0.7",
-    "tailwindcss": "^4",
-    "tw-animate-css": "^1.4.0",
-    "typescript": "5.9.3",
-    "wait-on": "^9.0.3"
-  },
-  "build": {
-    "appId": "com.automaker.app",
-    "productName": "Automaker",
-    "artifactName": "${productName}-${version}-${arch}.${ext}",
-    "afterPack": "./scripts/rebuild-server-natives.js",
-    "directories": {
-      "output": "dist"
-    },
-    "files": [
-      "electron/**/*",
-      "out/**/*",
-      "public/**/*",
-      "!node_modules/**/*"
-    ],
-    "extraResources": [
-      {
-        "from": "server-bundle/dist",
-        "to": "server"
-      },
-      {
-        "from": "server-bundle/node_modules",
-        "to": "server/node_modules"
-      },
-      {
-        "from": "server-bundle/package.json",
-        "to": "server/package.json"
-      },
-      {
-        "from": "../../.env",
-        "to": ".env",
-        "filter": [
-          "**/*"
-        ]
-      }
-    ],
-    "mac": {
-      "category": "public.app-category.developer-tools",
-      "target": [
-        {
-          "target": "dmg",
-          "arch": [
-            "x64",
-            "arm64"
-          ]
-        },
-        {
-          "target": "zip",
-          "arch": [
-            "x64",
-            "arm64"
-          ]
-        }
-      ],
-      "icon": "public/logo_larger.png"
-    },
-    "win": {
-      "target": [
-        {
-          "target": "nsis",
-          "arch": [
-            "x64"
-          ]
-        }
-      ],
-      "icon": "public/icon.ico"
-    },
-    "linux": {
-      "target": [
-        {
-          "target": "AppImage",
-          "arch": [
-            "x64"
-          ]
-        },
-        {
-          "target": "deb",
-          "arch": [
-            "x64"
-          ]
-        }
-      ],
-      "category": "Development",
-      "icon": "public/logo_larger.png",
-      "maintainer": "webdevcody@gmail.com",
-      "executableName": "automaker"
-    },
-    "nsis": {
-      "oneClick": false,
-      "allowToChangeInstallationDirectory": true,
-      "createDesktopShortcut": true,
-      "createStartMenuShortcut": true
-    }
-  }
-}

apps/app/playwright.config.ts

@@ -1,39 +0,0 @@
-import { defineConfig, devices } from "@playwright/test";
-
-const port = process.env.TEST_PORT || 3007;
-const reuseServer = process.env.TEST_REUSE_SERVER === "true";
-
-export default defineConfig({
-  testDir: "./tests",
-  fullyParallel: true,
-  forbidOnly: !!process.env.CI,
-  retries: process.env.CI ? 2 : 0,
-  workers: process.env.CI ? 1 : undefined,
-  reporter: "html",
-  timeout: 30000,
-  use: {
-    baseURL: `http://localhost:${port}`,
-    trace: "on-first-retry",
-    screenshot: "only-on-failure",
-  },
-  projects: [
-    {
-      name: "chromium",
-      use: { ...devices["Desktop Chrome"] },
-    },
-  ],
-  ...(reuseServer
-    ? {}
-    : {
-        webServer: {
-          command: `npx next dev -p ${port}`,
-          url: `http://localhost:${port}`,
-          reuseExistingServer: !process.env.CI,
-          timeout: 120000,
-          env: {
-            ...process.env,
-            NEXT_PUBLIC_SKIP_SETUP: "true",
-          },
-        },
-      }),
-});

apps/app/playwright.config.ts.bak

@@ -1,30 +0,0 @@
-import { defineConfig, devices } from "@playwright/test";
-
-const port = process.env.TEST_PORT || 3007;
-
-export default defineConfig({
-  testDir: "./tests",
-  fullyParallel: true,
-  forbidOnly: !!process.env.CI,
-  retries: process.env.CI ? 2 : 0,
-  workers: process.env.CI ? 1 : undefined,
-  reporter: "html",
-  timeout: 10000,
-  use: {
-    baseURL: `http://localhost:${port}`,
-    trace: "on-first-retry",
-    screenshot: "only-on-failure",
-  },
-  projects: [
-    {
-      name: "chromium",
-      use: { ...devices["Desktop Chrome"] },
-    },
-  ],
-  webServer: {
-    command: `npx next dev -p ${port}`,
-    url: `http://localhost:${port}`,
-    reuseExistingServer: true,
-    timeout: 60000,
-  },
-});

apps/app/postcss.config.mjs

@@ -1,7 +0,0 @@
-const config = {
-  plugins: {
-    "@tailwindcss/postcss": {},
-  },
-};
-
-export default config;

apps/app/src/app/api/claude/test/route.ts

@@ -1,97 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-
-interface AnthropicResponse {
-  content?: Array<{ type: string; text?: string }>;
-  model?: string;
-  error?: { message?: string };
-}
-
-export async function POST(request: NextRequest) {
-  try {
-    const { apiKey } = await request.json();
-
-    // Use provided API key or fall back to environment variable
-    const effectiveApiKey = apiKey || process.env.ANTHROPIC_API_KEY;
-
-    if (!effectiveApiKey) {
-      return NextResponse.json(
-        { success: false, error: "No API key provided or configured in environment" },
-        { status: 400 }
-      );
-    }
-
-    // Send a simple test prompt to the Anthropic API
-    const response = await fetch("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": effectiveApiKey,
-        "anthropic-version": "2023-06-01",
-      },
-      body: JSON.stringify({
-        model: "claude-sonnet-4-20250514",
-        max_tokens: 100,
-        messages: [
-          {
-            role: "user",
-            content: "Respond with exactly: 'Claude API connection successful!' and nothing else.",
-          },
-        ],
-      }),
-    });
-
-    if (!response.ok) {
-      const errorData = (await response.json()) as AnthropicResponse;
-      const errorMessage = errorData.error?.message || `HTTP ${response.status}`;
-
-      if (response.status === 401) {
-        return NextResponse.json(
-          { success: false, error: "Invalid API key. Please check your Anthropic API key." },
-          { status: 401 }
-        );
-      }
-
-      if (response.status === 429) {
-        return NextResponse.json(
-          { success: false, error: "Rate limit exceeded. Please try again later." },
-          { status: 429 }
-        );
-      }
-
-      return NextResponse.json(
-        { success: false, error: `API error: ${errorMessage}` },
-        { status: response.status }
-      );
-    }
-
-    const data = (await response.json()) as AnthropicResponse;
-
-    // Check if we got a valid response
-    if (data.content && data.content.length > 0) {
-      const textContent = data.content.find((block) => block.type === "text");
-      if (textContent && textContent.type === "text" && textContent.text) {
-        return NextResponse.json({
-          success: true,
-          message: `Connection successful! Response: "${textContent.text}"`,
-          model: data.model,
-        });
-      }
-    }
-
-    return NextResponse.json({
-      success: true,
-      message: "Connection successful! Claude responded.",
-      model: data.model,
-    });
-  } catch (error: unknown) {
-    console.error("Claude API test error:", error);
-
-    const errorMessage =
-      error instanceof Error ? error.message : "Failed to connect to Claude API";
-
-    return NextResponse.json(
-      { success: false, error: errorMessage },
-      { status: 500 }
-    );
-  }
-}

apps/app/src/app/api/gemini/test/route.ts

@@ -1,191 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-
-interface GeminiContent {
-  parts: Array<{
-    text?: string;
-    inlineData?: {
-      mimeType: string;
-      data: string;
-    };
-  }>;
-  role?: string;
-}
-
-interface GeminiRequest {
-  contents: GeminiContent[];
-  generationConfig?: {
-    maxOutputTokens?: number;
-    temperature?: number;
-  };
-}
-
-interface GeminiResponse {
-  candidates?: Array<{
-    content: {
-      parts: Array<{
-        text: string;
-      }>;
-      role: string;
-    };
-    finishReason: string;
-    safetyRatings?: Array<{
-      category: string;
-      probability: string;
-    }>;
-  }>;
-  promptFeedback?: {
-    safetyRatings?: Array<{
-      category: string;
-      probability: string;
-    }>;
-  };
-  error?: {
-    code: number;
-    message: string;
-    status: string;
-  };
-}
-
-export async function POST(request: NextRequest) {
-  try {
-    const { apiKey, imageData, mimeType, prompt } = await request.json();
-
-    // Use provided API key or fall back to environment variable
-    const effectiveApiKey = apiKey || process.env.GOOGLE_API_KEY;
-
-    if (!effectiveApiKey) {
-      return NextResponse.json(
-        { success: false, error: "No API key provided or configured in environment" },
-        { status: 400 }
-      );
-    }
-
-    // Build the request body
-    const requestBody: GeminiRequest = {
-      contents: [
-        {
-          parts: [],
-        },
-      ],
-      generationConfig: {
-        maxOutputTokens: 150,
-        temperature: 0.4,
-      },
-    };
-
-    // Add image if provided
-    if (imageData && mimeType) {
-      requestBody.contents[0].parts.push({
-        inlineData: {
-          mimeType: mimeType,
-          data: imageData,
-        },
-      });
-    }
-
-    // Add text prompt
-    const textPrompt = prompt || (imageData
-      ? "Describe what you see in this image briefly."
-      : "Respond with exactly: 'Gemini SDK connection successful!' and nothing else.");
-
-    requestBody.contents[0].parts.push({
-      text: textPrompt,
-    });
-
-    // Call Gemini API - using gemini-1.5-flash as it supports both text and vision
-    const model = imageData ? "gemini-1.5-flash" : "gemini-1.5-flash";
-    const geminiUrl = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${effectiveApiKey}`;
-
-    const response = await fetch(geminiUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(requestBody),
-    });
-
-    const data: GeminiResponse = await response.json();
-
-    // Check for API errors
-    if (data.error) {
-      const errorMessage = data.error.message || "Unknown Gemini API error";
-      const statusCode = data.error.code || 500;
-
-      if (statusCode === 400 && errorMessage.includes("API key")) {
-        return NextResponse.json(
-          { success: false, error: "Invalid API key. Please check your Google API key." },
-          { status: 401 }
-        );
-      }
-
-      if (statusCode === 429) {
-        return NextResponse.json(
-          { success: false, error: "Rate limit exceeded. Please try again later." },
-          { status: 429 }
-        );
-      }
-
-      return NextResponse.json(
-        { success: false, error: `API error: ${errorMessage}` },
-        { status: statusCode }
-      );
-    }
-
-    // Check for valid response
-    if (!response.ok) {
-      return NextResponse.json(
-        { success: false, error: `HTTP error: ${response.status} ${response.statusText}` },
-        { status: response.status }
-      );
-    }
-
-    // Extract response text
-    if (data.candidates && data.candidates.length > 0 && data.candidates[0].content?.parts?.length > 0) {
-      const responseText = data.candidates[0].content.parts
-        .filter((part) => part.text)
-        .map((part) => part.text)
-        .join("");
-
-      return NextResponse.json({
-        success: true,
-        message: `Connection successful! Response: "${responseText.substring(0, 200)}${responseText.length > 200 ? '...' : ''}"`,
-        model: model,
-        hasImage: !!imageData,
-      });
-    }
-
-    // Handle blocked responses
-    if (data.promptFeedback?.safetyRatings) {
-      return NextResponse.json({
-        success: true,
-        message: "Connection successful! Gemini responded (response may have been filtered).",
-        model: model,
-        hasImage: !!imageData,
-      });
-    }
-
-    return NextResponse.json({
-      success: true,
-      message: "Connection successful! Gemini responded.",
-      model: model,
-      hasImage: !!imageData,
-    });
-  } catch (error: unknown) {
-    console.error("Gemini API test error:", error);
-
-    if (error instanceof TypeError && error.message.includes("fetch")) {
-      return NextResponse.json(
-        { success: false, error: "Network error. Unable to reach Gemini API." },
-        { status: 503 }
-      );
-    }
-
-    const errorMessage =
-      error instanceof Error ? error.message : "Failed to connect to Gemini API";
-
-    return NextResponse.json(
-      { success: false, error: errorMessage },
-      { status: 500 }
-    );
-  }
-}

apps/app/src/app/layout.tsx

@@ -1,26 +0,0 @@
-import type { Metadata } from "next";
-import { GeistSans } from "geist/font/sans";
-import { GeistMono } from "geist/font/mono";
-import { Toaster } from "sonner";
-import "./globals.css";
-export const metadata: Metadata = {
-  title: "Automaker - Autonomous AI Development Studio",
-  description: "Build software autonomously with intelligent orchestration",
-};
-
-export default function RootLayout({
-  children,
-}: Readonly<{
-  children: React.ReactNode;
-}>) {
-  return (
-    <html lang="en" suppressHydrationWarning>
-      <body
-        className={`${GeistSans.variable} ${GeistMono.variable} antialiased`}
-      >
-        {children}
-        <Toaster richColors position="bottom-right" />
-      </body>
-    </html>
-  );
-}

apps/app/src/app/page.tsx

@@ -1,255 +0,0 @@
-"use client";
-
-import { useEffect, useState, useCallback } from "react";
-import { Sidebar } from "@/components/layout/sidebar";
-import { WelcomeView } from "@/components/views/welcome-view";
-import { BoardView } from "@/components/views/board-view";
-import { SpecView } from "@/components/views/spec-view";
-import { AgentView } from "@/components/views/agent-view";
-import { SettingsView } from "@/components/views/settings-view";
-import { InterviewView } from "@/components/views/interview-view";
-import { ContextView } from "@/components/views/context-view";
-import { ProfilesView } from "@/components/views/profiles-view";
-import { SetupView } from "@/components/views/setup-view";
-import { RunningAgentsView } from "@/components/views/running-agents-view";
-import { TerminalView } from "@/components/views/terminal-view";
-import { WikiView } from "@/components/views/wiki-view";
-import { useAppStore } from "@/store/app-store";
-import { useSetupStore } from "@/store/setup-store";
-import { getElectronAPI, isElectron } from "@/lib/electron";
-import {
-  FileBrowserProvider,
-  useFileBrowser,
-  setGlobalFileBrowser,
-} from "@/contexts/file-browser-context";
-
-function HomeContent() {
-  const {
-    currentView,
-    setCurrentView,
-    setIpcConnected,
-    theme,
-    currentProject,
-    previewTheme,
-    getEffectiveTheme,
-  } = useAppStore();
-  const { isFirstRun, setupComplete } = useSetupStore();
-  const [isMounted, setIsMounted] = useState(false);
-  const [streamerPanelOpen, setStreamerPanelOpen] = useState(false);
-  const { openFileBrowser } = useFileBrowser();
-
-  // Hidden streamer panel - opens with "\" key
-  const handleStreamerPanelShortcut = useCallback((event: KeyboardEvent) => {
-    // Don't trigger when typing in inputs
-    const activeElement = document.activeElement;
-    if (activeElement) {
-      const tagName = activeElement.tagName.toLowerCase();
-      if (
-        tagName === "input" ||
-        tagName === "textarea" ||
-        tagName === "select"
-      ) {
-        return;
-      }
-      if (activeElement.getAttribute("contenteditable") === "true") {
-        return;
-      }
-      const role = activeElement.getAttribute("role");
-      if (role === "textbox" || role === "searchbox" || role === "combobox") {
-        return;
-      }
-    }
-
-    // Don't trigger with modifier keys
-    if (event.ctrlKey || event.altKey || event.metaKey) {
-      return;
-    }
-
-    // Check for "\" key (backslash)
-    if (event.key === "\\") {
-      event.preventDefault();
-      setStreamerPanelOpen((prev) => !prev);
-    }
-  }, []);
-
-  // Register the "\" shortcut for streamer panel
-  useEffect(() => {
-    window.addEventListener("keydown", handleStreamerPanelShortcut);
-    return () => {
-      window.removeEventListener("keydown", handleStreamerPanelShortcut);
-    };
-  }, [handleStreamerPanelShortcut]);
-
-  // Compute the effective theme: previewTheme takes priority, then project theme, then global theme
-  // This is reactive because it depends on previewTheme, currentProject, and theme from the store
-  const effectiveTheme = getEffectiveTheme();
-
-  // Prevent hydration issues
-  useEffect(() => {
-    setIsMounted(true);
-  }, []);
-
-  // Initialize global file browser for HttpApiClient
-  useEffect(() => {
-    setGlobalFileBrowser(openFileBrowser);
-  }, [openFileBrowser]);
-
-  // Check if this is first run and redirect to setup if needed
-  useEffect(() => {
-    console.log("[Setup Flow] Checking setup state:", {
-      isMounted,
-      isFirstRun,
-      setupComplete,
-      currentView,
-      shouldShowSetup: isMounted && isFirstRun && !setupComplete,
-    });
-
-    if (isMounted && isFirstRun && !setupComplete) {
-      console.log(
-        "[Setup Flow] Redirecting to setup wizard (first run, not complete)"
-      );
-      setCurrentView("setup");
-    } else if (isMounted && setupComplete) {
-      console.log("[Setup Flow] Setup already complete, showing normal view");
-    }
-  }, [isMounted, isFirstRun, setupComplete, setCurrentView, currentView]);
-
-  // Test IPC connection on mount
-  useEffect(() => {
-    const testConnection = async () => {
-      try {
-        const api = getElectronAPI();
-        const result = await api.ping();
-        setIpcConnected(result === "pong");
-      } catch (error) {
-        console.error("IPC connection failed:", error);
-        setIpcConnected(false);
-      }
-    };
-
-    testConnection();
-  }, [setIpcConnected]);
-
-  // Apply theme class to document (uses effective theme - preview, project-specific, or global)
-  useEffect(() => {
-    const root = document.documentElement;
-    root.classList.remove(
-      "dark",
-      "retro",
-      "light",
-      "dracula",
-      "nord",
-      "monokai",
-      "tokyonight",
-      "solarized",
-      "gruvbox",
-      "catppuccin",
-      "onedark",
-      "synthwave",
-      "red"
-    );
-
-    if (effectiveTheme === "dark") {
-      root.classList.add("dark");
-    } else if (effectiveTheme === "retro") {
-      root.classList.add("retro");
-    } else if (effectiveTheme === "dracula") {
-      root.classList.add("dracula");
-    } else if (effectiveTheme === "nord") {
-      root.classList.add("nord");
-    } else if (effectiveTheme === "monokai") {
-      root.classList.add("monokai");
-    } else if (effectiveTheme === "tokyonight") {
-      root.classList.add("tokyonight");
-    } else if (effectiveTheme === "solarized") {
-      root.classList.add("solarized");
-    } else if (effectiveTheme === "gruvbox") {
-      root.classList.add("gruvbox");
-    } else if (effectiveTheme === "catppuccin") {
-      root.classList.add("catppuccin");
-    } else if (effectiveTheme === "onedark") {
-      root.classList.add("onedark");
-    } else if (effectiveTheme === "synthwave") {
-      root.classList.add("synthwave");
-    } else if (effectiveTheme === "red") {
-      root.classList.add("red");
-    } else if (effectiveTheme === "light") {
-      root.classList.add("light");
-    } else if (effectiveTheme === "system") {
-      // System theme
-      const isDark = window.matchMedia("(prefers-color-scheme: dark)").matches;
-      if (isDark) {
-        root.classList.add("dark");
-      } else {
-        root.classList.add("light");
-      }
-    }
-  }, [effectiveTheme, previewTheme, currentProject, theme]);
-
-  const renderView = () => {
-    switch (currentView) {
-      case "welcome":
-        return <WelcomeView />;
-      case "setup":
-        return <SetupView />;
-      case "board":
-        return <BoardView />;
-      case "spec":
-        return <SpecView />;
-      case "agent":
-        return <AgentView />;
-      case "settings":
-        return <SettingsView />;
-      case "interview":
-        return <InterviewView />;
-      case "context":
-        return <ContextView />;
-      case "profiles":
-        return <ProfilesView />;
-      case "running-agents":
-        return <RunningAgentsView />;
-      case "terminal":
-        return <TerminalView />;
-      case "wiki":
-        return <WikiView />;
-      default:
-        return <WelcomeView />;
-    }
-  };
-
-  // Setup view is full-screen without sidebar
-  if (currentView === "setup") {
-    return (
-      <main className="h-screen overflow-hidden" data-testid="app-container">
-        <SetupView />
-      </main>
-    );
-  }
-
-  return (
-    <main className="flex h-screen overflow-hidden" data-testid="app-container">
-      <Sidebar />
-      <div
-        className="flex-1 flex flex-col overflow-hidden transition-all duration-300"
-        style={{ marginRight: streamerPanelOpen ? "250px" : "0" }}
-      >
-        {renderView()}
-      </div>
-
-      {/* Hidden streamer panel - opens with "\" key, pushes content */}
-      <div
-        className={`fixed top-0 right-0 h-full w-[250px] bg-background border-l border-border transition-transform duration-300 ${
-          streamerPanelOpen ? "translate-x-0" : "translate-x-full"
-        }`}
-      />
-    </main>
-  );
-}
-
-export default function Home() {
-  return (
-    <FileBrowserProvider>
-      <HomeContent />
-    </FileBrowserProvider>
-  );
-}

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

@@ -1,316 +0,0 @@
-"use client";
-
-import { useState, useEffect, useRef } from "react";
-import {
-  FolderOpen,
-  Folder,
-  ChevronRight,
-  Home,
-  ArrowLeft,
-  HardDrive,
-  CornerDownLeft,
-} from "lucide-react";
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from "@/components/ui/dialog";
-import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
-
-interface DirectoryEntry {
-  name: string;
-  path: string;
-}
-
-interface BrowseResult {
-  success: boolean;
-  currentPath: string;
-  parentPath: string | null;
-  directories: DirectoryEntry[];
-  drives?: string[];
-  error?: string;
-  warning?: string;
-}
-
-interface FileBrowserDialogProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  onSelect: (path: string) => void;
-  title?: string;
-  description?: string;
-  initialPath?: string;
-}
-
-export function FileBrowserDialog({
-  open,
-  onOpenChange,
-  onSelect,
-  title = "Select Project Directory",
-  description = "Navigate to your project folder or paste a path directly",
-  initialPath,
-}: FileBrowserDialogProps) {
-  const [currentPath, setCurrentPath] = useState<string>("");
-  const [pathInput, setPathInput] = useState<string>("");
-  const [parentPath, setParentPath] = useState<string | null>(null);
-  const [directories, setDirectories] = useState<DirectoryEntry[]>([]);
-  const [drives, setDrives] = useState<string[]>([]);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState("");
-  const [warning, setWarning] = useState("");
-  const pathInputRef = useRef<HTMLInputElement>(null);
-
-  const browseDirectory = async (dirPath?: string) => {
-    setLoading(true);
-    setError("");
-    setWarning("");
-
-    try {
-      // Get server URL from environment or default
-      const serverUrl =
-        process.env.NEXT_PUBLIC_SERVER_URL || "http://localhost:3008";
-
-      const response = await fetch(`${serverUrl}/api/fs/browse`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ dirPath }),
-      });
-
-      const result: BrowseResult = await response.json();
-
-      if (result.success) {
-        setCurrentPath(result.currentPath);
-        setPathInput(result.currentPath);
-        setParentPath(result.parentPath);
-        setDirectories(result.directories);
-        setDrives(result.drives || []);
-        setWarning(result.warning || "");
-      } else {
-        setError(result.error || "Failed to browse directory");
-      }
-    } catch (err) {
-      setError(
-        err instanceof Error ? err.message : "Failed to load directories"
-      );
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  // Reset current path when dialog closes
-  useEffect(() => {
-    if (!open) {
-      setCurrentPath("");
-      setPathInput("");
-      setParentPath(null);
-      setDirectories([]);
-      setError("");
-      setWarning("");
-    }
-  }, [open]);
-
-  // Load initial path or home directory when dialog opens
-  useEffect(() => {
-    if (open && !currentPath) {
-      browseDirectory(initialPath);
-    }
-  }, [open, initialPath]);
-
-  const handleSelectDirectory = (dir: DirectoryEntry) => {
-    browseDirectory(dir.path);
-  };
-
-  const handleGoToParent = () => {
-    if (parentPath) {
-      browseDirectory(parentPath);
-    }
-  };
-
-  const handleGoHome = () => {
-    browseDirectory();
-  };
-
-  const handleSelectDrive = (drivePath: string) => {
-    browseDirectory(drivePath);
-  };
-
-  const handleGoToPath = () => {
-    const trimmedPath = pathInput.trim();
-    if (trimmedPath) {
-      browseDirectory(trimmedPath);
-    }
-  };
-
-  const handlePathInputKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
-    if (e.key === "Enter") {
-      e.preventDefault();
-      handleGoToPath();
-    }
-  };
-
-  const handleSelect = () => {
-    if (currentPath) {
-      onSelect(currentPath);
-      onOpenChange(false);
-    }
-  };
-
-  return (
-    <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="bg-popover border-border max-w-2xl max-h-[80vh] overflow-hidden flex flex-col">
-        <DialogHeader className="pb-2">
-          <DialogTitle className="flex items-center gap-2">
-            <FolderOpen className="w-5 h-5 text-brand-500" />
-            {title}
-          </DialogTitle>
-          <DialogDescription className="text-muted-foreground">
-            {description}
-          </DialogDescription>
-        </DialogHeader>
-
-        <div className="flex flex-col gap-3 min-h-[400px] flex-1 overflow-hidden py-2">
-          {/* Direct path input */}
-          <div className="flex items-center gap-2">
-            <Input
-              ref={pathInputRef}
-              type="text"
-              placeholder="Paste or type a full path (e.g., /home/user/projects/myapp)"
-              value={pathInput}
-              onChange={(e) => setPathInput(e.target.value)}
-              onKeyDown={handlePathInputKeyDown}
-              className="flex-1 font-mono text-sm"
-              data-testid="path-input"
-              disabled={loading}
-            />
-            <Button
-              variant="secondary"
-              size="sm"
-              onClick={handleGoToPath}
-              disabled={loading || !pathInput.trim()}
-              data-testid="go-to-path-button"
-            >
-              <CornerDownLeft className="w-4 h-4 mr-1" />
-              Go
-            </Button>
-          </div>
-
-          {/* Drives selector (Windows only) */}
-          {drives.length > 0 && (
-            <div className="flex flex-wrap gap-2 p-3 rounded-lg bg-sidebar-accent/10 border border-sidebar-border">
-              <div className="flex items-center gap-1 text-xs text-muted-foreground mr-2">
-                <HardDrive className="w-3 h-3" />
-                <span>Drives:</span>
-              </div>
-              {drives.map((drive) => (
-                <Button
-                  key={drive}
-                  variant={
-                    currentPath.startsWith(drive) ? "default" : "outline"
-                  }
-                  size="sm"
-                  onClick={() => handleSelectDrive(drive)}
-                  className="h-7 px-3 text-xs"
-                  disabled={loading}
-                >
-                  {drive.replace("\\", "")}
-                </Button>
-              ))}
-            </div>
-          )}
-
-          {/* Current path breadcrumb */}
-          <div className="flex items-center gap-2 p-3 rounded-lg bg-sidebar-accent/10 border border-sidebar-border">
-            <Button
-              variant="ghost"
-              size="sm"
-              onClick={handleGoHome}
-              className="h-7 px-2"
-              disabled={loading}
-            >
-              <Home className="w-4 h-4" />
-            </Button>
-            {parentPath && (
-              <Button
-                variant="ghost"
-                size="sm"
-                onClick={handleGoToParent}
-                className="h-7 px-2"
-                disabled={loading}
-              >
-                <ArrowLeft className="w-4 h-4" />
-              </Button>
-            )}
-            <div className="flex-1 font-mono text-sm truncate text-muted-foreground">
-              {currentPath || "Loading..."}
-            </div>
-          </div>
-
-          {/* Directory list */}
-          <div className="flex-1 overflow-y-auto border border-sidebar-border rounded-lg">
-            {loading && (
-              <div className="flex items-center justify-center h-full p-8">
-                <div className="text-sm text-muted-foreground">
-                  Loading directories...
-                </div>
-              </div>
-            )}
-
-            {error && (
-              <div className="flex items-center justify-center h-full p-8">
-                <div className="text-sm text-destructive">{error}</div>
-              </div>
-            )}
-
-            {warning && (
-              <div className="p-3 bg-yellow-500/10 border border-yellow-500/30 rounded-lg mb-2">
-                <div className="text-sm text-yellow-500">{warning}</div>
-              </div>
-            )}
-
-            {!loading && !error && !warning && directories.length === 0 && (
-              <div className="flex items-center justify-center h-full p-8">
-                <div className="text-sm text-muted-foreground">
-                  No subdirectories found
-                </div>
-              </div>
-            )}
-
-            {!loading && !error && directories.length > 0 && (
-              <div className="divide-y divide-sidebar-border">
-                {directories.map((dir) => (
-                  <button
-                    key={dir.path}
-                    onClick={() => handleSelectDirectory(dir)}
-                    className="w-full flex items-center gap-3 p-3 hover:bg-sidebar-accent/10 transition-colors text-left group"
-                  >
-                    <Folder className="w-5 h-5 text-brand-500 shrink-0" />
-                    <span className="flex-1 truncate text-sm">{dir.name}</span>
-                    <ChevronRight className="w-4 h-4 text-muted-foreground opacity-0 group-hover:opacity-100 transition-opacity shrink-0" />
-                  </button>
-                ))}
-              </div>
-            )}
-          </div>
-
-          <div className="text-xs text-muted-foreground">
-            Paste a full path above, or click on folders to navigate. Press
-            Enter or click Go to jump to a path.
-          </div>
-        </div>
-
-        <DialogFooter className="border-t border-border pt-4 gap-2">
-          <Button variant="ghost" onClick={() => onOpenChange(false)}>
-            Cancel
-          </Button>
-          <Button onClick={handleSelect} disabled={!currentPath || loading}>
-            <FolderOpen className="w-4 h-4 mr-2" />
-            Select Current Folder
-          </Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
-  );
-}

apps/app/src/components/layout/project-setup-dialog.tsx

@@ -1,167 +0,0 @@
-"use client";
-
-import { Sparkles, Clock } from "lucide-react";
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from "@/components/ui/dialog";
-import { Button } from "@/components/ui/button";
-import { Checkbox } from "@/components/ui/checkbox";
-import { cn } from "@/lib/utils";
-
-// Feature count options
-export type FeatureCount = 20 | 50 | 100;
-const FEATURE_COUNT_OPTIONS: {
-  value: FeatureCount;
-  label: string;
-  warning?: string;
-}[] = [
-  { value: 20, label: "20" },
-  { value: 50, label: "50", warning: "May take up to 5 minutes" },
-  { value: 100, label: "100", warning: "May take up to 5 minutes" },
-];
-
-interface ProjectSetupDialogProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  projectOverview: string;
-  onProjectOverviewChange: (value: string) => void;
-  generateFeatures: boolean;
-  onGenerateFeaturesChange: (value: boolean) => void;
-  featureCount: FeatureCount;
-  onFeatureCountChange: (value: FeatureCount) => void;
-  onCreateSpec: () => void;
-  onSkip: () => void;
-  isCreatingSpec: boolean;
-}
-
-export function ProjectSetupDialog({
-  open,
-  onOpenChange,
-  projectOverview,
-  onProjectOverviewChange,
-  generateFeatures,
-  onGenerateFeaturesChange,
-  featureCount,
-  onFeatureCountChange,
-  onCreateSpec,
-  onSkip,
-  isCreatingSpec,
-}: ProjectSetupDialogProps) {
-  return (
-    <Dialog
-      open={open}
-      onOpenChange={(open) => {
-        onOpenChange(open);
-        if (!open && !isCreatingSpec) {
-          onSkip();
-        }
-      }}
-    >
-      <DialogContent className="max-w-2xl">
-        <DialogHeader>
-          <DialogTitle>Set Up Your Project</DialogTitle>
-          <DialogDescription className="text-muted-foreground">
-            We didn&apos;t find an app_spec.txt file. Let us help you generate
-            your app_spec.txt to help describe your project for our system.
-            We&apos;ll analyze your project&apos;s tech stack and create a
-            comprehensive specification.
-          </DialogDescription>
-        </DialogHeader>
-
-        <div className="space-y-4 py-4">
-          <div className="space-y-2">
-            <label className="text-sm font-medium">Project Overview</label>
-            <p className="text-xs text-muted-foreground">
-              Describe what your project does and what features you want to
-              build. Be as detailed as you want - this will help us create a
-              better specification.
-            </p>
-            <textarea
-              className="w-full h-48 p-3 rounded-md border border-border bg-background font-mono text-sm resize-none focus:outline-none focus:ring-2 focus:ring-ring"
-              value={projectOverview}
-              onChange={(e) => onProjectOverviewChange(e.target.value)}
-              placeholder="e.g., A project management tool that allows teams to track tasks, manage sprints, and visualize progress through kanban boards. It should support user authentication, real-time updates, and file attachments..."
-              autoFocus
-            />
-          </div>
-
-          <div className="flex items-start space-x-3 pt-2">
-            <Checkbox
-              id="sidebar-generate-features"
-              checked={generateFeatures}
-              onCheckedChange={(checked) =>
-                onGenerateFeaturesChange(checked === true)
-              }
-            />
-            <div className="space-y-1">
-              <label
-                htmlFor="sidebar-generate-features"
-                className="text-sm font-medium cursor-pointer"
-              >
-                Generate feature list
-              </label>
-              <p className="text-xs text-muted-foreground">
-                Automatically create features in the features folder from the
-                implementation roadmap after the spec is generated.
-              </p>
-            </div>
-          </div>
-
-          {/* Feature Count Selection - only shown when generateFeatures is enabled */}
-          {generateFeatures && (
-            <div className="space-y-2 pt-2 pl-7">
-              <label className="text-sm font-medium">Number of Features</label>
-              <div className="flex gap-2">
-                {FEATURE_COUNT_OPTIONS.map((option) => (
-                  <Button
-                    key={option.value}
-                    type="button"
-                    variant={
-                      featureCount === option.value ? "default" : "outline"
-                    }
-                    size="sm"
-                    onClick={() => onFeatureCountChange(option.value)}
-                    className={cn(
-                      "flex-1 transition-all",
-                      featureCount === option.value
-                        ? "bg-primary hover:bg-primary/90 text-primary-foreground"
-                        : "bg-muted/30 hover:bg-muted/50 border-border"
-                    )}
-                    data-testid={`feature-count-${option.value}`}
-                  >
-                    {option.label}
-                  </Button>
-                ))}
-              </div>
-              {FEATURE_COUNT_OPTIONS.find((o) => o.value === featureCount)
-                ?.warning && (
-                <p className="text-xs text-amber-500 flex items-center gap-1">
-                  <Clock className="w-3 h-3" />
-                  {
-                    FEATURE_COUNT_OPTIONS.find((o) => o.value === featureCount)
-                      ?.warning
-                  }
-                </p>
-              )}
-            </div>
-          )}
-        </div>
-
-        <DialogFooter>
-          <Button variant="ghost" onClick={onSkip}>
-            Skip for now
-          </Button>
-          <Button onClick={onCreateSpec} disabled={!projectOverview.trim()}>
-            <Sparkles className="w-4 h-4 mr-2" />
-            Generate Spec
-          </Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
-  );
-}

apps/app/src/components/ui/badge.tsx

@@ -1,57 +0,0 @@
-import * as React from "react";
-import { cva, type VariantProps } from "class-variance-authority";
-
-import { cn } from "@/lib/utils";
-
-const badgeVariants = cva(
-  "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-medium transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 shadow-sm",
-  {
-    variants: {
-      variant: {
-        default:
-          "border-transparent bg-primary text-primary-foreground hover:bg-primary/90",
-        secondary:
-          "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
-        destructive:
-          "border-transparent bg-destructive text-white hover:bg-destructive/90",
-        outline:
-          "text-foreground border-border bg-background/50 backdrop-blur-sm",
-        // Semantic status variants using CSS variables
-        success:
-          "border-transparent bg-[var(--status-success-bg)] text-[var(--status-success)] border border-[var(--status-success)]/30",
-        warning:
-          "border-transparent bg-[var(--status-warning-bg)] text-[var(--status-warning)] border border-[var(--status-warning)]/30",
-        error:
-          "border-transparent bg-[var(--status-error-bg)] text-[var(--status-error)] border border-[var(--status-error)]/30",
-        info:
-          "border-transparent bg-[var(--status-info-bg)] text-[var(--status-info)] border border-[var(--status-info)]/30",
-        // Muted variants for subtle indication
-        muted:
-          "border-border/50 bg-muted/50 text-muted-foreground",
-        brand:
-          "border-transparent bg-brand-500/15 text-brand-500 border border-brand-500/30",
-      },
-      size: {
-        default: "px-2.5 py-0.5 text-xs",
-        sm: "px-2 py-0.5 text-[10px]",
-        lg: "px-3 py-1 text-sm",
-      },
-    },
-    defaultVariants: {
-      variant: "default",
-      size: "default",
-    },
-  }
-);
-
-export interface BadgeProps
-  extends React.HTMLAttributes<HTMLDivElement>,
-    VariantProps<typeof badgeVariants> {}
-
-function Badge({ className, variant, size, ...props }: BadgeProps) {
-  return (
-    <div className={cn(badgeVariants({ variant, size }), className)} {...props} />
-  );
-}
-
-export { Badge, badgeVariants };

apps/app/src/components/ui/card.tsx

@@ -1,100 +0,0 @@
-import * as React from "react";
-
-import { cn } from "@/lib/utils";
-
-interface CardProps extends React.ComponentProps<"div"> {
-  gradient?: boolean;
-}
-
-function Card({ className, gradient = false, ...props }: CardProps) {
-  return (
-    <div
-      data-slot="card"
-      className={cn(
-        "bg-card text-card-foreground flex flex-col gap-6 rounded-xl border border-white/10 backdrop-blur-md py-6",
-        // Premium layered shadow
-        "shadow-[0_1px_2px_rgba(0,0,0,0.05),0_4px_6px_rgba(0,0,0,0.05),0_10px_20px_rgba(0,0,0,0.04)]",
-        // Gradient border option
-        gradient && "relative before:absolute before:inset-0 before:rounded-xl before:p-[1px] before:bg-gradient-to-br before:from-white/20 before:to-transparent before:pointer-events-none before:-z-10",
-        className
-      )}
-      {...props}
-    />
-  );
-}
-
-function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="card-header"
-      className={cn(
-        "@container/card-header grid auto-rows-min grid-rows-[auto_auto] items-start gap-1.5 px-6 has-data-[slot=card-action]:grid-cols-[1fr_auto] [.border-b]:pb-6",
-        className
-      )}
-      {...props}
-    />
-  );
-}
-
-function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="card-title"
-      className={cn("leading-none font-semibold tracking-tight", className)}
-      {...props}
-    />
-  );
-}
-
-function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="card-description"
-      className={cn("text-muted-foreground text-sm leading-relaxed", className)}
-      {...props}
-    />
-  );
-}
-
-function CardAction({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="card-action"
-      className={cn(
-        "col-start-2 row-span-2 row-start-1 self-start justify-self-end",
-        className
-      )}
-      {...props}
-    />
-  );
-}
-
-function CardContent({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="card-content"
-      className={cn("px-6", className)}
-      {...props}
-    />
-  );
-}
-
-function CardFooter({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="card-footer"
-      className={cn("flex items-center gap-3 px-6 [.border-t]:pt-6", className)}
-      {...props}
-    />
-  );
-}
-
-export {
-  Card,
-  CardHeader,
-  CardFooter,
-  CardTitle,
-  CardAction,
-  CardDescription,
-  CardContent,
-};

apps/app/src/components/ui/category-autocomplete.tsx

@@ -1,91 +0,0 @@
-"use client";
-
-import * as React from "react";
-import { Check, ChevronsUpDown } from "lucide-react";
-
-import { cn } from "@/lib/utils";
-import { Button } from "@/components/ui/button";
-import {
-  Command,
-  CommandEmpty,
-  CommandGroup,
-  CommandInput,
-  CommandItem,
-  CommandList,
-} from "@/components/ui/command";
-import {
-  Popover,
-  PopoverContent,
-  PopoverTrigger,
-} from "@/components/ui/popover";
-
-interface CategoryAutocompleteProps {
-  value: string;
-  onChange: (value: string) => void;
-  suggestions: string[];
-  placeholder?: string;
-  className?: string;
-  disabled?: boolean;
-  "data-testid"?: string;
-}
-
-export function CategoryAutocomplete({
-  value,
-  onChange,
-  suggestions,
-  placeholder = "Select or type a category...",
-  className,
-  disabled = false,
-  "data-testid": testId,
-}: CategoryAutocompleteProps) {
-  const [open, setOpen] = React.useState(false);
-
-  return (
-    <Popover open={open} onOpenChange={setOpen}>
-      <PopoverTrigger asChild>
-        <Button
-          variant="outline"
-          role="combobox"
-          aria-expanded={open}
-          disabled={disabled}
-          className={cn("w-full justify-between", className)}
-          data-testid={testId}
-        >
-          {value
-            ? suggestions.find((s) => s === value) ?? value
-            : placeholder}
-          <ChevronsUpDown className="opacity-50" />
-        </Button>
-      </PopoverTrigger>
-      <PopoverContent className="w-[200px] p-0">
-        <Command>
-          <CommandInput placeholder="Search category..." className="h-9" />
-          <CommandList>
-            <CommandEmpty>No category found.</CommandEmpty>
-            <CommandGroup>
-              {suggestions.map((suggestion) => (
-                <CommandItem
-                  key={suggestion}
-                  value={suggestion}
-                  onSelect={(currentValue) => {
-                    onChange(currentValue === value ? "" : currentValue);
-                    setOpen(false);
-                  }}
-                  data-testid={`category-option-${suggestion.toLowerCase().replace(/\s+/g, "-")}`}
-                >
-                  {suggestion}
-                  <Check
-                    className={cn(
-                      "ml-auto",
-                      value === suggestion ? "opacity-100" : "opacity-0"
-                    )}
-                  />
-                </CommandItem>
-              ))}
-            </CommandGroup>
-          </CommandList>
-        </Command>
-      </PopoverContent>
-    </Popover>
-  );
-}

apps/app/src/components/ui/checkbox.tsx

@@ -1,42 +0,0 @@
-"use client";
-
-import * as React from "react";
-import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
-import { Check } from "lucide-react";
-
-import { cn } from "@/lib/utils";
-
-interface CheckboxProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "checked" | "defaultChecked"> {
-  checked?: boolean | "indeterminate";
-  defaultChecked?: boolean | "indeterminate";
-  onCheckedChange?: (checked: boolean) => void;
-  required?: boolean;
-}
-
-const Checkbox = React.forwardRef<HTMLButtonElement, CheckboxProps>(
-  ({ className, onCheckedChange, ...props }, ref) => (
-    <CheckboxPrimitive.Root
-      ref={ref}
-      className={cn(
-        "peer h-4 w-4 shrink-0 rounded-sm border border-primary ring-offset-background cursor-pointer focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground hover:border-primary/80",
-        className
-      )}
-      onCheckedChange={(checked) => {
-        // Handle indeterminate state by treating it as false for consumers expecting boolean
-        if (onCheckedChange) {
-          onCheckedChange(checked === true);
-        }
-      }}
-      {...props}
-    >
-      <CheckboxPrimitive.Indicator
-        className={cn("flex items-center justify-center text-current")}
-      >
-        <Check className="h-4 w-4" />
-      </CheckboxPrimitive.Indicator>
-    </CheckboxPrimitive.Root>
-  )
-);
-Checkbox.displayName = CheckboxPrimitive.Root.displayName;
-
-export { Checkbox };

apps/app/src/components/ui/course-promo-badge.tsx

@@ -1,88 +0,0 @@
-"use client";
-
-import * as React from "react";
-import { Sparkles, X } from "lucide-react";
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipProvider,
-  TooltipTrigger,
-} from "@/components/ui/tooltip";
-
-interface CoursePromoBadgeProps {
-  sidebarOpen?: boolean;
-}
-
-export function CoursePromoBadge({ sidebarOpen = true }: CoursePromoBadgeProps) {
-  const [dismissed, setDismissed] = React.useState(false);
-
-  if (dismissed) {
-    return null;
-  }
-
-  // Collapsed state - show only icon with tooltip
-  if (!sidebarOpen) {
-    return (
-      <div className="p-2 pb-0 flex justify-center">
-        <TooltipProvider delayDuration={300}>
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <a
-                href="https://agenticjumpstart.com"
-                target="_blank"
-                rel="noopener noreferrer"
-                className="group cursor-pointer flex items-center justify-center w-10 h-10 bg-primary/10 text-primary rounded-lg hover:bg-primary/20 transition-all border border-primary/30"
-                data-testid="course-promo-badge-collapsed"
-              >
-                <Sparkles className="size-4 shrink-0" />
-              </a>
-            </TooltipTrigger>
-            <TooltipContent side="right" className="flex items-center gap-2">
-              <span>Become a 10x Dev</span>
-              <span
-                onClick={(e) => {
-                  e.preventDefault();
-                  e.stopPropagation();
-                  setDismissed(true);
-                }}
-                className="p-0.5 rounded-full hover:bg-primary/30 transition-colors cursor-pointer"
-                aria-label="Dismiss"
-              >
-                <X className="size-3" />
-              </span>
-            </TooltipContent>
-          </Tooltip>
-        </TooltipProvider>
-      </div>
-    );
-  }
-
-  // Expanded state - show full badge
-  return (
-    <div className="p-2 pb-0">
-      <a
-        href="https://agenticjumpstart.com"
-        target="_blank"
-        rel="noopener noreferrer"
-        className="group cursor-pointer flex items-center justify-between w-full px-2 lg:px-3 py-2.5 bg-primary/10 text-primary rounded-lg font-medium text-sm hover:bg-primary/20 transition-all border border-primary/30"
-        data-testid="course-promo-badge"
-      >
-        <div className="flex items-center gap-2">
-          <Sparkles className="size-4 shrink-0" />
-          <span className="hidden lg:block">Become a 10x Dev</span>
-        </div>
-        <span
-          onClick={(e) => {
-            e.preventDefault();
-            e.stopPropagation();
-            setDismissed(true);
-          }}
-          className="hidden lg:block p-1 rounded-full hover:bg-primary/30 transition-colors cursor-pointer"
-          aria-label="Dismiss"
-        >
-          <X className="size-3.5" />
-        </span>
-      </a>
-    </div>
-  );
-}

apps/app/src/components/ui/description-image-dropzone.tsx

@@ -1,422 +0,0 @@
-"use client";
-
-import React, { useState, useRef, useCallback } from "react";
-import { cn } from "@/lib/utils";
-import { ImageIcon, X, Loader2 } from "lucide-react";
-import { Textarea } from "@/components/ui/textarea";
-import { getElectronAPI } from "@/lib/electron";
-import { useAppStore } from "@/store/app-store";
-
-export interface FeatureImagePath {
-  id: string;
-  path: string; // Path to the temp file
-  filename: string;
-  mimeType: string;
-}
-
-// Map to store preview data by image ID (persisted across component re-mounts)
-export type ImagePreviewMap = Map<string, string>;
-
-interface DescriptionImageDropZoneProps {
-  value: string;
-  onChange: (value: string) => void;
-  images: FeatureImagePath[];
-  onImagesChange: (images: FeatureImagePath[]) => void;
-  placeholder?: string;
-  className?: string;
-  disabled?: boolean;
-  maxFiles?: number;
-  maxFileSize?: number; // in bytes, default 10MB
-  // Optional: pass preview map from parent to persist across tab switches
-  previewMap?: ImagePreviewMap;
-  onPreviewMapChange?: (map: ImagePreviewMap) => void;
-  autoFocus?: boolean;
-  error?: boolean; // Show error state with red border
-}
-
-const ACCEPTED_IMAGE_TYPES = [
-  "image/jpeg",
-  "image/jpg",
-  "image/png",
-  "image/gif",
-  "image/webp",
-];
-const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
-
-export function DescriptionImageDropZone({
-  value,
-  onChange,
-  images,
-  onImagesChange,
-  placeholder = "Describe the feature...",
-  className,
-  disabled = false,
-  maxFiles = 5,
-  maxFileSize = DEFAULT_MAX_FILE_SIZE,
-  previewMap,
-  onPreviewMapChange,
-  autoFocus = false,
-  error = false,
-}: DescriptionImageDropZoneProps) {
-  const [isDragOver, setIsDragOver] = useState(false);
-  const [isProcessing, setIsProcessing] = useState(false);
-  // Use parent-provided preview map if available, otherwise use local state
-  const [localPreviewImages, setLocalPreviewImages] = useState<Map<string, string>>(
-    () => new Map()
-  );
-
-  // Determine which preview map to use - prefer parent-controlled state
-  const previewImages = previewMap !== undefined ? previewMap : localPreviewImages;
-  const setPreviewImages = useCallback((updater: Map<string, string> | ((prev: Map<string, string>) => Map<string, string>)) => {
-    if (onPreviewMapChange) {
-      const currentMap = previewMap !== undefined ? previewMap : localPreviewImages;
-      const newMap = typeof updater === 'function' ? updater(currentMap) : updater;
-      onPreviewMapChange(newMap);
-    } else {
-      setLocalPreviewImages((prev) => {
-        const newMap = typeof updater === 'function' ? updater(prev) : updater;
-        return newMap;
-      });
-    }
-  }, [onPreviewMapChange, previewMap, localPreviewImages]);
-
-  const fileInputRef = useRef<HTMLInputElement>(null);
-  const currentProject = useAppStore((state) => state.currentProject);
-
-  // Construct server URL for loading saved images
-  const getImageServerUrl = useCallback((imagePath: string): string => {
-    const serverUrl = process.env.NEXT_PUBLIC_SERVER_URL || "http://localhost:3008";
-    const projectPath = currentProject?.path || "";
-    return `${serverUrl}/api/fs/image?path=${encodeURIComponent(imagePath)}&projectPath=${encodeURIComponent(projectPath)}`;
-  }, [currentProject?.path]);
-
-  const fileToBase64 = (file: File): Promise<string> => {
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader();
-      reader.onload = () => {
-        if (typeof reader.result === "string") {
-          resolve(reader.result);
-        } else {
-          reject(new Error("Failed to read file as base64"));
-        }
-      };
-      reader.onerror = () => reject(new Error("Failed to read file"));
-      reader.readAsDataURL(file);
-    });
-  };
-
-  const saveImageToTemp = useCallback(async (
-    base64Data: string,
-    filename: string,
-    mimeType: string
-  ): Promise<string | null> => {
-    try {
-      const api = getElectronAPI();
-      // Check if saveImageToTemp method exists
-      if (!api.saveImageToTemp) {
-        // Fallback path when saveImageToTemp is not available
-        console.log("[DescriptionImageDropZone] Using fallback path for image");
-        return `.automaker/images/${Date.now()}_${filename}`;
-      }
-
-      // Get projectPath from the store if available
-      const projectPath = currentProject?.path;
-      const result = await api.saveImageToTemp(base64Data, filename, mimeType, projectPath);
-      if (result.success && result.path) {
-        return result.path;
-      }
-      console.error("[DescriptionImageDropZone] Failed to save image:", result.error);
-      return null;
-    } catch (error) {
-      console.error("[DescriptionImageDropZone] Error saving image:", error);
-      return null;
-    }
-  }, [currentProject?.path]);
-
-  const processFiles = useCallback(
-    async (files: FileList) => {
-      if (disabled || isProcessing) return;
-
-      setIsProcessing(true);
-      const newImages: FeatureImagePath[] = [];
-      const newPreviews = new Map(previewImages);
-      const errors: string[] = [];
-
-      for (const file of Array.from(files)) {
-        // Validate file type
-        if (!ACCEPTED_IMAGE_TYPES.includes(file.type)) {
-          errors.push(
-            `${file.name}: Unsupported file type. Please use JPG, PNG, GIF, or WebP.`
-          );
-          continue;
-        }
-
-        // Validate file size
-        if (file.size > maxFileSize) {
-          const maxSizeMB = maxFileSize / (1024 * 1024);
-          errors.push(
-            `${file.name}: File too large. Maximum size is ${maxSizeMB}MB.`
-          );
-          continue;
-        }
-
-        // Check if we've reached max files
-        if (newImages.length + images.length >= maxFiles) {
-          errors.push(`Maximum ${maxFiles} images allowed.`);
-          break;
-        }
-
-        try {
-          const base64 = await fileToBase64(file);
-          const tempPath = await saveImageToTemp(base64, file.name, file.type);
-
-          if (tempPath) {
-            const imageId = `img-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-            const imagePathRef: FeatureImagePath = {
-              id: imageId,
-              path: tempPath,
-              filename: file.name,
-              mimeType: file.type,
-            };
-            newImages.push(imagePathRef);
-            // Store preview for display
-            newPreviews.set(imageId, base64);
-          } else {
-            errors.push(`${file.name}: Failed to save image.`);
-          }
-        } catch (error) {
-          errors.push(`${file.name}: Failed to process image.`);
-        }
-      }
-
-      if (errors.length > 0) {
-        console.warn("Image upload errors:", errors);
-      }
-
-      if (newImages.length > 0) {
-        onImagesChange([...images, ...newImages]);
-        setPreviewImages(newPreviews);
-      }
-
-      setIsProcessing(false);
-    },
-    [disabled, isProcessing, images, maxFiles, maxFileSize, onImagesChange, previewImages, saveImageToTemp]
-  );
-
-  const handleDrop = useCallback(
-    (e: React.DragEvent) => {
-      e.preventDefault();
-      e.stopPropagation();
-      setIsDragOver(false);
-
-      if (disabled) return;
-
-      const files = e.dataTransfer.files;
-      if (files.length > 0) {
-        processFiles(files);
-      }
-    },
-    [disabled, processFiles]
-  );
-
-  const handleDragOver = useCallback(
-    (e: React.DragEvent) => {
-      e.preventDefault();
-      e.stopPropagation();
-      if (!disabled) {
-        setIsDragOver(true);
-      }
-    },
-    [disabled]
-  );
-
-  const handleDragLeave = useCallback((e: React.DragEvent) => {
-    e.preventDefault();
-    e.stopPropagation();
-    setIsDragOver(false);
-  }, []);
-
-  const handleFileSelect = useCallback(
-    (e: React.ChangeEvent<HTMLInputElement>) => {
-      const files = e.target.files;
-      if (files && files.length > 0) {
-        processFiles(files);
-      }
-      // Reset the input so the same file can be selected again
-      if (fileInputRef.current) {
-        fileInputRef.current.value = "";
-      }
-    },
-    [processFiles]
-  );
-
-  const handleBrowseClick = useCallback(() => {
-    if (!disabled && fileInputRef.current) {
-      fileInputRef.current.click();
-    }
-  }, [disabled]);
-
-  const removeImage = useCallback(
-    (imageId: string) => {
-      onImagesChange(images.filter((img) => img.id !== imageId));
-      setPreviewImages((prev) => {
-        const newMap = new Map(prev);
-        newMap.delete(imageId);
-        return newMap;
-      });
-    },
-    [images, onImagesChange]
-  );
-
-  return (
-    <div className={cn("relative", className)}>
-      {/* Hidden file input */}
-      <input
-        ref={fileInputRef}
-        type="file"
-        multiple
-        accept={ACCEPTED_IMAGE_TYPES.join(",")}
-        onChange={handleFileSelect}
-        className="hidden"
-        disabled={disabled}
-        data-testid="description-image-input"
-      />
-
-      {/* Drop zone wrapper */}
-      <div
-        onDrop={handleDrop}
-        onDragOver={handleDragOver}
-        onDragLeave={handleDragLeave}
-        className={cn(
-          "relative rounded-md transition-all duration-200",
-          {
-            "ring-2 ring-blue-400 ring-offset-2 ring-offset-background":
-              isDragOver && !disabled,
-          }
-        )}
-      >
-        {/* Drag overlay */}
-        {isDragOver && !disabled && (
-          <div
-            className="absolute inset-0 z-10 flex items-center justify-center rounded-md bg-blue-500/20 border-2 border-dashed border-blue-400 pointer-events-none"
-            data-testid="drop-overlay"
-          >
-            <div className="flex flex-col items-center gap-2 text-blue-400">
-              <ImageIcon className="w-8 h-8" />
-              <span className="text-sm font-medium">Drop images here</span>
-            </div>
-          </div>
-        )}
-
-        {/* Textarea */}
-        <Textarea
-          placeholder={placeholder}
-          value={value}
-          onChange={(e) => onChange(e.target.value)}
-          disabled={disabled}
-          autoFocus={autoFocus}
-          aria-invalid={error}
-          className={cn(
-            "min-h-[120px]",
-            isProcessing && "opacity-50 pointer-events-none"
-          )}
-          data-testid="feature-description-input"
-        />
-      </div>
-
-      {/* Hint text */}
-      <p className="text-xs text-muted-foreground mt-1">
-        Drag and drop images here or{" "}
-        <button
-          type="button"
-          onClick={handleBrowseClick}
-          className="text-primary hover:text-primary/80 underline"
-          disabled={disabled || isProcessing}
-        >
-          browse
-        </button>{" "}
-        to attach context images
-      </p>
-
-      {/* Processing indicator */}
-      {isProcessing && (
-        <div className="flex items-center gap-2 mt-2 text-sm text-muted-foreground">
-          <Loader2 className="w-4 h-4 animate-spin" />
-          <span>Saving images...</span>
-        </div>
-      )}
-
-      {/* Image previews */}
-      {images.length > 0 && (
-        <div className="mt-3 space-y-2" data-testid="description-image-previews">
-          <div className="flex items-center justify-between">
-            <p className="text-xs font-medium text-foreground">
-              {images.length} image{images.length > 1 ? "s" : ""} attached
-            </p>
-            <button
-              type="button"
-              onClick={() => {
-                onImagesChange([]);
-                setPreviewImages(new Map());
-              }}
-              className="text-xs text-muted-foreground hover:text-foreground"
-              disabled={disabled}
-            >
-              Clear all
-            </button>
-          </div>
-          <div className="flex flex-wrap gap-2">
-            {images.map((image) => (
-              <div
-                key={image.id}
-                className="relative group rounded-md border border-muted bg-muted/50 overflow-hidden"
-                data-testid={`description-image-preview-${image.id}`}
-              >
-                {/* Image thumbnail or placeholder */}
-                <div className="w-16 h-16 flex items-center justify-center bg-zinc-800">
-                  {previewImages.has(image.id) ? (
-                    <img
-                      src={previewImages.get(image.id)}
-                      alt={image.filename}
-                      className="max-w-full max-h-full object-contain"
-                    />
-                  ) : (
-                    <img
-                      src={getImageServerUrl(image.path)}
-                      alt={image.filename}
-                      className="max-w-full max-h-full object-contain"
-                      onError={(e) => {
-                        // If image fails to load, hide it
-                        (e.target as HTMLImageElement).style.display = 'none';
-                      }}
-                    />
-                  )}
-                </div>
-                {/* Remove button */}
-                {!disabled && (
-                  <button
-                    type="button"
-                    onClick={(e) => {
-                      e.stopPropagation();
-                      removeImage(image.id);
-                    }}
-                    className="absolute top-0.5 right-0.5 p-0.5 rounded-full bg-destructive text-destructive-foreground opacity-0 group-hover:opacity-100 transition-opacity"
-                    data-testid={`remove-description-image-${image.id}`}
-                  >
-                    <X className="h-3 w-3" />
-                  </button>
-                )}
-                {/* Filename tooltip on hover */}
-                <div className="absolute bottom-0 left-0 right-0 bg-black/60 px-1 py-0.5 opacity-0 group-hover:opacity-100 transition-opacity">
-                  <p className="text-[10px] text-white truncate">
-                    {image.filename}
-                  </p>
-                </div>
-              </div>
-            ))}
-          </div>
-        </div>
-      )}
-    </div>
-  );
-}

apps/app/src/components/ui/dialog.tsx

@@ -1,175 +0,0 @@
-"use client";
-
-import * as React from "react";
-import * as DialogPrimitive from "@radix-ui/react-dialog";
-import { XIcon } from "lucide-react";
-
-import { cn } from "@/lib/utils";
-
-function Dialog({
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Root>) {
-  return <DialogPrimitive.Root data-slot="dialog" {...props} />;
-}
-
-function DialogTrigger({
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Trigger>) {
-  return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />;
-}
-
-function DialogPortal({
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Portal>) {
-  return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />;
-}
-
-function DialogClose({
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Close>) {
-  return <DialogPrimitive.Close data-slot="dialog-close" {...props} />;
-}
-
-function DialogOverlay({
-  className,
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Overlay>) {
-  return (
-    <DialogPrimitive.Overlay
-      data-slot="dialog-overlay"
-      className={cn(
-        "fixed inset-0 z-50 bg-black/60 backdrop-blur-sm",
-        "data-[state=open]:animate-in data-[state=closed]:animate-out",
-        "data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
-        "duration-200",
-        className
-      )}
-      {...props}
-    />
-  );
-}
-
-function DialogContent({
-  className,
-  children,
-  showCloseButton = true,
-  compact = false,
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Content> & {
-  showCloseButton?: boolean;
-  compact?: boolean;
-}) {
-  // Check if className contains a custom max-width
-  const hasCustomMaxWidth =
-    typeof className === "string" && className.includes("max-w-");
-
-  return (
-    <DialogPortal data-slot="dialog-portal">
-      <DialogOverlay />
-      <DialogPrimitive.Content
-        data-slot="dialog-content"
-        className={cn(
-          "fixed top-[50%] left-[50%] z-50 translate-x-[-50%] translate-y-[-50%]",
-          "flex flex-col w-full max-w-[calc(100%-2rem)] max-h-[calc(100vh-4rem)]",
-          "bg-card border border-border rounded-xl shadow-2xl",
-          // Premium shadow
-          "shadow-[0_25px_50px_-12px_rgba(0,0,0,0.25)]",
-          // Animations - smoother with scale
-          "data-[state=open]:animate-in data-[state=closed]:animate-out",
-          "data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
-          "data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95",
-          "data-[state=closed]:slide-out-to-top-[2%] data-[state=open]:slide-in-from-top-[2%]",
-          "duration-200",
-          compact
-            ? "max-w-4xl p-4"
-            : !hasCustomMaxWidth
-            ? "sm:max-w-2xl p-6"
-            : "p-6",
-          className
-        )}
-        {...props}
-      >
-        {children}
-        {showCloseButton && (
-          <DialogPrimitive.Close
-            data-slot="dialog-close"
-            className={cn(
-              "absolute rounded-lg opacity-60 transition-all duration-200 cursor-pointer",
-              "hover:opacity-100 hover:bg-muted",
-              "focus:ring-2 focus:ring-ring focus:ring-offset-2 focus:outline-none",
-              "disabled:pointer-events-none disabled:cursor-not-allowed",
-              "[&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg]:size-4",
-              "p-1.5",
-              compact ? "top-2 right-3" : "top-4 right-4"
-            )}
-          >
-            <XIcon />
-            <span className="sr-only">Close</span>
-          </DialogPrimitive.Close>
-        )}
-      </DialogPrimitive.Content>
-    </DialogPortal>
-  );
-}
-
-function DialogHeader({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="dialog-header"
-      className={cn("flex flex-col gap-2 text-center sm:text-left", className)}
-      {...props}
-    />
-  );
-}
-
-function DialogFooter({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="dialog-footer"
-      className={cn(
-        "flex flex-col-reverse gap-2 sm:flex-row sm:justify-end mt-6",
-        className
-      )}
-      {...props}
-    />
-  );
-}
-
-function DialogTitle({
-  className,
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Title>) {
-  return (
-    <DialogPrimitive.Title
-      data-slot="dialog-title"
-      className={cn("text-lg leading-none font-semibold tracking-tight", className)}
-      {...props}
-    />
-  );
-}
-
-function DialogDescription({
-  className,
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Description>) {
-  return (
-    <DialogPrimitive.Description
-      data-slot="dialog-description"
-      className={cn("text-muted-foreground text-sm leading-relaxed", className)}
-      {...props}
-    />
-  );
-}
-
-export {
-  Dialog,
-  DialogClose,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogOverlay,
-  DialogPortal,
-  DialogTitle,
-  DialogTrigger,
-};

apps/app/src/components/ui/dropdown-menu.tsx

@@ -1,200 +0,0 @@
-"use client"
-
-import * as React from "react"
-import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu"
-import { Check, ChevronRight, Circle } from "lucide-react"
-
-import { cn } from "@/lib/utils"
-
-const DropdownMenu = DropdownMenuPrimitive.Root
-
-const DropdownMenuTrigger = DropdownMenuPrimitive.Trigger
-
-const DropdownMenuGroup = DropdownMenuPrimitive.Group
-
-const DropdownMenuPortal = DropdownMenuPrimitive.Portal
-
-const DropdownMenuSub = DropdownMenuPrimitive.Sub
-
-const DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup
-
-const DropdownMenuSubTrigger = React.forwardRef<
-  React.ElementRef<typeof DropdownMenuPrimitive.SubTrigger>,
-  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubTrigger> & {
-    inset?: boolean
-  }
->(({ className, inset, children, ...props }, ref) => (
-  <DropdownMenuPrimitive.SubTrigger
-    ref={ref}
-    className={cn(
-      "flex cursor-pointer select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent data-[state=open]:bg-accent hover:bg-accent",
-      inset && "pl-8",
-      className
-    )}
-    {...props}
-  >
-    {children}
-    <ChevronRight className="ml-auto h-4 w-4" />
-  </DropdownMenuPrimitive.SubTrigger>
-))
-DropdownMenuSubTrigger.displayName = DropdownMenuPrimitive.SubTrigger.displayName
-
-const DropdownMenuSubContent = React.forwardRef<
-  React.ElementRef<typeof DropdownMenuPrimitive.SubContent>,
-  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubContent>
->(({ className, ...props }, ref) => (
-  <DropdownMenuPrimitive.Portal>
-    <DropdownMenuPrimitive.SubContent
-      ref={ref}
-      className={cn(
-        "z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
-        className
-      )}
-      {...props}
-    />
-  </DropdownMenuPrimitive.Portal>
-))
-DropdownMenuSubContent.displayName = DropdownMenuPrimitive.SubContent.displayName
-
-const DropdownMenuContent = React.forwardRef<
-  React.ElementRef<typeof DropdownMenuPrimitive.Content>,
-  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content>
->(({ className, sideOffset = 4, ...props }, ref) => (
-  <DropdownMenuPrimitive.Portal>
-    <DropdownMenuPrimitive.Content
-      ref={ref}
-      sideOffset={sideOffset}
-      className={cn(
-        "z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
-        className
-      )}
-      {...props}
-    />
-  </DropdownMenuPrimitive.Portal>
-))
-DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName
-
-const DropdownMenuItem = React.forwardRef<
-  React.ElementRef<typeof DropdownMenuPrimitive.Item>,
-  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> & {
-    inset?: boolean
-  }
->(({ className, inset, ...props }, ref) => (
-  <DropdownMenuPrimitive.Item
-    ref={ref}
-    className={cn(
-      "relative flex cursor-pointer select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[disabled]:cursor-not-allowed hover:bg-accent",
-      inset && "pl-8",
-      className
-    )}
-    {...props}
-  />
-))
-DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName
-
-const DropdownMenuCheckboxItem = React.forwardRef<
-  React.ElementRef<typeof DropdownMenuPrimitive.CheckboxItem>,
-  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.CheckboxItem>
->(({ className, children, checked, ...props }, ref) => (
-  <DropdownMenuPrimitive.CheckboxItem
-    ref={ref}
-    className={cn(
-      "relative flex cursor-pointer select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[disabled]:cursor-not-allowed hover:bg-accent",
-      className
-    )}
-    checked={checked}
-    {...props}
-  >
-    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
-      <DropdownMenuPrimitive.ItemIndicator>
-        <Check className="h-4 w-4" />
-      </DropdownMenuPrimitive.ItemIndicator>
-    </span>
-    {children}
-  </DropdownMenuPrimitive.CheckboxItem>
-))
-DropdownMenuCheckboxItem.displayName =
-  DropdownMenuPrimitive.CheckboxItem.displayName
-
-const DropdownMenuRadioItem = React.forwardRef<
-  React.ElementRef<typeof DropdownMenuPrimitive.RadioItem>,
-  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.RadioItem>
->(({ className, children, ...props }, ref) => (
-  <DropdownMenuPrimitive.RadioItem
-    ref={ref}
-    className={cn(
-      "relative flex cursor-pointer select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[disabled]:cursor-not-allowed hover:bg-accent",
-      className
-    )}
-    {...props}
-  >
-    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
-      <DropdownMenuPrimitive.ItemIndicator>
-        <Circle className="h-2 w-2 fill-current" />
-      </DropdownMenuPrimitive.ItemIndicator>
-    </span>
-    {children}
-  </DropdownMenuPrimitive.RadioItem>
-))
-DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName
-
-const DropdownMenuLabel = React.forwardRef<
-  React.ElementRef<typeof DropdownMenuPrimitive.Label>,
-  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Label> & {
-    inset?: boolean
-  }
->(({ className, inset, ...props }, ref) => (
-  <DropdownMenuPrimitive.Label
-    ref={ref}
-    className={cn(
-      "px-2 py-1.5 text-sm font-semibold",
-      inset && "pl-8",
-      className
-    )}
-    {...props}
-  />
-))
-DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName
-
-const DropdownMenuSeparator = React.forwardRef<
-  React.ElementRef<typeof DropdownMenuPrimitive.Separator>,
-  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Separator>
->(({ className, ...props }, ref) => (
-  <DropdownMenuPrimitive.Separator
-    ref={ref}
-    className={cn("-mx-1 my-1 h-px bg-muted", className)}
-    {...props}
-  />
-))
-DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName
-
-const DropdownMenuShortcut = ({
-  className,
-  ...props
-}: React.HTMLAttributes<HTMLSpanElement>) => {
-  return (
-    <span
-      className={cn("ml-auto text-xs tracking-widest text-brand-400/70", className)}
-      {...props}
-    />
-  )
-}
-DropdownMenuShortcut.displayName = "DropdownMenuShortcut"
-
-export {
-  DropdownMenu,
-  DropdownMenuTrigger,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuCheckboxItem,
-  DropdownMenuRadioItem,
-  DropdownMenuLabel,
-  DropdownMenuSeparator,
-  DropdownMenuShortcut,
-  DropdownMenuGroup,
-  DropdownMenuPortal,
-  DropdownMenuSub,
-  DropdownMenuSubContent,
-  DropdownMenuSubTrigger,
-  DropdownMenuRadioGroup,
-}

apps/app/src/components/ui/image-drop-zone.tsx

@@ -1,290 +0,0 @@
-"use client";
-
-import React, { useState, useRef, useCallback } from "react";
-import { cn } from "@/lib/utils";
-import { ImageIcon, X, Upload } from "lucide-react";
-import type { ImageAttachment } from "@/store/app-store";
-
-interface ImageDropZoneProps {
-  onImagesSelected: (images: ImageAttachment[]) => void;
-  maxFiles?: number;
-  maxFileSize?: number; // in bytes, default 10MB
-  className?: string;
-  children?: React.ReactNode;
-  disabled?: boolean;
-  images?: ImageAttachment[]; // Optional controlled images prop
-}
-
-const ACCEPTED_IMAGE_TYPES = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp'];
-const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
-
-export function ImageDropZone({
-  onImagesSelected,
-  maxFiles = 5,
-  maxFileSize = DEFAULT_MAX_FILE_SIZE,
-  className,
-  children,
-  disabled = false,
-  images,
-}: ImageDropZoneProps) {
-  const [isDragOver, setIsDragOver] = useState(false);
-  const [isProcessing, setIsProcessing] = useState(false);
-  const [internalImages, setInternalImages] = useState<ImageAttachment[]>([]);
-  const fileInputRef = useRef<HTMLInputElement>(null);
-
-  // Use controlled images if provided, otherwise use internal state
-  const selectedImages = images ?? internalImages;
-
-  // Update images - for controlled mode, just call the callback; for uncontrolled, also update internal state
-  const updateImages = useCallback((newImages: ImageAttachment[]) => {
-    if (images === undefined) {
-      setInternalImages(newImages);
-    }
-    onImagesSelected(newImages);
-  }, [images, onImagesSelected]);
-
-  const processFiles = useCallback(async (files: FileList) => {
-    if (disabled || isProcessing) return;
-
-    setIsProcessing(true);
-    const newImages: ImageAttachment[] = [];
-    const errors: string[] = [];
-
-    for (const file of Array.from(files)) {
-      // Validate file type
-      if (!ACCEPTED_IMAGE_TYPES.includes(file.type)) {
-        errors.push(`${file.name}: Unsupported file type. Please use JPG, PNG, GIF, or WebP.`);
-        continue;
-      }
-
-      // Validate file size
-      if (file.size > maxFileSize) {
-        const maxSizeMB = maxFileSize / (1024 * 1024);
-        errors.push(`${file.name}: File too large. Maximum size is ${maxSizeMB}MB.`);
-        continue;
-      }
-
-      // Check if we've reached max files
-      if (newImages.length + selectedImages.length >= maxFiles) {
-        errors.push(`Maximum ${maxFiles} images allowed.`);
-        break;
-      }
-
-      try {
-        const base64 = await fileToBase64(file);
-        const imageAttachment: ImageAttachment = {
-          id: `img-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-          data: base64,
-          mimeType: file.type,
-          filename: file.name,
-          size: file.size,
-        };
-        newImages.push(imageAttachment);
-      } catch (error) {
-        errors.push(`${file.name}: Failed to process image.`);
-      }
-    }
-
-    if (errors.length > 0) {
-      console.warn('Image upload errors:', errors);
-      // You could show these errors to the user via a toast or notification
-    }
-
-    if (newImages.length > 0) {
-      const allImages = [...selectedImages, ...newImages];
-      updateImages(allImages);
-    }
-
-    setIsProcessing(false);
-  }, [disabled, isProcessing, maxFiles, maxFileSize, selectedImages, updateImages]);
-
-  const handleDrop = useCallback((e: React.DragEvent) => {
-    e.preventDefault();
-    e.stopPropagation();
-    setIsDragOver(false);
-
-    if (disabled) return;
-
-    const files = e.dataTransfer.files;
-    if (files.length > 0) {
-      processFiles(files);
-    }
-  }, [disabled, processFiles]);
-
-  const handleDragOver = useCallback((e: React.DragEvent) => {
-    e.preventDefault();
-    e.stopPropagation();
-    if (!disabled) {
-      setIsDragOver(true);
-    }
-  }, [disabled]);
-
-  const handleDragLeave = useCallback((e: React.DragEvent) => {
-    e.preventDefault();
-    e.stopPropagation();
-    setIsDragOver(false);
-  }, []);
-
-  const handleFileSelect = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
-    const files = e.target.files;
-    if (files && files.length > 0) {
-      processFiles(files);
-    }
-    // Reset the input so the same file can be selected again
-    if (fileInputRef.current) {
-      fileInputRef.current.value = '';
-    }
-  }, [processFiles]);
-
-  const handleBrowseClick = useCallback(() => {
-    if (!disabled && fileInputRef.current) {
-      fileInputRef.current.click();
-    }
-  }, [disabled]);
-
-  const removeImage = useCallback((imageId: string) => {
-    const updated = selectedImages.filter(img => img.id !== imageId);
-    updateImages(updated);
-  }, [selectedImages, updateImages]);
-
-  const clearAllImages = useCallback(() => {
-    updateImages([]);
-  }, [updateImages]);
-
-  return (
-    <div className={cn("relative", className)}>
-      {/* Hidden file input */}
-      <input
-        ref={fileInputRef}
-        type="file"
-        multiple
-        accept={ACCEPTED_IMAGE_TYPES.join(',')}
-        onChange={handleFileSelect}
-        className="hidden"
-        disabled={disabled}
-      />
-
-      {/* Drop zone */}
-      <div
-        onDrop={handleDrop}
-        onDragOver={handleDragOver}
-        onDragLeave={handleDragLeave}
-        className={cn(
-          "relative rounded-lg border-2 border-dashed transition-all duration-200",
-          {
-            "border-blue-400 bg-blue-50 dark:bg-blue-950/20": isDragOver && !disabled,
-            "border-muted-foreground/25": !isDragOver && !disabled,
-            "border-muted-foreground/10 opacity-50 cursor-not-allowed": disabled,
-            "hover:border-blue-400 hover:bg-blue-50/50 dark:hover:bg-blue-950/10": !disabled && !isDragOver,
-          }
-        )}
-      >
-        {children || (
-          <div className="flex flex-col items-center justify-center p-6 text-center">
-            <div className={cn(
-              "rounded-full p-3 mb-4",
-              isDragOver && !disabled ? "bg-blue-100 dark:bg-blue-900/30" : "bg-muted"
-            )}>
-              {isProcessing ? (
-                <Upload className="h-6 w-6 animate-spin text-muted-foreground" />
-              ) : (
-                <ImageIcon className="h-6 w-6 text-muted-foreground" />
-              )}
-            </div>
-            <p className="text-sm font-medium text-foreground mb-1">
-              {isDragOver && !disabled ? "Drop your images here" : "Drag images here or click to browse"}
-            </p>
-            <p className="text-xs text-muted-foreground">
-              {maxFiles > 1 ? `Up to ${maxFiles} images` : "1 image"}, max {Math.round(maxFileSize / (1024 * 1024))}MB each
-            </p>
-            {!disabled && (
-              <button
-                onClick={handleBrowseClick}
-                className="mt-2 text-xs text-blue-600 hover:text-blue-700 dark:text-blue-400 dark:hover:text-blue-300"
-                disabled={isProcessing}
-              >
-                Browse files
-              </button>
-            )}
-          </div>
-        )}
-      </div>
-
-      {/* Image previews */}
-      {selectedImages.length > 0 && (
-        <div className="mt-3 space-y-2">
-          <div className="flex items-center justify-between">
-            <p className="text-xs font-medium text-foreground">
-              {selectedImages.length} image{selectedImages.length > 1 ? 's' : ''} selected
-            </p>
-            <button
-              onClick={clearAllImages}
-              className="text-xs text-muted-foreground hover:text-foreground"
-              disabled={disabled}
-            >
-              Clear all
-            </button>
-          </div>
-          <div className="flex flex-wrap gap-2">
-            {selectedImages.map((image) => (
-              <div
-                key={image.id}
-                className="relative group rounded-md border border-muted bg-muted/50 p-2 flex items-center space-x-2"
-              >
-                {/* Image thumbnail */}
-                <div className="w-8 h-8 rounded overflow-hidden bg-muted flex-shrink-0">
-                  <img
-                    src={image.data}
-                    alt={image.filename}
-                    className="w-full h-full object-cover"
-                  />
-                </div>
-                {/* Image info */}
-                <div className="min-w-0 flex-1">
-                  <p className="text-xs font-medium text-foreground truncate">
-                    {image.filename}
-                  </p>
-                  <p className="text-xs text-muted-foreground">
-                    {formatFileSize(image.size)}
-                  </p>
-                </div>
-                {/* Remove button */}
-                {!disabled && (
-                  <button
-                    onClick={() => removeImage(image.id)}
-                    className="opacity-0 group-hover:opacity-100 transition-opacity p-1 rounded-full hover:bg-destructive hover:text-destructive-foreground text-muted-foreground"
-                  >
-                    <X className="h-3 w-3" />
-                  </button>
-                )}
-              </div>
-            ))}
-          </div>
-        </div>
-      )}
-    </div>
-  );
-}
-
-function fileToBase64(file: File): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => {
-      if (typeof reader.result === 'string') {
-        resolve(reader.result);
-      } else {
-        reject(new Error('Failed to read file as base64'));
-      }
-    };
-    reader.onerror = () => reject(new Error('Failed to read file'));
-    reader.readAsDataURL(file);
-  });
-}
-
-function formatFileSize(bytes: number): string {
-  if (bytes === 0) return '0 B';
-  const k = 1024;
-  const sizes = ['B', 'KB', 'MB', 'GB'];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
-}

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

@@ -1,660 +0,0 @@
-"use client";
-
-import * as React from "react";
-import { useAppStore, DEFAULT_KEYBOARD_SHORTCUTS, parseShortcut, formatShortcut } 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 { Input } from "@/components/ui/input";
-import { Button } from "@/components/ui/button";
-import { CheckCircle2, X, RotateCcw, Edit2 } from "lucide-react";
-import { Checkbox } from "@/components/ui/checkbox";
-import { Label } from "@/components/ui/label";
-
-// Detect if running on Mac
-const isMac = typeof navigator !== 'undefined' && navigator.platform.toUpperCase().indexOf('MAC') >= 0;
-
-// Keyboard layout - US QWERTY
-const KEYBOARD_ROWS = [
-  // Number row
-  [
-    { key: "`", label: "`", width: 1 },
-    { key: "1", label: "1", width: 1 },
-    { key: "2", label: "2", width: 1 },
-    { key: "3", label: "3", width: 1 },
-    { key: "4", label: "4", width: 1 },
-    { key: "5", label: "5", width: 1 },
-    { key: "6", label: "6", width: 1 },
-    { key: "7", label: "7", width: 1 },
-    { key: "8", label: "8", width: 1 },
-    { key: "9", label: "9", width: 1 },
-    { key: "0", label: "0", width: 1 },
-    { key: "-", label: "-", width: 1 },
-    { key: "=", label: "=", width: 1 },
-  ],
-  // Top letter row
-  [
-    { key: "Q", label: "Q", width: 1 },
-    { key: "W", label: "W", width: 1 },
-    { key: "E", label: "E", width: 1 },
-    { key: "R", label: "R", width: 1 },
-    { key: "T", label: "T", width: 1 },
-    { key: "Y", label: "Y", width: 1 },
-    { key: "U", label: "U", width: 1 },
-    { key: "I", label: "I", width: 1 },
-    { key: "O", label: "O", width: 1 },
-    { key: "P", label: "P", width: 1 },
-    { key: "[", label: "[", width: 1 },
-    { key: "]", label: "]", width: 1 },
-    { key: "\\", label: "\\", width: 1 },
-  ],
-  // Home row
-  [
-    { key: "A", label: "A", width: 1 },
-    { key: "S", label: "S", width: 1 },
-    { key: "D", label: "D", width: 1 },
-    { key: "F", label: "F", width: 1 },
-    { key: "G", label: "G", width: 1 },
-    { key: "H", label: "H", width: 1 },
-    { key: "J", label: "J", width: 1 },
-    { key: "K", label: "K", width: 1 },
-    { key: "L", label: "L", width: 1 },
-    { key: ";", label: ";", width: 1 },
-    { key: "'", label: "'", width: 1 },
-  ],
-  // Bottom letter row
-  [
-    { key: "Z", label: "Z", width: 1 },
-    { key: "X", label: "X", width: 1 },
-    { key: "C", label: "C", width: 1 },
-    { key: "V", label: "V", width: 1 },
-    { key: "B", label: "B", width: 1 },
-    { key: "N", label: "N", width: 1 },
-    { key: "M", label: "M", width: 1 },
-    { key: ",", label: ",", width: 1 },
-    { key: ".", label: ".", width: 1 },
-    { key: "/", label: "/", width: 1 },
-  ],
-];
-
-// Map shortcut names to human-readable labels
-const SHORTCUT_LABELS: Record<keyof KeyboardShortcuts, string> = {
-  board: "Kanban Board",
-  agent: "Agent Runner",
-  spec: "Spec Editor",
-  context: "Context",
-  settings: "Settings",
-  profiles: "AI Profiles",
-  terminal: "Terminal",
-  toggleSidebar: "Toggle Sidebar",
-  addFeature: "Add Feature",
-  addContextFile: "Add Context File",
-  startNext: "Start Next",
-  newSession: "New Session",
-  openProject: "Open Project",
-  projectPicker: "Project Picker",
-  cyclePrevProject: "Prev Project",
-  cycleNextProject: "Next Project",
-  addProfile: "Add Profile",
-  splitTerminalRight: "Split Right",
-  splitTerminalDown: "Split Down",
-  closeTerminal: "Close Terminal",
-};
-
-// Categorize shortcuts for color coding
-const SHORTCUT_CATEGORIES: Record<keyof KeyboardShortcuts, "navigation" | "ui" | "action"> = {
-  board: "navigation",
-  agent: "navigation",
-  spec: "navigation",
-  context: "navigation",
-  settings: "navigation",
-  profiles: "navigation",
-  terminal: "navigation",
-  toggleSidebar: "ui",
-  addFeature: "action",
-  addContextFile: "action",
-  startNext: "action",
-  newSession: "action",
-  openProject: "action",
-  projectPicker: "action",
-  cyclePrevProject: "action",
-  cycleNextProject: "action",
-  addProfile: "action",
-  splitTerminalRight: "action",
-  splitTerminalDown: "action",
-  closeTerminal: "action",
-};
-
-// Category colors
-const CATEGORY_COLORS = {
-  navigation: {
-    bg: "bg-blue-500/20",
-    border: "border-blue-500/50",
-    text: "text-blue-400",
-    label: "Navigation",
-  },
-  ui: {
-    bg: "bg-purple-500/20",
-    border: "border-purple-500/50",
-    text: "text-purple-400",
-    label: "UI Controls",
-  },
-  action: {
-    bg: "bg-green-500/20",
-    border: "border-green-500/50",
-    text: "text-green-400",
-    label: "Actions",
-  },
-};
-
-interface KeyboardMapProps {
-  onKeySelect?: (key: string) => void;
-  selectedKey?: string | null;
-  className?: string;
-}
-
-export function KeyboardMap({ onKeySelect, selectedKey, className }: KeyboardMapProps) {
-  const { keyboardShortcuts } = useAppStore();
-
-  // Merge with defaults to ensure new shortcuts are always shown
-  const mergedShortcuts = React.useMemo(() => ({
-    ...DEFAULT_KEYBOARD_SHORTCUTS,
-    ...keyboardShortcuts,
-  }), [keyboardShortcuts]);
-
-  // Create a reverse map: base key -> list of shortcut names (including info about modifiers)
-  const keyToShortcuts = React.useMemo(() => {
-    const map: Record<string, Array<{ name: keyof KeyboardShortcuts; hasModifiers: boolean }>> = {};
-    (Object.entries(mergedShortcuts) as [keyof KeyboardShortcuts, string][]).forEach(
-      ([shortcutName, shortcutStr]) => {
-        if (!shortcutStr) return; // Skip undefined shortcuts
-        const parsed = parseShortcut(shortcutStr);
-        const normalizedKey = parsed.key.toUpperCase();
-        const hasModifiers = !!(parsed.shift || parsed.cmdCtrl || parsed.alt);
-        if (!map[normalizedKey]) {
-          map[normalizedKey] = [];
-        }
-        map[normalizedKey].push({ name: shortcutName, hasModifiers });
-      }
-    );
-    return map;
-  }, [mergedShortcuts]);
-
-  const renderKey = (keyDef: { key: string; label: string; width: number }) => {
-    const normalizedKey = keyDef.key.toUpperCase();
-    const shortcutInfos = keyToShortcuts[normalizedKey] || [];
-    const shortcuts = shortcutInfos.map(s => s.name);
-    const isBound = shortcuts.length > 0;
-    const isSelected = selectedKey?.toUpperCase() === normalizedKey;
-    const isModified = shortcuts.some(
-      (s) => mergedShortcuts[s] !== DEFAULT_KEYBOARD_SHORTCUTS[s]
-    );
-
-    // Get category for coloring (use first shortcut's category if multiple)
-    const category = shortcuts.length > 0 ? SHORTCUT_CATEGORIES[shortcuts[0]] : null;
-    const colors = category ? CATEGORY_COLORS[category] : null;
-
-    const keyElement = (
-      <button
-        key={keyDef.key}
-        onClick={() => onKeySelect?.(keyDef.key)}
-        className={cn(
-          "relative flex flex-col items-center justify-center rounded-lg border transition-all",
-          "h-12 min-w-11 py-1",
-          keyDef.width > 1 && `w-[${keyDef.width * 2.75}rem]`,
-          // Base styles
-          !isBound && "bg-sidebar-accent/10 border-sidebar-border hover:bg-sidebar-accent/20",
-          // Bound key styles
-          isBound && colors && `${colors.bg} ${colors.border} hover:brightness-110`,
-          // Selected state
-          isSelected && "ring-2 ring-brand-500 ring-offset-2 ring-offset-background",
-          // Modified indicator
-          isModified && "ring-1 ring-yellow-500/50"
-        )}
-        data-testid={`keyboard-key-${keyDef.key}`}
-      >
-        {/* Key label - always at top */}
-        <span
-          className={cn(
-            "text-sm font-mono font-bold leading-none",
-            isBound && colors ? colors.text : "text-muted-foreground"
-          )}
-        >
-          {keyDef.label}
-        </span>
-        {/* Shortcut label - always takes up space to maintain consistent height */}
-        <span
-          className={cn(
-            "text-[9px] leading-tight text-center px-0.5 truncate max-w-full h-3 mt-0.5",
-            isBound && shortcuts.length > 0
-              ? (colors ? colors.text : "text-muted-foreground")
-              : "opacity-0"
-          )}
-        >
-          {isBound && shortcuts.length > 0
-            ? (shortcuts.length === 1
-                ? (SHORTCUT_LABELS[shortcuts[0]]?.split(" ")[0] ?? shortcuts[0])
-                : `${shortcuts.length}x`)
-            : "\u00A0" // Non-breaking space to maintain height
-          }
-        </span>
-        {isModified && (
-          <span className="absolute -top-1 -right-1 w-2 h-2 rounded-full bg-yellow-500" />
-        )}
-      </button>
-    );
-
-    // Wrap in tooltip if bound
-    if (isBound) {
-      return (
-        <Tooltip key={keyDef.key}>
-          <TooltipTrigger asChild>{keyElement}</TooltipTrigger>
-          <TooltipContent side="top" className="max-w-xs">
-            <div className="space-y-1">
-              {shortcuts.map((shortcut) => {
-                const shortcutStr = mergedShortcuts[shortcut];
-                const displayShortcut = formatShortcut(shortcutStr, true);
-                return (
-                  <div key={shortcut} className="flex items-center gap-2">
-                    <span
-                      className={cn(
-                        "w-2 h-2 rounded-full",
-                        SHORTCUT_CATEGORIES[shortcut] && CATEGORY_COLORS[SHORTCUT_CATEGORIES[shortcut]]
-                          ? CATEGORY_COLORS[SHORTCUT_CATEGORIES[shortcut]].bg.replace("/20", "")
-                          : "bg-muted-foreground"
-                      )}
-                    />
-                    <span className="text-sm">{SHORTCUT_LABELS[shortcut] ?? shortcut}</span>
-                    <kbd className="text-xs font-mono bg-sidebar-accent/30 px-1 rounded">
-                      {displayShortcut}
-                    </kbd>
-                    {mergedShortcuts[shortcut] !== DEFAULT_KEYBOARD_SHORTCUTS[shortcut] && (
-                      <span className="text-xs text-yellow-400">(custom)</span>
-                    )}
-                  </div>
-                );
-              })}
-            </div>
-          </TooltipContent>
-        </Tooltip>
-      );
-    }
-
-    return keyElement;
-  };
-
-  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>
-        </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>
-      </div>
-    </TooltipProvider>
-  );
-}
-
-// Full shortcut reference panel with editing capability
-interface ShortcutReferencePanelProps {
-  editable?: boolean;
-}
-
-export function ShortcutReferencePanel({ editable = false }: ShortcutReferencePanelProps) {
-  const { keyboardShortcuts, setKeyboardShortcut, resetKeyboardShortcuts } = useAppStore();
-  const [editingShortcut, setEditingShortcut] = React.useState<keyof KeyboardShortcuts | null>(null);
-  const [keyValue, setKeyValue] = React.useState("");
-  const [modifiers, setModifiers] = React.useState({ shift: false, cmdCtrl: false, alt: false });
-  const [shortcutError, setShortcutError] = React.useState<string | null>(null);
-
-  // Merge with defaults to ensure new shortcuts are always shown
-  const mergedShortcuts = React.useMemo(() => ({
-    ...DEFAULT_KEYBOARD_SHORTCUTS,
-    ...keyboardShortcuts,
-  }), [keyboardShortcuts]);
-
-  const groupedShortcuts = React.useMemo(() => {
-    const groups: Record<string, Array<{ key: keyof KeyboardShortcuts; label: string; value: string }>> = {
-      navigation: [],
-      ui: [],
-      action: [],
-    };
-
-    (Object.entries(SHORTCUT_CATEGORIES) as [keyof KeyboardShortcuts, string][]).forEach(
-      ([shortcut, category]) => {
-        groups[category].push({
-          key: shortcut,
-          label: SHORTCUT_LABELS[shortcut] ?? shortcut,
-          value: mergedShortcuts[shortcut],
-        });
-      }
-    );
-
-    return groups;
-  }, [mergedShortcuts]);
-
-  // Build the full shortcut string from key + modifiers
-  const buildShortcutString = React.useCallback((key: string, mods: typeof modifiers) => {
-    const parts: string[] = [];
-    if (mods.cmdCtrl) parts.push(isMac ? "Cmd" : "Ctrl");
-    if (mods.alt) parts.push(isMac ? "Opt" : "Alt");
-    if (mods.shift) parts.push("Shift");
-    parts.push(key.toUpperCase());
-    return parts.join("+");
-  }, []);
-
-  // Check for conflicts with other shortcuts
-  const checkConflict = React.useCallback((shortcutStr: string, currentKey: keyof KeyboardShortcuts) => {
-    const conflict = Object.entries(mergedShortcuts).find(
-      ([k, v]) => k !== currentKey && v?.toUpperCase() === shortcutStr.toUpperCase()
-    );
-    return conflict ? (SHORTCUT_LABELS[conflict[0] as keyof KeyboardShortcuts] ?? conflict[0]) : null;
-  }, [mergedShortcuts]);
-
-  const handleStartEdit = (key: keyof KeyboardShortcuts) => {
-    const currentValue = mergedShortcuts[key];
-    const parsed = parseShortcut(currentValue);
-    setEditingShortcut(key);
-    setKeyValue(parsed.key);
-    setModifiers({
-      shift: parsed.shift || false,
-      cmdCtrl: parsed.cmdCtrl || false,
-      alt: parsed.alt || false,
-    });
-    setShortcutError(null);
-  };
-
-  const handleSaveShortcut = () => {
-    if (!editingShortcut || shortcutError || !keyValue) return;
-    const shortcutStr = buildShortcutString(keyValue, modifiers);
-    setKeyboardShortcut(editingShortcut, shortcutStr);
-    setEditingShortcut(null);
-    setKeyValue("");
-    setModifiers({ shift: false, cmdCtrl: false, alt: false });
-    setShortcutError(null);
-  };
-
-  const handleCancelEdit = () => {
-    setEditingShortcut(null);
-    setKeyValue("");
-    setModifiers({ shift: false, cmdCtrl: false, alt: false });
-    setShortcutError(null);
-  };
-
-  const handleKeyChange = (value: string, currentKey: keyof KeyboardShortcuts) => {
-    setKeyValue(value);
-    // Check for conflicts with full shortcut string
-    if (!value) {
-      setShortcutError("Key cannot be empty");
-    } else {
-      const shortcutStr = buildShortcutString(value, modifiers);
-      const conflictLabel = checkConflict(shortcutStr, currentKey);
-      if (conflictLabel) {
-        setShortcutError(`Already used by "${conflictLabel}"`);
-      } else {
-        setShortcutError(null);
-      }
-    }
-  };
-
-  const handleModifierChange = (modifier: keyof typeof modifiers, checked: boolean, currentKey: keyof KeyboardShortcuts) => {
-    // Enforce single modifier: when checking, uncheck all others (radio-button behavior)
-    const newModifiers = checked
-      ? { shift: false, cmdCtrl: false, alt: false, [modifier]: true }
-      : { ...modifiers, [modifier]: false };
-
-    setModifiers(newModifiers);
-
-    // Recheck for conflicts
-    if (keyValue) {
-      const shortcutStr = buildShortcutString(keyValue, newModifiers);
-      const conflictLabel = checkConflict(shortcutStr, currentKey);
-      if (conflictLabel) {
-        setShortcutError(`Already used by "${conflictLabel}"`);
-      } else {
-        setShortcutError(null);
-      }
-    }
-  };
-
-  const handleKeyDown = (e: React.KeyboardEvent) => {
-    if (e.key === "Enter" && !shortcutError && keyValue) {
-      handleSaveShortcut();
-    } else if (e.key === "Escape") {
-      handleCancelEdit();
-    }
-  };
-
-  const handleResetShortcut = (key: keyof KeyboardShortcuts) => {
-    setKeyboardShortcut(key, DEFAULT_KEYBOARD_SHORTCUTS[key]);
-  };
-
-  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;
-
-                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>
-                          </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>
-                          )}
-                          {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>
-                );
-              })}
-            </div>
-            {editingShortcut && shortcutError && SHORTCUT_CATEGORIES[editingShortcut] === category && (
-              <p className="text-xs text-red-400 mt-1">{shortcutError}</p>
-            )}
-          </div>
-        );
-      })}
-    </div>
-    </TooltipProvider>
-  );
-}

apps/app/src/components/ui/label.tsx

@@ -1,24 +0,0 @@
-"use client"
-
-import * as React from "react"
-import * as LabelPrimitive from "@radix-ui/react-label"
-
-import { cn } from "@/lib/utils"
-
-function Label({
-  className,
-  ...props
-}: React.ComponentProps<typeof LabelPrimitive.Root>) {
-  return (
-    <LabelPrimitive.Root
-      data-slot="label"
-      className={cn(
-        "flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export { Label }

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

@@ -1,284 +0,0 @@
-"use client";
-
-import { useState, useMemo } from "react";
-import {
-  ChevronDown,
-  ChevronRight,
-  MessageSquare,
-  Wrench,
-  Zap,
-  AlertCircle,
-  CheckCircle2,
-  AlertTriangle,
-  Bug,
-  Info,
-  FileOutput,
-  Brain,
-} from "lucide-react";
-import { cn } from "@/lib/utils";
-import {
-  parseLogOutput,
-  getLogTypeColors,
-  type LogEntry,
-  type LogEntryType,
-} from "@/lib/log-parser";
-
-interface LogViewerProps {
-  output: string;
-  className?: string;
-}
-
-const getLogIcon = (type: LogEntryType) => {
-  switch (type) {
-    case "prompt":
-      return <MessageSquare className="w-4 h-4" />;
-    case "tool_call":
-      return <Wrench className="w-4 h-4" />;
-    case "tool_result":
-      return <FileOutput className="w-4 h-4" />;
-    case "phase":
-      return <Zap className="w-4 h-4" />;
-    case "error":
-      return <AlertCircle className="w-4 h-4" />;
-    case "success":
-      return <CheckCircle2 className="w-4 h-4" />;
-    case "warning":
-      return <AlertTriangle className="w-4 h-4" />;
-    case "thinking":
-      return <Brain className="w-4 h-4" />;
-    case "debug":
-      return <Bug className="w-4 h-4" />;
-    default:
-      return <Info className="w-4 h-4" />;
-  }
-};
-
-interface LogEntryItemProps {
-  entry: LogEntry;
-  isExpanded: boolean;
-  onToggle: () => void;
-}
-
-function LogEntryItem({ entry, isExpanded, onToggle }: LogEntryItemProps) {
-  const colors = getLogTypeColors(entry.type);
-  const hasContent = entry.content.length > 100;
-
-  // Format content - detect and highlight JSON
-  const formattedContent = useMemo(() => {
-    const content = entry.content;
-
-    // Try to find and format JSON blocks
-    const jsonRegex = /(\{[\s\S]*?\}|\[[\s\S]*?\])/g;
-    let lastIndex = 0;
-    const parts: { type: "text" | "json"; content: string }[] = [];
-
-    let match;
-    while ((match = jsonRegex.exec(content)) !== null) {
-      // Add text before JSON
-      if (match.index > lastIndex) {
-        parts.push({
-          type: "text",
-          content: content.slice(lastIndex, match.index),
-        });
-      }
-
-      // Try to parse and format JSON
-      try {
-        const parsed = JSON.parse(match[1]);
-        parts.push({
-          type: "json",
-          content: JSON.stringify(parsed, null, 2),
-        });
-      } catch {
-        // Not valid JSON, treat as text
-        parts.push({ type: "text", content: match[1] });
-      }
-
-      lastIndex = match.index + match[1].length;
-    }
-
-    // Add remaining text
-    if (lastIndex < content.length) {
-      parts.push({ type: "text", content: content.slice(lastIndex) });
-    }
-
-    return parts.length > 0 ? parts : [{ type: "text" as const, content }];
-  }, [entry.content]);
-
-  return (
-    <div
-      className={cn(
-        "rounded-lg border-l-4 transition-all duration-200",
-        colors.bg,
-        colors.border,
-        "hover:brightness-110"
-      )}
-      data-testid={`log-entry-${entry.type}`}
-    >
-      <button
-        onClick={onToggle}
-        className="w-full px-3 py-2 flex items-center gap-2 text-left"
-        data-testid={`log-entry-toggle-${entry.id}`}
-      >
-        {hasContent ? (
-          isExpanded ? (
-            <ChevronDown className="w-4 h-4 text-zinc-400 flex-shrink-0" />
-          ) : (
-            <ChevronRight className="w-4 h-4 text-zinc-400 flex-shrink-0" />
-          )
-        ) : (
-          <span className="w-4 flex-shrink-0" />
-        )}
-
-        <span className={cn("flex-shrink-0", colors.icon)}>
-          {getLogIcon(entry.type)}
-        </span>
-
-        <span
-          className={cn(
-            "text-xs font-medium px-2 py-0.5 rounded-full flex-shrink-0",
-            colors.badge
-          )}
-          data-testid="log-entry-badge"
-        >
-          {entry.title}
-        </span>
-
-        <span className="text-xs text-zinc-400 truncate flex-1 ml-2">
-          {!isExpanded &&
-            entry.content.slice(0, 80) +
-              (entry.content.length > 80 ? "..." : "")}
-        </span>
-      </button>
-
-      {(isExpanded || !hasContent) && (
-        <div
-          className="px-4 pb-3 pt-1"
-          data-testid={`log-entry-content-${entry.id}`}
-        >
-          <div className="font-mono text-xs space-y-1">
-            {formattedContent.map((part, index) => (
-              <div key={index}>
-                {part.type === "json" ? (
-                  <pre className="bg-zinc-900/50 rounded p-2 overflow-x-auto text-xs text-primary">
-                    {part.content}
-                  </pre>
-                ) : (
-                  <pre
-                    className={cn(
-                      "whitespace-pre-wrap break-words",
-                      colors.text
-                    )}
-                  >
-                    {part.content}
-                  </pre>
-                )}
-              </div>
-            ))}
-          </div>
-        </div>
-      )}
-    </div>
-  );
-}
-
-export function LogViewer({ output, className }: LogViewerProps) {
-  const [expandedIds, setExpandedIds] = useState<Set<string>>(new Set());
-
-  const entries = useMemo(() => parseLogOutput(output), [output]);
-
-  const toggleEntry = (id: string) => {
-    setExpandedIds((prev) => {
-      const next = new Set(prev);
-      if (next.has(id)) {
-        next.delete(id);
-      } else {
-        next.add(id);
-      }
-      return next;
-    });
-  };
-
-  const expandAll = () => {
-    setExpandedIds(new Set(entries.map((e) => e.id)));
-  };
-
-  const collapseAll = () => {
-    setExpandedIds(new Set());
-  };
-
-  if (entries.length === 0) {
-    return (
-      <div className="flex items-center justify-center p-8 text-muted-foreground">
-        <div className="text-center">
-          <Info className="w-8 h-8 mx-auto mb-2 opacity-50" />
-          <p className="text-sm">No log entries yet. Logs will appear here as the process runs.</p>
-          {output && output.trim() && (
-            <div className="mt-4 p-3 bg-zinc-900/50 rounded text-xs font-mono text-left max-h-40 overflow-auto">
-              <pre className="whitespace-pre-wrap">{output}</pre>
-            </div>
-          )}
-        </div>
-      </div>
-    );
-  }
-
-  // Count entries by type
-  const typeCounts = entries.reduce((acc, entry) => {
-    acc[entry.type] = (acc[entry.type] || 0) + 1;
-    return acc;
-  }, {} as Record<string, number>);
-
-  return (
-    <div className={cn("flex flex-col gap-2", className)}>
-      {/* Header with controls */}
-      <div className="flex items-center justify-between px-1" data-testid="log-viewer-header">
-        <div className="flex items-center gap-2 flex-wrap">
-          {Object.entries(typeCounts).map(([type, count]) => {
-            const colors = getLogTypeColors(type as LogEntryType);
-            return (
-              <span
-                key={type}
-                className={cn(
-                  "text-xs px-2 py-0.5 rounded-full",
-                  colors.badge
-                )}
-                data-testid={`log-type-count-${type}`}
-              >
-                {type}: {count}
-              </span>
-            );
-          })}
-        </div>
-        <div className="flex items-center gap-1">
-          <button
-            onClick={expandAll}
-            className="text-xs text-zinc-400 hover:text-zinc-200 px-2 py-1 rounded hover:bg-zinc-800/50 transition-colors"
-            data-testid="log-expand-all"
-          >
-            Expand All
-          </button>
-          <button
-            onClick={collapseAll}
-            className="text-xs text-zinc-400 hover:text-zinc-200 px-2 py-1 rounded hover:bg-zinc-800/50 transition-colors"
-            data-testid="log-collapse-all"
-          >
-            Collapse All
-          </button>
-        </div>
-      </div>
-
-      {/* Log entries */}
-      <div className="space-y-2" data-testid="log-entries-container">
-        {entries.map((entry) => (
-          <LogEntryItem
-            key={entry.id}
-            entry={entry}
-            isExpanded={expandedIds.has(entry.id)}
-            onToggle={() => toggleEntry(entry.id)}
-          />
-        ))}
-      </div>
-    </div>
-  );
-}

apps/app/src/components/ui/markdown.tsx

@@ -1,48 +0,0 @@
-"use client";
-
-import ReactMarkdown from "react-markdown";
-import { cn } from "@/lib/utils";
-
-interface MarkdownProps {
-  children: string;
-  className?: string;
-}
-
-/**
- * Reusable Markdown component for rendering markdown content
- * Theme-aware styling that adapts to all predefined themes
- */
-export function Markdown({ children, className }: MarkdownProps) {
-  return (
-    <div
-      className={cn(
-        "prose prose-sm prose-invert max-w-none",
-        // Headings
-        "[&_h1]:text-xl [&_h1]:text-foreground [&_h1]:font-semibold [&_h1]:mt-4 [&_h1]:mb-2",
-        "[&_h2]:text-lg [&_h2]:text-foreground [&_h2]:font-semibold [&_h2]:mt-4 [&_h2]:mb-2",
-        "[&_h3]:text-base [&_h3]:text-foreground [&_h3]:font-semibold [&_h3]:mt-3 [&_h3]:mb-2",
-        "[&_h4]:text-sm [&_h4]:text-foreground [&_h4]:font-semibold [&_h4]:mt-2 [&_h4]:mb-1",
-        // Paragraphs
-        "[&_p]:text-foreground-secondary [&_p]:leading-relaxed [&_p]:my-2",
-        // Lists
-        "[&_ul]:my-2 [&_ul]:pl-4 [&_ol]:my-2 [&_ol]:pl-4",
-        "[&_li]:text-foreground-secondary [&_li]:my-0.5",
-        // Code
-        "[&_code]:text-chart-2 [&_code]:bg-muted [&_code]:px-1.5 [&_code]:py-0.5 [&_code]:rounded [&_code]:text-sm",
-        "[&_pre]:bg-card [&_pre]:border [&_pre]:border-border [&_pre]:rounded-lg [&_pre]:my-2 [&_pre]:p-3 [&_pre]:overflow-x-auto",
-        "[&_pre_code]:bg-transparent [&_pre_code]:p-0",
-        // Strong/Bold
-        "[&_strong]:text-foreground [&_strong]:font-semibold",
-        // Links
-        "[&_a]:text-brand-500 [&_a]:no-underline hover:[&_a]:underline",
-        // Blockquotes
-        "[&_blockquote]:border-l-2 [&_blockquote]:border-border [&_blockquote]:pl-4 [&_blockquote]:text-muted-foreground [&_blockquote]:italic [&_blockquote]:my-2",
-        // Horizontal rules
-        "[&_hr]:border-border [&_hr]:my-4",
-        className
-      )}
-    >
-      <ReactMarkdown>{children}</ReactMarkdown>
-    </div>
-  );
-}

apps/app/src/components/ui/popover.tsx

@@ -1,48 +0,0 @@
-"use client"
-
-import * as React from "react"
-import * as PopoverPrimitive from "@radix-ui/react-popover"
-
-import { cn } from "@/lib/utils"
-
-function Popover({
-  ...props
-}: React.ComponentProps<typeof PopoverPrimitive.Root>) {
-  return <PopoverPrimitive.Root data-slot="popover" {...props} />
-}
-
-function PopoverTrigger({
-  ...props
-}: React.ComponentProps<typeof PopoverPrimitive.Trigger>) {
-  return <PopoverPrimitive.Trigger data-slot="popover-trigger" {...props} />
-}
-
-function PopoverContent({
-  className,
-  align = "center",
-  sideOffset = 4,
-  ...props
-}: React.ComponentProps<typeof PopoverPrimitive.Content>) {
-  return (
-    <PopoverPrimitive.Portal>
-      <PopoverPrimitive.Content
-        data-slot="popover-content"
-        align={align}
-        sideOffset={sideOffset}
-        className={cn(
-          "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-72 origin-(--radix-popover-content-transform-origin) rounded-md border p-4 shadow-md outline-hidden",
-          className
-        )}
-        {...props}
-      />
-    </PopoverPrimitive.Portal>
-  )
-}
-
-function PopoverAnchor({
-  ...props
-}: React.ComponentProps<typeof PopoverPrimitive.Anchor>) {
-  return <PopoverPrimitive.Anchor data-slot="popover-anchor" {...props} />
-}
-
-export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor }

apps/app/src/components/ui/slider.tsx

@@ -1,41 +0,0 @@
-"use client";
-
-import * as React from "react";
-import * as SliderPrimitive from "@radix-ui/react-slider";
-import { cn } from "@/lib/utils";
-
-interface SliderProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "defaultValue" | "dir"> {
-  value?: number[];
-  defaultValue?: number[];
-  onValueChange?: (value: number[]) => void;
-  onValueCommit?: (value: number[]) => void;
-  min?: number;
-  max?: number;
-  step?: number;
-  disabled?: boolean;
-  orientation?: "horizontal" | "vertical";
-  dir?: "ltr" | "rtl";
-  inverted?: boolean;
-  minStepsBetweenThumbs?: number;
-}
-
-const Slider = React.forwardRef<HTMLSpanElement, SliderProps>(
-  ({ className, ...props }, ref) => (
-    <SliderPrimitive.Root
-      ref={ref}
-      className={cn(
-        "relative flex w-full touch-none select-none items-center",
-        className
-      )}
-      {...props}
-    >
-      <SliderPrimitive.Track className="slider-track relative h-1.5 w-full grow overflow-hidden rounded-full bg-muted cursor-pointer">
-        <SliderPrimitive.Range className="slider-range absolute h-full bg-primary" />
-      </SliderPrimitive.Track>
-      <SliderPrimitive.Thumb className="slider-thumb block h-4 w-4 rounded-full border border-border bg-card shadow transition-colors cursor-grab active:cursor-grabbing focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50 disabled:cursor-not-allowed hover:bg-accent" />
-    </SliderPrimitive.Root>
-  )
-);
-Slider.displayName = SliderPrimitive.Root.displayName;
-
-export { Slider };

apps/app/src/components/ui/tabs.tsx

@@ -1,71 +0,0 @@
-"use client"
-
-import * as React from "react"
-import * as TabsPrimitive from "@radix-ui/react-tabs"
-
-import { cn } from "@/lib/utils"
-
-function Tabs({
-  className,
-  ...props
-}: React.ComponentProps<typeof TabsPrimitive.Root>) {
-  return (
-    <TabsPrimitive.Root
-      data-slot="tabs"
-      className={cn("flex flex-col gap-2", className)}
-      {...props}
-    />
-  )
-}
-
-function TabsList({
-  className,
-  ...props
-}: React.ComponentProps<typeof TabsPrimitive.List>) {
-  return (
-    <TabsPrimitive.List
-      data-slot="tabs-list"
-      className={cn(
-        "bg-muted text-muted-foreground inline-flex h-9 w-fit items-center justify-center rounded-lg p-[3px] border border-border",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function TabsTrigger({
-  className,
-  ...props
-}: React.ComponentProps<typeof TabsPrimitive.Trigger>) {
-  return (
-    <TabsPrimitive.Trigger
-      data-slot="tabs-trigger"
-      className={cn(
-        "inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center gap-1.5 rounded-md border border-transparent px-2 py-1 text-sm font-medium whitespace-nowrap transition-all duration-200 cursor-pointer",
-        "text-foreground/70 hover:text-foreground hover:bg-accent",
-        "data-[state=active]:bg-primary data-[state=active]:text-primary-foreground data-[state=active]:shadow-md data-[state=active]:border-primary/50",
-        "focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:outline-ring focus-visible:ring-[3px] focus-visible:outline-1",
-        "disabled:pointer-events-none disabled:opacity-50 disabled:cursor-not-allowed",
-        "[&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function TabsContent({
-  className,
-  ...props
-}: React.ComponentProps<typeof TabsPrimitive.Content>) {
-  return (
-    <TabsPrimitive.Content
-      data-slot="tabs-content"
-      className={cn("flex-1 outline-none", className)}
-      {...props}
-    />
-  )
-}
-
-export { Tabs, TabsList, TabsTrigger, TabsContent }

apps/app/src/components/ui/tooltip.tsx

@@ -1,42 +0,0 @@
-"use client"
-
-import * as React from "react"
-import * as TooltipPrimitive from "@radix-ui/react-tooltip"
-
-import { cn } from "@/lib/utils"
-
-const TooltipProvider = TooltipPrimitive.Provider
-
-const Tooltip = TooltipPrimitive.Root
-
-const TooltipTrigger = TooltipPrimitive.Trigger
-
-const TooltipContent = React.forwardRef<
-  React.ElementRef<typeof TooltipPrimitive.Content>,
-  React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>
->(({ className, sideOffset = 6, ...props }, ref) => (
-  <TooltipPrimitive.Portal>
-    <TooltipPrimitive.Content
-      ref={ref}
-      sideOffset={sideOffset}
-      className={cn(
-        "z-50 overflow-hidden rounded-lg border border-border bg-popover px-3 py-1.5 text-xs font-medium text-popover-foreground",
-        // Premium shadow
-        "shadow-lg shadow-black/10",
-        // Faster, snappier animations
-        "animate-in fade-in-0 zoom-in-95 duration-150",
-        "data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=closed]:duration-100",
-        // Slide from edge
-        "data-[side=bottom]:slide-in-from-top-1",
-        "data-[side=left]:slide-in-from-right-1",
-        "data-[side=right]:slide-in-from-left-1",
-        "data-[side=top]:slide-in-from-bottom-1",
-        className
-      )}
-      {...props}
-    />
-  </TooltipPrimitive.Portal>
-))
-TooltipContent.displayName = TooltipPrimitive.Content.displayName
-
-export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider }

apps/app/src/components/ui/xml-syntax-editor.tsx

@@ -1,120 +0,0 @@
-"use client";
-
-import CodeMirror from "@uiw/react-codemirror";
-import { xml } from "@codemirror/lang-xml";
-import { EditorView } from "@codemirror/view";
-import { Extension } from "@codemirror/state";
-import { HighlightStyle, syntaxHighlighting } from "@codemirror/language";
-import { tags as t } from "@lezer/highlight";
-import { cn } from "@/lib/utils";
-
-interface XmlSyntaxEditorProps {
-  value: string;
-  onChange: (value: string) => void;
-  placeholder?: string;
-  className?: string;
-  "data-testid"?: string;
-}
-
-// Syntax highlighting that uses CSS variables from the app's theme system
-// This automatically adapts to any theme (dark, light, dracula, nord, etc.)
-const syntaxColors = HighlightStyle.define([
-  // XML tags - use primary color
-  { tag: t.tagName, color: "var(--primary)" },
-  { tag: t.angleBracket, color: "var(--muted-foreground)" },
-
-  // Attributes
-  { tag: t.attributeName, color: "var(--chart-2, oklch(0.6 0.118 184.704))" },
-  { tag: t.attributeValue, color: "var(--chart-1, oklch(0.646 0.222 41.116))" },
-
-  // Strings and content
-  { tag: t.string, color: "var(--chart-1, oklch(0.646 0.222 41.116))" },
-  { tag: t.content, color: "var(--foreground)" },
-
-  // Comments
-  { tag: t.comment, color: "var(--muted-foreground)", fontStyle: "italic" },
-
-  // Special
-  { tag: t.processingInstruction, color: "var(--muted-foreground)" },
-  { tag: t.documentMeta, color: "var(--muted-foreground)" },
-]);
-
-// Editor theme using CSS variables
-const editorTheme = EditorView.theme({
-  "&": {
-    height: "100%",
-    fontSize: "0.875rem",
-    fontFamily: "ui-monospace, monospace",
-    backgroundColor: "transparent",
-    color: "var(--foreground)",
-  },
-  ".cm-scroller": {
-    overflow: "auto",
-    fontFamily: "ui-monospace, monospace",
-  },
-  ".cm-content": {
-    padding: "1rem",
-    minHeight: "100%",
-    caretColor: "var(--primary)",
-  },
-  ".cm-cursor, .cm-dropCursor": {
-    borderLeftColor: "var(--primary)",
-  },
-  "&.cm-focused .cm-selectionBackground, .cm-selectionBackground, .cm-content ::selection":
-    {
-      backgroundColor: "oklch(0.55 0.25 265 / 0.3)",
-    },
-  ".cm-activeLine": {
-    backgroundColor: "transparent",
-  },
-  ".cm-line": {
-    padding: "0",
-  },
-  "&.cm-focused": {
-    outline: "none",
-  },
-  ".cm-gutters": {
-    display: "none",
-  },
-  ".cm-placeholder": {
-    color: "var(--muted-foreground)",
-    fontStyle: "italic",
-  },
-});
-
-// Combine all extensions
-const extensions: Extension[] = [
-  xml(),
-  syntaxHighlighting(syntaxColors),
-  editorTheme,
-];
-
-export function XmlSyntaxEditor({
-  value,
-  onChange,
-  placeholder,
-  className,
-  "data-testid": testId,
-}: XmlSyntaxEditorProps) {
-  return (
-    <div className={cn("w-full h-full", className)} data-testid={testId}>
-      <CodeMirror
-        value={value}
-        onChange={onChange}
-        extensions={extensions}
-        theme="none"
-        placeholder={placeholder}
-        className="h-full [&_.cm-editor]:h-full"
-        basicSetup={{
-          lineNumbers: false,
-          foldGutter: false,
-          highlightActiveLine: false,
-          highlightSelectionMatches: true,
-          autocompletion: true,
-          bracketMatching: true,
-          indentOnInput: true,
-        }}
-      />
-    </div>
-  );
-}

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

@@ -1,735 +0,0 @@
-"use client";
-
-import { useEffect, useState, useCallback, useMemo } from "react";
-import { useAppStore } from "@/store/app-store";
-import { getElectronAPI } from "@/lib/electron";
-import { Button } from "@/components/ui/button";
-import { HotkeyButton } from "@/components/ui/hotkey-button";
-import { Card } from "@/components/ui/card";
-import {
-  Plus,
-  RefreshCw,
-  FileText,
-  Image as ImageIcon,
-  Trash2,
-  Save,
-  Upload,
-  File,
-  X,
-  BookOpen,
-  EditIcon,
-  Eye,
-} from "lucide-react";
-import {
-  useKeyboardShortcuts,
-  useKeyboardShortcutsConfig,
-  KeyboardShortcut,
-} from "@/hooks/use-keyboard-shortcuts";
-import {
-  Dialog,
-  DialogContent,
-  DialogHeader,
-  DialogTitle,
-  DialogDescription,
-  DialogFooter,
-} from "@/components/ui/dialog";
-import { Input } from "@/components/ui/input";
-import { Label } from "@/components/ui/label";
-import { cn } from "@/lib/utils";
-import { Markdown } from "../ui/markdown";
-
-interface ContextFile {
-  name: string;
-  type: "text" | "image";
-  content?: string;
-  path: string;
-}
-
-export function ContextView() {
-  const { currentProject } = useAppStore();
-  const shortcuts = useKeyboardShortcutsConfig();
-  const [contextFiles, setContextFiles] = useState<ContextFile[]>([]);
-  const [selectedFile, setSelectedFile] = useState<ContextFile | null>(null);
-  const [isLoading, setIsLoading] = useState(true);
-  const [isSaving, setIsSaving] = useState(false);
-  const [hasChanges, setHasChanges] = useState(false);
-  const [editedContent, setEditedContent] = useState("");
-  const [isAddDialogOpen, setIsAddDialogOpen] = useState(false);
-  const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false);
-  const [newFileName, setNewFileName] = useState("");
-  const [newFileType, setNewFileType] = useState<"text" | "image">("text");
-  const [uploadedImageData, setUploadedImageData] = useState<string | null>(
-    null
-  );
-  const [newFileContent, setNewFileContent] = useState("");
-  const [isDropHovering, setIsDropHovering] = useState(false);
-  const [isPreviewMode, setIsPreviewMode] = useState(false);
-
-  // Keyboard shortcuts for this view
-  const contextShortcuts: KeyboardShortcut[] = useMemo(
-    () => [
-      {
-        key: shortcuts.addContextFile,
-        action: () => setIsAddDialogOpen(true),
-        description: "Add new context file",
-      },
-    ],
-    [shortcuts]
-  );
-  useKeyboardShortcuts(contextShortcuts);
-
-  // Get context directory path for user-added context files
-  const getContextPath = useCallback(() => {
-    if (!currentProject) return null;
-    return `${currentProject.path}/.automaker/context`;
-  }, [currentProject]);
-
-  const isMarkdownFile = (filename: string): boolean => {
-    const ext = filename.toLowerCase().substring(filename.lastIndexOf("."));
-    return ext === ".md" || ext === ".markdown";
-  };
-
-  // Determine if a file is an image based on extension
-  const isImageFile = (filename: string): boolean => {
-    const imageExtensions = [
-      ".png",
-      ".jpg",
-      ".jpeg",
-      ".gif",
-      ".webp",
-      ".svg",
-      ".bmp",
-    ];
-    const ext = filename.toLowerCase().substring(filename.lastIndexOf("."));
-    return imageExtensions.includes(ext);
-  };
-
-  // Load context files
-  const loadContextFiles = useCallback(async () => {
-    const contextPath = getContextPath();
-    if (!contextPath) return;
-
-    setIsLoading(true);
-    try {
-      const api = getElectronAPI();
-
-      // Ensure context directory exists
-      await api.mkdir(contextPath);
-
-      // Read directory contents
-      const result = await api.readdir(contextPath);
-      if (result.success && result.entries) {
-        const files: ContextFile[] = result.entries
-          .filter((entry) => entry.isFile)
-          .map((entry) => ({
-            name: entry.name,
-            type: isImageFile(entry.name) ? "image" : "text",
-            path: `${contextPath}/${entry.name}`,
-          }));
-        setContextFiles(files);
-      }
-    } catch (error) {
-      console.error("Failed to load context files:", error);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [getContextPath]);
-
-  useEffect(() => {
-    loadContextFiles();
-  }, [loadContextFiles]);
-
-  // Load selected file content
-  const loadFileContent = useCallback(async (file: ContextFile) => {
-    try {
-      const api = getElectronAPI();
-      const result = await api.readFile(file.path);
-      if (result.success && result.content !== undefined) {
-        setEditedContent(result.content);
-        setSelectedFile({ ...file, content: result.content });
-        setHasChanges(false);
-      }
-    } catch (error) {
-      console.error("Failed to load file content:", error);
-    }
-  }, []);
-
-  // Select a file
-  const handleSelectFile = (file: ContextFile) => {
-    if (hasChanges) {
-      // Could add a confirmation dialog here
-    }
-    loadFileContent(file);
-    setIsPreviewMode(isMarkdownFile(file.name));
-  };
-
-  // Save current file
-  const saveFile = async () => {
-    if (!selectedFile) return;
-
-    setIsSaving(true);
-    try {
-      const api = getElectronAPI();
-      await api.writeFile(selectedFile.path, editedContent);
-      setSelectedFile({ ...selectedFile, content: editedContent });
-      setHasChanges(false);
-    } catch (error) {
-      console.error("Failed to save file:", error);
-    } finally {
-      setIsSaving(false);
-    }
-  };
-
-  // Handle content change
-  const handleContentChange = (value: string) => {
-    setEditedContent(value);
-    setHasChanges(true);
-  };
-
-  // Add new context file
-  const handleAddFile = async () => {
-    const contextPath = getContextPath();
-    if (!contextPath || !newFileName.trim()) return;
-
-    try {
-      const api = getElectronAPI();
-      let filename = newFileName.trim();
-
-      // Add default extension if not provided
-      if (newFileType === "text" && !filename.includes(".")) {
-        filename += ".md";
-      }
-
-      const filePath = `${contextPath}/${filename}`;
-
-      if (newFileType === "image" && uploadedImageData) {
-        // Write image data
-        await api.writeFile(filePath, uploadedImageData);
-      } else {
-        // Write text file with content (or empty if no content)
-        await api.writeFile(filePath, newFileContent);
-      }
-
-      setIsAddDialogOpen(false);
-      setNewFileName("");
-      setNewFileType("text");
-      setUploadedImageData(null);
-      setNewFileContent("");
-      setIsDropHovering(false);
-      await loadContextFiles();
-    } catch (error) {
-      console.error("Failed to add file:", error);
-    }
-  };
-
-  // Delete selected file
-  const handleDeleteFile = async () => {
-    if (!selectedFile) return;
-
-    try {
-      const api = getElectronAPI();
-      await api.deleteFile(selectedFile.path);
-
-      setIsDeleteDialogOpen(false);
-      setSelectedFile(null);
-      setEditedContent("");
-      setHasChanges(false);
-      await loadContextFiles();
-    } catch (error) {
-      console.error("Failed to delete file:", error);
-    }
-  };
-
-  // Handle image upload
-  const handleImageUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
-    const file = e.target.files?.[0];
-    if (!file) return;
-
-    const reader = new FileReader();
-    reader.onload = (event) => {
-      const base64 = event.target?.result as string;
-      setUploadedImageData(base64);
-      if (!newFileName) {
-        setNewFileName(file.name);
-      }
-    };
-    reader.readAsDataURL(file);
-  };
-
-  // Handle drag and drop for file upload
-  const handleDrop = async (e: React.DragEvent<HTMLDivElement>) => {
-    e.preventDefault();
-    e.stopPropagation();
-
-    const files = Array.from(e.dataTransfer.files);
-    if (files.length === 0) return;
-
-    const contextPath = getContextPath();
-    if (!contextPath) return;
-
-    const api = getElectronAPI();
-
-    for (const file of files) {
-      const reader = new FileReader();
-      reader.onload = async (event) => {
-        const content = event.target?.result as string;
-        const filePath = `${contextPath}/${file.name}`;
-        await api.writeFile(filePath, content);
-        await loadContextFiles();
-      };
-
-      if (isImageFile(file.name)) {
-        reader.readAsDataURL(file);
-      } else {
-        reader.readAsText(file);
-      }
-    }
-  };
-
-  const handleDragOver = (e: React.DragEvent<HTMLDivElement>) => {
-    e.preventDefault();
-    e.stopPropagation();
-  };
-
-  // Handle drag and drop for .txt and .md files in the add context dialog textarea
-  const handleTextAreaDrop = async (
-    e: React.DragEvent<HTMLTextAreaElement>
-  ) => {
-    e.preventDefault();
-    e.stopPropagation();
-    setIsDropHovering(false);
-
-    const files = Array.from(e.dataTransfer.files);
-    if (files.length === 0) return;
-
-    const file = files[0]; // Only handle the first file
-    const fileName = file.name.toLowerCase();
-
-    // Only accept .txt and .md files
-    if (!fileName.endsWith(".txt") && !fileName.endsWith(".md")) {
-      console.warn("Only .txt and .md files are supported for drag and drop");
-      return;
-    }
-
-    const reader = new FileReader();
-    reader.onload = (event) => {
-      const content = event.target?.result as string;
-      setNewFileContent(content);
-
-      // Auto-fill filename if empty
-      if (!newFileName) {
-        setNewFileName(file.name);
-      }
-    };
-    reader.readAsText(file);
-  };
-
-  const handleTextAreaDragOver = (e: React.DragEvent<HTMLTextAreaElement>) => {
-    e.preventDefault();
-    e.stopPropagation();
-    setIsDropHovering(true);
-  };
-
-  const handleTextAreaDragLeave = (e: React.DragEvent<HTMLTextAreaElement>) => {
-    e.preventDefault();
-    e.stopPropagation();
-    setIsDropHovering(false);
-  };
-
-  if (!currentProject) {
-    return (
-      <div
-        className="flex-1 flex items-center justify-center"
-        data-testid="context-view-no-project"
-      >
-        <p className="text-muted-foreground">No project selected</p>
-      </div>
-    );
-  }
-
-  if (isLoading) {
-    return (
-      <div
-        className="flex-1 flex items-center justify-center"
-        data-testid="context-view-loading"
-      >
-        <RefreshCw className="w-6 h-6 animate-spin text-muted-foreground" />
-      </div>
-    );
-  }
-
-  return (
-    <div
-      className="flex-1 flex flex-col overflow-hidden content-bg"
-      data-testid="context-view"
-    >
-      {/* Header */}
-      <div className="flex items-center justify-between p-4 border-b border-border bg-glass backdrop-blur-md">
-        <div className="flex items-center gap-3">
-          <BookOpen className="w-5 h-5 text-muted-foreground" />
-          <div>
-            <h1 className="text-xl font-bold">Context Files</h1>
-            <p className="text-sm text-muted-foreground">
-              Add context files to include in AI prompts
-            </p>
-          </div>
-        </div>
-        <div className="flex gap-2">
-          <HotkeyButton
-            size="sm"
-            onClick={() => setIsAddDialogOpen(true)}
-            hotkey={shortcuts.addContextFile}
-            hotkeyActive={false}
-            data-testid="add-context-file"
-          >
-            <Plus className="w-4 h-4 mr-2" />
-            Add File
-          </HotkeyButton>
-        </div>
-      </div>
-
-      {/* Main content area with file list and editor */}
-      <div
-        className="flex-1 flex overflow-hidden"
-        onDrop={handleDrop}
-        onDragOver={handleDragOver}
-        data-testid="context-drop-zone"
-      >
-        {/* Left Panel - File List */}
-        <div className="w-64 border-r border-border flex flex-col overflow-hidden">
-          <div className="p-3 border-b border-border">
-            <h2 className="text-sm font-semibold text-muted-foreground">
-              Context Files ({contextFiles.length})
-            </h2>
-          </div>
-          <div
-            className="flex-1 overflow-y-auto p-2"
-            data-testid="context-file-list"
-          >
-            {contextFiles.length === 0 ? (
-              <div className="flex flex-col items-center justify-center h-full text-center p-4">
-                <Upload className="w-8 h-8 text-muted-foreground mb-2" />
-                <p className="text-sm text-muted-foreground">
-                  No context files yet.
-                  <br />
-                  Drop files here or click Add File.
-                </p>
-              </div>
-            ) : (
-              <div className="space-y-1">
-                {contextFiles.map((file) => (
-                  <button
-                    key={file.path}
-                    onClick={() => handleSelectFile(file)}
-                    className={cn(
-                      "w-full flex items-center gap-2 px-3 py-2 rounded-lg text-left transition-colors",
-                      selectedFile?.path === file.path
-                        ? "bg-primary/20 text-foreground border border-primary/30"
-                        : "text-muted-foreground hover:bg-accent hover:text-foreground"
-                    )}
-                    data-testid={`context-file-${file.name}`}
-                  >
-                    {file.type === "image" ? (
-                      <ImageIcon className="w-4 h-4 flex-shrink-0" />
-                    ) : (
-                      <FileText className="w-4 h-4 flex-shrink-0" />
-                    )}
-                    <span className="truncate text-sm">{file.name}</span>
-                  </button>
-                ))}
-              </div>
-            )}
-          </div>
-        </div>
-
-        {/* Right Panel - Editor/Preview */}
-        <div className="flex-1 flex flex-col overflow-hidden">
-          {selectedFile ? (
-            <>
-              {/* File toolbar */}
-              <div className="flex items-center justify-between p-3 border-b border-border bg-card">
-                <div className="flex items-center gap-2">
-                  {selectedFile.type === "image" ? (
-                    <ImageIcon className="w-4 h-4 text-muted-foreground" />
-                  ) : (
-                    <FileText className="w-4 h-4 text-muted-foreground" />
-                  )}
-                  <span className="text-sm font-medium">
-                    {selectedFile.name}
-                  </span>
-                </div>
-                <div className="flex gap-2">
-                  {selectedFile.type === "text" &&
-                    isMarkdownFile(selectedFile.name) && (
-                      <Button
-                        variant={"outline"}
-                        size="sm"
-                        onClick={() => setIsPreviewMode(!isPreviewMode)}
-                        data-testid="toggle-preview-mode"
-                      >
-                        {isPreviewMode ? (
-                          <>
-                            <EditIcon className="w-4 h-4 mr-2" />
-                            Edit
-                          </>
-                        ) : (
-                          <>
-                            <Eye className="w-4 h-4 mr-2" />
-                            Preview
-                          </>
-                        )}
-                      </Button>
-                    )}
-                  {selectedFile.type === "text" && (
-                    <Button
-                      size="sm"
-                      onClick={saveFile}
-                      disabled={!hasChanges || isSaving}
-                      data-testid="save-context-file"
-                    >
-                      <Save className="w-4 h-4 mr-2" />
-                      {isSaving ? "Saving..." : hasChanges ? "Save" : "Saved"}
-                    </Button>
-                  )}
-                  <Button
-                    variant="outline"
-                    size="sm"
-                    onClick={() => setIsDeleteDialogOpen(true)}
-                    className="text-red-500 hover:text-red-400 hover:border-red-500/50"
-                    data-testid="delete-context-file"
-                  >
-                    <Trash2 className="w-4 h-4" />
-                  </Button>
-                </div>
-              </div>
-
-              {/* Content area */}
-              <div className="flex-1 overflow-hidden p-4">
-                {selectedFile.type === "image" ? (
-                  <div
-                    className="h-full flex items-center justify-center bg-card rounded-lg"
-                    data-testid="image-preview"
-                  >
-                    <img
-                      src={editedContent}
-                      alt={selectedFile.name}
-                      className="max-w-full max-h-full object-contain"
-                    />
-                  </div>
-                ) : isPreviewMode ? (
-                  <Card className="h-full overflow-auto p-4" data-testid="markdown-preview">
-                    <Markdown>{editedContent}</Markdown>
-                  </Card>
-                ) : (
-                  <Card className="h-full overflow-hidden">
-                    <textarea
-                      className="w-full h-full p-4 font-mono text-sm bg-transparent resize-none focus:outline-none"
-                      value={editedContent}
-                      onChange={(e) => handleContentChange(e.target.value)}
-                      placeholder="Enter context content here..."
-                      spellCheck={false}
-                      data-testid="context-editor"
-                    />
-                  </Card>
-                )}
-              </div>
-            </>
-          ) : (
-            <div className="flex-1 flex items-center justify-center">
-              <div className="text-center">
-                <File className="w-12 h-12 text-muted-foreground mx-auto mb-3" />
-                <p className="text-foreground-secondary">
-                  Select a file to view or edit
-                </p>
-                <p className="text-muted-foreground text-sm mt-1">
-                  Or drop files here to add them
-                </p>
-              </div>
-            </div>
-          )}
-        </div>
-      </div>
-
-      {/* Add File Dialog */}
-      <Dialog open={isAddDialogOpen} onOpenChange={setIsAddDialogOpen}>
-        <DialogContent
-          data-testid="add-context-dialog"
-          className="w-[60vw] max-w-[60vw] max-h-[80vh] flex flex-col"
-        >
-          <DialogHeader>
-            <DialogTitle>Add Context File</DialogTitle>
-            <DialogDescription>
-              Add a new text or image file to the context.
-            </DialogDescription>
-          </DialogHeader>
-          <div className="space-y-4 py-4">
-            <div className="flex gap-2">
-              <Button
-                variant={newFileType === "text" ? "default" : "outline"}
-                size="sm"
-                onClick={() => setNewFileType("text")}
-                data-testid="add-text-type"
-              >
-                <FileText className="w-4 h-4 mr-2" />
-                Text
-              </Button>
-              <Button
-                variant={newFileType === "image" ? "default" : "outline"}
-                size="sm"
-                onClick={() => setNewFileType("image")}
-                data-testid="add-image-type"
-              >
-                <ImageIcon className="w-4 h-4 mr-2" />
-                Image
-              </Button>
-            </div>
-
-            <div className="space-y-2">
-              <Label htmlFor="filename">File Name</Label>
-              <Input
-                id="filename"
-                value={newFileName}
-                onChange={(e) => setNewFileName(e.target.value)}
-                placeholder={
-                  newFileType === "text" ? "context.md" : "image.png"
-                }
-                data-testid="new-file-name"
-              />
-            </div>
-
-            {newFileType === "text" && (
-              <div className="space-y-2">
-                <Label htmlFor="context-content">Context Content</Label>
-                <div
-                  className={cn(
-                    "relative rounded-lg transition-colors",
-                    isDropHovering && "ring-2 ring-primary"
-                  )}
-                >
-                  <textarea
-                    id="context-content"
-                    value={newFileContent}
-                    onChange={(e) => setNewFileContent(e.target.value)}
-                    onDrop={handleTextAreaDrop}
-                    onDragOver={handleTextAreaDragOver}
-                    onDragLeave={handleTextAreaDragLeave}
-                    placeholder="Enter context content here or drag & drop a .txt or .md file..."
-                    className={cn(
-                      "w-full h-40 p-3 font-mono text-sm bg-background border border-border rounded-lg resize-none focus:outline-none focus:ring-2 focus:ring-ring focus:border-transparent",
-                      isDropHovering && "border-primary bg-primary/10"
-                    )}
-                    spellCheck={false}
-                    data-testid="new-file-content"
-                  />
-                  {isDropHovering && (
-                    <div className="absolute inset-0 flex items-center justify-center bg-primary/20 rounded-lg pointer-events-none">
-                      <div className="flex flex-col items-center text-primary">
-                        <Upload className="w-8 h-8 mb-2" />
-                        <span className="text-sm font-medium">
-                          Drop .txt or .md file here
-                        </span>
-                      </div>
-                    </div>
-                  )}
-                </div>
-                <p className="text-xs text-muted-foreground">
-                  Drag & drop .txt or .md files to import their content
-                </p>
-              </div>
-            )}
-
-            {newFileType === "image" && (
-              <div className="space-y-2">
-                <Label>Upload Image</Label>
-                <div className="border-2 border-dashed border-border rounded-lg p-4 text-center">
-                  <input
-                    type="file"
-                    accept="image/*"
-                    onChange={handleImageUpload}
-                    className="hidden"
-                    id="image-upload"
-                    data-testid="image-upload-input"
-                  />
-                  <label
-                    htmlFor="image-upload"
-                    className="cursor-pointer flex flex-col items-center"
-                  >
-                    {uploadedImageData ? (
-                      <img
-                        src={uploadedImageData}
-                        alt="Preview"
-                        className="max-w-32 max-h-32 object-contain mb-2"
-                      />
-                    ) : (
-                      <Upload className="w-8 h-8 text-muted-foreground mb-2" />
-                    )}
-                    <span className="text-sm text-muted-foreground">
-                      {uploadedImageData
-                        ? "Click to change"
-                        : "Click to upload"}
-                    </span>
-                  </label>
-                </div>
-              </div>
-            )}
-          </div>
-          <DialogFooter>
-            <Button
-              variant="outline"
-              onClick={() => {
-                setIsAddDialogOpen(false);
-                setNewFileName("");
-                setUploadedImageData(null);
-                setNewFileContent("");
-                setIsDropHovering(false);
-              }}
-            >
-              Cancel
-            </Button>
-            <HotkeyButton
-              onClick={handleAddFile}
-              disabled={
-                !newFileName.trim() ||
-                (newFileType === "image" && !uploadedImageData)
-              }
-              hotkey={{ key: "Enter", cmdCtrl: true }}
-              hotkeyActive={isAddDialogOpen}
-              data-testid="confirm-add-file"
-            >
-              Add File
-            </HotkeyButton>
-          </DialogFooter>
-        </DialogContent>
-      </Dialog>
-
-      {/* Delete Confirmation Dialog */}
-      <Dialog open={isDeleteDialogOpen} onOpenChange={setIsDeleteDialogOpen}>
-        <DialogContent data-testid="delete-context-dialog">
-          <DialogHeader>
-            <DialogTitle>Delete Context File</DialogTitle>
-            <DialogDescription>
-              Are you sure you want to delete "{selectedFile?.name}"? This
-              action cannot be undone.
-            </DialogDescription>
-          </DialogHeader>
-          <DialogFooter>
-            <Button
-              variant="outline"
-              onClick={() => setIsDeleteDialogOpen(false)}
-            >
-              Cancel
-            </Button>
-            <Button
-              variant="destructive"
-              onClick={handleDeleteFile}
-              className="bg-red-600 hover:bg-red-700"
-              data-testid="confirm-delete-file"
-            >
-              Delete
-            </Button>
-          </DialogFooter>
-        </DialogContent>
-      </Dialog>
-    </div>
-  );
-}

apps/app/src/components/views/profiles-view/components/index.ts

@@ -1,3 +0,0 @@
-export { SortableProfileCard } from "./sortable-profile-card";
-export { ProfileForm } from "./profile-form";
-export { ProfilesHeader } from "./profiles-header";

apps/app/src/components/views/profiles-view/constants.ts

@@ -1,48 +0,0 @@
-import {
-  Brain,
-  Zap,
-  Scale,
-  Cpu,
-  Rocket,
-  Sparkles,
-} from "lucide-react";
-import type { AgentModel, ThinkingLevel } from "@/store/app-store";
-
-// Icon mapping for profiles
-export const PROFILE_ICONS: Record<
-  string,
-  React.ComponentType<{ className?: string }>
-> = {
-  Brain,
-  Zap,
-  Scale,
-  Cpu,
-  Rocket,
-  Sparkles,
-};
-
-// Available icons for selection
-export const ICON_OPTIONS = [
-  { name: "Brain", icon: Brain },
-  { name: "Zap", icon: Zap },
-  { name: "Scale", icon: Scale },
-  { name: "Cpu", icon: Cpu },
-  { name: "Rocket", icon: Rocket },
-  { name: "Sparkles", icon: Sparkles },
-];
-
-// Model options for the form
-export const CLAUDE_MODELS: { id: AgentModel; label: string }[] = [
-  { id: "haiku", label: "Claude Haiku" },
-  { id: "sonnet", label: "Claude Sonnet" },
-  { id: "opus", label: "Claude Opus" },
-];
-
-export const THINKING_LEVELS: { id: ThinkingLevel; label: string }[] = [
-  { id: "none", label: "None" },
-  { id: "low", label: "Low" },
-  { id: "medium", label: "Medium" },
-  { id: "high", label: "High" },
-  { id: "ultrathink", label: "Ultrathink" },
-];
-

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

@@ -1,240 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import { useAppStore } from "@/store/app-store";
-import { Label } from "@/components/ui/label";
-import {
-  Key,
-  Palette,
-  Terminal,
-  FlaskConical,
-  Trash2,
-  Settings2,
-  Volume2,
-  VolumeX,
-} from "lucide-react";
-import { Checkbox } from "@/components/ui/checkbox";
-
-import { useCliStatus } from "./settings-view/hooks/use-cli-status";
-import { useScrollTracking } from "@/hooks/use-scroll-tracking";
-import { SettingsHeader } from "./settings-view/components/settings-header";
-import { KeyboardMapDialog } from "./settings-view/components/keyboard-map-dialog";
-import { DeleteProjectDialog } from "./settings-view/components/delete-project-dialog";
-import { SettingsNavigation } from "./settings-view/components/settings-navigation";
-import { ApiKeysSection } from "./settings-view/api-keys/api-keys-section";
-import { ClaudeCliStatus } from "./settings-view/cli-status/claude-cli-status";
-import { AppearanceSection } from "./settings-view/appearance/appearance-section";
-import { KeyboardShortcutsSection } from "./settings-view/keyboard-shortcuts/keyboard-shortcuts-section";
-import { FeatureDefaultsSection } from "./settings-view/feature-defaults/feature-defaults-section";
-import { DangerZoneSection } from "./settings-view/danger-zone/danger-zone-section";
-import type {
-  Project as SettingsProject,
-  Theme,
-} from "./settings-view/shared/types";
-import type { Project as ElectronProject } from "@/lib/electron";
-
-// Navigation items for the side panel
-const NAV_ITEMS = [
-  { id: "api-keys", label: "API Keys", icon: Key },
-  { id: "claude", label: "Claude", icon: Terminal },
-  { id: "appearance", label: "Appearance", icon: Palette },
-  { id: "audio", label: "Audio", icon: Volume2 },
-  { id: "keyboard", label: "Keyboard Shortcuts", icon: Settings2 },
-  { id: "defaults", label: "Feature Defaults", icon: FlaskConical },
-  { id: "danger", label: "Danger Zone", icon: Trash2 },
-];
-
-export function SettingsView() {
-  const {
-    theme,
-    setTheme,
-    setProjectTheme,
-    defaultSkipTests,
-    setDefaultSkipTests,
-    useWorktrees,
-    setUseWorktrees,
-    showProfilesOnly,
-    setShowProfilesOnly,
-    muteDoneSound,
-    setMuteDoneSound,
-    currentProject,
-    moveProjectToTrash,
-  } = useAppStore();
-
-  // Convert electron Project to settings-view Project type
-  const convertProject = (
-    project: ElectronProject | null
-  ): SettingsProject | null => {
-    if (!project) return null;
-    return {
-      id: project.id,
-      name: project.name,
-      path: project.path,
-      theme: project.theme as Theme | undefined,
-    };
-  };
-
-  const settingsProject = convertProject(currentProject);
-
-  // Compute the effective theme for the current project
-  const effectiveTheme = (settingsProject?.theme || theme) as Theme;
-
-  // Handler to set theme - always updates global theme (user's preference),
-  // and also sets per-project theme if a project is selected
-  const handleSetTheme = (newTheme: typeof theme) => {
-    // Always update global theme so user's preference persists across all projects
-    setTheme(newTheme);
-    // Also set per-project theme if a project is selected
-    if (currentProject) {
-      setProjectTheme(currentProject.id, newTheme);
-    }
-  };
-
-  // Use CLI status hook
-  const {
-    claudeCliStatus,
-    isCheckingClaudeCli,
-    handleRefreshClaudeCli,
-  } = useCliStatus();
-
-  // Use scroll tracking hook
-  const { activeSection, scrollToSection, scrollContainerRef } =
-    useScrollTracking({
-      items: NAV_ITEMS,
-      filterFn: (item) => item.id !== "danger" || !!currentProject,
-      initialSection: "api-keys",
-    });
-
-  const [showDeleteDialog, setShowDeleteDialog] = useState(false);
-  const [showKeyboardMapDialog, setShowKeyboardMapDialog] = useState(false);
-
-  return (
-    <div
-      className="flex-1 flex flex-col overflow-hidden content-bg"
-      data-testid="settings-view"
-    >
-      {/* Header Section */}
-      <SettingsHeader />
-
-      {/* Content Area with Sidebar */}
-      <div className="flex-1 flex overflow-hidden">
-        {/* Sticky Side Navigation */}
-        <SettingsNavigation
-          navItems={NAV_ITEMS}
-          activeSection={activeSection}
-          currentProject={currentProject}
-          onNavigate={scrollToSection}
-        />
-
-        {/* Scrollable Content */}
-        <div ref={scrollContainerRef} className="flex-1 overflow-y-auto p-8">
-          <div className="max-w-4xl mx-auto space-y-6 pb-96">
-            {/* API Keys Section */}
-            <ApiKeysSection />
-
-            {/* Claude CLI Status Section */}
-            {claudeCliStatus && (
-              <ClaudeCliStatus
-                status={claudeCliStatus}
-                isChecking={isCheckingClaudeCli}
-                onRefresh={handleRefreshClaudeCli}
-              />
-            )}
-
-            {/* Appearance Section */}
-            <AppearanceSection
-              effectiveTheme={effectiveTheme}
-              currentProject={settingsProject}
-              onThemeChange={handleSetTheme}
-            />
-
-
-            {/* Keyboard Shortcuts Section */}
-            <KeyboardShortcutsSection
-              onOpenKeyboardMap={() => setShowKeyboardMapDialog(true)}
-            />
-
-            {/* Audio Section */}
-            <div
-              id="audio"
-              className="rounded-2xl border border-border/50 bg-gradient-to-br from-card/90 via-card/70 to-card/80 backdrop-blur-xl shadow-sm shadow-black/5 overflow-hidden scroll-mt-6"
-            >
-              <div className="p-6 border-b border-border/50 bg-gradient-to-r from-transparent via-accent/5 to-transparent">
-                <div className="flex items-center gap-3 mb-2">
-                  <div className="w-9 h-9 rounded-xl bg-gradient-to-br from-brand-500/20 to-brand-600/10 flex items-center justify-center border border-brand-500/20">
-                    <Volume2 className="w-5 h-5 text-brand-500" />
-                  </div>
-                  <h2 className="text-lg font-semibold text-foreground tracking-tight">
-                    Audio
-                  </h2>
-                </div>
-                <p className="text-sm text-muted-foreground/80 ml-12">
-                  Configure audio and notification settings.
-                </p>
-              </div>
-              <div className="p-6 space-y-4">
-                {/* Mute Done Sound Setting */}
-                <div className="group flex items-start space-x-3 p-3 rounded-xl hover:bg-accent/30 transition-colors duration-200 -mx-3">
-                  <Checkbox
-                    id="mute-done-sound"
-                    checked={muteDoneSound}
-                    onCheckedChange={(checked) =>
-                      setMuteDoneSound(checked === true)
-                    }
-                    className="mt-1"
-                    data-testid="mute-done-sound-checkbox"
-                  />
-                  <div className="space-y-1.5">
-                    <Label
-                      htmlFor="mute-done-sound"
-                      className="text-foreground cursor-pointer font-medium flex items-center gap-2"
-                    >
-                      <VolumeX className="w-4 h-4 text-brand-500" />
-                      Mute notification sound when agents complete
-                    </Label>
-                    <p className="text-xs text-muted-foreground/80 leading-relaxed">
-                      When enabled, disables the &quot;ding&quot; sound that
-                      plays when an agent completes a feature. The feature
-                      will still move to the completed column, but without
-                      audio notification.
-                    </p>
-                  </div>
-                </div>
-              </div>
-            </div>
-
-            {/* Feature Defaults Section */}
-            <FeatureDefaultsSection
-              showProfilesOnly={showProfilesOnly}
-              defaultSkipTests={defaultSkipTests}
-              useWorktrees={useWorktrees}
-              onShowProfilesOnlyChange={setShowProfilesOnly}
-              onDefaultSkipTestsChange={setDefaultSkipTests}
-              onUseWorktreesChange={setUseWorktrees}
-            />
-
-            {/* Danger Zone Section - Only show when a project is selected */}
-            <DangerZoneSection
-              project={settingsProject}
-              onDeleteClick={() => setShowDeleteDialog(true)}
-            />
-          </div>
-        </div>
-      </div>
-
-      {/* Keyboard Map Dialog */}
-      <KeyboardMapDialog
-        open={showKeyboardMapDialog}
-        onOpenChange={setShowKeyboardMapDialog}
-      />
-
-      {/* Delete Project Confirmation Dialog */}
-      <DeleteProjectDialog
-        open={showDeleteDialog}
-        onOpenChange={setShowDeleteDialog}
-        project={currentProject}
-        onConfirm={moveProjectToTrash}
-      />
-    </div>
-  );
-}

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

@@ -1,88 +0,0 @@
-import { Button } from "@/components/ui/button";
-import { Label } from "@/components/ui/label";
-import { Palette } from "lucide-react";
-import { themeOptions } from "@/config/theme-options";
-import { cn } from "@/lib/utils";
-import type { Theme, Project } from "../shared/types";
-
-interface AppearanceSectionProps {
-  effectiveTheme: Theme;
-  currentProject: Project | null;
-  onThemeChange: (theme: Theme) => void;
-}
-
-export function AppearanceSection({
-  effectiveTheme,
-  currentProject,
-  onThemeChange,
-}: AppearanceSectionProps) {
-  return (
-    <div
-      id="appearance"
-      className={cn(
-        "rounded-2xl overflow-hidden scroll-mt-6",
-        "border border-border/50",
-        "bg-gradient-to-br from-card/90 via-card/70 to-card/80 backdrop-blur-xl",
-        "shadow-sm shadow-black/5"
-      )}
-    >
-      <div className="p-6 border-b border-border/50 bg-gradient-to-r from-transparent via-accent/5 to-transparent">
-        <div className="flex items-center gap-3 mb-2">
-          <div className="w-9 h-9 rounded-xl bg-gradient-to-br from-brand-500/20 to-brand-600/10 flex items-center justify-center border border-brand-500/20">
-            <Palette className="w-5 h-5 text-brand-500" />
-          </div>
-          <h2 className="text-lg font-semibold text-foreground tracking-tight">Appearance</h2>
-        </div>
-        <p className="text-sm text-muted-foreground/80 ml-12">
-          Customize the look and feel of your application.
-        </p>
-      </div>
-      <div className="p-6 space-y-4">
-        <div className="space-y-4">
-          <Label className="text-foreground font-medium">
-            Theme{" "}
-            <span className="text-muted-foreground font-normal">
-              {currentProject ? `(for ${currentProject.name})` : "(Global)"}
-            </span>
-          </Label>
-          <div className="grid grid-cols-2 md:grid-cols-4 gap-3">
-            {themeOptions.map(({ value, label, Icon, testId }) => {
-              const isActive = effectiveTheme === value;
-              return (
-                <button
-                  key={value}
-                  onClick={() => onThemeChange(value)}
-                  className={cn(
-                    "group flex items-center justify-center gap-2.5 px-4 py-3.5 rounded-xl",
-                    "text-sm font-medium transition-all duration-200 ease-out",
-                    isActive
-                      ? [
-                          "bg-gradient-to-br from-brand-500/15 to-brand-600/10",
-                          "border-2 border-brand-500/40",
-                          "text-foreground",
-                          "shadow-md shadow-brand-500/10",
-                        ]
-                      : [
-                          "bg-accent/30 hover:bg-accent/50",
-                          "border border-border/50 hover:border-border",
-                          "text-muted-foreground hover:text-foreground",
-                          "hover:shadow-sm",
-                        ],
-                    "hover:scale-[1.02] active:scale-[0.98]"
-                  )}
-                  data-testid={testId}
-                >
-                  <Icon className={cn(
-                    "w-4 h-4 transition-all duration-200",
-                    isActive ? "text-brand-500" : "group-hover:text-brand-400"
-                  )} />
-                  <span>{label}</span>
-                </button>
-              );
-            })}
-          </div>
-        </div>
-      </div>
-    </div>
-  );
-}

apps/app/src/components/views/settings-view/components/settings-header.tsx

@@ -1,37 +0,0 @@
-import { Settings } from "lucide-react";
-import { cn } from "@/lib/utils";
-
-interface SettingsHeaderProps {
-  title?: string;
-  description?: string;
-}
-
-export function SettingsHeader({
-  title = "Settings",
-  description = "Configure your API keys and preferences",
-}: SettingsHeaderProps) {
-  return (
-    <div className={cn(
-      "shrink-0",
-      "border-b border-border/50",
-      "bg-gradient-to-r from-card/90 via-card/70 to-card/80 backdrop-blur-xl"
-    )}>
-      <div className="px-8 py-6">
-        <div className="flex items-center gap-4">
-          <div className={cn(
-            "w-12 h-12 rounded-2xl flex items-center justify-center",
-            "bg-gradient-to-br from-brand-500 to-brand-600",
-            "shadow-lg shadow-brand-500/25",
-            "ring-1 ring-white/10"
-          )}>
-            <Settings className="w-6 h-6 text-white" />
-          </div>
-          <div>
-            <h1 className="text-2xl font-bold text-foreground tracking-tight">{title}</h1>
-            <p className="text-sm text-muted-foreground/80 mt-0.5">{description}</p>
-          </div>
-        </div>
-      </div>
-    </div>
-  );
-}

apps/app/src/components/views/settings-view/components/settings-navigation.tsx

@@ -1,70 +0,0 @@
-import { cn } from "@/lib/utils";
-import type { Project } from "@/lib/electron";
-import type { NavigationItem } from "../config/navigation";
-
-interface SettingsNavigationProps {
-  navItems: NavigationItem[];
-  activeSection: string;
-  currentProject: Project | null;
-  onNavigate: (sectionId: string) => void;
-}
-
-export function SettingsNavigation({
-  navItems,
-  activeSection,
-  currentProject,
-  onNavigate,
-}: SettingsNavigationProps) {
-  return (
-    <nav className={cn(
-      "hidden lg:block w-52 shrink-0",
-      "border-r border-border/50",
-      "bg-gradient-to-b from-card/80 via-card/60 to-card/40 backdrop-blur-xl"
-    )}>
-      <div className="sticky top-0 p-4 space-y-1.5">
-        {navItems
-          .filter((item) => item.id !== "danger" || currentProject)
-          .map((item) => {
-            const Icon = item.icon;
-            const isActive = activeSection === item.id;
-            return (
-              <button
-                key={item.id}
-                onClick={() => onNavigate(item.id)}
-                className={cn(
-                  "group w-full flex items-center gap-2.5 px-3 py-2.5 rounded-xl text-sm font-medium transition-all duration-200 ease-out text-left relative overflow-hidden",
-                  isActive
-                    ? [
-                        "bg-gradient-to-r from-brand-500/15 via-brand-500/10 to-brand-600/5",
-                        "text-foreground",
-                        "border border-brand-500/25",
-                        "shadow-sm shadow-brand-500/5",
-                      ]
-                    : [
-                        "text-muted-foreground hover:text-foreground",
-                        "hover:bg-accent/50",
-                        "border border-transparent hover:border-border/40",
-                      ],
-                  "hover:scale-[1.01] active:scale-[0.98]"
-                )}
-              >
-                {/* Active indicator bar */}
-                {isActive && (
-                  <div className="absolute inset-y-0 left-0 w-0.5 bg-gradient-to-b from-brand-400 via-brand-500 to-brand-600 rounded-r-full" />
-                )}
-                <Icon
-                  className={cn(
-                    "w-4 h-4 shrink-0 transition-all duration-200",
-                    isActive
-                      ? "text-brand-500"
-                      : "group-hover:text-brand-400 group-hover:scale-110"
-                  )}
-                />
-                <span className="truncate">{item.label}</span>
-              </button>
-            );
-          })}
-      </div>
-    </nav>
-  );
-}

apps/app/src/components/views/settings-view/config/navigation.ts

@@ -1,27 +0,0 @@
-import type { LucideIcon } from "lucide-react";
-import {
-  Key,
-  Terminal,
-  Palette,
-  LayoutGrid,
-  Settings2,
-  FlaskConical,
-  Trash2,
-} from "lucide-react";
-
-export interface NavigationItem {
-  id: string;
-  label: string;
-  icon: LucideIcon;
-}
-
-// Navigation items for the settings side panel
-export const NAV_ITEMS: NavigationItem[] = [
-  { id: "api-keys", label: "API Keys", icon: Key },
-  { id: "claude", label: "Claude", icon: Terminal },
-  { id: "appearance", label: "Appearance", icon: Palette },
-  { id: "kanban", label: "Kanban Display", icon: LayoutGrid },
-  { id: "keyboard", label: "Keyboard Shortcuts", icon: Settings2 },
-  { id: "defaults", label: "Feature Defaults", icon: FlaskConical },
-  { id: "danger", label: "Danger Zone", icon: Trash2 },
-];

apps/app/src/components/views/settings-view/danger-zone/danger-zone-section.tsx

@@ -1,71 +0,0 @@
-import { Button } from "@/components/ui/button";
-import { Trash2, Folder, AlertTriangle } from "lucide-react";
-import { cn } from "@/lib/utils";
-import type { Project } from "../shared/types";
-
-interface DangerZoneSectionProps {
-  project: Project | null;
-  onDeleteClick: () => void;
-}
-
-export function DangerZoneSection({
-  project,
-  onDeleteClick,
-}: DangerZoneSectionProps) {
-  if (!project) return null;
-
-  return (
-    <div
-      id="danger"
-      className={cn(
-        "rounded-2xl overflow-hidden scroll-mt-6",
-        "border border-destructive/30",
-        "bg-gradient-to-br from-destructive/5 via-card/70 to-card/80 backdrop-blur-xl",
-        "shadow-sm shadow-destructive/5"
-      )}
-    >
-      <div className="p-6 border-b border-destructive/20 bg-gradient-to-r from-destructive/5 via-transparent to-transparent">
-        <div className="flex items-center gap-3 mb-2">
-          <div className="w-9 h-9 rounded-xl bg-gradient-to-br from-destructive/20 to-destructive/10 flex items-center justify-center border border-destructive/20">
-            <AlertTriangle className="w-5 h-5 text-destructive" />
-          </div>
-          <h2 className="text-lg font-semibold text-foreground tracking-tight">Danger Zone</h2>
-        </div>
-        <p className="text-sm text-muted-foreground/80 ml-12">
-          Permanently remove this project from Automaker.
-        </p>
-      </div>
-      <div className="p-6">
-        <div className="flex items-center justify-between gap-4 p-4 rounded-xl bg-destructive/5 border border-destructive/10">
-          <div className="flex items-center gap-3.5 min-w-0">
-            <div className="w-11 h-11 rounded-xl bg-gradient-to-br from-brand-500/15 to-brand-600/10 border border-brand-500/20 flex items-center justify-center shrink-0">
-              <Folder className="w-5 h-5 text-brand-500" />
-            </div>
-            <div className="min-w-0">
-              <p className="font-medium text-foreground truncate">
-                {project.name}
-              </p>
-              <p className="text-xs text-muted-foreground/70 truncate mt-0.5">
-                {project.path}
-              </p>
-            </div>
-          </div>
-          <Button
-            variant="destructive"
-            onClick={onDeleteClick}
-            data-testid="delete-project-button"
-            className={cn(
-              "shrink-0",
-              "shadow-md shadow-destructive/20 hover:shadow-lg hover:shadow-destructive/25",
-              "transition-all duration-200 ease-out",
-              "hover:scale-[1.02] active:scale-[0.98]"
-            )}
-          >
-            <Trash2 className="w-4 h-4 mr-2" />
-            Delete Project
-          </Button>
-        </div>
-      </div>
-    </div>
-  );
-}

apps/app/src/components/views/settings-view/feature-defaults/feature-defaults-section.tsx

@@ -1,141 +0,0 @@
-import { Label } from "@/components/ui/label";
-import { Checkbox } from "@/components/ui/checkbox";
-import { FlaskConical, Settings2, TestTube, GitBranch } from "lucide-react";
-import { cn } from "@/lib/utils";
-
-interface FeatureDefaultsSectionProps {
-  showProfilesOnly: boolean;
-  defaultSkipTests: boolean;
-  useWorktrees: boolean;
-  onShowProfilesOnlyChange: (value: boolean) => void;
-  onDefaultSkipTestsChange: (value: boolean) => void;
-  onUseWorktreesChange: (value: boolean) => void;
-}
-
-export function FeatureDefaultsSection({
-  showProfilesOnly,
-  defaultSkipTests,
-  useWorktrees,
-  onShowProfilesOnlyChange,
-  onDefaultSkipTestsChange,
-  onUseWorktreesChange,
-}: FeatureDefaultsSectionProps) {
-  return (
-    <div
-      id="defaults"
-      className={cn(
-        "rounded-2xl overflow-hidden scroll-mt-6",
-        "border border-border/50",
-        "bg-gradient-to-br from-card/90 via-card/70 to-card/80 backdrop-blur-xl",
-        "shadow-sm shadow-black/5"
-      )}
-    >
-      <div className="p-6 border-b border-border/50 bg-gradient-to-r from-transparent via-accent/5 to-transparent">
-        <div className="flex items-center gap-3 mb-2">
-          <div className="w-9 h-9 rounded-xl bg-gradient-to-br from-brand-500/20 to-brand-600/10 flex items-center justify-center border border-brand-500/20">
-            <FlaskConical className="w-5 h-5 text-brand-500" />
-          </div>
-          <h2 className="text-lg font-semibold text-foreground tracking-tight">
-            Feature Defaults
-          </h2>
-        </div>
-        <p className="text-sm text-muted-foreground/80 ml-12">
-          Configure default settings for new features.
-        </p>
-      </div>
-      <div className="p-6 space-y-5">
-        {/* Profiles Only Setting */}
-        <div className="group flex items-start space-x-3 p-3 rounded-xl hover:bg-accent/30 transition-colors duration-200 -mx-3">
-          <Checkbox
-            id="show-profiles-only"
-            checked={showProfilesOnly}
-            onCheckedChange={(checked) =>
-              onShowProfilesOnlyChange(checked === true)
-            }
-            className="mt-1"
-            data-testid="show-profiles-only-checkbox"
-          />
-          <div className="space-y-1.5">
-            <Label
-              htmlFor="show-profiles-only"
-              className="text-foreground cursor-pointer font-medium flex items-center gap-2"
-            >
-              <Settings2 className="w-4 h-4 text-brand-500" />
-              Show profiles only by default
-            </Label>
-            <p className="text-xs text-muted-foreground/80 leading-relaxed">
-              When enabled, the Add Feature dialog will show only AI profiles
-              and hide advanced model tweaking options. This creates a cleaner, less
-              overwhelming UI.
-            </p>
-          </div>
-        </div>
-
-        {/* Separator */}
-        <div className="border-t border-border/30" />
-
-        {/* Automated Testing Setting */}
-        <div className="group flex items-start space-x-3 p-3 rounded-xl hover:bg-accent/30 transition-colors duration-200 -mx-3">
-          <Checkbox
-            id="default-skip-tests"
-            checked={!defaultSkipTests}
-            onCheckedChange={(checked) =>
-              onDefaultSkipTestsChange(checked !== true)
-            }
-            className="mt-1"
-            data-testid="default-skip-tests-checkbox"
-          />
-          <div className="space-y-1.5">
-            <Label
-              htmlFor="default-skip-tests"
-              className="text-foreground cursor-pointer font-medium flex items-center gap-2"
-            >
-              <TestTube className="w-4 h-4 text-brand-500" />
-              Enable automated testing by default
-            </Label>
-            <p className="text-xs text-muted-foreground/80 leading-relaxed">
-              When enabled, new features will use TDD with automated tests. When disabled, features will
-              require manual verification.
-            </p>
-          </div>
-        </div>
-
-        {/* Separator */}
-        <div className="border-t border-border/30" />
-
-        {/* Worktree Isolation Setting */}
-        <div className="group flex items-start space-x-3 p-3 rounded-xl transition-colors duration-200 -mx-3 opacity-60">
-          <Checkbox
-            id="use-worktrees"
-            checked={useWorktrees}
-            onCheckedChange={(checked) =>
-              onUseWorktreesChange(checked === true)
-            }
-            disabled={true}
-            className="mt-1"
-            data-testid="use-worktrees-checkbox"
-          />
-          <div className="space-y-1.5">
-            <Label
-              htmlFor="use-worktrees"
-              className="text-foreground font-medium flex items-center gap-2"
-            >
-              <GitBranch className="w-4 h-4 text-brand-500" />
-              Enable Git Worktree Isolation
-              <span className="text-[10px] px-1.5 py-0.5 rounded-md bg-amber-500/15 text-amber-500 border border-amber-500/20 font-medium">
-                experimental
-              </span>
-            </Label>
-            <p className="text-xs text-muted-foreground/80 leading-relaxed">
-              Creates isolated git branches for each feature. When disabled,
-              agents work directly in the main project directory.
-            </p>
-            <p className="text-xs text-orange-500/80 leading-relaxed font-medium">
-              ⚠️ This feature is still under development and temporarily disabled.
-            </p>
-          </div>
-        </div>
-      </div>
-    </div>
-  );
-}

apps/app/src/components/views/setup-view.tsx

@@ -1,122 +0,0 @@
-"use client";
-
-import { useSetupStore } from "@/store/setup-store";
-import { useAppStore } from "@/store/app-store";
-import { StepIndicator } from "./setup-view/components";
-import {
-  WelcomeStep,
-  CompleteStep,
-  ClaudeSetupStep,
-} from "./setup-view/steps";
-
-// Main Setup View
-export function SetupView() {
-  const {
-    currentStep,
-    setCurrentStep,
-    completeSetup,
-    setSkipClaudeSetup,
-  } = useSetupStore();
-  const { setCurrentView } = useAppStore();
-
-  const steps = ["welcome", "claude", "complete"] as const;
-  type StepName = (typeof steps)[number];
-  const getStepName = (): StepName => {
-    if (currentStep === "claude_detect" || currentStep === "claude_auth")
-      return "claude";
-    if (currentStep === "welcome") return "welcome";
-    return "complete";
-  };
-  const currentIndex = steps.indexOf(getStepName());
-
-  const handleNext = (from: string) => {
-    console.log(
-      "[Setup Flow] handleNext called from:",
-      from,
-      "currentStep:",
-      currentStep
-    );
-    switch (from) {
-      case "welcome":
-        console.log("[Setup Flow] Moving to claude_detect step");
-        setCurrentStep("claude_detect");
-        break;
-      case "claude":
-        console.log("[Setup Flow] Moving to complete step");
-        setCurrentStep("complete");
-        break;
-    }
-  };
-
-  const handleBack = (from: string) => {
-    console.log("[Setup Flow] handleBack called from:", from);
-    switch (from) {
-      case "claude":
-        setCurrentStep("welcome");
-        break;
-    }
-  };
-
-  const handleSkipClaude = () => {
-    console.log("[Setup Flow] Skipping Claude setup");
-    setSkipClaudeSetup(true);
-    setCurrentStep("complete");
-  };
-
-  const handleFinish = () => {
-    console.log("[Setup Flow] handleFinish called - completing setup");
-    completeSetup();
-    console.log("[Setup Flow] Setup completed, redirecting to welcome view");
-    setCurrentView("welcome");
-  };
-
-  return (
-    <div className="h-full flex flex-col content-bg" data-testid="setup-view">
-      {/* Header */}
-      <div className="shrink-0 border-b border-border bg-glass backdrop-blur-md titlebar-drag-region">
-        <div className="px-8 py-4">
-          <div className="flex items-center gap-3 titlebar-no-drag">
-            {/* eslint-disable-next-line @next/next/no-img-element */}
-            <img src="/logo.png" alt="Automaker" className="w-8 h-8" />
-            <span className="text-lg font-semibold text-foreground">
-              Automaker Setup
-            </span>
-          </div>
-        </div>
-      </div>
-
-      {/* Content */}
-      <div className="flex-1 overflow-y-auto min-h-0">
-        <div className="p-8">
-          <div className="w-full max-w-2xl mx-auto">
-            <div className="mb-8">
-              <StepIndicator
-                currentStep={currentIndex}
-                totalSteps={steps.length}
-              />
-            </div>
-
-            <div className="py-8">
-              {currentStep === "welcome" && (
-                <WelcomeStep onNext={() => handleNext("welcome")} />
-              )}
-
-              {(currentStep === "claude_detect" ||
-                currentStep === "claude_auth") && (
-                <ClaudeSetupStep
-                  onNext={() => handleNext("claude")}
-                  onBack={() => handleBack("claude")}
-                  onSkip={handleSkipClaude}
-                />
-              )}
-
-              {currentStep === "complete" && (
-                <CompleteStep onFinish={handleFinish} />
-              )}
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  );
-}

apps/app/src/components/views/setup-view/components/index.ts

@@ -1,9 +0,0 @@
-// Re-export all setup-view components for easier imports
-export { StepIndicator } from "./step-indicator";
-export { StatusBadge } from "./status-badge";
-export { StatusRow } from "./status-row";
-export { TerminalOutput } from "./terminal-output";
-export { CopyableCommandField } from "./copyable-command-field";
-export { CliInstallationCard } from "./cli-installation-card";
-export { ReadyStateCard } from "./ready-state-card";
-export { AuthMethodSelector } from "./auth-method-selector";

apps/app/src/components/views/setup-view/components/terminal-output.tsx

@@ -1,18 +0,0 @@
-interface TerminalOutputProps {
-  lines: string[];
-}
-
-export function TerminalOutput({ lines }: TerminalOutputProps) {
-  return (
-    <div className="bg-zinc-900 rounded-lg p-4 font-mono text-sm max-h-48 overflow-y-auto">
-      {lines.map((line, index) => (
-        <div key={index} className="text-zinc-400">
-          <span className="text-green-500">$</span> {line}
-        </div>
-      ))}
-      {lines.length === 0 && (
-        <div className="text-zinc-500 italic">Waiting for output...</div>
-      )}
-    </div>
-  );
-}

apps/app/src/components/views/setup-view/hooks/index.ts

@@ -1,4 +0,0 @@
-// Re-export all hooks for easier imports
-export { useCliStatus } from "./use-cli-status";
-export { useCliInstallation } from "./use-cli-installation";
-export { useTokenSave } from "./use-token-save";

apps/app/src/components/views/setup-view/steps/complete-step.tsx

@@ -1,46 +0,0 @@
-import { Button } from "@/components/ui/button";
-import { Card, CardContent } from "@/components/ui/card";
-import { CheckCircle2, AlertCircle, Shield, Sparkles } from "lucide-react";
-import { useSetupStore } from "@/store/setup-store";
-import { useAppStore } from "@/store/app-store";
-
-interface CompleteStepProps {
-  onFinish: () => void;
-}
-
-export function CompleteStep({ onFinish }: CompleteStepProps) {
-  const { claudeCliStatus, claudeAuthStatus } = useSetupStore();
-  const { apiKeys } = useAppStore();
-
-  const claudeReady =
-    (claudeCliStatus?.installed && claudeAuthStatus?.authenticated) ||
-    apiKeys.anthropic;
-
-  return (
-    <div className="text-center space-y-6">
-      <div className="w-20 h-20 rounded-full bg-gradient-to-br from-green-500 to-emerald-600 shadow-lg shadow-green-500/30 flex items-center justify-center mx-auto">
-        <CheckCircle2 className="w-10 h-10 text-white" />
-      </div>
-
-      <div>
-        <h2 className="text-3xl font-bold text-foreground mb-3">
-          Setup Complete!
-        </h2>
-        <p className="text-muted-foreground max-w-md mx-auto">
-          Your development environment is configured. You&apos;re ready to start
-          building with AI-powered assistance.
-        </p>
-      </div>
-
-      <Button
-        size="lg"
-        className="bg-gradient-to-r from-brand-500 to-brand-600 hover:from-brand-600 hover:to-brand-700 text-white"
-        onClick={onFinish}
-        data-testid="setup-finish-button"
-      >
-        <Sparkles className="w-4 h-4 mr-2" />
-        Start Building
-      </Button>
-    </div>
-  );
-}

apps/app/src/components/views/setup-view/steps/index.ts

@@ -1,4 +0,0 @@
-// Re-export all setup step components for easier imports
-export { WelcomeStep } from "./welcome-step";
-export { CompleteStep } from "./complete-step";
-export { ClaudeSetupStep } from "./claude-setup-step";

apps/app/src/components/views/terminal-view.tsx

@@ -1,697 +0,0 @@
-"use client";
-
-import React, { useState, useEffect, useCallback, useMemo, useRef } from "react";
-import {
-  Terminal as TerminalIcon,
-  Plus,
-  Lock,
-  Unlock,
-  SplitSquareHorizontal,
-  SplitSquareVertical,
-  Loader2,
-  AlertCircle,
-  RefreshCw,
-  X,
-  SquarePlus,
-} from "lucide-react";
-import { useAppStore, type TerminalPanelContent, type TerminalTab } from "@/store/app-store";
-import { useKeyboardShortcutsConfig, type KeyboardShortcut } from "@/hooks/use-keyboard-shortcuts";
-import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
-import {
-  Panel,
-  PanelGroup,
-  PanelResizeHandle,
-} from "react-resizable-panels";
-import { TerminalPanel } from "./terminal-view/terminal-panel";
-import {
-  DndContext,
-  DragEndEvent,
-  DragStartEvent,
-  DragOverEvent,
-  PointerSensor,
-  useSensor,
-  useSensors,
-  closestCenter,
-  DragOverlay,
-  useDroppable,
-} from "@dnd-kit/core";
-import { cn } from "@/lib/utils";
-
-interface TerminalStatus {
-  enabled: boolean;
-  passwordRequired: boolean;
-  platform: {
-    platform: string;
-    isWSL: boolean;
-    defaultShell: string;
-    arch: string;
-  };
-}
-
-// Tab component with drop target support
-function TerminalTabButton({
-  tab,
-  isActive,
-  onClick,
-  onClose,
-  isDropTarget,
-}: {
-  tab: TerminalTab;
-  isActive: boolean;
-  onClick: () => void;
-  onClose: () => void;
-  isDropTarget: boolean;
-}) {
-  const { setNodeRef, isOver } = useDroppable({
-    id: `tab-${tab.id}`,
-    data: { type: "tab", tabId: tab.id },
-  });
-
-  return (
-    <div
-      ref={setNodeRef}
-      className={cn(
-        "flex items-center gap-1 px-3 py-1.5 text-sm rounded-t-md border-b-2 cursor-pointer transition-colors",
-        isActive
-          ? "bg-background border-brand-500 text-foreground"
-          : "bg-muted border-transparent text-muted-foreground hover:text-foreground hover:bg-accent",
-        isOver && isDropTarget && "ring-2 ring-green-500"
-      )}
-      onClick={onClick}
-    >
-      <TerminalIcon className="h-3 w-3" />
-      <span className="max-w-24 truncate">{tab.name}</span>
-      <button
-        className="ml-1 p-0.5 rounded hover:bg-accent text-muted-foreground hover:text-destructive"
-        onClick={(e) => {
-          e.stopPropagation();
-          onClose();
-        }}
-      >
-        <X className="h-3 w-3" />
-      </button>
-    </div>
-  );
-}
-
-// New tab drop zone
-function NewTabDropZone({ isDropTarget }: { isDropTarget: boolean }) {
-  const { setNodeRef, isOver } = useDroppable({
-    id: "new-tab-zone",
-    data: { type: "new-tab" },
-  });
-
-  return (
-    <div
-      ref={setNodeRef}
-      className={cn(
-        "flex items-center justify-center px-3 py-1.5 rounded-t-md border-2 border-dashed transition-all",
-        isOver && isDropTarget
-          ? "border-green-500 bg-green-500/10 text-green-500"
-          : "border-transparent text-muted-foreground hover:border-border"
-      )}
-    >
-      <SquarePlus className="h-4 w-4" />
-    </div>
-  );
-}
-
-export function TerminalView() {
-  const {
-    terminalState,
-    setTerminalUnlocked,
-    addTerminalToLayout,
-    removeTerminalFromLayout,
-    setActiveTerminalSession,
-    swapTerminals,
-    currentProject,
-    addTerminalTab,
-    removeTerminalTab,
-    setActiveTerminalTab,
-    moveTerminalToTab,
-    setTerminalPanelFontSize,
-  } = useAppStore();
-
-  const [status, setStatus] = useState<TerminalStatus | null>(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
-  const [password, setPassword] = useState("");
-  const [authLoading, setAuthLoading] = useState(false);
-  const [authError, setAuthError] = useState<string | null>(null);
-  const [activeDragId, setActiveDragId] = useState<string | null>(null);
-  const [dragOverTabId, setDragOverTabId] = useState<string | null>(null);
-  const lastCreateTimeRef = useRef<number>(0);
-  const isCreatingRef = useRef<boolean>(false);
-
-  const serverUrl = process.env.NEXT_PUBLIC_SERVER_URL || "http://localhost:3008";
-  const CREATE_COOLDOWN_MS = 500; // Prevent rapid terminal creation
-
-  // Get active tab
-  const activeTab = terminalState.tabs.find(t => t.id === terminalState.activeTabId);
-
-  // DnD sensors with activation constraint to avoid accidental drags
-  const sensors = useSensors(
-    useSensor(PointerSensor, {
-      activationConstraint: {
-        distance: 8,
-      },
-    })
-  );
-
-  // Handle drag start
-  const handleDragStart = useCallback((event: DragStartEvent) => {
-    setActiveDragId(event.active.id as string);
-  }, []);
-
-  // Handle drag over - track which tab we're hovering
-  const handleDragOver = useCallback((event: DragOverEvent) => {
-    const { over } = event;
-    if (over?.data?.current?.type === "tab") {
-      setDragOverTabId(over.data.current.tabId);
-    } else if (over?.data?.current?.type === "new-tab") {
-      setDragOverTabId("new");
-    } else {
-      setDragOverTabId(null);
-    }
-  }, []);
-
-  // Handle drag end
-  const handleDragEnd = useCallback((event: DragEndEvent) => {
-    const { active, over } = event;
-    setActiveDragId(null);
-    setDragOverTabId(null);
-
-    if (!over) return;
-
-    const activeId = active.id as string;
-    const overData = over.data?.current;
-
-    // If dropped on a tab, move terminal to that tab
-    if (overData?.type === "tab") {
-      moveTerminalToTab(activeId, overData.tabId);
-      return;
-    }
-
-    // If dropped on new tab zone, create new tab with this terminal
-    if (overData?.type === "new-tab") {
-      moveTerminalToTab(activeId, "new");
-      return;
-    }
-
-    // Otherwise, swap terminals within current tab
-    if (active.id !== over.id) {
-      swapTerminals(activeId, over.id as string);
-    }
-  }, [swapTerminals, moveTerminalToTab]);
-
-  // Fetch terminal status
-  const fetchStatus = useCallback(async () => {
-    try {
-      setLoading(true);
-      setError(null);
-      const response = await fetch(`${serverUrl}/api/terminal/status`);
-      const data = await response.json();
-      if (data.success) {
-        setStatus(data.data);
-        if (!data.data.passwordRequired) {
-          setTerminalUnlocked(true);
-        }
-      } else {
-        setError(data.error || "Failed to get terminal status");
-      }
-    } catch (err) {
-      setError("Failed to connect to server");
-      console.error("[Terminal] Status fetch error:", err);
-    } finally {
-      setLoading(false);
-    }
-  }, [serverUrl, setTerminalUnlocked]);
-
-  useEffect(() => {
-    fetchStatus();
-  }, [fetchStatus]);
-
-  // Handle password authentication
-  const handleAuth = async (e: React.FormEvent) => {
-    e.preventDefault();
-    setAuthLoading(true);
-    setAuthError(null);
-
-    try {
-      const response = await fetch(`${serverUrl}/api/terminal/auth`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ password }),
-      });
-      const data = await response.json();
-
-      if (data.success) {
-        setTerminalUnlocked(true, data.data.token);
-        setPassword("");
-      } else {
-        setAuthError(data.error || "Authentication failed");
-      }
-    } catch (err) {
-      setAuthError("Failed to authenticate");
-      console.error("[Terminal] Auth error:", err);
-    } finally {
-      setAuthLoading(false);
-    }
-  };
-
-  // Create a new terminal session
-  // targetSessionId: the terminal to split (if splitting an existing terminal)
-  const createTerminal = async (direction?: "horizontal" | "vertical", targetSessionId?: string) => {
-    // Debounce: prevent rapid terminal creation
-    const now = Date.now();
-    if (now - lastCreateTimeRef.current < CREATE_COOLDOWN_MS || isCreatingRef.current) {
-      console.log("[Terminal] Debounced terminal creation");
-      return;
-    }
-    lastCreateTimeRef.current = now;
-    isCreatingRef.current = true;
-
-    try {
-      const headers: Record<string, string> = {
-        "Content-Type": "application/json",
-      };
-      if (terminalState.authToken) {
-        headers["X-Terminal-Token"] = terminalState.authToken;
-      }
-
-      const response = await fetch(`${serverUrl}/api/terminal/sessions`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          cwd: currentProject?.path || undefined,
-          cols: 80,
-          rows: 24,
-        }),
-      });
-      const data = await response.json();
-
-      if (data.success) {
-        addTerminalToLayout(data.data.id, direction, targetSessionId);
-      } else {
-        console.error("[Terminal] Failed to create session:", data.error);
-      }
-    } catch (err) {
-      console.error("[Terminal] Create session error:", err);
-    } finally {
-      isCreatingRef.current = false;
-    }
-  };
-
-  // Create terminal in new tab
-  const createTerminalInNewTab = async () => {
-    const tabId = addTerminalTab();
-    try {
-      const headers: Record<string, string> = {
-        "Content-Type": "application/json",
-      };
-      if (terminalState.authToken) {
-        headers["X-Terminal-Token"] = terminalState.authToken;
-      }
-
-      const response = await fetch(`${serverUrl}/api/terminal/sessions`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          cwd: currentProject?.path || undefined,
-          cols: 80,
-          rows: 24,
-        }),
-      });
-      const data = await response.json();
-
-      if (data.success) {
-        // Add to the newly created tab
-        const { addTerminalToTab } = useAppStore.getState();
-        addTerminalToTab(data.data.id, tabId);
-      }
-    } catch (err) {
-      console.error("[Terminal] Create session error:", err);
-    }
-  };
-
-  // Kill a terminal session
-  const killTerminal = async (sessionId: string) => {
-    try {
-      const headers: Record<string, string> = {};
-      if (terminalState.authToken) {
-        headers["X-Terminal-Token"] = terminalState.authToken;
-      }
-
-      await fetch(`${serverUrl}/api/terminal/sessions/${sessionId}`, {
-        method: "DELETE",
-        headers,
-      });
-      removeTerminalFromLayout(sessionId);
-    } catch (err) {
-      console.error("[Terminal] Kill session error:", err);
-    }
-  };
-
-  // Get keyboard shortcuts config
-  const shortcuts = useKeyboardShortcutsConfig();
-
-  // Handle terminal-specific keyboard shortcuts
-  useEffect(() => {
-    const handleKeyDown = (e: KeyboardEvent) => {
-      // Only handle shortcuts when terminal is unlocked and has an active session
-      if (!terminalState.isUnlocked || !terminalState.activeSessionId) return;
-
-      const isMac = navigator.platform.toUpperCase().indexOf('MAC') >= 0;
-      const cmdOrCtrl = isMac ? e.metaKey : e.ctrlKey;
-
-      // Parse shortcut string to check for match
-      const matchesShortcut = (shortcutStr: string | undefined) => {
-        if (!shortcutStr) return false;
-        const parts = shortcutStr.toLowerCase().split('+');
-        const key = parts[parts.length - 1];
-        const needsCmd = parts.includes('cmd');
-        const needsShift = parts.includes('shift');
-        const needsAlt = parts.includes('alt');
-
-        // Check modifiers
-        const cmdMatches = needsCmd ? cmdOrCtrl : !cmdOrCtrl;
-        const shiftMatches = needsShift ? e.shiftKey : !e.shiftKey;
-        const altMatches = needsAlt ? e.altKey : !e.altKey;
-
-        return (
-          e.key.toLowerCase() === key &&
-          cmdMatches &&
-          shiftMatches &&
-          altMatches
-        );
-      };
-
-      // Split terminal right (Cmd+D / Ctrl+D)
-      if (matchesShortcut(shortcuts.splitTerminalRight)) {
-        e.preventDefault();
-        createTerminal("horizontal", terminalState.activeSessionId);
-        return;
-      }
-
-      // Split terminal down (Cmd+Shift+D / Ctrl+Shift+D)
-      if (matchesShortcut(shortcuts.splitTerminalDown)) {
-        e.preventDefault();
-        createTerminal("vertical", terminalState.activeSessionId);
-        return;
-      }
-
-      // Close terminal (Cmd+W / Ctrl+W)
-      if (matchesShortcut(shortcuts.closeTerminal)) {
-        e.preventDefault();
-        killTerminal(terminalState.activeSessionId);
-        return;
-      }
-    };
-
-    window.addEventListener('keydown', handleKeyDown);
-    return () => window.removeEventListener('keydown', handleKeyDown);
-  }, [terminalState.isUnlocked, terminalState.activeSessionId, shortcuts]);
-
-  // Get a stable key for a panel
-  const getPanelKey = (panel: TerminalPanelContent): string => {
-    if (panel.type === "terminal") {
-      return panel.sessionId;
-    }
-    return `split-${panel.direction}-${panel.panels.map(getPanelKey).join("-")}`;
-  };
-
-  // Render panel content recursively
-  const renderPanelContent = (content: TerminalPanelContent): React.ReactNode => {
-    if (content.type === "terminal") {
-      // Use per-terminal fontSize or fall back to default
-      const terminalFontSize = content.fontSize ?? terminalState.defaultFontSize;
-      return (
-        <TerminalPanel
-          key={content.sessionId}
-          sessionId={content.sessionId}
-          authToken={terminalState.authToken}
-          isActive={terminalState.activeSessionId === content.sessionId}
-          onFocus={() => setActiveTerminalSession(content.sessionId)}
-          onClose={() => killTerminal(content.sessionId)}
-          onSplitHorizontal={() => createTerminal("horizontal", content.sessionId)}
-          onSplitVertical={() => createTerminal("vertical", content.sessionId)}
-          isDragging={activeDragId === content.sessionId}
-          isDropTarget={activeDragId !== null && activeDragId !== content.sessionId}
-          fontSize={terminalFontSize}
-          onFontSizeChange={(size) => setTerminalPanelFontSize(content.sessionId, size)}
-        />
-      );
-    }
-
-    const isHorizontal = content.direction === "horizontal";
-    const defaultSizePerPanel = 100 / content.panels.length;
-
-    return (
-      <PanelGroup direction={content.direction}>
-        {content.panels.map((panel, index) => {
-          const panelSize = panel.type === "terminal" && panel.size
-            ? panel.size
-            : defaultSizePerPanel;
-
-          return (
-            <React.Fragment key={getPanelKey(panel)}>
-              {index > 0 && (
-                <PanelResizeHandle
-                  className={
-                    isHorizontal
-                      ? "w-1 h-full bg-border hover:bg-brand-500 transition-colors data-[resize-handle-state=hover]:bg-brand-500 data-[resize-handle-state=drag]:bg-brand-500"
-                      : "h-1 w-full bg-border hover:bg-brand-500 transition-colors data-[resize-handle-state=hover]:bg-brand-500 data-[resize-handle-state=drag]:bg-brand-500"
-                  }
-                />
-              )}
-              <Panel defaultSize={panelSize} minSize={15}>
-                {renderPanelContent(panel)}
-              </Panel>
-            </React.Fragment>
-          );
-        })}
-      </PanelGroup>
-    );
-  };
-
-  // Loading state
-  if (loading) {
-    return (
-      <div className="flex-1 flex items-center justify-center">
-        <Loader2 className="h-8 w-8 animate-spin text-muted-foreground" />
-      </div>
-    );
-  }
-
-  // Error state
-  if (error) {
-    return (
-      <div className="flex-1 flex flex-col items-center justify-center text-center p-6">
-        <div className="p-4 rounded-full bg-destructive/10 mb-4">
-          <AlertCircle className="h-12 w-12 text-destructive" />
-        </div>
-        <h2 className="text-lg font-medium mb-2">Terminal Unavailable</h2>
-        <p className="text-muted-foreground max-w-md mb-4">{error}</p>
-        <Button variant="outline" onClick={fetchStatus}>
-          <RefreshCw className="h-4 w-4 mr-2" />
-          Retry
-        </Button>
-      </div>
-    );
-  }
-
-  // Disabled state
-  if (!status?.enabled) {
-    return (
-      <div className="flex-1 flex flex-col items-center justify-center text-center p-6">
-        <div className="p-4 rounded-full bg-muted/50 mb-4">
-          <TerminalIcon className="h-12 w-12 text-muted-foreground" />
-        </div>
-        <h2 className="text-lg font-medium mb-2">Terminal Disabled</h2>
-        <p className="text-muted-foreground max-w-md">
-          Terminal access has been disabled. Set <code className="px-1.5 py-0.5 rounded bg-muted">TERMINAL_ENABLED=true</code> in your server .env file to enable it.
-        </p>
-      </div>
-    );
-  }
-
-  // Password gate
-  if (status.passwordRequired && !terminalState.isUnlocked) {
-    return (
-      <div className="flex-1 flex flex-col items-center justify-center text-center p-6">
-        <div className="p-4 rounded-full bg-muted/50 mb-4">
-          <Lock className="h-12 w-12 text-muted-foreground" />
-        </div>
-        <h2 className="text-lg font-medium mb-2">Terminal Protected</h2>
-        <p className="text-muted-foreground max-w-md mb-6">
-          Terminal access requires authentication. Enter the password to unlock.
-        </p>
-
-        <form onSubmit={handleAuth} className="w-full max-w-xs space-y-4">
-          <Input
-            type="password"
-            placeholder="Enter password"
-            value={password}
-            onChange={(e) => setPassword(e.target.value)}
-            disabled={authLoading}
-            autoFocus
-          />
-          {authError && (
-            <p className="text-sm text-destructive">{authError}</p>
-          )}
-          <Button type="submit" className="w-full" disabled={authLoading || !password}>
-            {authLoading ? (
-              <Loader2 className="h-4 w-4 mr-2 animate-spin" />
-            ) : (
-              <Unlock className="h-4 w-4 mr-2" />
-            )}
-            Unlock Terminal
-          </Button>
-        </form>
-
-        {status.platform && (
-          <p className="text-xs text-muted-foreground mt-6">
-            Platform: {status.platform.platform}
-            {status.platform.isWSL && " (WSL)"}
-            {" | "}Shell: {status.platform.defaultShell}
-          </p>
-        )}
-      </div>
-    );
-  }
-
-  // No terminals yet - show welcome screen
-  if (terminalState.tabs.length === 0) {
-    return (
-      <div className="flex-1 flex flex-col items-center justify-center text-center p-6">
-        <div className="p-4 rounded-full bg-brand-500/10 mb-4">
-          <TerminalIcon className="h-12 w-12 text-brand-500" />
-        </div>
-        <h2 className="text-lg font-medium mb-2">Terminal</h2>
-        <p className="text-muted-foreground max-w-md mb-6">
-          Create a new terminal session to start executing commands.
-          {currentProject && (
-            <span className="block mt-2 text-sm">
-              Working directory: <code className="px-1.5 py-0.5 rounded bg-muted">{currentProject.path}</code>
-            </span>
-          )}
-        </p>
-
-        <Button onClick={() => createTerminal()}>
-          <Plus className="h-4 w-4 mr-2" />
-          New Terminal
-        </Button>
-
-        {status?.platform && (
-          <p className="text-xs text-muted-foreground mt-6">
-            Platform: {status.platform.platform}
-            {status.platform.isWSL && " (WSL)"}
-            {" | "}Shell: {status.platform.defaultShell}
-          </p>
-        )}
-      </div>
-    );
-  }
-
-  // Terminal view with tabs
-  return (
-    <DndContext
-      sensors={sensors}
-      collisionDetection={closestCenter}
-      onDragStart={handleDragStart}
-      onDragOver={handleDragOver}
-      onDragEnd={handleDragEnd}
-    >
-      <div className="flex-1 flex flex-col overflow-hidden">
-        {/* Tab bar */}
-        <div className="flex items-center bg-card border-b border-border px-2">
-          {/* Tabs */}
-          <div className="flex items-center gap-1 flex-1 overflow-x-auto py-1">
-            {terminalState.tabs.map((tab) => (
-              <TerminalTabButton
-                key={tab.id}
-                tab={tab}
-                isActive={tab.id === terminalState.activeTabId}
-                onClick={() => setActiveTerminalTab(tab.id)}
-                onClose={() => removeTerminalTab(tab.id)}
-                isDropTarget={activeDragId !== null}
-              />
-            ))}
-
-            {/* New tab drop zone (visible when dragging) */}
-            {activeDragId && (
-              <NewTabDropZone isDropTarget={true} />
-            )}
-
-            {/* New tab button */}
-            <button
-              className="flex items-center justify-center p-1.5 rounded hover:bg-accent text-muted-foreground hover:text-foreground"
-              onClick={createTerminalInNewTab}
-              title="New Tab"
-            >
-              <Plus className="h-4 w-4" />
-            </button>
-          </div>
-
-          {/* Toolbar buttons */}
-          <div className="flex items-center gap-1 pl-2 border-l border-border">
-            <Button
-              variant="ghost"
-              size="sm"
-              className="h-7 px-2 text-muted-foreground hover:text-foreground"
-              onClick={() => createTerminal("horizontal")}
-              title="Split Right"
-            >
-              <SplitSquareHorizontal className="h-4 w-4" />
-            </Button>
-            <Button
-              variant="ghost"
-              size="sm"
-              className="h-7 px-2 text-muted-foreground hover:text-foreground"
-              onClick={() => createTerminal("vertical")}
-              title="Split Down"
-            >
-              <SplitSquareVertical className="h-4 w-4" />
-            </Button>
-          </div>
-        </div>
-
-        {/* Active tab content */}
-        <div className="flex-1 overflow-hidden bg-background">
-          {activeTab?.layout ? (
-            renderPanelContent(activeTab.layout)
-          ) : (
-            <div className="flex-1 flex flex-col items-center justify-center text-center p-6">
-              <p className="text-muted-foreground mb-4">This tab is empty</p>
-              <Button
-                variant="outline"
-                size="sm"
-                onClick={() => createTerminal()}
-              >
-                <Plus className="h-4 w-4 mr-2" />
-                New Terminal
-              </Button>
-            </div>
-          )}
-        </div>
-      </div>
-
-      {/* Drag overlay */}
-      <DragOverlay dropAnimation={null} zIndex={1000}>
-        {activeDragId ? (
-          <div className="relative inline-flex items-center gap-2 px-3.5 py-2 bg-card border-2 border-brand-500 rounded-lg shadow-xl pointer-events-none overflow-hidden">
-            <TerminalIcon className="h-4 w-4 text-brand-500 shrink-0" />
-            <span className="text-sm font-medium text-foreground whitespace-nowrap">
-              {dragOverTabId === "new"
-                ? "New tab"
-                : dragOverTabId
-                ? "Move to tab"
-                : "Terminal"}
-            </span>
-          </div>
-        ) : null}
-      </DragOverlay>
-    </DndContext>
-  );
-}

apps/app/src/components/views/terminal-view/terminal-panel.tsx

@@ -1,624 +0,0 @@
-"use client";
-
-import { useEffect, useRef, useCallback, useState } from "react";
-import {
-  X,
-  SplitSquareHorizontal,
-  SplitSquareVertical,
-  GripHorizontal,
-  Terminal,
-  ZoomIn,
-  ZoomOut,
-} from "lucide-react";
-import { Button } from "@/components/ui/button";
-import { cn } from "@/lib/utils";
-import { useDraggable, useDroppable } from "@dnd-kit/core";
-import { useAppStore } from "@/store/app-store";
-import { getTerminalTheme } from "@/config/terminal-themes";
-
-// Font size constraints
-const MIN_FONT_SIZE = 8;
-const MAX_FONT_SIZE = 32;
-const DEFAULT_FONT_SIZE = 14;
-
-interface TerminalPanelProps {
-  sessionId: string;
-  authToken: string | null;
-  isActive: boolean;
-  onFocus: () => void;
-  onClose: () => void;
-  onSplitHorizontal: () => void;
-  onSplitVertical: () => void;
-  isDragging?: boolean;
-  isDropTarget?: boolean;
-  fontSize: number;
-  onFontSizeChange: (size: number) => void;
-}
-
-// Type for xterm Terminal - we'll use any since we're dynamically importing
-type XTerminal = InstanceType<typeof import("@xterm/xterm").Terminal>;
-type XFitAddon = InstanceType<typeof import("@xterm/addon-fit").FitAddon>;
-
-export function TerminalPanel({
-  sessionId,
-  authToken,
-  isActive,
-  onFocus,
-  onClose,
-  onSplitHorizontal,
-  onSplitVertical,
-  isDragging = false,
-  isDropTarget = false,
-  fontSize,
-  onFontSizeChange,
-}: TerminalPanelProps) {
-  const terminalRef = useRef<HTMLDivElement>(null);
-  const containerRef = useRef<HTMLDivElement>(null);
-  const xtermRef = useRef<XTerminal | null>(null);
-  const fitAddonRef = useRef<XFitAddon | null>(null);
-  const wsRef = useRef<WebSocket | null>(null);
-  const reconnectTimeoutRef = useRef<NodeJS.Timeout | null>(null);
-  const lastShortcutTimeRef = useRef<number>(0);
-  const [isTerminalReady, setIsTerminalReady] = useState(false);
-  const [shellName, setShellName] = useState("shell");
-
-  // Get effective theme from store
-  const getEffectiveTheme = useAppStore((state) => state.getEffectiveTheme);
-  const effectiveTheme = getEffectiveTheme();
-
-  // Use refs for callbacks and values to avoid effect re-runs
-  const onFocusRef = useRef(onFocus);
-  onFocusRef.current = onFocus;
-  const onCloseRef = useRef(onClose);
-  onCloseRef.current = onClose;
-  const onSplitHorizontalRef = useRef(onSplitHorizontal);
-  onSplitHorizontalRef.current = onSplitHorizontal;
-  const onSplitVerticalRef = useRef(onSplitVertical);
-  onSplitVerticalRef.current = onSplitVertical;
-  const fontSizeRef = useRef(fontSize);
-  fontSizeRef.current = fontSize;
-  const themeRef = useRef(effectiveTheme);
-  themeRef.current = effectiveTheme;
-
-  // Zoom functions - use the prop callback
-  const zoomIn = useCallback(() => {
-    onFontSizeChange(Math.min(fontSize + 1, MAX_FONT_SIZE));
-  }, [fontSize, onFontSizeChange]);
-
-  const zoomOut = useCallback(() => {
-    onFontSizeChange(Math.max(fontSize - 1, MIN_FONT_SIZE));
-  }, [fontSize, onFontSizeChange]);
-
-  const resetZoom = useCallback(() => {
-    onFontSizeChange(DEFAULT_FONT_SIZE);
-  }, [onFontSizeChange]);
-
-  const serverUrl = process.env.NEXT_PUBLIC_SERVER_URL || "http://localhost:3008";
-  const wsUrl = serverUrl.replace(/^http/, "ws");
-
-  // Draggable - only the drag handle triggers drag
-  const {
-    attributes: dragAttributes,
-    listeners: dragListeners,
-    setNodeRef: setDragRef,
-  } = useDraggable({
-    id: sessionId,
-  });
-
-  // Droppable - the entire panel is a drop target
-  const {
-    setNodeRef: setDropRef,
-    isOver,
-  } = useDroppable({
-    id: sessionId,
-  });
-
-  // Initialize terminal - dynamically import xterm to avoid SSR issues
-  useEffect(() => {
-    if (!terminalRef.current) return;
-
-    let mounted = true;
-
-    const initTerminal = async () => {
-      // Dynamically import xterm modules
-      const [
-        { Terminal },
-        { FitAddon },
-        { WebglAddon },
-      ] = await Promise.all([
-        import("@xterm/xterm"),
-        import("@xterm/addon-fit"),
-        import("@xterm/addon-webgl"),
-      ]);
-
-      // Also import CSS
-      await import("@xterm/xterm/css/xterm.css");
-
-      if (!mounted || !terminalRef.current) return;
-
-      // Get terminal theme matching the app theme
-      const terminalTheme = getTerminalTheme(themeRef.current);
-
-      // Create terminal instance with the current global font size and theme
-      const terminal = new Terminal({
-        cursorBlink: true,
-        cursorStyle: "block",
-        fontSize: fontSizeRef.current,
-        fontFamily: "Menlo, Monaco, 'Courier New', monospace",
-        theme: terminalTheme,
-        allowProposedApi: true,
-      });
-
-      // Create fit addon
-      const fitAddon = new FitAddon();
-      terminal.loadAddon(fitAddon);
-
-      // Open terminal
-      terminal.open(terminalRef.current);
-
-      // Try to load WebGL addon for better performance
-      try {
-        const webglAddon = new WebglAddon();
-        webglAddon.onContextLoss(() => {
-          webglAddon.dispose();
-        });
-        terminal.loadAddon(webglAddon);
-      } catch {
-        console.warn("[Terminal] WebGL addon not available, falling back to canvas");
-      }
-
-      // Fit terminal to container
-      setTimeout(() => {
-        fitAddon.fit();
-      }, 0);
-
-      xtermRef.current = terminal;
-      fitAddonRef.current = fitAddon;
-      setIsTerminalReady(true);
-
-      // Handle focus - use ref to avoid re-running effect
-      terminal.onData(() => {
-        onFocusRef.current();
-      });
-
-      // Custom key handler to intercept terminal shortcuts
-      // Return false to prevent xterm from handling the key
-      const SHORTCUT_COOLDOWN_MS = 300; // Prevent rapid firing
-
-      terminal.attachCustomKeyEventHandler((event) => {
-        // Only intercept keydown events
-        if (event.type !== 'keydown') return true;
-
-        // Check cooldown to prevent rapid terminal creation
-        const now = Date.now();
-        const canTrigger = now - lastShortcutTimeRef.current > SHORTCUT_COOLDOWN_MS;
-
-        // Use event.code for keyboard-layout-independent key detection
-        const code = event.code;
-
-        // Alt+D - Split right
-        if (event.altKey && !event.shiftKey && !event.ctrlKey && !event.metaKey && code === 'KeyD') {
-          event.preventDefault();
-          if (canTrigger) {
-            lastShortcutTimeRef.current = now;
-            onSplitHorizontalRef.current();
-          }
-          return false;
-        }
-
-        // Alt+S - Split down
-        if (event.altKey && !event.shiftKey && !event.ctrlKey && !event.metaKey && code === 'KeyS') {
-          event.preventDefault();
-          if (canTrigger) {
-            lastShortcutTimeRef.current = now;
-            onSplitVerticalRef.current();
-          }
-          return false;
-        }
-
-        // Alt+W - Close terminal
-        if (event.altKey && !event.shiftKey && !event.ctrlKey && !event.metaKey && code === 'KeyW') {
-          event.preventDefault();
-          if (canTrigger) {
-            lastShortcutTimeRef.current = now;
-            onCloseRef.current();
-          }
-          return false;
-        }
-
-        // Let xterm handle all other keys
-        return true;
-      });
-    };
-
-    initTerminal();
-
-    // Cleanup
-    return () => {
-      mounted = false;
-      if (xtermRef.current) {
-        xtermRef.current.dispose();
-        xtermRef.current = null;
-      }
-      fitAddonRef.current = null;
-      setIsTerminalReady(false);
-    };
-  }, []); // No dependencies - only run once on mount
-
-  // Connect WebSocket - wait for terminal to be ready
-  useEffect(() => {
-    if (!isTerminalReady || !sessionId) return;
-    const terminal = xtermRef.current;
-    if (!terminal) return;
-
-    const connect = () => {
-      // Build WebSocket URL with token
-      let url = `${wsUrl}/api/terminal/ws?sessionId=${sessionId}`;
-      if (authToken) {
-        url += `&token=${encodeURIComponent(authToken)}`;
-      }
-
-      const ws = new WebSocket(url);
-      wsRef.current = ws;
-
-      ws.onopen = () => {
-        console.log(`[Terminal] WebSocket connected for session ${sessionId}`);
-      };
-
-      ws.onmessage = (event) => {
-        try {
-          const msg = JSON.parse(event.data);
-          switch (msg.type) {
-            case "data":
-              terminal.write(msg.data);
-              break;
-            case "scrollback":
-              // Replay scrollback buffer (previous terminal output)
-              if (msg.data) {
-                terminal.write(msg.data);
-              }
-              break;
-            case "connected":
-              console.log(`[Terminal] Session connected: ${msg.shell} in ${msg.cwd}`);
-              if (msg.shell) {
-                // Extract shell name from path (e.g., "/bin/bash" -> "bash")
-                const name = msg.shell.split("/").pop() || msg.shell;
-                setShellName(name);
-              }
-              break;
-            case "exit":
-              terminal.write(`\r\n\x1b[33m[Process exited with code ${msg.exitCode}]\x1b[0m\r\n`);
-              break;
-            case "pong":
-              // Heartbeat response
-              break;
-          }
-        } catch (err) {
-          console.error("[Terminal] Message parse error:", err);
-        }
-      };
-
-      ws.onclose = (event) => {
-        console.log(`[Terminal] WebSocket closed for session ${sessionId}:`, event.code, event.reason);
-        wsRef.current = null;
-
-        // Don't reconnect if closed normally or auth failed
-        if (event.code === 1000 || event.code === 4001 || event.code === 4003) {
-          return;
-        }
-
-        // Attempt reconnect after a delay
-        reconnectTimeoutRef.current = setTimeout(() => {
-          if (xtermRef.current) {
-            console.log(`[Terminal] Attempting reconnect for session ${sessionId}`);
-            connect();
-          }
-        }, 2000);
-      };
-
-      ws.onerror = (error) => {
-        console.error(`[Terminal] WebSocket error for session ${sessionId}:`, error);
-      };
-    };
-
-    connect();
-
-    // Handle terminal input
-    const dataHandler = terminal.onData((data) => {
-      if (wsRef.current?.readyState === WebSocket.OPEN) {
-        wsRef.current.send(JSON.stringify({ type: "input", data }));
-      }
-    });
-
-    // Cleanup
-    return () => {
-      dataHandler.dispose();
-      if (reconnectTimeoutRef.current) {
-        clearTimeout(reconnectTimeoutRef.current);
-      }
-      if (wsRef.current) {
-        wsRef.current.close();
-        wsRef.current = null;
-      }
-    };
-  }, [sessionId, authToken, wsUrl, isTerminalReady]);
-
-  // Handle resize
-  const handleResize = useCallback(() => {
-    if (fitAddonRef.current && xtermRef.current) {
-      fitAddonRef.current.fit();
-      const { cols, rows } = xtermRef.current;
-
-      // Send resize to server
-      if (wsRef.current?.readyState === WebSocket.OPEN) {
-        wsRef.current.send(JSON.stringify({ type: "resize", cols, rows }));
-      }
-    }
-  }, []);
-
-  // Resize observer
-  useEffect(() => {
-    const container = terminalRef.current;
-    if (!container) return;
-
-    const resizeObserver = new ResizeObserver(() => {
-      handleResize();
-    });
-
-    resizeObserver.observe(container);
-
-    // Also handle window resize
-    window.addEventListener("resize", handleResize);
-
-    return () => {
-      resizeObserver.disconnect();
-      window.removeEventListener("resize", handleResize);
-    };
-  }, [handleResize]);
-
-  // Focus terminal when becoming active
-  useEffect(() => {
-    if (isActive && xtermRef.current) {
-      xtermRef.current.focus();
-    }
-  }, [isActive]);
-
-  // Update terminal font size when it changes
-  useEffect(() => {
-    if (xtermRef.current && isTerminalReady) {
-      xtermRef.current.options.fontSize = fontSize;
-      // Refit after font size change
-      if (fitAddonRef.current) {
-        fitAddonRef.current.fit();
-        // Notify server of new dimensions
-        const { cols, rows } = xtermRef.current;
-        if (wsRef.current?.readyState === WebSocket.OPEN) {
-          wsRef.current.send(JSON.stringify({ type: "resize", cols, rows }));
-        }
-      }
-    }
-  }, [fontSize, isTerminalReady]);
-
-  // Update terminal theme when app theme changes
-  useEffect(() => {
-    if (xtermRef.current && isTerminalReady) {
-      const terminalTheme = getTerminalTheme(effectiveTheme);
-      xtermRef.current.options.theme = terminalTheme;
-    }
-  }, [effectiveTheme, isTerminalReady]);
-
-  // Handle keyboard shortcuts for zoom (Ctrl+Plus, Ctrl+Minus, Ctrl+0)
-  useEffect(() => {
-    const container = containerRef.current;
-    if (!container) return;
-
-    const handleKeyDown = (e: KeyboardEvent) => {
-      // Only handle if Ctrl (or Cmd on Mac) is pressed
-      if (!e.ctrlKey && !e.metaKey) return;
-
-      // Ctrl/Cmd + Plus or Ctrl/Cmd + = (for keyboards without numpad)
-      if (e.key === "+" || e.key === "=") {
-        e.preventDefault();
-        e.stopPropagation();
-        zoomIn();
-        return;
-      }
-
-      // Ctrl/Cmd + Minus
-      if (e.key === "-") {
-        e.preventDefault();
-        e.stopPropagation();
-        zoomOut();
-        return;
-      }
-
-      // Ctrl/Cmd + 0 to reset
-      if (e.key === "0") {
-        e.preventDefault();
-        e.stopPropagation();
-        resetZoom();
-        return;
-      }
-    };
-
-    container.addEventListener("keydown", handleKeyDown);
-    return () => container.removeEventListener("keydown", handleKeyDown);
-  }, [zoomIn, zoomOut, resetZoom]);
-
-  // Handle mouse wheel zoom (Ctrl+Wheel)
-  useEffect(() => {
-    const container = containerRef.current;
-    if (!container) return;
-
-    const handleWheel = (e: WheelEvent) => {
-      // Only zoom if Ctrl (or Cmd on Mac) is pressed
-      if (!e.ctrlKey && !e.metaKey) return;
-
-      e.preventDefault();
-      e.stopPropagation();
-
-      if (e.deltaY < 0) {
-        // Scroll up = zoom in
-        zoomIn();
-      } else if (e.deltaY > 0) {
-        // Scroll down = zoom out
-        zoomOut();
-      }
-    };
-
-    // Use passive: false to allow preventDefault
-    container.addEventListener("wheel", handleWheel, { passive: false });
-    return () => container.removeEventListener("wheel", handleWheel);
-  }, [zoomIn, zoomOut]);
-
-  // Combine refs for the container
-  const setRefs = useCallback((node: HTMLDivElement | null) => {
-    containerRef.current = node;
-    setDropRef(node);
-  }, [setDropRef]);
-
-  // Get current terminal theme for xterm styling
-  const currentTerminalTheme = getTerminalTheme(effectiveTheme);
-
-  return (
-    <div
-      ref={setRefs}
-      className={cn(
-        "flex flex-col h-full relative",
-        isActive && "ring-1 ring-brand-500 ring-inset",
-        // Visual feedback when dragging this terminal
-        isDragging && "opacity-50",
-        // Visual feedback when hovering over as drop target
-        isOver && isDropTarget && "ring-2 ring-green-500 ring-inset"
-      )}
-      onClick={onFocus}
-      tabIndex={0}
-      data-terminal-container="true"
-    >
-      {/* Drop indicator overlay */}
-      {isOver && isDropTarget && (
-        <div className="absolute inset-0 bg-green-500/10 z-10 pointer-events-none flex items-center justify-center">
-          <div className="px-3 py-2 bg-green-500/90 rounded-md text-white text-sm font-medium">
-            Drop to swap
-          </div>
-        </div>
-      )}
-
-      {/* Header bar with drag handle - uses app theme CSS variables */}
-      <div className="flex items-center h-7 px-1 shrink-0 bg-card border-b border-border">
-        {/* Drag handle */}
-        <button
-          ref={setDragRef}
-          {...dragAttributes}
-          {...dragListeners}
-          className={cn(
-            "p-1 rounded cursor-grab active:cursor-grabbing mr-1 transition-colors text-muted-foreground hover:text-foreground hover:bg-accent",
-            isDragging && "cursor-grabbing"
-          )}
-          title="Drag to swap terminals"
-        >
-          <GripHorizontal className="h-3 w-3" />
-        </button>
-
-        {/* Terminal icon and label */}
-        <div className="flex items-center gap-1.5 flex-1 min-w-0">
-          <Terminal className="h-3 w-3 shrink-0 text-muted-foreground" />
-          <span className="text-xs truncate text-foreground">
-            {shellName}
-          </span>
-          {/* Font size indicator - only show when not default */}
-          {fontSize !== DEFAULT_FONT_SIZE && (
-            <button
-              onClick={(e) => {
-                e.stopPropagation();
-                resetZoom();
-              }}
-              className="text-[10px] px-1 rounded transition-colors text-muted-foreground hover:text-foreground hover:bg-accent"
-              title="Click to reset zoom (Ctrl+0)"
-            >
-              {fontSize}px
-            </button>
-          )}
-        </div>
-
-        {/* Zoom and action buttons */}
-        <div className="flex items-center gap-0.5">
-          {/* Zoom controls */}
-          <Button
-            variant="ghost"
-            size="icon"
-            className="h-5 w-5 text-muted-foreground hover:text-foreground"
-            onClick={(e) => {
-              e.stopPropagation();
-              zoomOut();
-            }}
-            title="Zoom Out (Ctrl+-)"
-            disabled={fontSize <= MIN_FONT_SIZE}
-          >
-            <ZoomOut className="h-3 w-3" />
-          </Button>
-          <Button
-            variant="ghost"
-            size="icon"
-            className="h-5 w-5 text-muted-foreground hover:text-foreground"
-            onClick={(e) => {
-              e.stopPropagation();
-              zoomIn();
-            }}
-            title="Zoom In (Ctrl++)"
-            disabled={fontSize >= MAX_FONT_SIZE}
-          >
-            <ZoomIn className="h-3 w-3" />
-          </Button>
-
-          <div className="w-px h-3 mx-0.5 bg-border" />
-
-          {/* Split/close buttons */}
-          <Button
-            variant="ghost"
-            size="icon"
-            className="h-5 w-5 text-muted-foreground hover:text-foreground"
-            onClick={(e) => {
-              e.stopPropagation();
-              onSplitHorizontal();
-            }}
-            title="Split Right (Cmd+D)"
-          >
-            <SplitSquareHorizontal className="h-3 w-3" />
-          </Button>
-          <Button
-            variant="ghost"
-            size="icon"
-            className="h-5 w-5 text-muted-foreground hover:text-foreground"
-            onClick={(e) => {
-              e.stopPropagation();
-              onSplitVertical();
-            }}
-            title="Split Down (Cmd+Shift+D)"
-          >
-            <SplitSquareVertical className="h-3 w-3" />
-          </Button>
-          <Button
-            variant="ghost"
-            size="icon"
-            className="h-5 w-5 text-muted-foreground hover:text-destructive"
-            onClick={(e) => {
-              e.stopPropagation();
-              onClose();
-            }}
-            title="Close Terminal (Cmd+W)"
-          >
-            <X className="h-3 w-3" />
-          </Button>
-        </div>
-      </div>
-
-      {/* Terminal container - uses terminal theme */}
-      <div
-        ref={terminalRef}
-        className="flex-1 overflow-hidden"
-        style={{ backgroundColor: currentTerminalTheme.background }}
-      />
-    </div>
-  );
-}

apps/app/src/components/views/wiki-view.tsx

@@ -1,479 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import { cn } from "@/lib/utils";
-import {
-  ChevronDown,
-  ChevronRight,
-  Rocket,
-  Layers,
-  Sparkles,
-  GitBranch,
-  FolderTree,
-  Component,
-  Settings,
-  PlayCircle,
-  Bot,
-  LayoutGrid,
-  FileText,
-  Terminal,
-  Palette,
-  Keyboard,
-  Cpu,
-  Zap,
-  Image,
-  TestTube,
-  Brain,
-  Users,
-} from "lucide-react";
-
-interface WikiSection {
-  id: string;
-  title: string;
-  icon: React.ElementType;
-  content: React.ReactNode;
-}
-
-function CollapsibleSection({
-  section,
-  isOpen,
-  onToggle,
-}: {
-  section: WikiSection;
-  isOpen: boolean;
-  onToggle: () => void;
-}) {
-  const Icon = section.icon;
-
-  return (
-    <div className="border border-border rounded-lg overflow-hidden bg-card/50 backdrop-blur-sm">
-      <button
-        onClick={onToggle}
-        className="w-full flex items-center gap-3 p-4 text-left hover:bg-accent/50 transition-colors"
-      >
-        <div className="flex items-center justify-center w-8 h-8 rounded-lg bg-brand-500/10 text-brand-500">
-          <Icon className="w-4 h-4" />
-        </div>
-        <span className="flex-1 font-medium text-foreground">{section.title}</span>
-        {isOpen ? (
-          <ChevronDown className="w-4 h-4 text-muted-foreground" />
-        ) : (
-          <ChevronRight className="w-4 h-4 text-muted-foreground" />
-        )}
-      </button>
-      {isOpen && (
-        <div className="px-4 pb-4 pt-0 border-t border-border/50">
-          <div className="pt-4 text-sm text-muted-foreground leading-relaxed">
-            {section.content}
-          </div>
-        </div>
-      )}
-    </div>
-  );
-}
-
-function CodeBlock({ children, title }: { children: string; title?: string }) {
-  return (
-    <div className="my-3 rounded-lg overflow-hidden border border-border">
-      {title && (
-        <div className="px-3 py-1.5 bg-muted/50 border-b border-border text-xs font-medium text-muted-foreground">
-          {title}
-        </div>
-      )}
-      <pre className="p-3 bg-muted/30 overflow-x-auto text-xs font-mono text-foreground">
-        {children}
-      </pre>
-    </div>
-  );
-}
-
-function FeatureList({ items }: { items: { icon: React.ElementType; title: string; description: string }[] }) {
-  return (
-    <div className="grid gap-3 mt-3">
-      {items.map((item, index) => {
-        const ItemIcon = item.icon;
-        return (
-          <div key={index} className="flex items-start gap-3 p-3 rounded-lg bg-muted/30 border border-border/50">
-            <div className="flex items-center justify-center w-6 h-6 rounded bg-brand-500/10 text-brand-500 shrink-0 mt-0.5">
-              <ItemIcon className="w-3.5 h-3.5" />
-            </div>
-            <div>
-              <div className="font-medium text-foreground text-sm">{item.title}</div>
-              <div className="text-xs text-muted-foreground mt-0.5">{item.description}</div>
-            </div>
-          </div>
-        );
-      })}
-    </div>
-  );
-}
-
-export function WikiView() {
-  const [openSections, setOpenSections] = useState<Set<string>>(new Set(["overview"]));
-
-  const toggleSection = (id: string) => {
-    setOpenSections((prev) => {
-      const newSet = new Set(prev);
-      if (newSet.has(id)) {
-        newSet.delete(id);
-      } else {
-        newSet.add(id);
-      }
-      return newSet;
-    });
-  };
-
-  const expandAll = () => {
-    setOpenSections(new Set(sections.map((s) => s.id)));
-  };
-
-  const collapseAll = () => {
-    setOpenSections(new Set());
-  };
-
-  const sections: WikiSection[] = [
-    {
-      id: "overview",
-      title: "Project Overview",
-      icon: Rocket,
-      content: (
-        <div className="space-y-3">
-          <p>
-            <strong className="text-foreground">Automaker</strong> is an autonomous AI development studio that helps developers build software faster using AI agents.
-          </p>
-          <p>
-            At its core, Automaker provides a visual Kanban board to manage features. When you're ready, AI agents automatically implement those features in your codebase, complete with git worktree isolation for safe parallel development.
-          </p>
-          <div className="p-3 rounded-lg bg-brand-500/10 border border-brand-500/20 mt-4">
-            <p className="text-brand-400 text-sm">
-              Think of it as having a team of AI developers that can work on multiple features simultaneously while you focus on the bigger picture.
-            </p>
-          </div>
-        </div>
-      ),
-    },
-    {
-      id: "architecture",
-      title: "Architecture",
-      icon: Layers,
-      content: (
-        <div className="space-y-3">
-          <p>Automaker is built as a monorepo with two main applications:</p>
-          <ul className="list-disc list-inside space-y-2 ml-2">
-            <li>
-              <strong className="text-foreground">apps/app</strong> - Next.js + Electron frontend for the desktop application
-            </li>
-            <li>
-              <strong className="text-foreground">apps/server</strong> - Express backend handling API requests and agent orchestration
-            </li>
-          </ul>
-          <div className="mt-4 space-y-2">
-            <p className="font-medium text-foreground">Key Technologies:</p>
-            <ul className="list-disc list-inside space-y-1 ml-2">
-              <li>Electron wraps Next.js for cross-platform desktop support</li>
-              <li>Real-time communication via WebSocket for live agent updates</li>
-              <li>State management with Zustand for reactive UI updates</li>
-              <li>Claude Agent SDK for AI capabilities</li>
-            </ul>
-          </div>
-        </div>
-      ),
-    },
-    {
-      id: "features",
-      title: "Key Features",
-      icon: Sparkles,
-      content: (
-        <div>
-          <FeatureList
-            items={[
-              {
-                icon: LayoutGrid,
-                title: "Kanban Board",
-                description: "4 columns: Backlog, In Progress, Waiting Approval, Verified. Drag and drop to manage feature lifecycle.",
-              },
-              {
-                icon: Bot,
-                title: "AI Agent Integration",
-                description: "Powered by Claude via the Agent SDK with full file, bash, and git access.",
-              },
-              {
-                icon: Cpu,
-                title: "Multi-Model Support",
-                description: "Claude Haiku/Sonnet/Opus models. Choose the right model for each task.",
-              },
-              {
-                icon: Brain,
-                title: "Extended Thinking",
-                description: "Configurable thinking levels (none, low, medium, high, ultrathink) for complex tasks.",
-              },
-              {
-                icon: Zap,
-                title: "Real-time Streaming",
-                description: "Watch AI agents work in real-time with live output streaming.",
-              },
-              {
-                icon: GitBranch,
-                title: "Git Worktree Isolation",
-                description: "Each feature runs in its own git worktree for safe parallel development.",
-              },
-              {
-                icon: Users,
-                title: "AI Profiles",
-                description: "Pre-configured model + thinking level combinations for different task types.",
-              },
-              {
-                icon: Terminal,
-                title: "Integrated Terminal",
-                description: "Built-in terminal with tab support and split panes.",
-              },
-              {
-                icon: Keyboard,
-                title: "Keyboard Shortcuts",
-                description: "Fully customizable shortcuts for power users.",
-              },
-              {
-                icon: Palette,
-                title: "14 Themes",
-                description: "From light to dark, retro to synthwave - pick your style.",
-              },
-              {
-                icon: Image,
-                title: "Image Support",
-                description: "Attach images to features for visual context.",
-              },
-              {
-                icon: TestTube,
-                title: "Test Integration",
-                description: "Automatic test running and TDD support for quality assurance.",
-              },
-            ]}
-          />
-        </div>
-      ),
-    },
-    {
-      id: "data-flow",
-      title: "How It Works (Data Flow)",
-      icon: GitBranch,
-      content: (
-        <div className="space-y-3">
-          <p>Here's what happens when you use Automaker to implement a feature:</p>
-          <ol className="list-decimal list-inside space-y-3 ml-2 mt-4">
-            <li className="text-foreground">
-              <strong>Create Feature</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Add a new feature card to the Kanban board with description and steps</p>
-            </li>
-            <li className="text-foreground">
-              <strong>Feature Saved</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Feature saved to <code className="px-1 py-0.5 bg-muted rounded text-xs">.automaker/features/&#123;id&#125;/feature.json</code></p>
-            </li>
-            <li className="text-foreground">
-              <strong>Start Work</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Drag to "In Progress" or enable auto mode to start implementation</p>
-            </li>
-            <li className="text-foreground">
-              <strong>Git Worktree Created</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Backend AutoModeService creates isolated git worktree (if enabled)</p>
-            </li>
-            <li className="text-foreground">
-              <strong>Agent Executes</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Claude Agent SDK runs with file/bash/git tool access</p>
-            </li>
-            <li className="text-foreground">
-              <strong>Progress Streamed</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Real-time updates via WebSocket as agent works</p>
-            </li>
-            <li className="text-foreground">
-              <strong>Completion</strong>
-              <p className="text-muted-foreground ml-5 mt-1">On success, feature moves to "waiting_approval" for your review</p>
-            </li>
-            <li className="text-foreground">
-              <strong>Verify</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Review changes and move to "verified" when satisfied</p>
-            </li>
-          </ol>
-        </div>
-      ),
-    },
-    {
-      id: "structure",
-      title: "Project Structure",
-      icon: FolderTree,
-      content: (
-        <div>
-          <p className="mb-3">The Automaker codebase is organized as follows:</p>
-          <CodeBlock title="Directory Structure">
-{`/automaker/
-├── apps/
-│   ├── app/              # Frontend (Next.js + Electron)
-│   │   ├── electron/     # Electron main process
-│   │   └── src/
-│   │       ├── app/      # Next.js App Router pages
-│   │       ├── components/  # React components
-│   │       ├── store/    # Zustand state management
-│   │       ├── hooks/    # Custom React hooks
-│   │       └── lib/      # Utilities and helpers
-│   └── server/           # Backend (Express)
-│       └── src/
-│           ├── routes/   # API endpoints
-│           └── services/ # Business logic (AutoModeService, etc.)
-├── docs/                 # Documentation
-└── package.json          # Workspace root`}
-          </CodeBlock>
-        </div>
-      ),
-    },
-    {
-      id: "components",
-      title: "Key Components",
-      icon: Component,
-      content: (
-        <div className="space-y-3">
-          <p>The main UI components that make up Automaker:</p>
-          <div className="grid gap-2 mt-4">
-            {[
-              { file: "sidebar.tsx", desc: "Main navigation with project picker and view switching" },
-              { file: "board-view.tsx", desc: "Kanban board with drag-and-drop cards" },
-              { file: "agent-view.tsx", desc: "AI chat interface for conversational development" },
-              { file: "spec-view.tsx", desc: "Project specification editor" },
-              { file: "context-view.tsx", desc: "Context file manager for AI context" },
-              { file: "terminal-view.tsx", desc: "Integrated terminal with splits and tabs" },
-              { file: "profiles-view.tsx", desc: "AI profile management (model + thinking presets)" },
-              { file: "app-store.ts", desc: "Central Zustand state management" },
-            ].map((item) => (
-              <div key={item.file} className="flex items-center gap-3 p-2 rounded bg-muted/30 border border-border/50">
-                <code className="text-xs font-mono text-brand-400 bg-brand-500/10 px-2 py-0.5 rounded">{item.file}</code>
-                <span className="text-xs text-muted-foreground">{item.desc}</span>
-              </div>
-            ))}
-          </div>
-        </div>
-      ),
-    },
-    {
-      id: "configuration",
-      title: "Configuration",
-      icon: Settings,
-      content: (
-        <div className="space-y-3">
-          <p>Automaker stores project configuration in the <code className="px-1 py-0.5 bg-muted rounded text-xs">.automaker/</code> directory:</p>
-          <div className="grid gap-2 mt-4">
-            {[
-              { file: "app_spec.txt", desc: "Project specification describing your app for AI context" },
-              { file: "context/", desc: "Additional context files (docs, examples) for AI" },
-              { file: "features/", desc: "Feature definitions with descriptions and steps" },
-            ].map((item) => (
-              <div key={item.file} className="flex items-center gap-3 p-2 rounded bg-muted/30 border border-border/50">
-                <code className="text-xs font-mono text-brand-400 bg-brand-500/10 px-2 py-0.5 rounded">{item.file}</code>
-                <span className="text-xs text-muted-foreground">{item.desc}</span>
-              </div>
-            ))}
-          </div>
-          <div className="mt-4 p-3 rounded-lg bg-muted/30 border border-border/50">
-            <p className="text-sm text-foreground font-medium mb-2">Tip: App Spec Best Practices</p>
-            <ul className="list-disc list-inside space-y-1 text-xs text-muted-foreground">
-              <li>Include your tech stack and key dependencies</li>
-              <li>Describe the project structure and conventions</li>
-              <li>List any important patterns or architectural decisions</li>
-              <li>Note testing requirements and coding standards</li>
-            </ul>
-          </div>
-        </div>
-      ),
-    },
-    {
-      id: "getting-started",
-      title: "Getting Started",
-      icon: PlayCircle,
-      content: (
-        <div className="space-y-3">
-          <p>Follow these steps to start building with Automaker:</p>
-          <ol className="list-decimal list-inside space-y-4 ml-2 mt-4">
-            <li className="text-foreground">
-              <strong>Create or Open a Project</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Use the sidebar to create a new project or open an existing folder</p>
-            </li>
-            <li className="text-foreground">
-              <strong>Write an App Spec</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Go to Spec Editor and describe your project. This helps AI understand your codebase.</p>
-            </li>
-            <li className="text-foreground">
-              <strong>Add Context (Optional)</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Add relevant documentation or examples to the Context view for better AI results</p>
-            </li>
-            <li className="text-foreground">
-              <strong>Create Features</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Add feature cards to your Kanban board with clear descriptions and implementation steps</p>
-            </li>
-            <li className="text-foreground">
-              <strong>Configure AI Profile</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Choose an AI profile or customize model/thinking settings per feature</p>
-            </li>
-            <li className="text-foreground">
-              <strong>Start Implementation</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Drag features to "In Progress" or enable auto mode to let AI work</p>
-            </li>
-            <li className="text-foreground">
-              <strong>Review and Verify</strong>
-              <p className="text-muted-foreground ml-5 mt-1">Check completed features, review changes, and mark as verified</p>
-            </li>
-          </ol>
-          <div className="mt-6 p-4 rounded-lg bg-brand-500/10 border border-brand-500/20">
-            <p className="text-brand-400 text-sm font-medium mb-2">Pro Tips:</p>
-            <ul className="list-disc list-inside space-y-1 text-xs text-brand-400/80">
-              <li>Use keyboard shortcuts for faster navigation (press <code className="px-1 py-0.5 bg-brand-500/20 rounded">?</code> to see all)</li>
-              <li>Enable git worktree isolation for parallel feature development</li>
-              <li>Start with "Quick Edit" profile for simple tasks, use "Heavy Task" for complex work</li>
-              <li>Keep your app spec up to date as your project evolves</li>
-            </ul>
-          </div>
-        </div>
-      ),
-    },
-  ];
-
-  return (
-    <div className="flex-1 flex flex-col overflow-hidden bg-background">
-      {/* Header */}
-      <div className="border-b border-border bg-card/30 backdrop-blur-sm px-6 py-4 shrink-0">
-        <div className="flex items-center justify-between">
-          <div>
-            <h1 className="text-xl font-semibold text-foreground">Wiki</h1>
-            <p className="text-sm text-muted-foreground mt-1">
-              Learn how Automaker works and how to use it effectively
-            </p>
-          </div>
-          <div className="flex items-center gap-2">
-            <button
-              onClick={expandAll}
-              className="px-3 py-1.5 text-xs font-medium text-muted-foreground hover:text-foreground hover:bg-accent rounded-md transition-colors"
-            >
-              Expand All
-            </button>
-            <button
-              onClick={collapseAll}
-              className="px-3 py-1.5 text-xs font-medium text-muted-foreground hover:text-foreground hover:bg-accent rounded-md transition-colors"
-            >
-              Collapse All
-            </button>
-          </div>
-        </div>
-      </div>
-
-      {/* Content */}
-      <div className="flex-1 overflow-y-auto">
-        <div className="max-w-4xl mx-auto px-6 py-6 space-y-3">
-          {sections.map((section) => (
-            <CollapsibleSection
-              key={section.id}
-              section={section}
-              isOpen={openSections.has(section.id)}
-              onToggle={() => toggleSection(section.id)}
-            />
-          ))}
-        </div>
-      </div>
-    </div>
-  );
-}

apps/app/src/config/model-config.ts

@@ -1,94 +0,0 @@
-/**
- * Model Configuration - Centralized model settings for the app
- *
- * Models can be overridden via environment variables:
- * - AUTOMAKER_MODEL_CHAT: Model for chat interactions
- * - AUTOMAKER_MODEL_DEFAULT: Fallback model for all operations
- */
-
-/**
- * Claude model aliases for convenience
- */
-export const CLAUDE_MODEL_MAP: Record<string, string> = {
-  haiku: "claude-haiku-4-5",
-  sonnet: "claude-sonnet-4-20250514",
-  opus: "claude-opus-4-5-20251101",
-} as const;
-
-/**
- * Default models per use case
- */
-export const DEFAULT_MODELS = {
-  chat: "claude-opus-4-5-20251101",
-  default: "claude-opus-4-5-20251101",
-} as const;
-
-/**
- * Resolve a model alias to a full model string
- */
-export function resolveModelString(
-  modelKey?: string,
-  defaultModel: string = DEFAULT_MODELS.default
-): string {
-  if (!modelKey) {
-    return defaultModel;
-  }
-
-  // Full Claude model string - pass through
-  if (modelKey.includes("claude-")) {
-    return modelKey;
-  }
-
-  // Check alias map
-  const resolved = CLAUDE_MODEL_MAP[modelKey];
-  if (resolved) {
-    return resolved;
-  }
-
-  // Unknown key - use default
-  return defaultModel;
-}
-
-/**
- * Get the model for chat operations
- *
- * Priority:
- * 1. Explicit model parameter
- * 2. AUTOMAKER_MODEL_CHAT environment variable
- * 3. AUTOMAKER_MODEL_DEFAULT environment variable
- * 4. Default chat model
- */
-export function getChatModel(explicitModel?: string): string {
-  if (explicitModel) {
-    return resolveModelString(explicitModel);
-  }
-
-  const envModel =
-    process.env.AUTOMAKER_MODEL_CHAT || process.env.AUTOMAKER_MODEL_DEFAULT;
-
-  if (envModel) {
-    return resolveModelString(envModel);
-  }
-
-  return DEFAULT_MODELS.chat;
-}
-
-/**
- * Default allowed tools for chat interactions
- */
-export const CHAT_TOOLS = [
-  "Read",
-  "Write",
-  "Edit",
-  "Glob",
-  "Grep",
-  "Bash",
-  "WebSearch",
-  "WebFetch",
-] as const;
-
-/**
- * Default max turns for chat
- */
-export const CHAT_MAX_TURNS = 1000;
-

apps/app/src/config/terminal-themes.ts

@@ -1,393 +0,0 @@
-/**
- * Terminal themes that match the app themes
- * Each theme provides colors for xterm.js terminal emulator
- */
-
-import type { ThemeMode } from "@/store/app-store";
-
-export interface TerminalTheme {
-  background: string;
-  foreground: string;
-  cursor: string;
-  cursorAccent: string;
-  selectionBackground: string;
-  selectionForeground?: string;
-  black: string;
-  red: string;
-  green: string;
-  yellow: string;
-  blue: string;
-  magenta: string;
-  cyan: string;
-  white: string;
-  brightBlack: string;
-  brightRed: string;
-  brightGreen: string;
-  brightYellow: string;
-  brightBlue: string;
-  brightMagenta: string;
-  brightCyan: string;
-  brightWhite: string;
-}
-
-// Dark theme (default)
-const darkTheme: TerminalTheme = {
-  background: "#0a0a0a",
-  foreground: "#d4d4d4",
-  cursor: "#d4d4d4",
-  cursorAccent: "#0a0a0a",
-  selectionBackground: "#264f78",
-  black: "#1e1e1e",
-  red: "#f44747",
-  green: "#6a9955",
-  yellow: "#dcdcaa",
-  blue: "#569cd6",
-  magenta: "#c586c0",
-  cyan: "#4ec9b0",
-  white: "#d4d4d4",
-  brightBlack: "#808080",
-  brightRed: "#f44747",
-  brightGreen: "#6a9955",
-  brightYellow: "#dcdcaa",
-  brightBlue: "#569cd6",
-  brightMagenta: "#c586c0",
-  brightCyan: "#4ec9b0",
-  brightWhite: "#ffffff",
-};
-
-// Light theme
-const lightTheme: TerminalTheme = {
-  background: "#ffffff",
-  foreground: "#383a42",
-  cursor: "#383a42",
-  cursorAccent: "#ffffff",
-  selectionBackground: "#add6ff",
-  black: "#383a42",
-  red: "#e45649",
-  green: "#50a14f",
-  yellow: "#c18401",
-  blue: "#4078f2",
-  magenta: "#a626a4",
-  cyan: "#0184bc",
-  white: "#fafafa",
-  brightBlack: "#4f525e",
-  brightRed: "#e06c75",
-  brightGreen: "#98c379",
-  brightYellow: "#e5c07b",
-  brightBlue: "#61afef",
-  brightMagenta: "#c678dd",
-  brightCyan: "#56b6c2",
-  brightWhite: "#ffffff",
-};
-
-// Retro / Cyberpunk theme - neon green on black
-const retroTheme: TerminalTheme = {
-  background: "#000000",
-  foreground: "#39ff14",
-  cursor: "#39ff14",
-  cursorAccent: "#000000",
-  selectionBackground: "#39ff14",
-  selectionForeground: "#000000",
-  black: "#000000",
-  red: "#ff0055",
-  green: "#39ff14",
-  yellow: "#ffff00",
-  blue: "#00ffff",
-  magenta: "#ff00ff",
-  cyan: "#00ffff",
-  white: "#39ff14",
-  brightBlack: "#555555",
-  brightRed: "#ff5555",
-  brightGreen: "#55ff55",
-  brightYellow: "#ffff55",
-  brightBlue: "#55ffff",
-  brightMagenta: "#ff55ff",
-  brightCyan: "#55ffff",
-  brightWhite: "#ffffff",
-};
-
-// Dracula theme
-const draculaTheme: TerminalTheme = {
-  background: "#282a36",
-  foreground: "#f8f8f2",
-  cursor: "#f8f8f2",
-  cursorAccent: "#282a36",
-  selectionBackground: "#44475a",
-  black: "#21222c",
-  red: "#ff5555",
-  green: "#50fa7b",
-  yellow: "#f1fa8c",
-  blue: "#bd93f9",
-  magenta: "#ff79c6",
-  cyan: "#8be9fd",
-  white: "#f8f8f2",
-  brightBlack: "#6272a4",
-  brightRed: "#ff6e6e",
-  brightGreen: "#69ff94",
-  brightYellow: "#ffffa5",
-  brightBlue: "#d6acff",
-  brightMagenta: "#ff92df",
-  brightCyan: "#a4ffff",
-  brightWhite: "#ffffff",
-};
-
-// Nord theme
-const nordTheme: TerminalTheme = {
-  background: "#2e3440",
-  foreground: "#d8dee9",
-  cursor: "#d8dee9",
-  cursorAccent: "#2e3440",
-  selectionBackground: "#434c5e",
-  black: "#3b4252",
-  red: "#bf616a",
-  green: "#a3be8c",
-  yellow: "#ebcb8b",
-  blue: "#81a1c1",
-  magenta: "#b48ead",
-  cyan: "#88c0d0",
-  white: "#e5e9f0",
-  brightBlack: "#4c566a",
-  brightRed: "#bf616a",
-  brightGreen: "#a3be8c",
-  brightYellow: "#ebcb8b",
-  brightBlue: "#81a1c1",
-  brightMagenta: "#b48ead",
-  brightCyan: "#8fbcbb",
-  brightWhite: "#eceff4",
-};
-
-// Monokai theme
-const monokaiTheme: TerminalTheme = {
-  background: "#272822",
-  foreground: "#f8f8f2",
-  cursor: "#f8f8f2",
-  cursorAccent: "#272822",
-  selectionBackground: "#49483e",
-  black: "#272822",
-  red: "#f92672",
-  green: "#a6e22e",
-  yellow: "#f4bf75",
-  blue: "#66d9ef",
-  magenta: "#ae81ff",
-  cyan: "#a1efe4",
-  white: "#f8f8f2",
-  brightBlack: "#75715e",
-  brightRed: "#f92672",
-  brightGreen: "#a6e22e",
-  brightYellow: "#f4bf75",
-  brightBlue: "#66d9ef",
-  brightMagenta: "#ae81ff",
-  brightCyan: "#a1efe4",
-  brightWhite: "#f9f8f5",
-};
-
-// Tokyo Night theme
-const tokyonightTheme: TerminalTheme = {
-  background: "#1a1b26",
-  foreground: "#a9b1d6",
-  cursor: "#c0caf5",
-  cursorAccent: "#1a1b26",
-  selectionBackground: "#33467c",
-  black: "#15161e",
-  red: "#f7768e",
-  green: "#9ece6a",
-  yellow: "#e0af68",
-  blue: "#7aa2f7",
-  magenta: "#bb9af7",
-  cyan: "#7dcfff",
-  white: "#a9b1d6",
-  brightBlack: "#414868",
-  brightRed: "#f7768e",
-  brightGreen: "#9ece6a",
-  brightYellow: "#e0af68",
-  brightBlue: "#7aa2f7",
-  brightMagenta: "#bb9af7",
-  brightCyan: "#7dcfff",
-  brightWhite: "#c0caf5",
-};
-
-// Solarized Dark theme
-const solarizedTheme: TerminalTheme = {
-  background: "#002b36",
-  foreground: "#839496",
-  cursor: "#839496",
-  cursorAccent: "#002b36",
-  selectionBackground: "#073642",
-  black: "#073642",
-  red: "#dc322f",
-  green: "#859900",
-  yellow: "#b58900",
-  blue: "#268bd2",
-  magenta: "#d33682",
-  cyan: "#2aa198",
-  white: "#eee8d5",
-  brightBlack: "#002b36",
-  brightRed: "#cb4b16",
-  brightGreen: "#586e75",
-  brightYellow: "#657b83",
-  brightBlue: "#839496",
-  brightMagenta: "#6c71c4",
-  brightCyan: "#93a1a1",
-  brightWhite: "#fdf6e3",
-};
-
-// Gruvbox Dark theme
-const gruvboxTheme: TerminalTheme = {
-  background: "#282828",
-  foreground: "#ebdbb2",
-  cursor: "#ebdbb2",
-  cursorAccent: "#282828",
-  selectionBackground: "#504945",
-  black: "#282828",
-  red: "#cc241d",
-  green: "#98971a",
-  yellow: "#d79921",
-  blue: "#458588",
-  magenta: "#b16286",
-  cyan: "#689d6a",
-  white: "#a89984",
-  brightBlack: "#928374",
-  brightRed: "#fb4934",
-  brightGreen: "#b8bb26",
-  brightYellow: "#fabd2f",
-  brightBlue: "#83a598",
-  brightMagenta: "#d3869b",
-  brightCyan: "#8ec07c",
-  brightWhite: "#ebdbb2",
-};
-
-// Catppuccin Mocha theme
-const catppuccinTheme: TerminalTheme = {
-  background: "#1e1e2e",
-  foreground: "#cdd6f4",
-  cursor: "#f5e0dc",
-  cursorAccent: "#1e1e2e",
-  selectionBackground: "#45475a",
-  black: "#45475a",
-  red: "#f38ba8",
-  green: "#a6e3a1",
-  yellow: "#f9e2af",
-  blue: "#89b4fa",
-  magenta: "#cba6f7",
-  cyan: "#94e2d5",
-  white: "#bac2de",
-  brightBlack: "#585b70",
-  brightRed: "#f38ba8",
-  brightGreen: "#a6e3a1",
-  brightYellow: "#f9e2af",
-  brightBlue: "#89b4fa",
-  brightMagenta: "#cba6f7",
-  brightCyan: "#94e2d5",
-  brightWhite: "#a6adc8",
-};
-
-// One Dark theme
-const onedarkTheme: TerminalTheme = {
-  background: "#282c34",
-  foreground: "#abb2bf",
-  cursor: "#528bff",
-  cursorAccent: "#282c34",
-  selectionBackground: "#3e4451",
-  black: "#282c34",
-  red: "#e06c75",
-  green: "#98c379",
-  yellow: "#e5c07b",
-  blue: "#61afef",
-  magenta: "#c678dd",
-  cyan: "#56b6c2",
-  white: "#abb2bf",
-  brightBlack: "#5c6370",
-  brightRed: "#e06c75",
-  brightGreen: "#98c379",
-  brightYellow: "#e5c07b",
-  brightBlue: "#61afef",
-  brightMagenta: "#c678dd",
-  brightCyan: "#56b6c2",
-  brightWhite: "#ffffff",
-};
-
-// Synthwave '84 theme
-const synthwaveTheme: TerminalTheme = {
-  background: "#262335",
-  foreground: "#ffffff",
-  cursor: "#ff7edb",
-  cursorAccent: "#262335",
-  selectionBackground: "#463465",
-  black: "#262335",
-  red: "#fe4450",
-  green: "#72f1b8",
-  yellow: "#fede5d",
-  blue: "#03edf9",
-  magenta: "#ff7edb",
-  cyan: "#03edf9",
-  white: "#ffffff",
-  brightBlack: "#614d85",
-  brightRed: "#fe4450",
-  brightGreen: "#72f1b8",
-  brightYellow: "#f97e72",
-  brightBlue: "#03edf9",
-  brightMagenta: "#ff7edb",
-  brightCyan: "#03edf9",
-  brightWhite: "#ffffff",
-};
-
-// Red theme - Dark theme with red accents
-const redTheme: TerminalTheme = {
-  background: "#1a0a0a",
-  foreground: "#c8b0b0",
-  cursor: "#ff4444",
-  cursorAccent: "#1a0a0a",
-  selectionBackground: "#5a2020",
-  black: "#2a1010",
-  red: "#ff4444",
-  green: "#6a9a6a",
-  yellow: "#ccaa55",
-  blue: "#6688aa",
-  magenta: "#aa5588",
-  cyan: "#558888",
-  white: "#b0a0a0",
-  brightBlack: "#6a4040",
-  brightRed: "#ff6666",
-  brightGreen: "#88bb88",
-  brightYellow: "#ddbb66",
-  brightBlue: "#88aacc",
-  brightMagenta: "#cc77aa",
-  brightCyan: "#77aaaa",
-  brightWhite: "#d0c0c0",
-};
-
-// Theme mapping
-const terminalThemes: Record<ThemeMode, TerminalTheme> = {
-  light: lightTheme,
-  dark: darkTheme,
-  system: darkTheme, // Will be resolved at runtime
-  retro: retroTheme,
-  dracula: draculaTheme,
-  nord: nordTheme,
-  monokai: monokaiTheme,
-  tokyonight: tokyonightTheme,
-  solarized: solarizedTheme,
-  gruvbox: gruvboxTheme,
-  catppuccin: catppuccinTheme,
-  onedark: onedarkTheme,
-  synthwave: synthwaveTheme,
-  red: redTheme,
-};
-
-/**
- * Get terminal theme for the given app theme
- * For "system" theme, it checks the user's system preference
- */
-export function getTerminalTheme(theme: ThemeMode): TerminalTheme {
-  if (theme === "system") {
-    // Check system preference
-    if (typeof window !== "undefined") {
-      const prefersDark = window.matchMedia("(prefers-color-scheme: dark)").matches;
-      return prefersDark ? darkTheme : lightTheme;
-    }
-    return darkTheme; // Default to dark for SSR
-  }
-  return terminalThemes[theme] || darkTheme;
-}
-
-export default terminalThemes;

apps/app/src/config/theme-options.ts

@@ -1,95 +0,0 @@
-import {
-  type LucideIcon,
-  Atom,
-  Cat,
-  Eclipse,
-  Flame,
-  Ghost,
-  Heart,
-  Moon,
-  Radio,
-  Snowflake,
-  Sparkles,
-  Sun,
-  Terminal,
-  Trees,
-} from "lucide-react";
-import { Theme } from "@/components/views/settings-view/shared/types";
-
-export interface ThemeOption {
-  value: Theme;
-  label: string;
-  Icon: LucideIcon;
-  testId: string;
-}
-
-export const themeOptions: ReadonlyArray<ThemeOption> = [
-  { value: "dark", label: "Dark", Icon: Moon, testId: "dark-mode-button" },
-  { value: "light", label: "Light", Icon: Sun, testId: "light-mode-button" },
-  {
-    value: "retro",
-    label: "Retro",
-    Icon: Terminal,
-    testId: "retro-mode-button",
-  },
-  {
-    value: "dracula",
-    label: "Dracula",
-    Icon: Ghost,
-    testId: "dracula-mode-button",
-  },
-  {
-    value: "nord",
-    label: "Nord",
-    Icon: Snowflake,
-    testId: "nord-mode-button",
-  },
-  {
-    value: "monokai",
-    label: "Monokai",
-    Icon: Flame,
-    testId: "monokai-mode-button",
-  },
-  {
-    value: "tokyonight",
-    label: "Tokyo Night",
-    Icon: Sparkles,
-    testId: "tokyonight-mode-button",
-  },
-  {
-    value: "solarized",
-    label: "Solarized",
-    Icon: Eclipse,
-    testId: "solarized-mode-button",
-  },
-  {
-    value: "gruvbox",
-    label: "Gruvbox",
-    Icon: Trees,
-    testId: "gruvbox-mode-button",
-  },
-  {
-    value: "catppuccin",
-    label: "Catppuccin",
-    Icon: Cat,
-    testId: "catppuccin-mode-button",
-  },
-  {
-    value: "onedark",
-    label: "One Dark",
-    Icon: Atom,
-    testId: "onedark-mode-button",
-  },
-  {
-    value: "synthwave",
-    label: "Synthwave",
-    Icon: Radio,
-    testId: "synthwave-mode-button",
-  },
-  {
-    value: "red",
-    label: "Red",
-    Icon: Heart,
-    testId: "red-mode-button",
-  },
-];

apps/app/src/hooks/use-auto-mode.ts

@@ -1,391 +0,0 @@
-import { useEffect, useCallback, useMemo } from "react";
-import { useShallow } from "zustand/react/shallow";
-import { useAppStore } from "@/store/app-store";
-import { getElectronAPI } from "@/lib/electron";
-import type { AutoModeEvent } from "@/types/electron";
-
-/**
- * Hook for managing auto mode (scoped per project)
- */
-export function useAutoMode() {
-  const {
-    autoModeByProject,
-    setAutoModeRunning,
-    addRunningTask,
-    removeRunningTask,
-    clearRunningTasks,
-    currentProject,
-    addAutoModeActivity,
-    maxConcurrency,
-    projects,
-  } = useAppStore(
-    useShallow((state) => ({
-      autoModeByProject: state.autoModeByProject,
-      setAutoModeRunning: state.setAutoModeRunning,
-      addRunningTask: state.addRunningTask,
-      removeRunningTask: state.removeRunningTask,
-      clearRunningTasks: state.clearRunningTasks,
-      currentProject: state.currentProject,
-      addAutoModeActivity: state.addAutoModeActivity,
-      maxConcurrency: state.maxConcurrency,
-      projects: state.projects,
-    }))
-  );
-
-  // Helper to look up project ID from path
-  const getProjectIdFromPath = useCallback(
-    (path: string): string | undefined => {
-      const project = projects.find((p) => p.path === path);
-      return project?.id;
-    },
-    [projects]
-  );
-
-  // Get project-specific auto mode state
-  const projectId = currentProject?.id;
-  const projectAutoModeState = useMemo(() => {
-    if (!projectId) return { isRunning: false, runningTasks: [] };
-    return (
-      autoModeByProject[projectId] || { isRunning: false, runningTasks: [] }
-    );
-  }, [autoModeByProject, projectId]);
-
-  const isAutoModeRunning = projectAutoModeState.isRunning;
-  const runningAutoTasks = projectAutoModeState.runningTasks;
-
-  // Check if we can start a new task based on concurrency limit
-  const canStartNewTask = runningAutoTasks.length < maxConcurrency;
-
-  // Handle auto mode events - listen globally for all projects
-  useEffect(() => {
-    const api = getElectronAPI();
-    if (!api?.autoMode) return;
-
-    const unsubscribe = api.autoMode.onEvent((event: AutoModeEvent) => {
-      console.log("[AutoMode Event]", event);
-
-      // Events include projectPath from backend - use it to look up project ID
-      // Fall back to current projectId if not provided in event
-      let eventProjectId: string | undefined;
-      if ("projectPath" in event && event.projectPath) {
-        eventProjectId = getProjectIdFromPath(event.projectPath);
-      }
-      if (!eventProjectId && "projectId" in event && event.projectId) {
-        eventProjectId = event.projectId;
-      }
-      if (!eventProjectId) {
-        eventProjectId = projectId;
-      }
-
-      // Skip event if we couldn't determine the project
-      if (!eventProjectId) {
-        console.warn(
-          "[AutoMode] Could not determine project for event:",
-          event
-        );
-        return;
-      }
-
-      switch (event.type) {
-        case "auto_mode_feature_start":
-          if (event.featureId) {
-            addRunningTask(eventProjectId, event.featureId);
-            addAutoModeActivity({
-              featureId: event.featureId,
-              type: "start",
-              message: `Started working on feature`,
-            });
-          }
-          break;
-
-        case "auto_mode_feature_complete":
-          // Feature completed - remove from running tasks and UI will reload features on its own
-          if (event.featureId) {
-            console.log(
-              "[AutoMode] Feature completed:",
-              event.featureId,
-              "passes:",
-              event.passes
-            );
-            removeRunningTask(eventProjectId, event.featureId);
-            addAutoModeActivity({
-              featureId: event.featureId,
-              type: "complete",
-              message: event.passes
-                ? "Feature completed successfully"
-                : "Feature completed with failures",
-              passes: event.passes,
-            });
-          }
-          break;
-
-        case "auto_mode_stopped":
-          // Auto mode was explicitly stopped (by user or error)
-          setAutoModeRunning(eventProjectId, false);
-          clearRunningTasks(eventProjectId);
-          console.log("[AutoMode] Auto mode stopped");
-          break;
-
-        case "auto_mode_started":
-          // Auto mode started - ensure UI reflects running state
-          console.log("[AutoMode] Auto mode started:", event.message);
-          break;
-
-        case "auto_mode_idle":
-          // Auto mode is running but has no pending features to pick up
-          // This is NOT a stop - auto mode keeps running and will pick up new features
-          console.log("[AutoMode] Auto mode idle - waiting for new features");
-          break;
-
-        case "auto_mode_complete":
-          // Legacy event - only handle if it looks like a stop (for backwards compatibility)
-          if (event.message === "Auto mode stopped") {
-            setAutoModeRunning(eventProjectId, false);
-            clearRunningTasks(eventProjectId);
-            console.log("[AutoMode] Auto mode stopped (legacy event)");
-          }
-          break;
-
-        case "auto_mode_error":
-          console.error("[AutoMode Error]", event.error);
-          if (event.featureId && event.error) {
-            // Check for authentication errors and provide a more helpful message
-            const isAuthError =
-              event.errorType === "authentication" ||
-              event.error.includes("Authentication failed") ||
-              event.error.includes("Invalid API key");
-
-            const errorMessage = isAuthError
-              ? `Authentication failed: Please check your API key in Settings or run 'claude login' in terminal to re-authenticate.`
-              : event.error;
-
-            addAutoModeActivity({
-              featureId: event.featureId,
-              type: "error",
-              message: errorMessage,
-              errorType: isAuthError ? "authentication" : "execution",
-            });
-
-            // Remove the task from running since it failed
-            if (eventProjectId) {
-              removeRunningTask(eventProjectId, event.featureId);
-            }
-          }
-          break;
-
-        case "auto_mode_progress":
-          // Log progress updates (throttle to avoid spam)
-          if (event.featureId && event.content && event.content.length > 10) {
-            addAutoModeActivity({
-              featureId: event.featureId,
-              type: "progress",
-              message: event.content.substring(0, 200), // Limit message length
-            });
-          }
-          break;
-
-        case "auto_mode_tool":
-          // Log tool usage
-          if (event.featureId && event.tool) {
-            addAutoModeActivity({
-              featureId: event.featureId,
-              type: "tool",
-              message: `Using tool: ${event.tool}`,
-              tool: event.tool,
-            });
-          }
-          break;
-
-        case "auto_mode_phase":
-          // Log phase transitions (Planning, Action, Verification)
-          if (event.featureId && event.phase && event.message) {
-            console.log(
-              `[AutoMode] Phase: ${event.phase} for ${event.featureId}`
-            );
-            addAutoModeActivity({
-              featureId: event.featureId,
-              type: event.phase,
-              message: event.message,
-              phase: event.phase,
-            });
-          }
-          break;
-      }
-    });
-
-    return unsubscribe;
-  }, [
-    projectId,
-    addRunningTask,
-    removeRunningTask,
-    clearRunningTasks,
-    setAutoModeRunning,
-    addAutoModeActivity,
-    getProjectIdFromPath,
-  ]);
-
-  // Restore auto mode for all projects that were running when app was closed
-  // This runs once on mount to restart auto loops for persisted running states
-  useEffect(() => {
-    const api = getElectronAPI();
-    if (!api?.autoMode) return;
-
-    // Find all projects that have auto mode marked as running
-    const projectsToRestart: Array<{ projectId: string; projectPath: string }> =
-      [];
-    for (const [projectId, state] of Object.entries(autoModeByProject)) {
-      if (state.isRunning) {
-        // Find the project path for this project ID
-        const project = projects.find((p) => p.id === projectId);
-        if (project) {
-          projectsToRestart.push({ projectId, projectPath: project.path });
-        }
-      }
-    }
-
-    // Restart auto mode for each project
-    for (const { projectId, projectPath } of projectsToRestart) {
-      console.log(`[AutoMode] Restoring auto mode for project: ${projectPath}`);
-      api.autoMode
-        .start(projectPath, maxConcurrency)
-        .then((result) => {
-          if (!result.success) {
-            console.error(
-              `[AutoMode] Failed to restore auto mode for ${projectPath}:`,
-              result.error
-            );
-            // Mark as not running if we couldn't restart
-            setAutoModeRunning(projectId, false);
-          } else {
-            console.log(`[AutoMode] Restored auto mode for ${projectPath}`);
-          }
-        })
-        .catch((error) => {
-          console.error(
-            `[AutoMode] Error restoring auto mode for ${projectPath}:`,
-            error
-          );
-          setAutoModeRunning(projectId, false);
-        });
-    }
-    // Only run once on mount - intentionally empty dependency array
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-
-  // Start auto mode
-  const start = useCallback(async () => {
-    if (!currentProject) {
-      console.error("No project selected");
-      return;
-    }
-
-    try {
-      const api = getElectronAPI();
-      if (!api?.autoMode) {
-        throw new Error("Auto mode API not available");
-      }
-
-      const result = await api.autoMode.start(
-        currentProject.path,
-        maxConcurrency
-      );
-
-      if (result.success) {
-        setAutoModeRunning(currentProject.id, true);
-        console.log(
-          `[AutoMode] Started successfully with maxConcurrency: ${maxConcurrency}`
-        );
-      } else {
-        console.error("[AutoMode] Failed to start:", result.error);
-        throw new Error(result.error || "Failed to start auto mode");
-      }
-    } catch (error) {
-      console.error("[AutoMode] Error starting:", error);
-      if (currentProject) {
-        setAutoModeRunning(currentProject.id, false);
-      }
-      throw error;
-    }
-  }, [currentProject, setAutoModeRunning, maxConcurrency]);
-
-  // Stop auto mode - only turns off the toggle, running tasks continue
-  const stop = useCallback(async () => {
-    if (!currentProject) {
-      console.error("No project selected");
-      return;
-    }
-
-    try {
-      const api = getElectronAPI();
-      if (!api?.autoMode) {
-        throw new Error("Auto mode API not available");
-      }
-
-      const result = await api.autoMode.stop(currentProject.path);
-
-      if (result.success) {
-        setAutoModeRunning(currentProject.id, false);
-        // NOTE: We intentionally do NOT clear running tasks here.
-        // Stopping auto mode only turns off the toggle to prevent new features
-        // from being picked up. Running tasks will complete naturally and be
-        // removed via the auto_mode_feature_complete event.
-        console.log(
-          "[AutoMode] Stopped successfully - running tasks will continue"
-        );
-      } else {
-        console.error("[AutoMode] Failed to stop:", result.error);
-        throw new Error(result.error || "Failed to stop auto mode");
-      }
-    } catch (error) {
-      console.error("[AutoMode] Error stopping:", error);
-      throw error;
-    }
-  }, [currentProject, setAutoModeRunning]);
-
-  // Stop a specific feature
-  const stopFeature = useCallback(
-    async (featureId: string) => {
-      if (!currentProject) {
-        console.error("No project selected");
-        return;
-      }
-
-      try {
-        const api = getElectronAPI();
-        if (!api?.autoMode?.stopFeature) {
-          throw new Error("Stop feature API not available");
-        }
-
-        const result = await api.autoMode.stopFeature(featureId);
-
-        if (result.success) {
-          removeRunningTask(currentProject.id, featureId);
-          console.log("[AutoMode] Feature stopped successfully:", featureId);
-          addAutoModeActivity({
-            featureId,
-            type: "complete",
-            message: "Feature stopped by user",
-            passes: false,
-          });
-        } else {
-          console.error("[AutoMode] Failed to stop feature:", result.error);
-          throw new Error(result.error || "Failed to stop feature");
-        }
-      } catch (error) {
-        console.error("[AutoMode] Error stopping feature:", error);
-        throw error;
-      }
-    },
-    [currentProject, removeRunningTask, addAutoModeActivity]
-  );
-
-  return {
-    isRunning: isAutoModeRunning,
-    runningTasks: runningAutoTasks,
-    maxConcurrency,
-    canStartNewTask,
-    start,
-    stop,
-    stopFeature,
-  };
-}

apps/app/src/hooks/use-electron-agent.ts

@@ -1,424 +0,0 @@
-import { useState, useEffect, useCallback, useRef } from "react";
-import type { Message, StreamEvent } from "@/types/electron";
-import { useMessageQueue } from "./use-message-queue";
-import type { ImageAttachment } from "@/store/app-store";
-import { getElectronAPI } from "@/lib/electron";
-
-interface UseElectronAgentOptions {
-  sessionId: string;
-  workingDirectory?: string;
-  onToolUse?: (toolName: string, toolInput: unknown) => void;
-}
-
-interface UseElectronAgentResult {
-  messages: Message[];
-  isProcessing: boolean;
-  isConnected: boolean;
-  sendMessage: (content: string, images?: ImageAttachment[]) => Promise<void>;
-  stopExecution: () => Promise<void>;
-  clearHistory: () => Promise<void>;
-  error: string | null;
-  // Queue-related state
-  queuedMessages: { id: string; content: string; images?: ImageAttachment[]; timestamp: Date }[];
-  isQueueProcessing: boolean;
-  clearMessageQueue: () => void;
-}
-
-/**
- * React hook for interacting with the Electron-based Claude agent
- *
- * This hook provides a clean interface to the agent running in the Electron
- * main process, which survives Next.js restarts.
- */
-export function useElectronAgent({
-  sessionId,
-  workingDirectory,
-  onToolUse,
-}: UseElectronAgentOptions): UseElectronAgentResult {
-  const [messages, setMessages] = useState<Message[]>([]);
-  const [isProcessing, setIsProcessing] = useState(false);
-  const [isConnected, setIsConnected] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const unsubscribeRef = useRef<(() => void) | null>(null);
-  const currentMessageRef = useRef<Message | null>(null);
-
-  // Send message directly to the agent (bypassing queue)
-  const sendMessageDirectly = useCallback(
-    async (content: string, images?: ImageAttachment[]) => {
-      const api = getElectronAPI();
-      if (!api?.agent) {
-        setError("API not available");
-        return;
-      }
-
-      if (isProcessing) {
-        throw new Error("Agent is already processing a message");
-      }
-
-      setIsProcessing(true);
-      setError(null);
-
-      try {
-        console.log("[useElectronAgent] Sending message directly", {
-          hasImages: images && images.length > 0,
-          imageCount: images?.length || 0
-        });
-
-        // Save images to .automaker/images and get paths
-        let imagePaths: string[] | undefined;
-        if (images && images.length > 0 && api.saveImageToTemp) {
-          imagePaths = [];
-          for (const image of images) {
-            const result = await api.saveImageToTemp(
-              image.data,
-              image.filename,
-              image.mimeType,
-              workingDirectory // Pass workingDirectory as projectPath
-            );
-            if (result.success && result.path) {
-              imagePaths.push(result.path);
-              console.log("[useElectronAgent] Saved image to .automaker/images:", result.path);
-            } else {
-              console.error("[useElectronAgent] Failed to save image:", result.error);
-            }
-          }
-        }
-
-        const result = await api.agent!.send(
-          sessionId,
-          content,
-          workingDirectory,
-          imagePaths
-        );
-
-        if (!result.success) {
-          setError(result.error || "Failed to send message");
-          setIsProcessing(false);
-        }
-        // Note: We don't set isProcessing to false here because
-        // it will be set by the "complete" or "error" stream event
-      } catch (err) {
-        console.error("[useElectronAgent] Failed to send message:", err);
-        setError(err instanceof Error ? err.message : "Failed to send message");
-        setIsProcessing(false);
-        throw err;
-      }
-    },
-    [sessionId, workingDirectory, isProcessing]
-  );
-
-  // Message queue for queuing messages when agent is busy
-  const {
-    queuedMessages,
-    isProcessingQueue,
-    addToQueue,
-    clearQueue,
-    processNext,
-  } = useMessageQueue({
-    onProcessNext: async (queuedMessage) => {
-      await sendMessageDirectly(queuedMessage.content, queuedMessage.images);
-    },
-  });
-
-  // Initialize connection and load history
-  useEffect(() => {
-    const api = getElectronAPI();
-    if (!api?.agent) {
-      setError("API not available.");
-      return;
-    }
-
-    if (!sessionId) {
-      // No session selected - reset state
-      setMessages([]);
-      setIsConnected(false);
-      setIsProcessing(false);
-      setError(null);
-      return;
-    }
-
-    let mounted = true;
-
-    const initialize = async () => {
-      // Reset error state when switching sessions
-      setError(null);
-
-      try {
-        console.log("[useElectronAgent] Starting session:", sessionId);
-        const result = await api.agent!.start(
-          sessionId,
-          workingDirectory
-        );
-
-        if (!mounted) return;
-
-        if (result.success && result.messages) {
-          console.log("[useElectronAgent] Loaded", result.messages.length, "messages");
-          setMessages(result.messages);
-          setIsConnected(true);
-
-          // Check if the agent is currently running for this session
-          const historyResult = await api.agent!.getHistory(sessionId);
-          if (mounted && historyResult.success) {
-            const isRunning = historyResult.isRunning || false;
-            console.log("[useElectronAgent] Session running state:", isRunning);
-            setIsProcessing(isRunning);
-          }
-        } else {
-          setError(result.error || "Failed to start session");
-          setIsProcessing(false);
-        }
-      } catch (err) {
-        if (!mounted) return;
-        console.error("[useElectronAgent] Failed to initialize:", err);
-        setError(err instanceof Error ? err.message : "Failed to initialize");
-        setIsProcessing(false);
-      }
-    };
-
-    initialize();
-
-    return () => {
-      mounted = false;
-    };
-  }, [sessionId, workingDirectory]);
-
-  // Auto-process queue when agent finishes processing
-  useEffect(() => {
-    if (!isProcessing && !isProcessingQueue && queuedMessages.length > 0) {
-      console.log("[useElectronAgent] Auto-processing next queued message");
-      processNext();
-    }
-  }, [isProcessing, isProcessingQueue, queuedMessages.length, processNext]);
-
-  // Subscribe to streaming events
-  useEffect(() => {
-    const api = getElectronAPI();
-    if (!api?.agent) return;
-    if (!sessionId) return; // Don't subscribe if no session
-
-    console.log("[useElectronAgent] Subscribing to stream events for session:", sessionId);
-
-    const handleStream = (event: StreamEvent) => {
-      // CRITICAL: Only process events for our specific session
-      if (event.sessionId !== sessionId) {
-        console.log("[useElectronAgent] Ignoring event for different session:", event.sessionId);
-        return;
-      }
-
-      console.log("[useElectronAgent] Stream event for", sessionId, ":", event.type);
-
-      switch (event.type) {
-        case "message":
-          // User message added
-          setMessages((prev) => [...prev, event.message]);
-          break;
-
-        case "stream":
-          // Assistant message streaming
-          if (event.isComplete) {
-            // Final update
-            setMessages((prev) =>
-              prev.map((msg) =>
-                msg.id === event.messageId
-                  ? { ...msg, content: event.content }
-                  : msg
-              )
-            );
-            currentMessageRef.current = null;
-          } else {
-            // Streaming update
-            setMessages((prev) => {
-              const existingIndex = prev.findIndex((m) => m.id === event.messageId);
-              if (existingIndex >= 0) {
-                // Update existing message
-                return prev.map((msg) =>
-                  msg.id === event.messageId
-                    ? { ...msg, content: event.content }
-                    : msg
-                );
-              } else {
-                // Create new message
-                const newMessage: Message = {
-                  id: event.messageId,
-                  role: "assistant",
-                  content: event.content,
-                  timestamp: new Date().toISOString(),
-                };
-                currentMessageRef.current = newMessage;
-                return [...prev, newMessage];
-              }
-            });
-          }
-          break;
-
-        case "tool_use":
-          // Tool being used
-          console.log("[useElectronAgent] Tool use:", event.tool.name);
-          onToolUse?.(event.tool.name, event.tool.input);
-          break;
-
-        case "complete":
-          // Agent finished processing for THIS session
-          console.log("[useElectronAgent] Processing complete for session:", sessionId);
-          setIsProcessing(false);
-          if (event.messageId) {
-            setMessages((prev) =>
-              prev.map((msg) =>
-                msg.id === event.messageId
-                  ? { ...msg, content: event.content }
-                  : msg
-              )
-            );
-          }
-          break;
-
-        case "error":
-          // Error occurred for THIS session
-          console.error("[useElectronAgent] Agent error for session:", sessionId, event.error);
-          setIsProcessing(false);
-          setError(event.error);
-          if (event.message) {
-            const errorMessage = event.message;
-            setMessages((prev) => [...prev, errorMessage]);
-          }
-          break;
-      }
-    };
-
-    unsubscribeRef.current = api.agent!.onStream(handleStream as (data: unknown) => void);
-
-    return () => {
-      if (unsubscribeRef.current) {
-        console.log("[useElectronAgent] Unsubscribing from stream events for session:", sessionId);
-        unsubscribeRef.current();
-        unsubscribeRef.current = null;
-      }
-    };
-  }, [sessionId, onToolUse]);
-
-  // Send a message to the agent
-  const sendMessage = useCallback(
-    async (content: string, images?: ImageAttachment[]) => {
-      const api = getElectronAPI();
-      if (!api?.agent) {
-        setError("API not available");
-        return;
-      }
-
-      if (isProcessing) {
-        console.warn("[useElectronAgent] Already processing a message");
-        return;
-      }
-
-      setIsProcessing(true);
-      setError(null);
-
-      try {
-        console.log("[useElectronAgent] Sending message", {
-          hasImages: images && images.length > 0,
-          imageCount: images?.length || 0
-        });
-
-        // Save images to .automaker/images and get paths
-        let imagePaths: string[] | undefined;
-        if (images && images.length > 0 && api.saveImageToTemp) {
-          imagePaths = [];
-          for (const image of images) {
-            const result = await api.saveImageToTemp(
-              image.data,
-              image.filename,
-              image.mimeType,
-              workingDirectory // Pass workingDirectory as projectPath
-            );
-            if (result.success && result.path) {
-              imagePaths.push(result.path);
-              console.log("[useElectronAgent] Saved image to .automaker/images:", result.path);
-            } else {
-              console.error("[useElectronAgent] Failed to save image:", result.error);
-            }
-          }
-        }
-
-        const result = await api.agent!.send(
-          sessionId,
-          content,
-          workingDirectory,
-          imagePaths
-        );
-
-        if (!result.success) {
-          setError(result.error || "Failed to send message");
-          setIsProcessing(false);
-        }
-        // Note: We don't set isProcessing to false here because
-        // it will be set by the "complete" or "error" stream event
-      } catch (err) {
-        console.error("[useElectronAgent] Failed to send message:", err);
-        setError(err instanceof Error ? err.message : "Failed to send message");
-        setIsProcessing(false);
-      }
-    },
-    [sessionId, workingDirectory, isProcessing]
-  );
-
-  // Stop current execution
-  const stopExecution = useCallback(async () => {
-    const api = getElectronAPI();
-    if (!api?.agent) {
-      setError("API not available");
-      return;
-    }
-
-    try {
-      console.log("[useElectronAgent] Stopping execution");
-      const result = await api.agent!.stop(sessionId);
-
-      if (!result.success) {
-        setError(result.error || "Failed to stop execution");
-      } else {
-        setIsProcessing(false);
-      }
-    } catch (err) {
-      console.error("[useElectronAgent] Failed to stop:", err);
-      setError(err instanceof Error ? err.message : "Failed to stop execution");
-    }
-  }, [sessionId]);
-
-  // Clear conversation history
-  const clearHistory = useCallback(async () => {
-    const api = getElectronAPI();
-    if (!api?.agent) {
-      setError("API not available");
-      return;
-    }
-
-    try {
-      console.log("[useElectronAgent] Clearing history");
-      const result = await api.agent!.clear(sessionId);
-
-      if (result.success) {
-        setMessages([]);
-        setError(null);
-      } else {
-        setError(result.error || "Failed to clear history");
-      }
-    } catch (err) {
-      console.error("[useElectronAgent] Failed to clear:", err);
-      setError(err instanceof Error ? err.message : "Failed to clear history");
-    }
-  }, [sessionId]);
-
-  return {
-    messages,
-    isProcessing,
-    isConnected,
-    sendMessage,
-    stopExecution,
-    clearHistory,
-    error,
-    queuedMessages,
-    isQueueProcessing: isProcessingQueue,
-    clearMessageQueue: clearQueue,
-  };
-}

apps/app/src/hooks/use-keyboard-shortcuts.ts

@@ -1,149 +0,0 @@
-"use client";
-
-import { useEffect, useCallback } from "react";
-import { useAppStore, parseShortcut } from "@/store/app-store";
-
-export interface KeyboardShortcut {
-  key: string;  // Can be simple "K" or with modifiers "Shift+N", "Cmd+K"
-  action: () => void;
-  description?: string;
-}
-
-/**
- * Check if the currently focused element is an input, textarea, or contenteditable element
- * or if an autocomplete/typeahead dropdown is open
- */
-function isInputFocused(): boolean {
-  const activeElement = document.activeElement;
-  if (!activeElement) return false;
-
-  // Check if it's a form input element
-  const tagName = activeElement.tagName.toLowerCase();
-  if (tagName === "input" || tagName === "textarea" || tagName === "select") {
-    return true;
-  }
-
-  // Check if it's a contenteditable element
-  if (activeElement.getAttribute("contenteditable") === "true") {
-    return true;
-  }
-
-  // Check if it has a role of textbox or searchbox
-  const role = activeElement.getAttribute("role");
-  if (role === "textbox" || role === "searchbox" || role === "combobox") {
-    return true;
-  }
-
-  // Check if focus is inside an xterm terminal (they use a hidden textarea)
-  const xtermContainer = activeElement.closest(".xterm");
-  if (xtermContainer) {
-    return true;
-  }
-
-  // Also check if any parent has data-terminal-container attribute
-  const terminalContainer = activeElement.closest("[data-terminal-container]");
-  if (terminalContainer) {
-    return true;
-  }
-
-  // Check for autocomplete/typeahead dropdowns being open
-  const autocompleteList = document.querySelector(
-    '[data-testid="category-autocomplete-list"]'
-  );
-  if (autocompleteList) {
-    return true;
-  }
-
-  // Check for any open dialogs
-  const dialog = document.querySelector('[role="dialog"][data-state="open"]');
-  if (dialog) {
-    return true;
-  }
-
-  // Check for project picker dropdown being open
-  const projectPickerDropdown = document.querySelector(
-    '[data-testid="project-picker-dropdown"]'
-  );
-  if (projectPickerDropdown) {
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Check if a keyboard event matches a shortcut definition
- */
-function matchesShortcut(event: KeyboardEvent, shortcutStr: string): boolean {
-  const shortcut = parseShortcut(shortcutStr);
-
-  // Check if the key matches (case-insensitive)
-  if (event.key.toLowerCase() !== shortcut.key.toLowerCase()) {
-    return false;
-  }
-
-  // Check modifier keys
-  const cmdCtrlPressed = event.metaKey || event.ctrlKey;
-  const shiftPressed = event.shiftKey;
-  const altPressed = event.altKey;
-
-  // If shortcut requires cmdCtrl, it must be pressed
-  if (shortcut.cmdCtrl && !cmdCtrlPressed) return false;
-  // If shortcut doesn't require cmdCtrl, it shouldn't be pressed
-  if (!shortcut.cmdCtrl && cmdCtrlPressed) return false;
-
-  // If shortcut requires shift, it must be pressed
-  if (shortcut.shift && !shiftPressed) return false;
-  // If shortcut doesn't require shift, it shouldn't be pressed
-  if (!shortcut.shift && shiftPressed) return false;
-
-  // If shortcut requires alt, it must be pressed
-  if (shortcut.alt && !altPressed) return false;
-  // If shortcut doesn't require alt, it shouldn't be pressed
-  if (!shortcut.alt && altPressed) return false;
-
-  return true;
-}
-
-/**
- * Hook to manage keyboard shortcuts
- * Shortcuts won't fire when user is typing in inputs, textareas, or when dialogs are open
- * Supports modifier keys: Shift, Cmd/Ctrl, Alt/Option
- */
-export function useKeyboardShortcuts(shortcuts: KeyboardShortcut[]) {
-  const handleKeyDown = useCallback(
-    (event: KeyboardEvent) => {
-      // Don't trigger shortcuts when typing in inputs
-      if (isInputFocused()) {
-        return;
-      }
-
-      // Find matching shortcut
-      const matchingShortcut = shortcuts.find(
-        (shortcut) => matchesShortcut(event, shortcut.key)
-      );
-
-      if (matchingShortcut) {
-        event.preventDefault();
-        matchingShortcut.action();
-      }
-    },
-    [shortcuts]
-  );
-
-  useEffect(() => {
-    window.addEventListener("keydown", handleKeyDown);
-    return () => {
-      window.removeEventListener("keydown", handleKeyDown);
-    };
-  }, [handleKeyDown]);
-}
-
-/**
- * Hook to get current keyboard shortcuts from store
- * This replaces the static constants and allows customization
- */
-export function useKeyboardShortcutsConfig() {
-  const keyboardShortcuts = useAppStore((state) => state.keyboardShortcuts);
-  return keyboardShortcuts;
-}

apps/app/src/lib/http-api-client.ts

@@ -1,785 +0,0 @@
-/**
- * HTTP API Client for web mode
- *
- * This client provides the same API as the Electron IPC bridge,
- * but communicates with the backend server via HTTP/WebSocket.
- */
-
-import type {
-  ElectronAPI,
-  FileResult,
-  WriteResult,
-  ReaddirResult,
-  StatResult,
-  DialogResult,
-  SaveImageResult,
-  AutoModeAPI,
-  FeaturesAPI,
-  SuggestionsAPI,
-  SpecRegenerationAPI,
-  AutoModeEvent,
-  SuggestionsEvent,
-  SpecRegenerationEvent,
-  FeatureSuggestion,
-  SuggestionType,
-} from "./electron";
-import type { Message, SessionListItem } from "@/types/electron";
-import type { Feature } from "@/store/app-store";
-import type {
-  WorktreeAPI,
-  GitAPI,
-  ModelDefinition,
-  ProviderStatus,
-} from "@/types/electron";
-import { getGlobalFileBrowser } from "@/contexts/file-browser-context";
-
-// Server URL - configurable via environment variable
-const getServerUrl = (): string => {
-  if (typeof window !== "undefined") {
-    const envUrl = process.env.NEXT_PUBLIC_SERVER_URL;
-    if (envUrl) return envUrl;
-  }
-  return "http://localhost:3008";
-};
-
-// Get API key from environment variable
-const getApiKey = (): string | null => {
-  if (typeof window !== "undefined") {
-    return process.env.NEXT_PUBLIC_AUTOMAKER_API_KEY || null;
-  }
-  return null;
-};
-
-type EventType =
-  | "agent:stream"
-  | "auto-mode:event"
-  | "suggestions:event"
-  | "spec-regeneration:event";
-
-type EventCallback = (payload: unknown) => void;
-
-/**
- * HTTP API Client that implements ElectronAPI interface
- */
-export class HttpApiClient implements ElectronAPI {
-  private serverUrl: string;
-  private ws: WebSocket | null = null;
-  private eventCallbacks: Map<EventType, Set<EventCallback>> = new Map();
-  private reconnectTimer: NodeJS.Timeout | null = null;
-  private isConnecting = false;
-
-  constructor() {
-    this.serverUrl = getServerUrl();
-    this.connectWebSocket();
-  }
-
-  private connectWebSocket(): void {
-    if (
-      this.isConnecting ||
-      (this.ws && this.ws.readyState === WebSocket.OPEN)
-    ) {
-      return;
-    }
-
-    this.isConnecting = true;
-
-    try {
-      const wsUrl = this.serverUrl.replace(/^http/, "ws") + "/api/events";
-      this.ws = new WebSocket(wsUrl);
-
-      this.ws.onopen = () => {
-        console.log("[HttpApiClient] WebSocket connected");
-        this.isConnecting = false;
-        if (this.reconnectTimer) {
-          clearTimeout(this.reconnectTimer);
-          this.reconnectTimer = null;
-        }
-      };
-
-      this.ws.onmessage = (event) => {
-        try {
-          const data = JSON.parse(event.data);
-          const callbacks = this.eventCallbacks.get(data.type);
-          if (callbacks) {
-            callbacks.forEach((cb) => cb(data.payload));
-          }
-        } catch (error) {
-          console.error(
-            "[HttpApiClient] Failed to parse WebSocket message:",
-            error
-          );
-        }
-      };
-
-      this.ws.onclose = () => {
-        console.log("[HttpApiClient] WebSocket disconnected");
-        this.isConnecting = false;
-        this.ws = null;
-        // Attempt to reconnect after 5 seconds
-        if (!this.reconnectTimer) {
-          this.reconnectTimer = setTimeout(() => {
-            this.reconnectTimer = null;
-            this.connectWebSocket();
-          }, 5000);
-        }
-      };
-
-      this.ws.onerror = (error) => {
-        console.error("[HttpApiClient] WebSocket error:", error);
-        this.isConnecting = false;
-      };
-    } catch (error) {
-      console.error("[HttpApiClient] Failed to create WebSocket:", error);
-      this.isConnecting = false;
-    }
-  }
-
-  private subscribeToEvent(
-    type: EventType,
-    callback: EventCallback
-  ): () => void {
-    if (!this.eventCallbacks.has(type)) {
-      this.eventCallbacks.set(type, new Set());
-    }
-    this.eventCallbacks.get(type)!.add(callback);
-
-    // Ensure WebSocket is connected
-    this.connectWebSocket();
-
-    return () => {
-      const callbacks = this.eventCallbacks.get(type);
-      if (callbacks) {
-        callbacks.delete(callback);
-      }
-    };
-  }
-
-  private getHeaders(): Record<string, string> {
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-    };
-    const apiKey = getApiKey();
-    if (apiKey) {
-      headers["X-API-Key"] = apiKey;
-    }
-    return headers;
-  }
-
-  private async post<T>(endpoint: string, body?: unknown): Promise<T> {
-    const response = await fetch(`${this.serverUrl}${endpoint}`, {
-      method: "POST",
-      headers: this.getHeaders(),
-      body: body ? JSON.stringify(body) : undefined,
-    });
-    return response.json();
-  }
-
-  private async get<T>(endpoint: string): Promise<T> {
-    const headers = this.getHeaders();
-    const response = await fetch(`${this.serverUrl}${endpoint}`, { headers });
-    return response.json();
-  }
-
-  private async put<T>(endpoint: string, body?: unknown): Promise<T> {
-    const response = await fetch(`${this.serverUrl}${endpoint}`, {
-      method: "PUT",
-      headers: this.getHeaders(),
-      body: body ? JSON.stringify(body) : undefined,
-    });
-    return response.json();
-  }
-
-  private async httpDelete<T>(endpoint: string): Promise<T> {
-    const response = await fetch(`${this.serverUrl}${endpoint}`, {
-      method: "DELETE",
-      headers: this.getHeaders(),
-    });
-    return response.json();
-  }
-
-  // Basic operations
-  async ping(): Promise<string> {
-    const result = await this.get<{ status: string }>("/api/health");
-    return result.status === "ok" ? "pong" : "error";
-  }
-
-  async openExternalLink(
-    url: string
-  ): Promise<{ success: boolean; error?: string }> {
-    // Open in new tab
-    window.open(url, "_blank", "noopener,noreferrer");
-    return { success: true };
-  }
-
-  // File picker - uses server-side file browser dialog
-  async openDirectory(): Promise<DialogResult> {
-    const fileBrowser = getGlobalFileBrowser();
-
-    if (!fileBrowser) {
-      console.error("File browser not initialized");
-      return { canceled: true, filePaths: [] };
-    }
-
-    const path = await fileBrowser();
-
-    if (!path) {
-      return { canceled: true, filePaths: [] };
-    }
-
-    // Validate with server
-    const result = await this.post<{
-      success: boolean;
-      path?: string;
-      error?: string;
-    }>("/api/fs/validate-path", { filePath: path });
-
-    if (result.success && result.path) {
-      return { canceled: false, filePaths: [result.path] };
-    }
-
-    console.error("Invalid directory:", result.error);
-    return { canceled: true, filePaths: [] };
-  }
-
-  async openFile(options?: object): Promise<DialogResult> {
-    const fileBrowser = getGlobalFileBrowser();
-
-    if (!fileBrowser) {
-      console.error("File browser not initialized");
-      return { canceled: true, filePaths: [] };
-    }
-
-    // For now, use the same directory browser (could be enhanced for file selection)
-    const path = await fileBrowser();
-
-    if (!path) {
-      return { canceled: true, filePaths: [] };
-    }
-
-    const result = await this.post<{ success: boolean; exists: boolean }>(
-      "/api/fs/exists",
-      { filePath: path }
-    );
-
-    if (result.success && result.exists) {
-      return { canceled: false, filePaths: [path] };
-    }
-
-    console.error("File not found");
-    return { canceled: true, filePaths: [] };
-  }
-
-  // File system operations
-  async readFile(filePath: string): Promise<FileResult> {
-    return this.post("/api/fs/read", { filePath });
-  }
-
-  async writeFile(filePath: string, content: string): Promise<WriteResult> {
-    return this.post("/api/fs/write", { filePath, content });
-  }
-
-  async mkdir(dirPath: string): Promise<WriteResult> {
-    return this.post("/api/fs/mkdir", { dirPath });
-  }
-
-  async readdir(dirPath: string): Promise<ReaddirResult> {
-    return this.post("/api/fs/readdir", { dirPath });
-  }
-
-  async exists(filePath: string): Promise<boolean> {
-    const result = await this.post<{ success: boolean; exists: boolean }>(
-      "/api/fs/exists",
-      { filePath }
-    );
-    return result.exists;
-  }
-
-  async stat(filePath: string): Promise<StatResult> {
-    return this.post("/api/fs/stat", { filePath });
-  }
-
-  async deleteFile(filePath: string): Promise<WriteResult> {
-    return this.post("/api/fs/delete", { filePath });
-  }
-
-  async trashItem(filePath: string): Promise<WriteResult> {
-    // In web mode, trash is just delete
-    return this.deleteFile(filePath);
-  }
-
-  async getPath(name: string): Promise<string> {
-    // Server provides data directory
-    if (name === "userData") {
-      const result = await this.get<{ dataDir: string }>(
-        "/api/health/detailed"
-      );
-      return result.dataDir || "/data";
-    }
-    return `/data/${name}`;
-  }
-
-  async saveImageToTemp(
-    data: string,
-    filename: string,
-    mimeType: string,
-    projectPath?: string
-  ): Promise<SaveImageResult> {
-    return this.post("/api/fs/save-image", {
-      data,
-      filename,
-      mimeType,
-      projectPath,
-    });
-  }
-
-  async saveBoardBackground(
-    data: string,
-    filename: string,
-    mimeType: string,
-    projectPath: string
-  ): Promise<{ success: boolean; path?: string; error?: string }> {
-    return this.post("/api/fs/save-board-background", {
-      data,
-      filename,
-      mimeType,
-      projectPath,
-    });
-  }
-
-  async deleteBoardBackground(
-    projectPath: string
-  ): Promise<{ success: boolean; error?: string }> {
-    return this.post("/api/fs/delete-board-background", { projectPath });
-  }
-
-  // CLI checks - server-side
-  async checkClaudeCli(): Promise<{
-    success: boolean;
-    status?: string;
-    method?: string;
-    version?: string;
-    path?: string;
-    recommendation?: string;
-    installCommands?: {
-      macos?: string;
-      windows?: string;
-      linux?: string;
-      npm?: string;
-    };
-    error?: string;
-  }> {
-    return this.get("/api/setup/claude-status");
-  }
-
-  // Model API
-  model = {
-    getAvailable: async (): Promise<{
-      success: boolean;
-      models?: ModelDefinition[];
-      error?: string;
-    }> => {
-      return this.get("/api/models/available");
-    },
-    checkProviders: async (): Promise<{
-      success: boolean;
-      providers?: Record<string, ProviderStatus>;
-      error?: string;
-    }> => {
-      return this.get("/api/models/providers");
-    },
-  };
-
-  // Setup API
-  setup = {
-    getClaudeStatus: (): Promise<{
-      success: boolean;
-      status?: string;
-      installed?: boolean;
-      method?: string;
-      version?: string;
-      path?: string;
-      auth?: {
-        authenticated: boolean;
-        method: string;
-        hasCredentialsFile?: boolean;
-        hasToken?: boolean;
-        hasStoredOAuthToken?: boolean;
-        hasStoredApiKey?: boolean;
-        hasEnvApiKey?: boolean;
-        hasEnvOAuthToken?: boolean;
-        hasCliAuth?: boolean;
-        hasRecentActivity?: boolean;
-      };
-      error?: string;
-    }> => this.get("/api/setup/claude-status"),
-
-    installClaude: (): Promise<{
-      success: boolean;
-      message?: string;
-      error?: string;
-    }> => this.post("/api/setup/install-claude"),
-
-    authClaude: (): Promise<{
-      success: boolean;
-      token?: string;
-      requiresManualAuth?: boolean;
-      terminalOpened?: boolean;
-      command?: string;
-      error?: string;
-      message?: string;
-      output?: string;
-    }> => this.post("/api/setup/auth-claude"),
-
-    storeApiKey: (
-      provider: string,
-      apiKey: string
-    ): Promise<{
-      success: boolean;
-      error?: string;
-    }> => this.post("/api/setup/store-api-key", { provider, apiKey }),
-
-    deleteApiKey: (
-      provider: string
-    ): Promise<{
-      success: boolean;
-      error?: string;
-      message?: string;
-    }> => this.post("/api/setup/delete-api-key", { provider }),
-
-    getApiKeys: (): Promise<{
-      success: boolean;
-      hasAnthropicKey: boolean;
-      hasGoogleKey: boolean;
-    }> => this.get("/api/setup/api-keys"),
-
-    getPlatform: (): Promise<{
-      success: boolean;
-      platform: string;
-      arch: string;
-      homeDir: string;
-      isWindows: boolean;
-      isMac: boolean;
-      isLinux: boolean;
-    }> => this.get("/api/setup/platform"),
-
-    verifyClaudeAuth: (authMethod?: "cli" | "api_key"): Promise<{
-      success: boolean;
-      authenticated: boolean;
-      error?: string;
-    }> => this.post("/api/setup/verify-claude-auth", { authMethod }),
-
-    onInstallProgress: (callback: (progress: unknown) => void) => {
-      return this.subscribeToEvent("agent:stream", callback);
-    },
-
-    onAuthProgress: (callback: (progress: unknown) => void) => {
-      return this.subscribeToEvent("agent:stream", callback);
-    },
-  };
-
-  // Features API
-  features: FeaturesAPI = {
-    getAll: (projectPath: string) =>
-      this.post("/api/features/list", { projectPath }),
-    get: (projectPath: string, featureId: string) =>
-      this.post("/api/features/get", { projectPath, featureId }),
-    create: (projectPath: string, feature: Feature) =>
-      this.post("/api/features/create", { projectPath, feature }),
-    update: (
-      projectPath: string,
-      featureId: string,
-      updates: Partial<Feature>
-    ) => this.post("/api/features/update", { projectPath, featureId, updates }),
-    delete: (projectPath: string, featureId: string) =>
-      this.post("/api/features/delete", { projectPath, featureId }),
-    getAgentOutput: (projectPath: string, featureId: string) =>
-      this.post("/api/features/agent-output", { projectPath, featureId }),
-  };
-
-  // Auto Mode API
-  autoMode: AutoModeAPI = {
-    start: (projectPath: string, maxConcurrency?: number) =>
-      this.post("/api/auto-mode/start", { projectPath, maxConcurrency }),
-    stop: (projectPath: string) =>
-      this.post("/api/auto-mode/stop", { projectPath }),
-    stopFeature: (featureId: string) =>
-      this.post("/api/auto-mode/stop-feature", { featureId }),
-    status: (projectPath?: string) =>
-      this.post("/api/auto-mode/status", { projectPath }),
-    runFeature: (
-      projectPath: string,
-      featureId: string,
-      useWorktrees?: boolean
-    ) =>
-      this.post("/api/auto-mode/run-feature", {
-        projectPath,
-        featureId,
-        useWorktrees,
-      }),
-    verifyFeature: (projectPath: string, featureId: string) =>
-      this.post("/api/auto-mode/verify-feature", { projectPath, featureId }),
-    resumeFeature: (projectPath: string, featureId: string) =>
-      this.post("/api/auto-mode/resume-feature", { projectPath, featureId }),
-    contextExists: (projectPath: string, featureId: string) =>
-      this.post("/api/auto-mode/context-exists", { projectPath, featureId }),
-    analyzeProject: (projectPath: string) =>
-      this.post("/api/auto-mode/analyze-project", { projectPath }),
-    followUpFeature: (
-      projectPath: string,
-      featureId: string,
-      prompt: string,
-      imagePaths?: string[]
-    ) =>
-      this.post("/api/auto-mode/follow-up-feature", {
-        projectPath,
-        featureId,
-        prompt,
-        imagePaths,
-      }),
-    commitFeature: (projectPath: string, featureId: string) =>
-      this.post("/api/auto-mode/commit-feature", { projectPath, featureId }),
-    onEvent: (callback: (event: AutoModeEvent) => void) => {
-      return this.subscribeToEvent(
-        "auto-mode:event",
-        callback as EventCallback
-      );
-    },
-  };
-
-  // Worktree API
-  worktree: WorktreeAPI = {
-    revertFeature: (projectPath: string, featureId: string) =>
-      this.post("/api/worktree/revert", { projectPath, featureId }),
-    mergeFeature: (projectPath: string, featureId: string, options?: object) =>
-      this.post("/api/worktree/merge", { projectPath, featureId, options }),
-    getInfo: (projectPath: string, featureId: string) =>
-      this.post("/api/worktree/info", { projectPath, featureId }),
-    getStatus: (projectPath: string, featureId: string) =>
-      this.post("/api/worktree/status", { projectPath, featureId }),
-    list: (projectPath: string) =>
-      this.post("/api/worktree/list", { projectPath }),
-    getDiffs: (projectPath: string, featureId: string) =>
-      this.post("/api/worktree/diffs", { projectPath, featureId }),
-    getFileDiff: (projectPath: string, featureId: string, filePath: string) =>
-      this.post("/api/worktree/file-diff", {
-        projectPath,
-        featureId,
-        filePath,
-      }),
-  };
-
-  // Git API
-  git: GitAPI = {
-    getDiffs: (projectPath: string) =>
-      this.post("/api/git/diffs", { projectPath }),
-    getFileDiff: (projectPath: string, filePath: string) =>
-      this.post("/api/git/file-diff", { projectPath, filePath }),
-  };
-
-  // Suggestions API
-  suggestions: SuggestionsAPI = {
-    generate: (projectPath: string, suggestionType?: SuggestionType) =>
-      this.post("/api/suggestions/generate", { projectPath, suggestionType }),
-    stop: () => this.post("/api/suggestions/stop"),
-    status: () => this.get("/api/suggestions/status"),
-    onEvent: (callback: (event: SuggestionsEvent) => void) => {
-      return this.subscribeToEvent(
-        "suggestions:event",
-        callback as EventCallback
-      );
-    },
-  };
-
-  // Spec Regeneration API
-  specRegeneration: SpecRegenerationAPI = {
-    create: (
-      projectPath: string,
-      projectOverview: string,
-      generateFeatures?: boolean,
-      analyzeProject?: boolean,
-      maxFeatures?: number
-    ) =>
-      this.post("/api/spec-regeneration/create", {
-        projectPath,
-        projectOverview,
-        generateFeatures,
-        analyzeProject,
-        maxFeatures,
-      }),
-    generate: (
-      projectPath: string,
-      projectDefinition: string,
-      generateFeatures?: boolean,
-      analyzeProject?: boolean,
-      maxFeatures?: number
-    ) =>
-      this.post("/api/spec-regeneration/generate", {
-        projectPath,
-        projectDefinition,
-        generateFeatures,
-        analyzeProject,
-        maxFeatures,
-      }),
-    generateFeatures: (projectPath: string, maxFeatures?: number) =>
-      this.post("/api/spec-regeneration/generate-features", { projectPath, maxFeatures }),
-    stop: () => this.post("/api/spec-regeneration/stop"),
-    status: () => this.get("/api/spec-regeneration/status"),
-    onEvent: (callback: (event: SpecRegenerationEvent) => void) => {
-      return this.subscribeToEvent(
-        "spec-regeneration:event",
-        callback as EventCallback
-      );
-    },
-  };
-
-  // Running Agents API
-  runningAgents = {
-    getAll: (): Promise<{
-      success: boolean;
-      runningAgents?: Array<{
-        featureId: string;
-        projectPath: string;
-        projectName: string;
-        isAutoMode: boolean;
-      }>;
-      totalCount?: number;
-      autoLoopRunning?: boolean;
-      error?: string;
-    }> => this.get("/api/running-agents"),
-  };
-
-  // Workspace API
-  workspace = {
-    getConfig: (): Promise<{
-      success: boolean;
-      configured: boolean;
-      workspaceDir?: string;
-      error?: string;
-    }> => this.get("/api/workspace/config"),
-
-    getDirectories: (): Promise<{
-      success: boolean;
-      directories?: Array<{ name: string; path: string }>;
-      error?: string;
-    }> => this.get("/api/workspace/directories"),
-  };
-
-  // Agent API
-  agent = {
-    start: (
-      sessionId: string,
-      workingDirectory?: string
-    ): Promise<{
-      success: boolean;
-      messages?: Message[];
-      error?: string;
-    }> => this.post("/api/agent/start", { sessionId, workingDirectory }),
-
-    send: (
-      sessionId: string,
-      message: string,
-      workingDirectory?: string,
-      imagePaths?: string[]
-    ): Promise<{ success: boolean; error?: string }> =>
-      this.post("/api/agent/send", {
-        sessionId,
-        message,
-        workingDirectory,
-        imagePaths,
-      }),
-
-    getHistory: (
-      sessionId: string
-    ): Promise<{
-      success: boolean;
-      messages?: Message[];
-      isRunning?: boolean;
-      error?: string;
-    }> => this.post("/api/agent/history", { sessionId }),
-
-    stop: (sessionId: string): Promise<{ success: boolean; error?: string }> =>
-      this.post("/api/agent/stop", { sessionId }),
-
-    clear: (sessionId: string): Promise<{ success: boolean; error?: string }> =>
-      this.post("/api/agent/clear", { sessionId }),
-
-    onStream: (callback: (data: unknown) => void): (() => void) => {
-      return this.subscribeToEvent("agent:stream", callback as EventCallback);
-    },
-  };
-
-  // Templates API
-  templates = {
-    clone: (
-      repoUrl: string,
-      projectName: string,
-      parentDir: string
-    ): Promise<{
-      success: boolean;
-      projectPath?: string;
-      projectName?: string;
-      error?: string;
-    }> =>
-      this.post("/api/templates/clone", { repoUrl, projectName, parentDir }),
-  };
-
-  // Sessions API
-  sessions = {
-    list: (
-      includeArchived?: boolean
-    ): Promise<{
-      success: boolean;
-      sessions?: SessionListItem[];
-      error?: string;
-    }> => this.get(`/api/sessions?includeArchived=${includeArchived || false}`),
-
-    create: (
-      name: string,
-      projectPath: string,
-      workingDirectory?: string
-    ): Promise<{
-      success: boolean;
-      session?: {
-        id: string;
-        name: string;
-        projectPath: string;
-        workingDirectory?: string;
-        createdAt: string;
-        updatedAt: string;
-      };
-      error?: string;
-    }> => this.post("/api/sessions", { name, projectPath, workingDirectory }),
-
-    update: (
-      sessionId: string,
-      name?: string,
-      tags?: string[]
-    ): Promise<{ success: boolean; error?: string }> =>
-      this.put(`/api/sessions/${sessionId}`, { name, tags }),
-
-    archive: (
-      sessionId: string
-    ): Promise<{ success: boolean; error?: string }> =>
-      this.post(`/api/sessions/${sessionId}/archive`, {}),
-
-    unarchive: (
-      sessionId: string
-    ): Promise<{ success: boolean; error?: string }> =>
-      this.post(`/api/sessions/${sessionId}/unarchive`, {}),
-
-    delete: (
-      sessionId: string
-    ): Promise<{ success: boolean; error?: string }> =>
-      this.httpDelete(`/api/sessions/${sessionId}`),
-  };
-}
-
-// Singleton instance
-let httpApiClientInstance: HttpApiClient | null = null;
-
-export function getHttpApiClient(): HttpApiClient {
-  if (!httpApiClientInstance) {
-    httpApiClientInstance = new HttpApiClient();
-  }
-  return httpApiClientInstance;
-}

apps/app/src/lib/log-parser.ts

@@ -1,434 +0,0 @@
-/**
- * Log Parser Utility
- * Parses agent output into structured sections for display
- */
-
-export type LogEntryType =
-  | "prompt"
-  | "tool_call"
-  | "tool_result"
-  | "phase"
-  | "error"
-  | "success"
-  | "info"
-  | "debug"
-  | "warning"
-  | "thinking";
-
-export interface LogEntry {
-  id: string;
-  type: LogEntryType;
-  title: string;
-  content: string;
-  timestamp?: string;
-  collapsed?: boolean;
-  metadata?: {
-    toolName?: string;
-    phase?: string;
-    [key: string]: string | undefined;
-  };
-}
-
-/**
- * Generates a deterministic ID based on content and position
- * This ensures the same log entry always gets the same ID,
- * preserving expanded/collapsed state when new logs stream in
- *
- * Uses only the first 200 characters of content to ensure stability
- * even when entries are merged (which appends content at the end)
- */
-const generateDeterministicId = (content: string, lineIndex: number): string => {
-  // Use first 200 chars to ensure stability when entries are merged
-  const stableContent = content.slice(0, 200);
-  // Simple hash function for the content
-  let hash = 0;
-  const str = stableContent + '|' + lineIndex.toString();
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = ((hash << 5) - hash) + char;
-    hash = hash & hash; // Convert to 32bit integer
-  }
-  return 'log_' + Math.abs(hash).toString(36);
-};
-
-/**
- * Detects the type of log entry based on content patterns
- */
-function detectEntryType(content: string): LogEntryType {
-  const trimmed = content.trim();
-
-  // Tool calls
-  if (trimmed.startsWith("🔧 Tool:") || trimmed.match(/^Tool:\s*/)) {
-    return "tool_call";
-  }
-
-  // Tool results / Input
-  if (trimmed.startsWith("Input:") || trimmed.startsWith("Result:") || trimmed.startsWith("Output:")) {
-    return "tool_result";
-  }
-
-  // Phase changes
-  if (
-    trimmed.startsWith("📋") ||
-    trimmed.startsWith("⚡") ||
-    trimmed.startsWith("✅") ||
-    trimmed.match(/^(Planning|Action|Verification)/i) ||
-    trimmed.match(/\[Phase:\s*([^\]]+)\]/) ||
-    trimmed.match(/Phase:\s*\w+/i)
-  ) {
-    return "phase";
-  }
-  
-  // Feature creation events
-  if (
-    trimmed.match(/\[Feature Creation\]/i) ||
-    trimmed.match(/Feature Creation/i) ||
-    trimmed.match(/Creating feature/i)
-  ) {
-    return "success";
-  }
-
-  // Errors
-  if (trimmed.startsWith("❌") || trimmed.toLowerCase().includes("error:")) {
-    return "error";
-  }
-
-  // Success messages
-  if (
-    trimmed.startsWith("✅") ||
-    trimmed.toLowerCase().includes("success") ||
-    trimmed.toLowerCase().includes("completed")
-  ) {
-    return "success";
-  }
-
-  // Warnings
-  if (trimmed.startsWith("⚠️") || trimmed.toLowerCase().includes("warning:")) {
-    return "warning";
-  }
-
-  // Thinking/Preparation info
-  if (
-    trimmed.toLowerCase().includes("ultrathink") ||
-    trimmed.toLowerCase().includes("thinking level") ||
-    trimmed.toLowerCase().includes("estimated cost") ||
-    trimmed.toLowerCase().includes("estimated time") ||
-    trimmed.toLowerCase().includes("budget tokens") ||
-    trimmed.match(/thinking.*preparation/i)
-  ) {
-    return "thinking";
-  }
-
-  // Debug info (JSON, stack traces, etc.)
-  if (
-    trimmed.startsWith("{") ||
-    trimmed.startsWith("[") ||
-    trimmed.includes("at ") ||
-    trimmed.match(/^\s*\d+\s*\|/)
-  ) {
-    return "debug";
-  }
-
-  // Default to info
-  return "info";
-}
-
-/**
- * Extracts tool name from a tool call entry
- */
-function extractToolName(content: string): string | undefined {
-  const match = content.match(/🔧\s*Tool:\s*(\S+)/);
-  return match?.[1];
-}
-
-/**
- * Extracts phase name from a phase entry
- */
-function extractPhase(content: string): string | undefined {
-  if (content.includes("📋")) return "planning";
-  if (content.includes("⚡")) return "action";
-  if (content.includes("✅")) return "verification";
-
-  // Extract from [Phase: ...] format
-  const phaseMatch = content.match(/\[Phase:\s*([^\]]+)\]/);
-  if (phaseMatch) {
-    return phaseMatch[1].toLowerCase();
-  }
-
-  const match = content.match(/^(Planning|Action|Verification)/i);
-  return match?.[1]?.toLowerCase();
-}
-
-/**
- * Generates a title for a log entry
- */
-function generateTitle(type: LogEntryType, content: string): string {
-  switch (type) {
-    case "tool_call": {
-      const toolName = extractToolName(content);
-      return toolName ? `Tool Call: ${toolName}` : "Tool Call";
-    }
-    case "tool_result":
-      return "Tool Input/Result";
-    case "phase": {
-      const phase = extractPhase(content);
-      if (phase) {
-        // Capitalize first letter of each word
-        const formatted = phase.split(/\s+/).map(word => 
-          word.charAt(0).toUpperCase() + word.slice(1)
-        ).join(" ");
-        return `Phase: ${formatted}`;
-      }
-      return "Phase Change";
-    }
-    case "error":
-      return "Error";
-    case "success":
-      return "Success";
-    case "warning":
-      return "Warning";
-    case "thinking":
-      return "Thinking Level";
-    case "debug":
-      return "Debug Info";
-    case "prompt":
-      return "Prompt";
-    default:
-      return "Info";
-  }
-}
-
-/**
- * Parses raw log output into structured entries
- */
-export function parseLogOutput(rawOutput: string): LogEntry[] {
-  if (!rawOutput || !rawOutput.trim()) {
-    return [];
-  }
-
-  const entries: LogEntry[] = [];
-  const lines = rawOutput.split("\n");
-
-  let currentEntry: Omit<LogEntry, 'id'> & { id?: string } | null = null;
-  let currentContent: string[] = [];
-  let entryStartLine = 0; // Track the starting line for deterministic ID generation
-
-  const finalizeEntry = () => {
-    if (currentEntry && currentContent.length > 0) {
-      currentEntry.content = currentContent.join("\n").trim();
-      if (currentEntry.content) {
-        // Generate deterministic ID based on content and position
-        const entryWithId: LogEntry = {
-          ...currentEntry as Omit<LogEntry, 'id'>,
-          id: generateDeterministicId(currentEntry.content, entryStartLine),
-        };
-        entries.push(entryWithId);
-      }
-    }
-    currentContent = [];
-  };
-
-  let lineIndex = 0;
-  for (const line of lines) {
-    const trimmedLine = line.trim();
-
-    // Skip empty lines at the beginning
-    if (!trimmedLine && !currentEntry) {
-      lineIndex++;
-      continue;
-    }
-
-    // Detect if this line starts a new entry
-    const lineType = detectEntryType(trimmedLine);
-    const isNewEntry =
-      trimmedLine.startsWith("🔧") ||
-      trimmedLine.startsWith("📋") ||
-      trimmedLine.startsWith("⚡") ||
-      trimmedLine.startsWith("✅") ||
-      trimmedLine.startsWith("❌") ||
-      trimmedLine.startsWith("⚠️") ||
-      trimmedLine.startsWith("🧠") ||
-      trimmedLine.match(/\[Phase:\s*([^\]]+)\]/) ||
-      trimmedLine.match(/\[Feature Creation\]/i) ||
-      trimmedLine.match(/\[Tool\]/i) ||
-      trimmedLine.match(/\[Agent\]/i) ||
-      trimmedLine.match(/\[Complete\]/i) ||
-      trimmedLine.match(/\[ERROR\]/i) ||
-      trimmedLine.match(/\[Status\]/i) ||
-      trimmedLine.toLowerCase().includes("ultrathink preparation") ||
-      trimmedLine.toLowerCase().includes("thinking level") ||
-      (trimmedLine.startsWith("Input:") && currentEntry?.type === "tool_call");
-
-    if (isNewEntry) {
-      // Finalize previous entry
-      finalizeEntry();
-
-      // Track starting line for deterministic ID
-      entryStartLine = lineIndex;
-
-      // Start new entry (ID will be generated when finalizing)
-      currentEntry = {
-        type: lineType,
-        title: generateTitle(lineType, trimmedLine),
-        content: "",
-        metadata: {
-          toolName: extractToolName(trimmedLine),
-          phase: extractPhase(trimmedLine),
-        },
-      };
-      currentContent.push(trimmedLine);
-    } else if (currentEntry) {
-      // Continue current entry
-      currentContent.push(line);
-    } else {
-      // Track starting line for deterministic ID
-      entryStartLine = lineIndex;
-
-      // No current entry, create a default info entry
-      currentEntry = {
-        type: "info",
-        title: "Info",
-        content: "",
-      };
-      currentContent.push(line);
-    }
-    lineIndex++;
-  }
-
-  // Finalize last entry
-  finalizeEntry();
-
-  // Merge consecutive entries of the same type if they're both debug or info
-  const mergedEntries = mergeConsecutiveEntries(entries);
-
-  return mergedEntries;
-}
-
-/**
- * Merges consecutive entries of the same type for cleaner display
- */
-function mergeConsecutiveEntries(entries: LogEntry[]): LogEntry[] {
-  if (entries.length <= 1) return entries;
-
-  const merged: LogEntry[] = [];
-  let current: LogEntry | null = null;
-  let mergeIndex = 0;
-
-  for (const entry of entries) {
-    if (
-      current &&
-      (current.type === "debug" || current.type === "info") &&
-      current.type === entry.type
-    ) {
-      // Merge into current - regenerate ID based on merged content
-      current.content += "\n\n" + entry.content;
-      current.id = generateDeterministicId(current.content, mergeIndex);
-    } else {
-      if (current) {
-        merged.push(current);
-      }
-      current = { ...entry };
-      mergeIndex = merged.length;
-    }
-  }
-
-  if (current) {
-    merged.push(current);
-  }
-
-  return merged;
-}
-
-/**
- * Gets the color classes for a log entry type
- */
-export function getLogTypeColors(type: LogEntryType): {
-  bg: string;
-  border: string;
-  text: string;
-  icon: string;
-  badge: string;
-} {
-  switch (type) {
-    case "prompt":
-      return {
-        bg: "bg-blue-500/10",
-        border: "border-l-blue-500",
-        text: "text-blue-300",
-        icon: "text-blue-400",
-        badge: "bg-blue-500/20 text-blue-300",
-      };
-    case "tool_call":
-      return {
-        bg: "bg-amber-500/10",
-        border: "border-l-amber-500",
-        text: "text-amber-300",
-        icon: "text-amber-400",
-        badge: "bg-amber-500/20 text-amber-300",
-      };
-    case "tool_result":
-      return {
-        bg: "bg-slate-500/10",
-        border: "border-l-slate-400",
-        text: "text-slate-300",
-        icon: "text-slate-400",
-        badge: "bg-slate-500/20 text-slate-300",
-      };
-    case "phase":
-      return {
-        bg: "bg-cyan-500/10",
-        border: "border-l-cyan-500",
-        text: "text-cyan-300",
-        icon: "text-cyan-400",
-        badge: "bg-cyan-500/20 text-cyan-300",
-      };
-    case "error":
-      return {
-        bg: "bg-red-500/10",
-        border: "border-l-red-500",
-        text: "text-red-300",
-        icon: "text-red-400",
-        badge: "bg-red-500/20 text-red-300",
-      };
-    case "success":
-      return {
-        bg: "bg-emerald-500/10",
-        border: "border-l-emerald-500",
-        text: "text-emerald-300",
-        icon: "text-emerald-400",
-        badge: "bg-emerald-500/20 text-emerald-300",
-      };
-    case "warning":
-      return {
-        bg: "bg-orange-500/10",
-        border: "border-l-orange-500",
-        text: "text-orange-300",
-        icon: "text-orange-400",
-        badge: "bg-orange-500/20 text-orange-300",
-      };
-    case "thinking":
-      return {
-        bg: "bg-indigo-500/10",
-        border: "border-l-indigo-500",
-        text: "text-indigo-300",
-        icon: "text-indigo-400",
-        badge: "bg-indigo-500/20 text-indigo-300",
-      };
-    case "debug":
-      return {
-        bg: "bg-primary/10",
-        border: "border-l-primary",
-        text: "text-primary",
-        icon: "text-primary",
-        badge: "bg-primary/20 text-primary",
-      };
-    default:
-      return {
-        bg: "bg-zinc-500/10",
-        border: "border-l-zinc-500",
-        text: "text-zinc-300",
-        icon: "text-zinc-400",
-        badge: "bg-zinc-500/20 text-zinc-300",
-      };
-  }
-}

apps/app/src/lib/templates.ts

@@ -1,62 +0,0 @@
-/**
- * Starter Kit Templates
- *
- * Define GitHub templates that users can clone when creating new projects.
- */
-
-export interface StarterTemplate {
-  id: string;
-  name: string;
-  description: string;
-  repoUrl: string;
-  techStack: string[];
-  features: string[];
-  category: "fullstack" | "frontend" | "backend" | "ai" | "other";
-  author: string;
-}
-
-export const starterTemplates: StarterTemplate[] = [
-  {
-    id: "agentic-jumpstart",
-    name: "Agentic Jumpstart",
-    description: "A starter template for building agentic AI applications with a pre-configured development environment including database setup, Docker support, and TypeScript configuration.",
-    repoUrl: "https://github.com/webdevcody/agentic-jumpstart-starter-kit",
-    techStack: ["TypeScript", "Vite", "Drizzle ORM", "Docker", "PostCSS"],
-    features: [
-      "Pre-configured VS Code settings",
-      "Docker Compose setup",
-      "Database migrations with Drizzle",
-      "Type-safe development",
-      "Environment setup with .env.example"
-    ],
-    category: "ai",
-    author: "webdevcody"
-  },
-  {
-    id: "full-stack-campus",
-    name: "Full Stack Campus",
-    description: "A feature-driven development template for building community platforms. Includes authentication, Stripe payments, file uploads, and real-time features using TanStack Start.",
-    repoUrl: "https://github.com/webdevcody/full-stack-campus",
-    techStack: ["TanStack Start", "PostgreSQL", "Drizzle ORM", "Better Auth", "Tailwind CSS", "Radix UI", "Stripe", "AWS S3/R2"],
-    features: [
-      "Community posts with comments and reactions",
-      "User profiles and portfolios",
-      "Calendar event management",
-      "Direct messaging",
-      "Member discovery directory",
-      "Real-time notifications",
-      "Tiered subscriptions (free/basic/pro)",
-      "File uploads with presigned URLs"
-    ],
-    category: "fullstack",
-    author: "webdevcody"
-  }
-];
-
-export function getTemplateById(id: string): StarterTemplate | undefined {
-  return starterTemplates.find(t => t.id === id);
-}
-
-export function getTemplatesByCategory(category: StarterTemplate["category"]): StarterTemplate[] {
-  return starterTemplates.filter(t => t.category === category);
-}

apps/app/src/lib/utils.ts

@@ -1,27 +0,0 @@
-import { clsx, type ClassValue } from "clsx"
-import { twMerge } from "tailwind-merge"
-import type { AgentModel } from "@/store/app-store"
-
-export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs))
-}
-
-/**
- * Determine if the current model supports extended thinking controls
- */
-export function modelSupportsThinking(model?: AgentModel | string): boolean {
-  // All Claude models support thinking
-  return true;
-}
-
-/**
- * Get display name for a model
- */
-export function getModelDisplayName(model: AgentModel | string): string {
-  const displayNames: Record<string, string> = {
-    haiku: "Claude Haiku",
-    sonnet: "Claude Sonnet",
-    opus: "Claude Opus",
-  };
-  return displayNames[model] || model;
-}

apps/app/tests/context-view.spec.ts

@@ -1,688 +0,0 @@
-import { test, expect } from "@playwright/test";
-import * as fs from "fs";
-import * as path from "path";
-import {
-  resetContextDirectory,
-  createContextFileOnDisk,
-  contextFileExistsOnDisk,
-  setupProjectWithFixture,
-  getFixturePath,
-  navigateToContext,
-  waitForFileContentToLoad,
-  switchToEditMode,
-  waitForContextFile,
-  selectContextFile,
-  simulateFileDrop,
-  setContextEditorContent,
-  getContextEditorContent,
-  clickElement,
-  fillInput,
-  getByTestId,
-  waitForNetworkIdle,
-} from "./utils";
-
-const WORKSPACE_ROOT = path.resolve(process.cwd(), "../..");
-const TEST_IMAGE_SRC = path.join(WORKSPACE_ROOT, "apps/app/public/logo.png");
-
-// Configure all tests to run serially to prevent interference with shared context directory
-test.describe.configure({ mode: "serial" });
-
-// ============================================================================
-// Test Suite 1: Context View - File Management
-// ============================================================================
-test.describe("Context View - File Management", () => {
-
-  test.beforeEach(async () => {
-    resetContextDirectory();
-  });
-
-  test.afterEach(async () => {
-    resetContextDirectory();
-  });
-
-  test("should create a new MD context file", async ({ page }) => {
-    await setupProjectWithFixture(page, getFixturePath());
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    await navigateToContext(page);
-
-    // Click Add File button
-    await clickElement(page, "add-context-file");
-    await page.waitForSelector('[data-testid="add-context-dialog"]', {
-      timeout: 5000,
-    });
-
-    // Select text type (should be default)
-    await clickElement(page, "add-text-type");
-
-    // Enter filename
-    await fillInput(page, "new-file-name", "test-context.md");
-
-    // Enter content
-    const testContent = "# Test Context\n\nThis is test content";
-    await fillInput(page, "new-file-content", testContent);
-
-    // Click confirm
-    await clickElement(page, "confirm-add-file");
-
-    // Wait for dialog to close
-    await page.waitForFunction(
-      () => !document.querySelector('[data-testid="add-context-dialog"]'),
-      { timeout: 5000 }
-    );
-
-    // Wait for file list to refresh (file should appear)
-    await waitForContextFile(page, "test-context.md", 10000);
-
-    // Verify file appears in list
-    const fileButton = await getByTestId(page, "context-file-test-context.md");
-    await expect(fileButton).toBeVisible();
-
-    // Click on the file and wait for it to be selected
-    await selectContextFile(page, "test-context.md");
-
-    // Wait for content to load
-    await waitForFileContentToLoad(page);
-
-    // Switch to edit mode if in preview mode (markdown files default to preview)
-    await switchToEditMode(page);
-
-    // Wait for editor to be visible
-    await page.waitForSelector('[data-testid="context-editor"]', {
-      timeout: 5000,
-    });
-
-    // Verify content in editor
-    const editorContent = await getContextEditorContent(page);
-    expect(editorContent).toBe(testContent);
-  });
-
-  test("should edit an existing MD context file", async ({ page }) => {
-    // Create a test file on disk first
-    const originalContent = "# Original Content\n\nThis will be edited.";
-    createContextFileOnDisk("edit-test.md", originalContent);
-
-    await setupProjectWithFixture(page, getFixturePath());
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    await navigateToContext(page);
-
-    // Click on the existing file and wait for it to be selected
-    await selectContextFile(page, "edit-test.md");
-
-    // Wait for file content to load
-    await waitForFileContentToLoad(page);
-
-    // Switch to edit mode (markdown files open in preview mode by default)
-    await switchToEditMode(page);
-
-    // Wait for editor
-    await page.waitForSelector('[data-testid="context-editor"]', {
-      timeout: 5000,
-    });
-
-    // Modify content
-    const newContent = "# Modified Content\n\nThis has been edited.";
-    await setContextEditorContent(page, newContent);
-
-    // Click save
-    await clickElement(page, "save-context-file");
-
-    // Wait for save to complete
-    await page.waitForFunction(
-      () =>
-        document
-          .querySelector('[data-testid="save-context-file"]')
-          ?.textContent?.includes("Saved"),
-      { timeout: 5000 }
-    );
-
-    // Reload page
-    await page.reload();
-    await waitForNetworkIdle(page);
-
-    // Navigate back to context view
-    await navigateToContext(page);
-
-    // Wait for file to appear after reload and select it
-    await selectContextFile(page, "edit-test.md");
-
-    // Wait for content to load
-    await waitForFileContentToLoad(page);
-
-    // Switch to edit mode (markdown files open in preview mode)
-    await switchToEditMode(page);
-
-    await page.waitForSelector('[data-testid="context-editor"]', {
-      timeout: 5000,
-    });
-
-    // Verify content persisted
-    const persistedContent = await getContextEditorContent(page);
-    expect(persistedContent).toBe(newContent);
-  });
-
-  test("should remove an MD context file", async ({ page }) => {
-    // Create a test file on disk first
-    createContextFileOnDisk("delete-test.md", "# Delete Me");
-
-    await setupProjectWithFixture(page, getFixturePath());
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    await navigateToContext(page);
-
-    // Click on the file to select it
-    const fileButton = await getByTestId(page, "context-file-delete-test.md");
-    await fileButton.waitFor({ state: "visible", timeout: 5000 });
-    await fileButton.click();
-
-    // Click delete button
-    await clickElement(page, "delete-context-file");
-
-    // Wait for delete dialog
-    await page.waitForSelector('[data-testid="delete-context-dialog"]', {
-      timeout: 5000,
-    });
-
-    // Confirm deletion
-    await clickElement(page, "confirm-delete-file");
-
-    // Wait for dialog to close
-    await page.waitForFunction(
-      () => !document.querySelector('[data-testid="delete-context-dialog"]'),
-      { timeout: 5000 }
-    );
-
-    // Verify file is removed from list
-    const deletedFile = await getByTestId(page, "context-file-delete-test.md");
-    await expect(deletedFile).not.toBeVisible();
-
-    // Verify file is removed from disk
-    expect(contextFileExistsOnDisk("delete-test.md")).toBe(false);
-  });
-
-  test("should upload an image context file", async ({ page }) => {
-    await setupProjectWithFixture(page, getFixturePath());
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    await navigateToContext(page);
-
-    // Click Add File button
-    await clickElement(page, "add-context-file");
-    await page.waitForSelector('[data-testid="add-context-dialog"]', {
-      timeout: 5000,
-    });
-
-    // Select image type
-    await clickElement(page, "add-image-type");
-
-    // Enter filename
-    await fillInput(page, "new-file-name", "test-image.png");
-
-    // Upload image using file input
-    await page.setInputFiles(
-      '[data-testid="image-upload-input"]',
-      TEST_IMAGE_SRC
-    );
-
-    // Wait for image preview to appear (indicates upload success)
-    const addDialog = await getByTestId(page, "add-context-dialog");
-    await addDialog.locator("img").waitFor({ state: "visible" });
-
-    // Click confirm
-    await clickElement(page, "confirm-add-file");
-
-    // Wait for dialog to close
-    await page.waitForFunction(
-      () => !document.querySelector('[data-testid="add-context-dialog"]'),
-      { timeout: 5000 }
-    );
-
-    // Verify file appears in list
-    const fileButton = await getByTestId(page, "context-file-test-image.png");
-    await expect(fileButton).toBeVisible();
-
-    // Click on the image to view it
-    await fileButton.click();
-
-    // Verify image preview is displayed
-    await page.waitForSelector('[data-testid="image-preview"]', {
-      timeout: 5000,
-    });
-    const imagePreview = await getByTestId(page, "image-preview");
-    await expect(imagePreview).toBeVisible();
-  });
-
-  test("should remove an image context file", async ({ page }) => {
-    // Create a test image file on disk as base64 data URL (matching app's storage format)
-    const imageContent = fs.readFileSync(TEST_IMAGE_SRC);
-    const base64DataUrl = `data:image/png;base64,${imageContent.toString("base64")}`;
-    const contextPath = path.join(getFixturePath(), ".automaker/context");
-    fs.writeFileSync(path.join(contextPath, "delete-image.png"), base64DataUrl);
-
-    await setupProjectWithFixture(page, getFixturePath());
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    await navigateToContext(page);
-
-    // Wait for the image file and select it
-    await selectContextFile(page, "delete-image.png");
-
-    // Wait for file content (image preview) to load
-    await waitForFileContentToLoad(page);
-
-    // Click delete button
-    await clickElement(page, "delete-context-file");
-
-    // Wait for delete dialog
-    await page.waitForSelector('[data-testid="delete-context-dialog"]', {
-      timeout: 5000,
-    });
-
-    // Confirm deletion
-    await clickElement(page, "confirm-delete-file");
-
-    // Wait for dialog to close
-    await page.waitForFunction(
-      () => !document.querySelector('[data-testid="delete-context-dialog"]'),
-      { timeout: 5000 }
-    );
-
-    // Verify file is removed from list
-    const deletedImageFile = await getByTestId(page, "context-file-delete-image.png");
-    await expect(deletedImageFile).not.toBeVisible();
-  });
-
-  test("should toggle markdown preview mode", async ({ page }) => {
-    // Create a markdown file with content
-    const mdContent =
-      "# Heading\n\n**Bold text** and *italic text*\n\n- List item 1\n- List item 2";
-    createContextFileOnDisk("preview-test.md", mdContent);
-
-    await setupProjectWithFixture(page, getFixturePath());
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    await navigateToContext(page);
-
-    // Click on the markdown file
-    const fileButton = await getByTestId(page, "context-file-preview-test.md");
-    await fileButton.waitFor({ state: "visible", timeout: 5000 });
-    await fileButton.click();
-
-    // Wait for content to load (markdown files open in preview mode by default)
-    await waitForFileContentToLoad(page);
-
-    // Check if preview button is visible (indicates it's a markdown file)
-    const previewToggle = await getByTestId(page, "toggle-preview-mode");
-    await expect(previewToggle).toBeVisible();
-
-    // Markdown files always open in preview mode by default (see context-view.tsx:163)
-    // Verify we're in preview mode
-    const markdownPreview = await getByTestId(page, "markdown-preview");
-    await expect(markdownPreview).toBeVisible();
-
-    // Click to switch to edit mode
-    await previewToggle.click();
-    await page.waitForSelector('[data-testid="context-editor"]', {
-      timeout: 5000,
-    });
-
-    // Verify editor is shown
-    const editor = await getByTestId(page, "context-editor");
-    await expect(editor).toBeVisible();
-    await expect(markdownPreview).not.toBeVisible();
-
-    // Click to switch back to preview mode
-    await previewToggle.click();
-    await page.waitForSelector('[data-testid="markdown-preview"]', {
-      timeout: 5000,
-    });
-
-    // Verify preview is shown
-    await expect(markdownPreview).toBeVisible();
-  });
-});
-
-// ============================================================================
-// Test Suite 2: Context View - Drag and Drop
-// ============================================================================
-test.describe("Context View - Drag and Drop", () => {
-  test.beforeEach(async () => {
-    resetContextDirectory();
-  });
-
-  test.afterEach(async () => {
-    resetContextDirectory();
-  });
-
-  test("should handle drag and drop of MD file onto textarea in add dialog", async ({
-    page,
-  }) => {
-    await setupProjectWithFixture(page, getFixturePath());
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    await navigateToContext(page);
-
-    // Open add file dialog
-    await clickElement(page, "add-context-file");
-    await page.waitForSelector('[data-testid="add-context-dialog"]', {
-      timeout: 5000,
-    });
-
-    // Ensure text type is selected
-    await clickElement(page, "add-text-type");
-
-    // Simulate drag and drop of a .md file onto the textarea
-    const droppedContent = "# Dropped Content\n\nThis was dragged and dropped.";
-    await simulateFileDrop(
-      page,
-      '[data-testid="new-file-content"]',
-      "dropped-file.md",
-      droppedContent
-    );
-
-    // Wait for content to be populated in textarea
-    const textarea = await getByTestId(page, "new-file-content");
-    await textarea.waitFor({ state: "visible" });
-    await expect(textarea).toHaveValue(droppedContent);
-
-    // Verify content is populated in textarea
-    const textareaContent = await textarea.inputValue();
-    expect(textareaContent).toBe(droppedContent);
-
-    // Verify filename is auto-filled
-    const filenameValue = await page
-      .locator('[data-testid="new-file-name"]')
-      .inputValue();
-    expect(filenameValue).toBe("dropped-file.md");
-
-    // Confirm and create the file
-    await clickElement(page, "confirm-add-file");
-
-    // Wait for dialog to close
-    await page.waitForFunction(
-      () => !document.querySelector('[data-testid="add-context-dialog"]'),
-      { timeout: 5000 }
-    );
-
-    // Verify file was created
-    const droppedFile = await getByTestId(page, "context-file-dropped-file.md");
-    await expect(droppedFile).toBeVisible();
-  });
-
-  test("should handle drag and drop of file onto main view", async ({
-    page,
-  }) => {
-    await setupProjectWithFixture(page, getFixturePath());
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    await navigateToContext(page);
-
-    // Wait for the context view to be fully loaded
-    await page.waitForSelector('[data-testid="context-file-list"]', {
-      timeout: 5000,
-    });
-
-    // Simulate drag and drop onto the drop zone
-    const droppedContent = "This is a text file dropped onto the main view.";
-    await simulateFileDrop(
-      page,
-      '[data-testid="context-drop-zone"]',
-      "main-drop.txt",
-      droppedContent
-    );
-
-    // Wait for file to appear in the list (drag-drop triggers file creation)
-    await waitForContextFile(page, "main-drop.txt", 15000);
-
-    // Verify file appears in the file list
-    const fileButton = await getByTestId(page, "context-file-main-drop.txt");
-    await expect(fileButton).toBeVisible();
-
-    // Select file and verify content
-    await fileButton.click();
-    await page.waitForSelector('[data-testid="context-editor"]', {
-      timeout: 5000,
-    });
-
-    const editorContent = await getContextEditorContent(page);
-    expect(editorContent).toBe(droppedContent);
-  });
-});
-
-// ============================================================================
-// Test Suite 3: Context View - Edge Cases
-// ============================================================================
-test.describe("Context View - Edge Cases", () => {
-  test.beforeEach(async () => {
-    resetContextDirectory();
-  });
-
-  test.afterEach(async () => {
-    resetContextDirectory();
-  });
-
-  test("should handle duplicate filename (overwrite behavior)", async ({
-    page,
-  }) => {
-    // Create an existing file
-    createContextFileOnDisk("test.md", "# Original Content");
-
-    await setupProjectWithFixture(page, getFixturePath());
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    await navigateToContext(page);
-
-    // Verify the original file exists
-    const originalFile = await getByTestId(page, "context-file-test.md");
-    await expect(originalFile).toBeVisible();
-
-    // Try to create another file with the same name
-    await clickElement(page, "add-context-file");
-    await page.waitForSelector('[data-testid="add-context-dialog"]', {
-      timeout: 5000,
-    });
-
-    await clickElement(page, "add-text-type");
-    await fillInput(page, "new-file-name", "test.md");
-    await fillInput(page, "new-file-content", "# New Content - Overwritten");
-
-    await clickElement(page, "confirm-add-file");
-
-    // Wait for dialog to close
-    await page.waitForFunction(
-      () => !document.querySelector('[data-testid="add-context-dialog"]'),
-      { timeout: 5000 }
-    );
-
-    // File should still exist (was overwritten)
-    await expect(originalFile).toBeVisible();
-
-    // Select the file and verify the new content
-    await originalFile.click();
-
-    // Wait for content to load
-    await waitForFileContentToLoad(page);
-
-    // Switch to edit mode (markdown files open in preview mode)
-    await switchToEditMode(page);
-
-    await page.waitForSelector('[data-testid="context-editor"]', {
-      timeout: 5000,
-    });
-
-    const editorContent = await getContextEditorContent(page);
-    expect(editorContent).toBe("# New Content - Overwritten");
-  });
-
-  test("should handle special characters in filename", async ({ page }) => {
-    await setupProjectWithFixture(page, getFixturePath());
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    await navigateToContext(page);
-
-    // Test file with parentheses
-    await clickElement(page, "add-context-file");
-    await page.waitForSelector('[data-testid="add-context-dialog"]', {
-      timeout: 5000,
-    });
-
-    await clickElement(page, "add-text-type");
-    await fillInput(page, "new-file-name", "context (1).md");
-    await fillInput(page, "new-file-content", "Content with parentheses in filename");
-
-    await clickElement(page, "confirm-add-file");
-    await page.waitForFunction(
-      () => !document.querySelector('[data-testid="add-context-dialog"]'),
-      { timeout: 5000 }
-    );
-
-    // Verify file is created - use CSS escape for special characters
-    const fileWithParens = await getByTestId(page, "context-file-context (1).md");
-    await expect(fileWithParens).toBeVisible();
-
-    // Test file with hyphens and underscores
-    await clickElement(page, "add-context-file");
-    await page.waitForSelector('[data-testid="add-context-dialog"]', {
-      timeout: 5000,
-    });
-
-    await clickElement(page, "add-text-type");
-    await fillInput(page, "new-file-name", "test-file_v2.md");
-    await fillInput(page, "new-file-content", "Content with hyphens and underscores");
-
-    await clickElement(page, "confirm-add-file");
-    await page.waitForFunction(
-      () => !document.querySelector('[data-testid="add-context-dialog"]'),
-      { timeout: 5000 }
-    );
-
-    // Verify file is created
-    const fileWithHyphens = await getByTestId(page, "context-file-test-file_v2.md");
-    await expect(fileWithHyphens).toBeVisible();
-
-    // Verify both files are accessible
-    await fileWithHyphens.click();
-
-    // Wait for content to load
-    await waitForFileContentToLoad(page);
-
-    // Switch to edit mode (markdown files open in preview mode)
-    await switchToEditMode(page);
-
-    await page.waitForSelector('[data-testid="context-editor"]', {
-      timeout: 5000,
-    });
-
-    const content = await getContextEditorContent(page);
-    expect(content).toBe("Content with hyphens and underscores");
-  });
-
-  test("should handle empty content", async ({ page }) => {
-    await setupProjectWithFixture(page, getFixturePath());
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    await navigateToContext(page);
-
-    // Create file with empty content
-    await clickElement(page, "add-context-file");
-    await page.waitForSelector('[data-testid="add-context-dialog"]', {
-      timeout: 5000,
-    });
-
-    await clickElement(page, "add-text-type");
-    await fillInput(page, "new-file-name", "empty-file.md");
-    // Don't fill any content - leave it empty
-
-    await clickElement(page, "confirm-add-file");
-    await page.waitForFunction(
-      () => !document.querySelector('[data-testid="add-context-dialog"]'),
-      { timeout: 5000 }
-    );
-
-    // Verify file is created
-    const emptyFile = await getByTestId(page, "context-file-empty-file.md");
-    await expect(emptyFile).toBeVisible();
-
-    // Select file and verify editor shows empty content
-    await emptyFile.click();
-
-    // Wait for content to load
-    await waitForFileContentToLoad(page);
-
-    // Switch to edit mode (markdown files open in preview mode)
-    await switchToEditMode(page);
-
-    await page.waitForSelector('[data-testid="context-editor"]', {
-      timeout: 5000,
-    });
-
-    const editorContent = await getContextEditorContent(page);
-    expect(editorContent).toBe("");
-
-    // Verify save works with empty content
-    // The save button should be disabled when there are no changes
-    // Let's add some content first, then clear it and save
-    await setContextEditorContent(page, "temporary");
-    await setContextEditorContent(page, "");
-
-    // Save should work
-    await clickElement(page, "save-context-file");
-    await page.waitForFunction(
-      () =>
-        document
-          .querySelector('[data-testid="save-context-file"]')
-          ?.textContent?.includes("Saved"),
-      { timeout: 5000 }
-    );
-  });
-
-  test("should verify persistence across page refresh", async ({ page }) => {
-    // Create a file directly on disk to ensure it persists across refreshes
-    const testContent = "# Persistence Test\n\nThis content should persist.";
-    createContextFileOnDisk("persist-test.md", testContent);
-
-    await setupProjectWithFixture(page, getFixturePath());
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    await navigateToContext(page);
-
-    // Verify file exists before refresh
-    await waitForContextFile(page, "persist-test.md", 10000);
-
-    // Refresh the page
-    await page.reload();
-    await waitForNetworkIdle(page);
-
-    // Navigate back to context view
-    await navigateToContext(page);
-
-    // Select the file after refresh (uses robust clicking mechanism)
-    await selectContextFile(page, "persist-test.md");
-
-    // Wait for file content to load
-    await waitForFileContentToLoad(page);
-
-    // Switch to edit mode (markdown files open in preview mode)
-    await switchToEditMode(page);
-
-    await page.waitForSelector('[data-testid="context-editor"]', {
-      timeout: 5000,
-    });
-
-    const persistedContent = await getContextEditorContent(page);
-    expect(persistedContent).toBe(testContent);
-  });
-});

apps/app/tests/spec-editor-persistence.spec.ts

@@ -1,323 +0,0 @@
-import { test, expect } from "@playwright/test";
-import {
-  resetFixtureSpec,
-  setupProjectWithFixture,
-  getFixturePath,
-  navigateToSpecEditor,
-  getEditorContent,
-  setEditorContent,
-  clickSaveButton,
-  getByTestId,
-  clickElement,
-  fillInput,
-  waitForNetworkIdle,
-  waitForElement,
-} from "./utils";
-
-test.describe("Spec Editor Persistence", () => {
-  test.beforeEach(async () => {
-    // Reset the fixture spec file to original content before each test
-    resetFixtureSpec();
-  });
-
-  test.afterEach(async () => {
-    // Clean up - reset the spec file after each test
-    resetFixtureSpec();
-  });
-
-  test("should open project, edit spec, save, and persist changes after refresh", async ({
-    page,
-  }) => {
-    // Use the resolved fixture path
-    const fixturePath = getFixturePath();
-
-    // Step 1: Set up the project in localStorage pointing to our fixture
-    await setupProjectWithFixture(page, fixturePath);
-
-    // Step 2: Navigate to the app
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    // Step 3: Verify we're on the dashboard with the project loaded
-    // The sidebar should show the project selector
-    const sidebar = await getByTestId(page, "sidebar");
-    await sidebar.waitFor({ state: "visible", timeout: 10000 });
-
-    // Step 4: Click on the Spec Editor in the sidebar
-    await navigateToSpecEditor(page);
-
-    // Step 5: Wait for the spec editor to load
-    const specEditor = await getByTestId(page, "spec-editor");
-    await specEditor.waitFor({ state: "visible", timeout: 10000 });
-
-    // Step 6: Wait for CodeMirror to initialize (it has a .cm-content element)
-    await specEditor.locator(".cm-content").waitFor({ state: "visible", timeout: 10000 });
-
-    // Small delay to ensure editor is fully initialized
-    await page.waitForTimeout(500);
-
-    // Step 7: Modify the editor content to "hello world"
-    await setEditorContent(page, "hello world");
-
-    // Step 8: Click the save button
-    await clickSaveButton(page);
-
-    // Step 9: Refresh the page
-    await page.reload();
-    await waitForNetworkIdle(page);
-
-    // Step 10: Navigate back to the spec editor
-    // After reload, we need to wait for the app to initialize
-    await waitForElement(page, "sidebar", { timeout: 10000 });
-
-    // Navigate to spec editor again
-    await navigateToSpecEditor(page);
-
-    // Wait for CodeMirror to be ready
-    const specEditorAfterReload = await getByTestId(page, "spec-editor");
-    await specEditorAfterReload.locator(".cm-content").waitFor({ state: "visible", timeout: 10000 });
-
-    // Small delay to ensure editor content is loaded
-    await page.waitForTimeout(500);
-
-    // Step 11: Verify the content was persisted
-    const persistedContent = await getEditorContent(page);
-    expect(persistedContent.trim()).toBe("hello world");
-  });
-
-  test("should handle opening project via Open Project button and file browser", async ({
-    page,
-  }) => {
-    // This test covers the flow of:
-    // 1. Clicking Open Project button
-    // 2. Using the file browser to navigate to the fixture directory
-    // 3. Opening the project
-    // 4. Editing the spec
-
-    // Set up without a current project to test the open project flow
-    await page.addInitScript(() => {
-      const mockState = {
-        state: {
-          projects: [],
-          currentProject: null,
-          currentView: "welcome",
-          theme: "dark",
-          sidebarOpen: true,
-          apiKeys: { anthropic: "", google: "" },
-          chatSessions: [],
-          chatHistoryOpen: false,
-          maxConcurrency: 3,
-        },
-        version: 0,
-      };
-      localStorage.setItem("automaker-storage", JSON.stringify(mockState));
-
-      // Mark setup as complete
-      const setupState = {
-        state: {
-          isFirstRun: false,
-          setupComplete: true,
-          currentStep: "complete",
-          skipClaudeSetup: false,
-        },
-        version: 0,
-      };
-      localStorage.setItem("automaker-setup", JSON.stringify(setupState));
-    });
-
-    // Navigate to the app
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    // Wait for the sidebar to be visible
-    const sidebar = await getByTestId(page, "sidebar");
-    await sidebar.waitFor({ state: "visible", timeout: 10000 });
-
-    // Click the Open Project button
-    const openProjectButton = await getByTestId(page, "open-project-button");
-
-    // Check if the button is visible (it might not be in collapsed sidebar)
-    const isButtonVisible = await openProjectButton
-      .isVisible()
-      .catch(() => false);
-
-    if (isButtonVisible) {
-      await clickElement(page, "open-project-button");
-
-      // The file browser dialog should open
-      // Note: In web mode, this might use the FileBrowserDialog component
-      // which makes requests to the backend server at /api/fs/browse
-
-      // Wait a bit to see if a dialog appears
-      await page.waitForTimeout(1000);
-
-      // Check if a dialog is visible
-      const dialog = page.locator('[role="dialog"]');
-      const dialogVisible = await dialog.isVisible().catch(() => false);
-
-      if (dialogVisible) {
-        // If file browser dialog is open, we need to navigate to the fixture path
-        // This depends on the current directory structure
-
-        // For now, let's verify the dialog appeared and close it
-        // A full test would navigate through directories
-        console.log("File browser dialog opened successfully");
-
-        // Press Escape to close the dialog
-        await page.keyboard.press("Escape");
-      }
-    }
-
-    // For a complete e2e test with file browsing, we'd need to:
-    // 1. Navigate through the directory tree
-    // 2. Select the projectA directory
-    // 3. Click "Select Current Folder"
-
-    // Since this involves actual file system navigation,
-    // and depends on the backend server being properly configured,
-    // we'll verify the basic UI elements are present
-
-    expect(sidebar).toBeTruthy();
-  });
-});
-
-test.describe("Spec Editor - Full Open Project Flow", () => {
-  test.beforeEach(async () => {
-    // Reset the fixture spec file to original content before each test
-    resetFixtureSpec();
-  });
-
-  test.afterEach(async () => {
-    // Clean up - reset the spec file after each test
-    resetFixtureSpec();
-  });
-
-  test("should open project via file browser, edit spec, and persist", async ({
-    page,
-  }) => {
-    // Navigate to app first
-    await page.goto("/");
-    await waitForNetworkIdle(page);
-
-    // Set up localStorage state (without a current project, but mark setup complete)
-    // Using evaluate instead of addInitScript so it only runs once
-    // Note: In CI, setup wizard is also skipped via NEXT_PUBLIC_SKIP_SETUP env var
-    await page.evaluate(() => {
-      const mockState = {
-        state: {
-          projects: [],
-          currentProject: null,
-          currentView: "welcome",
-          theme: "dark",
-          sidebarOpen: true,
-          apiKeys: { anthropic: "", google: "" },
-          chatSessions: [],
-          chatHistoryOpen: false,
-          maxConcurrency: 3,
-        },
-        version: 0,
-      };
-      localStorage.setItem("automaker-storage", JSON.stringify(mockState));
-
-      // Mark setup as complete (fallback for when NEXT_PUBLIC_SKIP_SETUP isn't set)
-      const setupState = {
-        state: {
-          isFirstRun: false,
-          setupComplete: true,
-          currentStep: "complete",
-          skipClaudeSetup: false,
-        },
-        version: 0,
-      };
-      localStorage.setItem("automaker-setup", JSON.stringify(setupState));
-    });
-
-    // Reload to apply the localStorage state
-    await page.reload();
-    await waitForNetworkIdle(page);
-
-    // Wait for sidebar
-    await waitForElement(page, "sidebar", { timeout: 10000 });
-
-    // Click the Open Project button
-    const openProjectButton = await getByTestId(page, "open-project-button");
-    await openProjectButton.waitFor({ state: "visible", timeout: 10000 });
-    await clickElement(page, "open-project-button");
-
-    // Wait for the file browser dialog to open
-    const dialogTitle = page.locator('text="Select Project Directory"');
-    await dialogTitle.waitFor({ state: "visible", timeout: 10000 });
-
-    // Wait for the dialog to fully load (loading to complete)
-    await page.waitForFunction(
-      () => !document.body.textContent?.includes("Loading directories..."),
-      { timeout: 10000 }
-    );
-
-    // Use the path input to directly navigate to the fixture directory
-    const pathInput = await getByTestId(page, "path-input");
-    await pathInput.waitFor({ state: "visible", timeout: 5000 });
-
-    // Clear the input and type the full path to the fixture
-    await fillInput(page, "path-input", getFixturePath());
-
-    // Click the Go button to navigate to the path
-    await clickElement(page, "go-to-path-button");
-
-    // Wait for loading to complete
-    await page.waitForFunction(
-      () => !document.body.textContent?.includes("Loading directories..."),
-      { timeout: 10000 }
-    );
-
-    // Verify we're in the right directory by checking the path display
-    const pathDisplay = page.locator(".font-mono.text-sm.truncate");
-    await expect(pathDisplay).toContainText("projectA");
-
-    // Click "Select Current Folder" button
-    const selectFolderButton = page.locator(
-      'button:has-text("Select Current Folder")'
-    );
-    await selectFolderButton.click();
-
-    // Wait for dialog to close and project to load
-    await page.waitForFunction(
-      () => !document.querySelector('[role="dialog"]'),
-      { timeout: 10000 }
-    );
-    await page.waitForTimeout(500);
-
-    // Navigate to spec editor
-    const specNav = await getByTestId(page, "nav-spec");
-    await specNav.waitFor({ state: "visible", timeout: 10000 });
-    await clickElement(page, "nav-spec");
-
-    // Wait for spec view with the editor (not the empty state)
-    await waitForElement(page, "spec-view", { timeout: 10000 });
-    const specEditorForOpenFlow = await getByTestId(page, "spec-editor");
-    await specEditorForOpenFlow.locator(".cm-content").waitFor({ state: "visible", timeout: 10000 });
-    await page.waitForTimeout(500);
-
-    // Edit the content
-    await setEditorContent(page, "hello world");
-
-    // Click save button
-    await clickSaveButton(page);
-
-    // Refresh and verify persistence
-    await page.reload();
-    await waitForNetworkIdle(page);
-
-    // Navigate back to spec editor
-    await specNav.waitFor({ state: "visible", timeout: 10000 });
-    await clickElement(page, "nav-spec");
-
-    const specEditorAfterRefresh = await getByTestId(page, "spec-editor");
-    await specEditorAfterRefresh.locator(".cm-content").waitFor({ state: "visible", timeout: 10000 });
-    await page.waitForTimeout(500);
-
-    // Verify the content persisted
-    const persistedContent = await getEditorContent(page);
-    expect(persistedContent.trim()).toBe("hello world");
-  });
-});

apps/app/tests/utils/components/autocomplete.ts

@@ -1,59 +0,0 @@
-import { Page, Locator } from "@playwright/test";
-import { waitForElement, waitForElementHidden } from "../core/waiting";
-
-/**
- * Check if the category autocomplete dropdown is visible
- */
-export async function isCategoryAutocompleteListVisible(
-  page: Page
-): Promise<boolean> {
-  const list = page.locator('[data-testid="category-autocomplete-list"]');
-  return await list.isVisible();
-}
-
-/**
- * Wait for the category autocomplete dropdown to be visible
- */
-export async function waitForCategoryAutocompleteList(
-  page: Page,
-  options?: { timeout?: number }
-): Promise<Locator> {
-  return await waitForElement(page, "category-autocomplete-list", options);
-}
-
-/**
- * Wait for the category autocomplete dropdown to be hidden
- */
-export async function waitForCategoryAutocompleteListHidden(
-  page: Page,
-  options?: { timeout?: number }
-): Promise<void> {
-  await waitForElementHidden(page, "category-autocomplete-list", options);
-}
-
-/**
- * Click a category option in the autocomplete dropdown
- */
-export async function clickCategoryOption(
-  page: Page,
-  categoryName: string
-): Promise<void> {
-  const optionTestId = `category-option-${categoryName
-    .toLowerCase()
-    .replace(/\s+/g, "-")}`;
-  const option = page.locator(`[data-testid="${optionTestId}"]`);
-  await option.click();
-}
-
-/**
- * Get a category option element by name
- */
-export async function getCategoryOption(
-  page: Page,
-  categoryName: string
-): Promise<Locator> {
-  const optionTestId = `category-option-${categoryName
-    .toLowerCase()
-    .replace(/\s+/g, "-")}`;
-  return page.locator(`[data-testid="${optionTestId}"]`);
-}