feat: Introduce new UI layout with floating dock, visual effects, and expanded theme options.

feat: task dependency graph view

.automaker/.gitignore

@@ -1,13 +0,0 @@
-# Backup files - these are created automatically by the UpdateFeatureStatus tool
-feature_list.backup.json
-
-# Agent context files - created during feature execution
-agents-context/
-
-# Attached images - uploaded by users as feature context
-images/
-
-# Launch script - local development script
-launch.sh
-
-.cursor

.automaker/agents-context/feature-1765333578668-qbzk7xihs.md

@@ -1,8 +0,0 @@
-📋 Planning implementation for: For example i got haiku model running or codex one but we can still see opus 4.5 check if it not hardcoded and fix it to use proper model name that was used in this task
-⚡ Executing implementation for: For example i got haiku model running or codex one but we can still see opus 4.5 check if it not hardcoded and fix it to use proper model name that was used in this task
-
-❌ Error: Reconnecting... 1/5
-📋 Planning implementation for: For example i got haiku model running or codex one but we can still see opus 4.5 check if it not hardcoded and fix it to use proper model name that was used in this task
-⚡ Executing implementation for: For example i got haiku model running or codex one but we can still see opus 4.5 check if it not hardcoded and fix it to use proper model name that was used in this task
-📋 Planning implementation for: For example i got haiku model running or codex one but we can still see opus 4.5 check if it not hardcoded and fix it to use proper model name that was used in this task
-⚡ Executing implementation for: For example i got haiku model running or codex one but we can still see opus 4.5 check if it not hardcoded and fix it to use proper model name that was used in this task

.automaker/agents-context/feature-1765334118538-zc6n2ngu8.md

@@ -1,4 +0,0 @@
-📋 Planning implementation for: For example i got haiku model running or codex one but we can still see opus 4.5 check if it not hardcoded and fix it to use proper model name that was used in this task
-⚡ Executing implementation for: For example i got haiku model running or codex one but we can still see opus 4.5 check if it not hardcoded and fix it to use proper model name that was used in this task
-📋 Planning implementation for: For example i got haiku model running or codex one but we can still see opus 4.5 check if it not hardcoded and fix it to use proper model name that was used in this task
-⚡ Executing implementation for: For example i got haiku model running or codex one but we can still see opus 4.5 check if it not hardcoded and fix it to use proper model name that was used in this task

.automaker/app_spec.txt

@@ -1,136 +0,0 @@
-<project_specification>
-  <project_name>Automaker - Autonomous AI Development Studio</project_name>
-  
-  <overview>
-    Automaker is a native desktop application that empowers developers to build software autonomously. It acts as an intelligent orchestrator, managing the entire development lifecycle from specification to implementation. Built with Electron and Next.js, it provides a seamless GUI for configuring projects, defining requirements (.automaker/app_spec.txt), and tracking progress via an interactive Kanban board. It leverages a dual-model architecture: Claude 3.5 Opus for complex logic/architecture and Gemini 3 Pro for UI/UX design.
-  </overview>
-
-  <technology_stack>
-    <frontend>
-      <framework>Next.js (App Router)</framework>
-      <ui_library>shadcn/ui</ui_library>
-      <styling>Tailwind CSS</styling>
-      <state_management>Zustand / TanStack Query</state_management>
-      <drag_drop>dnd-kit (for Kanban)</drag_drop>
-      <icons>Lucide React</icons>
-    </frontend>
-    <desktop_shell>
-      <framework>Electron</framework>
-      <language>TypeScript</language>
-      <inter_process_communication>Electron IPC (tRPC or raw IPC)</inter_process_communication>
-      <file_system>Node.js fs/promises</file_system>
-    </desktop_shell>
-    <ai_engine>
-      <logic_model>Claude 3.5 Opus (via Anthropic SDK)</logic_model>
-      <design_model>Gemini 3 Pro (via Google Generative AI SDK)</design_model>
-      <orchestration>LangChain or Custom Agent Loop</orchestration>
-    </ai_engine>
-    <testing>
-      <framework>Playwright (for E2E testing of Automaker itself)</framework>
-      <unit>Vitest</unit>
-    </testing>
-  </technology_stack>
-
-  <core_capabilities>
-    <project_management>
-      - Open existing local projects
-      - Create new projects from scratch (Wizard/Interview Mode)
-      - Project configuration (name, path, ignore patterns)
-      - Visual file explorer
-    </project_management>
-    
-    <intelligent_analysis>
-      - "Project Ingestion": Analyzes existing codebases to understand structure
-      - Auto-generation of `.automaker/app_spec.txt` based on codebase analysis
-      - Auto-generation of `.automaker/feature_list.json`:
-        - Scans code for implemented features
-        - Creates test cases for existing features
-        - Marks existing features as "passes": true automatically
-    </intelligent_analysis>
-
-    <kanban_workflow>
-      - Visual representation of `.automaker/feature_list.json`
-      - Columns: Backlog, Planned, In Progress, Review, Verified (Passed), Failed
-      - Drag-and-drop interface to reprioritize tasks
-      - direct editing of feature details (steps, description) from the card
-      - "Play" button on cards to trigger the agent for that specific feature
-    </kanban_workflow>
-
-    <autonomous_agent_engine>
-      - **The Architect (Claude 3.5 Opus)**:
-        - Reads spec and feature list
-        - Plans implementation steps
-        - Writes functional code (backend, logic, state)
-        - Writes tests
-        - Uses standard prompts (e.g. `.automaker/coding_prompt.md`) to ensure quality and consistency.
-      - **The Designer (Gemini 3 Pro)**:
-        - Receives UI requirements
-        - Generates Tailwind classes and React components
-        - Ensures visual consistency and aesthetics
-      - **The Interviewer**:
-        - Interactive chat mode to gather requirements for new projects.
-        - Asks clarifying questions to define the `.automaker/app_spec.txt`.
-        - Suggests tech stacks and features based on user intent.
-      - **The QA Bot**:
-        - Runs local tests (Playwright/Jest) in the target project
-        - Reports results back to the Kanban board
-        - Updates "passes" status automatically
-    </autonomous_agent_engine>
-
-    <extensibility>
-      - Workflow Editor: Configure the agent loop (e.g., Plan -> Code -> Test -> Review)
-      - Prompt Manager: Edit system prompts for Architect and Designer. Defaults to using `.automaker/coding_prompt.md` as the base instruction set.
-      - Model Registry: Add/Configure different models (OpenAI, Groq, local LLMs)
-      - Plugin System: Hooks for pre/post generation steps
-    </extensibility>
-  </core_capabilities>
-
-  <ui_layout>
-    <window_structure>
-      - Sidebar: Project List, Settings, Logs, Plugins
-      - Main Content:
-        - **Spec View**: Split editor for `.automaker/app_spec.txt`
-        - **Board View**: Kanban board for `.automaker/feature_list.json`
-        - **Code View**: Read-only Monaco editor to see what the agent is writing
-        - **Agent View**: Chat-like interface showing agent thought process and tool usage. Also used for the "New Project Interview".
-    </window_structure>
-    <theme>
-      - Dark/Light mode support (system sync)
-      - "Hacker" aesthetic option (terminal-like)
-      - Professional/Clean default
-    </theme>
-  </ui_layout>
-
-  <development_workflow>
-    <local_testing>
-      - "Browser Mode": Run the Next.js frontend in a standard browser with mocked Electron IPC for rapid UI iteration.
-      - "Electron Mode": Full desktop app testing.
-      - Hot Reloading for both Main and Renderer processes.
-    </local_testing>
-  </development_workflow>
-
-  <implementation_roadmap>
-    <phase_1_foundation>
-      - Setup Next.js + Electron boilerplate
-      - Implement IPC bridge
-      - Create Project Management UI (Open/Create)
-    </phase_1_foundation>
-    <phase_2_core_logic>
-      - Port python agent logic to TypeScript
-      - Implement "Project Ingestion" (Spec/Feature List generation)
-      - Integrate Claude 3.5 Opus and Gemini 3 Pro
-      - Implement "New Project Interview" workflow
-    </phase_2_core_logic>
-    <phase_3_kanban_and_interaction>
-      - Build Kanban board with drag-and-drop
-      - Connect Kanban state to `.automaker/feature_list.json` filesystem
-      - Implement "Run Feature" capability
-      - Integrate standard prompts library
-    </phase_3_kanban_and_interaction>
-    <phase_4_polish>
-      - Advanced terminal integration
-      - Settings & Extensibility
-      - UI refinement
-    </phase_4_polish>
-  </implementation_roadmap>
-</project_specification>

.automaker/categories.json

@@ -1,8 +0,0 @@
-[
-  "Agent Runner",
-  "Core",
-  "Kanban",
-  "Other",
-  "Settings",
-  "Uncategorized"
-]

.automaker/context/gemini.md

@@ -1,70 +0,0 @@
-You are a very strong reasoner and planner. Use these critical instructions to structure your plans, thoughts, and responses.
-
-Before taking any action (either tool calls or responses to the user), you must proactively, methodically, and independently plan and reason about:
-
-1. Logical dependencies and constraints:
-
-Analyze the intended action against the following factors. Resolve conflicts in order of importance:
-
-1.1) Policy-based rules, mandatory prerequisites, and constraints.
-1.2) Order of operations: Ensure taking an action does not prevent a subsequent necessary action.
- 1.2.1) The user may request actions in a random order, but you may need to reorder operations to maximize successful completion of the task.
-1.3) Other prerequisites (information and/or actions needed).
-1.4) Explicit user constraints or preferences.
-
-2. Risk assessment:
-
-What are the consequences of taking the action? Will the new state cause any future issues?
-
-2.1) For exploratory tasks (like searches), missing optional parameters is a LOW risk.
-Prefer calling the tool with the available information over asking the user, unless your Rule 1 (Logical Dependencies) reasoning determines that optional information is required for a later step in your plan.
-
-3. Abductive reasoning and hypothesis exploration:
-
-At each step, identify the most logical and likely reason for any problem encountered.
-
-3.1) Look beyond immediate or obvious causes. The most likely reason may not be the simplest and may require deeper inference.
-3.2) Hypotheses may require additional research. Each hypothesis may take multiple steps to test.
-3.3) Prioritize hypotheses based on likelihood, but do not discard less likely ones prematurely. A low-probability event may still be the root cause.
-
-4. Outcome evaluation and adaptability:
-
-Does the previous observation require any changes to your plan?
-
-4.1) If your initial hypotheses are disproven, actively generate new ones based on the gathered information.
-
-5. Information availability:
-
-Incorporate all applicable and alternative sources of information, including:
-
-5.1) Using available tools and their capabilities
-5.2) All policies, rules, checklists, and constraints
-5.3) Previous observations and conversation history
-5.4) Information only available by asking the user
-
-6. Precision and Grounding:
-
-Ensure your reasoning is extremely precise and relevant to each exact ongoing situation.
-
-6.1) Verify your claims by quoting the exact applicable information (including policies) when referring to them.
-
-7. Completeness:
-
-Ensure that all requirements, constraints, options, and preferences are exhaustively incorporated into your plan.
-
-7.1) Resolve conflicts using the order of importance in #1.
-7.2) Avoid premature conclusions: There may be multiple relevant options for a given situation.
- 7.2.1) To check for whether an option is relevant, reason about all information sources from #5.
- 7.2.2) You may need to consult the user to even know whether something is applicable. Do not assume it is not applicable without checking.
-7.3) Review applicable sources of information from #5 to confirm which are relevant to the current state.
-
-8. Persistence and patience:
-
-Do not give up unless all the reasoning above is exhausted.
-
-8.1) Don't be dissuaded by time taken or user frustration.
-8.2) This persistence must be intelligent: On transient errors (e.g. please try again), you must retry unless an explicit retry limit (e.g., max x tries) has been reached. If such a limit is hit, you must stop. On other errors, you must change your strategy or arguments, not repeat the same failed call.
-
-9. Inhibit your response:
-
-Only take an action after all the above reasoning is completed. Once you've taken an action, you cannot take it back.

.automaker/feature_list.json

@@ -1,395 +0,0 @@
-[
-  {
-    "id": "feature-1765387670653-bl83444lj",
-    "category": "Kanban",
-    "description": "In the output logs of the proc agent output in the file diffs Can you add a scroll bar so it actually scroll to see all these new styles right now it seems like I can't scroll",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T17:42:09.158Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Fixed scrolling for file diffs in agent output modal. Changed approach: parent container (agent-output-modal.tsx) now handles scrolling with overflow-y-auto, while GitDiffPanel uses natural height without flex-based scrolling. Modified: agent-output-modal.tsx (line 304), git-diff-panel.tsx (lines 461, 500, 525, 614).",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765387746902-na752mp1y",
-    "category": "Kanban",
-    "description": "When the add feature modal pops up, make sure that the description is always the main focus. When it first loads up. Do not focus the prompt tab, which is currently doing this.",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T17:29:13.854Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Added autoFocus prop to DescriptionImageDropZone component. Modified: description-image-dropzone.tsx (added autoFocus prop support), board-view.tsx (enabled autoFocus on add feature modal). Now the description textarea receives focus when the modal opens instead of the prompt tab.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765388139100-ln31jgp5n",
-    "category": "Uncategorized",
-    "description": "Can you add a disclaimer .md file to this project saying that this uses a bunch of AI related tooling which could have access to your operating system and change and delete files and so use at your own risk. We tried to check it for security of vulnerability to make sure it's good. But you assume the risk and you should be reviewing the code yourself before you try to run it. And also sandboxing this so it doesn't have access to your whole operating system like using Docker to sandbox before you run it or use a virtual machine to sandbox it. and that we do not recommend running locally on your computer due to the risk of it having access to everything on your computer.\n\nUpdate or read me with a short paragraph overview/description at the top followed by a disclaimer section in red that points to the disclaimer file with the same disclaimer information.\n\nThen a section that lists out all the features of cool emojis.",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T17:35:40.700Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Created DISCLAIMER.md with comprehensive security warnings about AI tooling risks and sandboxing recommendations. Updated README.md with project overview, red caution disclaimer section linking to DISCLAIMER.md, and features list with emojis covering all major functionality (Kanban, AI agents, multi-model support, etc.).",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765388388144-oa1dewze9",
-    "category": "Uncategorized",
-    "description": "Please fix the styling of the hotkeys to be more using the theme colors. Notice that they're kind of gray. I would rather than have some type of like light green if they're not active and then the brighter green if they are active and also the add feature but in the top right it's not very legible. So fix the accessibility of the hotkey but also keep it within the theme. You might just have to change the text inside of it to be bright green.",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T17:40:02.745Z",
-    "imagePaths": [
-      {
-        "id": "img-1765388352835-dgx4ishp0",
-        "path": "/Users/webdevcody/Library/Application Support/automaker/images/1765388352832-6jnbgw8kg_Screenshot_2025-12-10_at_12.39.10_PM.png",
-        "filename": "Screenshot 2025-12-10 at 12.39.10 PM.png",
-        "mimeType": "image/png"
-      },
-      {
-        "id": "img-1765388356955-a0gdovp5b",
-        "path": "/Users/webdevcody/Library/Application Support/automaker/images/1765388356954-d59a65nf9_Screenshot_2025-12-10_at_12.39.15_PM.png",
-        "filename": "Screenshot 2025-12-10 at 12.39.15 PM.png",
-        "mimeType": "image/png"
-      }
-    ],
-    "skipTests": true,
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765388402095-x66aduwg3",
-    "category": "Uncategorized",
-    "description": "Can you please add some spacing and fix the styling of the hotkey with the command enter and make it so they're both vertically aligned for those icons?",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T17:44:08.667Z",
-    "imagePaths": [
-      {
-        "id": "img-1765388390408-eefybe95t",
-        "path": "/Users/webdevcody/Library/Application Support/automaker/images/1765388390408-nn320yoyc_Screenshot_2025-12-10_at_12.39.47_PM.png",
-        "filename": "Screenshot 2025-12-10 at 12.39.47 PM.png",
-        "mimeType": "image/png"
-      }
-    ],
-    "skipTests": true,
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765388662444-as3hqn7be",
-    "category": "Uncategorized",
-    "description": "Fix the styling on all the buttons when I hover over them with my mouse they never change to a click mouse cursor. In order they seem to show any type of like hover state changes, if they do, at least for the certain game I'm using, it's not very obvious that you're hovering over the button.",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T17:45:59.666Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Fixed hover cursor styling on all interactive elements. Modified: button.tsx (added cursor-pointer to base styles), dropdown-menu.tsx (added cursor-pointer to all menu items), checkbox.tsx (added cursor-pointer), tabs.tsx (added cursor-pointer to triggers), dialog.tsx (added cursor-pointer to close button), slider.tsx (added cursor-grab to thumb, cursor-pointer to track), globals.css (added global CSS rules for clickable elements to ensure consistent cursor behavior).",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765388693856-yx1dk1acj",
-    "category": "Kanban",
-    "description": "The tabs in the add new feature modal for the prompt model and testing tabs. They don't seem to look like tabs when I'm on a certain theme. Can you verify that those are hooked into the theme? And make sure that the active one is colored differently than the unactive ones. Keep the primary colors when doing this.",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T17:46:00.019Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Fixed tabs component theme integration. Modified: tabs.tsx. Changes: (1) Added visible border to TabsList container using theme's border color, (2) Changed inactive tab text to foreground/70 for better contrast, (3) Enhanced active tab with shadow-md and semi-transparent primary border, (4) Improved hover state with full accent background. Active tabs now properly use bg-primary/text-primary-foreground which adapts to each theme.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765388754462-bek0flvkj",
-    "category": "Uncategorized",
-    "description": "There's a strange issue when I when when these agents are like doing things it seems like it completely refreshes the whole Kanban board and there's like a black flash. Can you verify that the data loading does not cause the entire component to refresh? Maybe there's an issue with the react effect or how the component is rendered maybe we need some used memos or something but it shouldn't refresh the whole page it should just like update the individual cards when they change.",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T17:47:20.170Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Fixed Kanban board flash/refresh issue. Changes: (1) board-view.tsx - Added isInitialLoadRef to only show loading spinner on initial load, not on feature reloads; memoized column features with useMemo to prevent recalculation on every render. (2) kanban-card.tsx - Wrapped with React.memo to prevent unnecessary re-renders. (3) kanban-column.tsx - Wrapped with React.memo for performance. The flash was caused by loadFeatures setting isLoading=true on every reload, which caused the entire board to unmount and show a loading spinner.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765388793845-yhluf0sry",
-    "category": "Uncategorized",
-    "description": "Add in the ability so that every project can have its own selected theme. This will allow me to have different projects have different themes so I can easily differentiate when I have one project selected or not.",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T18:00:33.814Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Fixed per-project theme support. Modified: settings-view.tsx (now saves theme to project when project is selected, shows label indicating scope), page.tsx (computes effectiveTheme from currentProject?.theme || theme), app-store.ts (added setProjectTheme action, theme property on Project interface). When a project is selected, changing theme in Settings saves to that project only.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765389333728-y74hmz2yp",
-    "category": "Agent Runner",
-    "description": "On the Agent Runner, I took a screenshot and dropped it into the text area and after a certain amount of time, it's like the image preview just completely went away. Can you debug and fix this on the Agent Runner?",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T18:11:17.561Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765389352488-j9bez5ztx",
-    "category": "Kanban",
-    "description": "It seems like the category typehead is no longer working. Can you double check that code didn't break? It should have kept track of categories inside of the categories.json file inside the .automaker folder when adding new features modal",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T18:17:22.274Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Fixed category typeahead dropdown being clipped by overflow containers. Modified: category-autocomplete.tsx. Changed dropdown to use React Portal (createPortal) to render to document.body with fixed positioning and z-index 9999. Added scroll/resize position tracking to keep dropdown aligned with input.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765389420151-jzdsjzn9u",
-    "category": "Kanban",
-    "description": "Add in the ability to just click and drag a card from the waiting approval directly into the verify column as I can usually just commit it manually if I want to.",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T18:05:08.252Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Fixed drag-and-drop from waiting_approval to verified column. The issue was condition ordering in handleDragEnd - the skipTests check was intercepting waiting_approval features before they could be handled. Moved waiting_approval status check before skipTests check in board-view.tsx:731-752. Also updated agent memory with this lesson.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765389468077-9x3vt1yjq",
-    "category": "Uncategorized",
-    "description": "The commit functionality on the waiting approval cards doesn't seem to work. It just committed everything in my working copy for git. I think I should be a little bit more intelligent and figure out what files it changed for that AI session and then only try to git add those individual files and commit those. Right now it just basically did a git add all and committed those. Re-factor the prompting or figure out a way to make it so it's more specific on what it's going to commit with the future change.",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T18:17:22.580Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Fixed commit functionality to only commit files changed during the AI session, not all working directory changes. Added git state tracking in context-manager.js (saveInitialGitState, getFilesChangedDuringSession methods) and updated commit prompt in feature-executor.js to use specific file lists instead of 'git add .'",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765389502705-6deep7mvi",
-    "category": "Uncategorized",
-    "description": "I'm noticing that a lot of buttons in the UI, especially the ones that are submitting, are either missing the submit hotkey or they're not styled properly. Look at the add feature submit button that's on the add feature modal and abstract away a submit button so that on every single page that needs to submit something I can reuse this type of hotkey functionality. In fact, every single button should be abstracted enough where I can provide a hotkey and it will automatically listen if I press that hotkey when it's in view.",
-    "steps": [],
-    "status": "waiting_approval",
-    "startedAt": "2025-12-10T19:03:41.338Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Fixed duplicate hotkey listener issue. When HotkeyButton was used with simple keys (N, F, G) that were already handled by useKeyboardShortcuts, it created duplicate listeners. Added hotkeyActive={false} to HotkeyButton instances in board-view.tsx (Add Feature, Start Next), context-view.tsx (Add File), profiles-view.tsx (New Profile), and session-manager.tsx (New) where useKeyboardShortcuts already handles the hotkey. Also updated memory.md with this lesson learned.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765389772166-an3yk3kpo",
-    "category": "Uncategorized",
-    "description": "Can you add some more padding to the bottom of the settings panel? Notice that I can't scroll down all the way. And that doesn't highlight the left sub navigation to highlight it pink when I'm on that section. I should be able to scroll a bit further and just have like blank space at the bottom. So I can eventually get to that actual section.",
-    "steps": [],
-    "status": "verified",
-    "imagePaths": [
-      {
-        "id": "img-1765389750685-jhq6rcidc",
-        "path": "/Users/webdevcody/Library/Application Support/automaker/images/1765389750683-mqb0j7a3z_Screenshot_2025-12-10_at_1.02.26_PM.png",
-        "filename": "Screenshot 2025-12-10 at 1.02.26 PM.png",
-        "mimeType": "image/png"
-      }
-    ],
-    "skipTests": true,
-    "summary": "Added bottom padding (pb-96) to settings panel content area to allow scrolling past last section. Improved scroll detection to highlight the last navigation item when scrolled to bottom. Modified: settings-view.tsx",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765389829239-bbk596u6z",
-    "category": "Uncategorized",
-    "description": "Add some type of XML highlighting to the spec editor view. Right now it's just all grayscale and it's kind of ugly to look at. And try to make the syntax highlighting match the current selected theme.",
-    "steps": [],
-    "status": "verified",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Added XML syntax highlighting to spec editor view. Created: xml-syntax-editor.tsx component with custom XML tokenizer and theme-aware syntax highlighting. Modified: spec-view.tsx to use new editor, globals.css with 500+ lines of theme-specific syntax highlighting colors for all 12 themes (light, dark, retro, dracula, nord, monokai, tokyonight, solarized, gruvbox, catppuccin, onedark, synthwave). Features: highlights tag brackets, tag names, attribute names, attribute values, comments, CDATA, DOCTYPE. Tab key indentation supported.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765389859334-si9ivtehw",
-    "category": "Uncategorized",
-    "description": "Add a search bar to the top of the Kanban column that allows me to search the filter down just to show the cards I'm interested in by keyword.",
-    "steps": [],
-    "status": "verified",
-    "startedAt": "2025-12-10T18:09:26.193Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Added forward slash (/) keyboard shortcut to focus search input. Modified: board-view.tsx - added searchInputRef, registered '/' shortcut in boardShortcuts, updated placeholder to show hint '(Press / to focus)'",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765390022638-nalulsdxv",
-    "category": "Uncategorized",
-    "description": "In the project select can you actually remove the whole like 1 2 3 4 5 hotkeys instead? Just make it be a type ahead so when I open the panel I just should be able to type in the first letter or two of the project that I want and press enter and that should Just select it for me",
-    "steps": [],
-    "status": "verified",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Replaced hotkey-based project selection (1-9) with type-ahead search. Modified: sidebar.tsx. Added search input with filtering, arrow key navigation (↑↓), Enter to select, and visual highlighting. Auto-focuses search when dropdown opens.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765390055621-ewc4w7k5h",
-    "category": "Uncategorized",
-    "description": "In the add new feature prompt, instead of disabling the add feature button until we type into the description, keep it enabled. But if you click it, make sure you just show the client side validation and turn the description box in any other required field as red so that the user knows they have to fill it in.",
-    "steps": [],
-    "status": "verified",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Added client-side validation for the Add Feature dialog. The Add Feature button is now always enabled. When clicked without a description, it shows a red border around the description field using aria-invalid styling. Modified: board-view.tsx (added descriptionError state, validation in handleAddFeature, error prop passing), description-image-dropzone.tsx (added error prop that sets aria-invalid on textarea).",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765390131625-ymqxr5gln",
-    "category": "Uncategorized",
-    "description": "Can you please in the top right of the Kanban board use the show three icons for the Kanban card display formatting. You can look at the settings page to see that there's three different settings that we use for displaying the Kanban card information. But I also just want this to be really quickly accessible at the top right of the Kanban that they can switch between those three toggles. Keep them simple only just icons you don't need to put words in them. Make sure they do have harbor states though, or tooltips I mean.",
-    "steps": [],
-    "status": "waiting_approval",
-    "startedAt": "2025-12-10T18:58:21.431Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Moved Kanban card detail toggle icons to search bar row. Modified: board-view.tsx. Three icons (Minimize2, Square, Maximize2) now appear on the right side of the search bar with tooltips and hover states.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765390359456-n0vvdurjb",
-    "category": "Kanban",
-    "description": "When the item is in the backlog, do not show the logs. There's no reason for a user to look at the logs if it's in the backlog. So remove the logs button from the card, the Kanban card, if it's in the backlog.",
-    "steps": [],
-    "status": "verified",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Removed logs button from Kanban cards when feature is in backlog. Modified: kanban-card.tsx - removed the dedicated logs button section for backlog items (lines 743-761) and added condition to hide logs option in dropdown menu for backlog items.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765390428237-4ekiscpsf",
-    "category": "Uncategorized",
-    "description": "On the Kanban search bar, instead of press slash to focus, just use the normal shortcut display button that we've been using everywhere else in the application. Can you keep it consistent, please?",
-    "steps": [],
-    "status": "verified",
-    "imagePaths": [
-      {
-        "id": "img-1765390414226-66vm6cly4",
-        "path": "/Users/webdevcody/Library/Application Support/automaker/images/1765390414225-7o9wizw90_Screenshot_2025-12-10_at_1.13.32_PM.png",
-        "filename": "Screenshot 2025-12-10 at 1.13.32 PM.png",
-        "mimeType": "image/png"
-      }
-    ],
-    "skipTests": true,
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765390699789-uaxtse6hn",
-    "category": "Uncategorized",
-    "description": "Please fix the styling of this on the Agent Runner, make it match the theme of the project.",
-    "steps": [],
-    "status": "verified",
-    "imagePaths": [
-      {
-        "id": "img-1765390692809-0hahbe30j",
-        "path": "/Users/webdevcody/Library/Application Support/automaker/images/1765390692808-u8dgwxx9n_Screenshot_2025-12-10_at_1.18.07_PM.png",
-        "filename": "Screenshot 2025-12-10 at 1.18.07 PM.png",
-        "mimeType": "image/png"
-      }
-    ],
-    "skipTests": true,
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765393057026-cjgr70d97",
-    "category": "Kanban",
-    "description": "there is a major bug: stopping auto mode should not cancel all running tasks, it should just turn off the auto toggle.",
-    "steps": [],
-    "status": "waiting_approval",
-    "startedAt": "2025-12-10T18:57:56.137Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Fixed auto mode stop to only turn off the toggle, not cancel running tasks. Modified: auto-mode-service.js (removed abort/clear logic from stop()), use-auto-mode.ts (removed clearRunningTasks from stop callback). Running features now complete naturally.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765393405243-xe047s4h5",
-    "category": "Uncategorized",
-    "description": "fix the style of the input on the kanban route to add a border around the entire input",
-    "steps": [],
-    "status": "waiting_approval",
-    "startedAt": "2025-12-10T19:08:38.024Z",
-    "imagePaths": [
-      {
-        "id": "img-1765393386453-nd1qucdne",
-        "path": "/Users/webdevcody/Workspace/automaker/.automaker/images/1765393386452-bz4q5pbkw_Screenshot_2025-12-10_at_2.03.04_PM.png",
-        "filename": "Screenshot 2025-12-10 at 2.03.04 PM.png",
-        "mimeType": "image/png"
-      }
-    ],
-    "skipTests": true,
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765395197833-hkxty2nb9",
-    "category": "Uncategorized",
-    "description": "on the agent runner chat window, style the text to match the theme primary or secondary, restyle it to match the selected theme",
-    "steps": [],
-    "status": "waiting_approval",
-    "startedAt": "2025-12-10T19:33:18.742Z",
-    "imagePaths": [
-      {
-        "id": "img-1765395175327-vdj77vwtb",
-        "path": "/Users/webdevcody/Workspace/automaker/.automaker/images/1765395175325-plp2txel3_Screenshot_2025-12-10_at_2.32.52_PM.png",
-        "filename": "Screenshot 2025-12-10 at 2.32.52 PM.png",
-        "mimeType": "image/png"
-      }
-    ],
-    "skipTests": true,
-    "summary": "Styled agent chat messages to use theme primary colors. Modified: agent-view.tsx, interview-view.tsx. Assistant messages now have border-l-4 border-primary, text-primary for content and timestamps. Loading/thinking indicators also styled with theme colors.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  },
-  {
-    "id": "feature-1765395217816-22cwdpnu9",
-    "category": "Uncategorized",
-    "description": "the add feature shortcut on the add new feature modal does not work anymore, please fix it",
-    "steps": [],
-    "status": "waiting_approval",
-    "startedAt": "2025-12-10T19:35:54.453Z",
-    "imagePaths": [],
-    "skipTests": true,
-    "summary": "Fixed Cmd+Enter shortcut not working in Add Feature modal when input is focused. Modified: hotkey-button.tsx - Changed logic to allow cmdCtrl modifier shortcuts even when typing in input fields, since they are intentional submit actions.",
-    "model": "opus",
-    "thinkingLevel": "none"
-  }
-]

.automaker/memory.md

@@ -1,172 +0,0 @@
-# Agent Memory - Lessons Learned
-
-This file documents issues encountered by previous agents and their solutions. Read this before starting work to avoid repeating mistakes.
-
-## Testing Issues
-
-### Issue: Mock project setup not navigating to board view
-
-**Problem:** Setting `currentProject` in localStorage didn't automatically show the board view - app stayed on welcome view.
-**Fix:** The `currentView` state is not persisted in localStorage. Instead of trying to set it, have tests click on the recent project from the welcome view to trigger `setCurrentProject()` which handles the view transition properly.
-
-```typescript
-// Don't do this:
-await setupMockProject(page); // Sets localStorage
-await page.goto("/");
-await waitForElement(page, "board-view"); // ❌ Fails - still on welcome view
-
-// Do this instead:
-await setupMockProject(page);
-await page.goto("/");
-await waitForElement(page, "welcome-view");
-const recentProject = page.locator(
-  '[data-testid="recent-project-test-project-1"]'
-);
-await recentProject.click(); // ✅ Triggers proper view transition
-await waitForElement(page, "board-view");
-```
-
-### Issue: View output button test IDs are conditional
-
-**Problem:** Tests failed looking for `view-output-inprogress-${featureId}` when the actual button had `view-output-${featureId}`.
-**Fix:** The button test ID depends on whether the feature is actively running:
-
-- `view-output-${featureId}` - shown when feature is in `runningAutoTasks` (actively running)
-- `view-output-inprogress-${featureId}` - shown when status is "in_progress" but NOT actively running
-
-After dragging a feature to in_progress, wait for the `auto_mode_feature_start` event to fire before looking for the button:
-
-```typescript
-// Wait for feature to start running
-const viewOutputButton = page
-  .locator(
-    `[data-testid="view-output-${featureId}"], [data-testid="view-output-inprogress-${featureId}"]`
-  )
-  .first();
-await expect(viewOutputButton).toBeVisible({ timeout: 8000 });
-```
-
-### Issue: Elements not appearing due to async event timing
-
-**Problem:** Tests checked for UI elements before async events (like `auto_mode_feature_start`) had fired and updated the UI.
-**Fix:** Add appropriate timeouts when waiting for elements that depend on async events. The mock auto mode takes ~2.4 seconds to complete, so allow sufficient time:
-
-```typescript
-// Mock auto mode timing: ~2.4s + 1.5s delay = ~4s total
-await waitForAgentOutputModalHidden(page, { timeout: 10000 });
-```
-
-### Issue: Slider interaction testing
-
-**Problem:** Clicking on slider track didn't reliably set specific values.
-**Fix:** Use the slider's keyboard interaction or calculate the exact click position on the track. For max value, click on the rightmost edge of the track.
-
-### Issue: Port binding blocked in sandbox mode
-
-**Problem:** Playwright tests couldn't bind to port in sandbox mode.
-**Fix:** Tests don't need sandbox disabled - the issue was TEST_REUSE_SERVER environment variable. Make sure to start the dev server separately or let Playwright's webServer config handle it.
-
-## Code Architecture
-
-### Issue: Understanding store state persistence
-
-**Problem:** Not all store state is persisted to localStorage.
-**Fix:** Check the `partialize` function in `app-store.ts` to see which state is persisted:
-
-```typescript
-partialize: (state) => ({
-  projects: state.projects,
-  currentProject: state.currentProject,
-  theme: state.theme,
-  sidebarOpen: state.sidebarOpen,
-  apiKeys: state.apiKeys,
-  chatSessions: state.chatSessions,
-  chatHistoryOpen: state.chatHistoryOpen,
-  maxConcurrency: state.maxConcurrency, // Added for concurrency feature
-});
-```
-
-Note: `currentView` is NOT persisted - it's managed through actions.
-
-### Issue: Auto mode task lifecycle
-
-**Problem:** Confusion about when features are considered "running" vs "in_progress".
-**Fix:** Understand the task lifecycle:
-
-1. Feature dragged to "in_progress" column → status becomes "in_progress"
-2. `auto_mode_feature_start` event fires → feature added to `runningAutoTasks`
-3. Agent works on feature → periodic events sent
-4. `auto_mode_feature_complete` event fires → feature removed from `runningAutoTasks`
-5. If `passes: true` → status becomes "verified", if `passes: false` → stays "in_progress"
-
-### Issue: waiting_approval features not draggable when skipTests=true
-
-**Problem:** Features in `waiting_approval` status couldn't be dragged to `verified` column, even though the code appeared to handle it.
-**Fix:** The order of condition checks in `handleDragEnd` matters. The `skipTests` check was catching `waiting_approval` features before the `waiting_approval` status check could handle them. Move the `waiting_approval` status check **before** the `skipTests` check in `board-view.tsx`:
-
-```typescript
-// Correct order in handleDragEnd:
-if (draggedFeature.status === "backlog") {
-  // ...
-} else if (draggedFeature.status === "waiting_approval") {
-  // Handle waiting_approval BEFORE skipTests check
-  // because waiting_approval features often have skipTests=true
-} else if (draggedFeature.skipTests) {
-  // Handle other skipTests features
-}
-```
-
-## Best Practices Discovered
-
-### Testing utilities are critical
-
-Create comprehensive testing utilities in `tests/utils.ts` to avoid repeating selector logic:
-
-- `waitForElement` - waits for elements to appear
-- `waitForElementHidden` - waits for elements to disappear
-- `setupMockProject` - sets up mock localStorage state
-- `navigateToBoard` - handles navigation from welcome to board view
-
-### Always add data-testid attributes
-
-When implementing features, immediately add `data-testid` attributes to key UI elements. This makes tests more reliable and easier to write.
-
-### Test timeouts should be generous but not excessive
-
-- Default timeout: 30s (set in playwright.config.ts)
-- Element waits: 5-15s for critical elements
-- Auto mode completion: 10s (accounts for ~4s mock duration)
-- Don't increase timeouts past 10s for individual operations
-
-### Mock auto mode timing
-
-The mock auto mode in `electron.ts` has predictable timing:
-
-- Total duration: ~2.4 seconds (300+500+300+300+500+500ms)
-- Plus 1.5s delay before auto-closing modals
-- Total: ~4 seconds from start to completion
-
-### Issue: HotkeyButton conflicting with useKeyboardShortcuts
-
-**Problem:** Adding `HotkeyButton` with a simple key (like "N") to buttons that already had keyboard shortcuts registered via `useKeyboardShortcuts` caused the hotkey to stop working. Both registered duplicate listeners, and the HotkeyButton's `stopPropagation()` call could interfere.
-**Fix:** When a simple single-key hotkey is already handled by `useKeyboardShortcuts`, set `hotkeyActive={false}` on the `HotkeyButton` so it only displays the indicator badge without registering a duplicate listener:
-
-```tsx
-// In views that already use useKeyboardShortcuts for the "N" key:
-<HotkeyButton
-  onClick={() => setShowAddDialog(true)}
-  hotkey={shortcuts.addFeature}
-  hotkeyActive={false}  // <-- Important! Prevents duplicate listener
->
-  Add Feature
-</HotkeyButton>
-
-// HotkeyButton should only actively listen when it's the sole handler (e.g., Cmd+Enter in dialogs)
-<HotkeyButton
-  onClick={handleSubmit}
-  hotkey={{ key: "Enter", cmdCtrl: true }}
-  hotkeyActive={isDialogOpen}  // Active when dialog is open
->
-  Submit
-</HotkeyButton>
-```

.claude_settings.json

@@ -21,4 +21,4 @@
       "mcp__puppeteer__puppeteer_evaluate"
     ]
   }
-}
+}

.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

@@ -0,0 +1,355 @@
+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',
+  endpoint: process.env.R2_ENDPOINT,
+  credentials: {
+    accessKeyId: process.env.R2_ACCESS_KEY_ID,
+    secretAccessKey: process.env.R2_SECRET_ACCESS_KEY,
+  },
+});
+
+const BUCKET = process.env.R2_BUCKET_NAME;
+const PUBLIC_URL = process.env.R2_PUBLIC_URL;
+const VERSION = process.env.RELEASE_VERSION;
+const RELEASE_TAG = process.env.RELEASE_TAG || `v${VERSION}`;
+const GITHUB_REPO = process.env.GITHUB_REPOSITORY;
+
+async function fetchExistingReleases() {
+  try {
+    const response = await s3Client.send(
+      new GetObjectCommand({
+        Bucket: BUCKET,
+        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');
+      return { latestVersion: null, releases: [] };
+    }
+    throw error;
+  }
+}
+
+async function uploadFile(localPath, r2Key, contentType) {
+  const fileBuffer = fs.readFileSync(localPath);
+  const stats = fs.statSync(localPath);
+
+  await s3Client.send(
+    new PutObjectCommand({
+      Bucket: BUCKET,
+      Key: r2Key,
+      Body: fileBuffer,
+      ContentType: contentType,
+    })
+  );
+
+  console.log(`Uploaded: ${r2Key} (${stats.size} bytes)`);
+  return stats.size;
+}
+
+function findArtifacts(dir, pattern) {
+  if (!fs.existsSync(dir)) return [];
+  const files = fs.readdirSync(dir);
+  return files.filter((f) => pattern.test(f)).map((f) => path.join(dir, f));
+}
+
+async function checkUrlAccessible(url, maxRetries = 10, initialDelay = 1000) {
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      const result = await new Promise((resolve, reject) => {
+        const request = https.get(url, { timeout: 10000 }, (response) => {
+          const statusCode = response.statusCode;
+
+          // Follow redirects
+          if (
+            statusCode === 302 ||
+            statusCode === 301 ||
+            statusCode === 307 ||
+            statusCode === 308
+          ) {
+            const redirectUrl = response.headers.location;
+            response.destroy();
+            if (!redirectUrl) {
+              resolve({
+                accessible: false,
+                statusCode,
+                error: 'Redirect without location header',
+              });
+              return;
+            }
+            // Follow the redirect URL
+            return https
+              .get(redirectUrl, { timeout: 10000 }, (redirectResponse) => {
+                const redirectStatus = redirectResponse.statusCode;
+                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;
+                redirectResponse.destroy();
+                resolve({
+                  accessible: isGood,
+                  statusCode: redirectStatus,
+                  finalUrl: redirectUrl,
+                  contentType,
+                });
+              })
+              .on('error', (error) => {
+                resolve({
+                  accessible: false,
+                  statusCode,
+                  error: error.message,
+                });
+              })
+              .on('timeout', function () {
+                this.destroy();
+                resolve({
+                  accessible: false,
+                  statusCode,
+                  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 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');
+          const isGood = statusCode >= 200 && statusCode < 300 && isFile;
+          response.destroy();
+          resolve({ accessible: isGood, statusCode, contentType });
+        });
+
+        request.on('error', (error) => {
+          resolve({
+            accessible: false,
+            statusCode: null,
+            error: error.message,
+          });
+        });
+
+        request.on('timeout', () => {
+          request.destroy();
+          resolve({
+            accessible: false,
+            statusCode: null,
+            error: 'Request timeout',
+          });
+        });
+      });
+
+      if (result.accessible) {
+        if (attempt > 0) {
+          console.log(
+            `✓ URL ${url} is now accessible after ${attempt} retries (status: ${result.statusCode})`
+          );
+        } else {
+          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}`);
+      }
+    } catch (error) {
+      console.log(`✗ URL ${url} check failed: ${error.message}`);
+    }
+
+    if (attempt < maxRetries - 1) {
+      const delay = initialDelay * Math.pow(2, attempt);
+      console.log(`  Retrying in ${delay}ms... (attempt ${attempt + 1}/${maxRetries})`);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+
+  throw new Error(`URL ${url} is not accessible after ${maxRetries} attempts`);
+}
+
+async function downloadFromGitHub(url, outputPath) {
+  return new Promise((resolve, reject) => {
+    const request = https.get(url, { timeout: 30000 }, (response) => {
+      const statusCode = response.statusCode;
+
+      // Follow redirects (all redirect types)
+      if (statusCode === 301 || statusCode === 302 || statusCode === 307 || statusCode === 308) {
+        const redirectUrl = response.headers.location;
+        response.destroy();
+        if (!redirectUrl) {
+          reject(new Error(`Redirect without location header for ${url}`));
+          return;
+        }
+        // Resolve relative redirects
+        const finalRedirectUrl = redirectUrl.startsWith('http')
+          ? redirectUrl
+          : new URL(redirectUrl, url).href;
+        console.log(`  Following redirect: ${finalRedirectUrl}`);
+        return downloadFromGitHub(finalRedirectUrl, outputPath).then(resolve).catch(reject);
+      }
+
+      if (statusCode !== 200) {
+        response.destroy();
+        reject(new Error(`Failed to download ${url}: ${statusCode} ${response.statusMessage}`));
+        return;
+      }
+
+      const fileStream = fs.createWriteStream(outputPath);
+      response.pipe(fileStream);
+      fileStream.on('finish', () => {
+        fileStream.close();
+        resolve();
+      });
+      fileStream.on('error', (error) => {
+        response.destroy();
+        reject(error);
+      });
+    });
+
+    request.on('error', reject);
+    request.on('timeout', () => {
+      request.destroy();
+      reject(new Error(`Request timeout for ${url}`));
+    });
+  });
+}
+
+async function main() {
+  const artifactsDir = 'artifacts';
+  const tempDir = path.join(artifactsDir, 'temp');
+
+  // Create temp directory for downloaded GitHub archives
+  if (!fs.existsSync(tempDir)) {
+    fs.mkdirSync(tempDir, { recursive: true });
+  }
+
+  // Download source archives from GitHub
+  const githubZipUrl = `https://github.com/${GITHUB_REPO}/archive/refs/tags/${RELEASE_TAG}.zip`;
+  const githubTarGzUrl = `https://github.com/${GITHUB_REPO}/archive/refs/tags/${RELEASE_TAG}.tar.gz`;
+
+  const sourceZipPath = path.join(tempDir, `automaker-${VERSION}.zip`);
+  const sourceTarGzPath = path.join(tempDir, `automaker-${VERSION}.tar.gz`);
+
+  console.log(`Waiting for source archives to be available on GitHub...`);
+  console.log(`  ZIP: ${githubZipUrl}`);
+  console.log(`  TAR.GZ: ${githubTarGzUrl}`);
+
+  // Wait for archives to be accessible with exponential backoff
+  // This returns the final URL after following redirects
+  const finalZipUrl = await checkUrlAccessible(githubZipUrl);
+  const finalTarGzUrl = await checkUrlAccessible(githubTarGzUrl);
+
+  console.log(`Downloading source archives from GitHub...`);
+  await downloadFromGitHub(finalZipUrl, sourceZipPath);
+  await downloadFromGitHub(finalTarGzUrl, sourceTarGzPath);
+
+  console.log(`Downloaded source archives successfully`);
+
+  // 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$/),
+    sourceZip: [sourceZipPath],
+    sourceTarGz: [sourceTarGzPath],
+  };
+
+  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'}`
+    );
+  }
+
+  // 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',
+  };
+
+  for (const [platform, files] of Object.entries(artifacts)) {
+    if (files.length === 0) {
+      console.warn(`Warning: No artifact found for ${platform}`);
+      continue;
+    }
+
+    // Use the first matching file for each platform
+    const localPath = files[0];
+    const filename = path.basename(localPath);
+    const r2Key = `releases/${VERSION}/${filename}`;
+    const size = await uploadFile(localPath, r2Key, contentTypes[platform]);
+
+    assets[platform] = {
+      url: `${PUBLIC_URL}/releases/${VERSION}/${filename}`,
+      filename,
+      size,
+      arch:
+        platform === 'macosArm'
+          ? 'arm64'
+          : platform === 'sourceZip' || platform === 'sourceTarGz'
+            ? 'source'
+            : 'x64',
+    };
+  }
+
+  // Fetch and update releases.json
+  const releasesData = await fetchExistingReleases();
+
+  const newRelease = {
+    version: VERSION,
+    date: new Date().toISOString(),
+    assets,
+    githubReleaseUrl: `https://github.com/${GITHUB_REPO}/releases/tag/${RELEASE_TAG}`,
+  };
+
+  // Remove existing entry for this version if re-running
+  releasesData.releases = releasesData.releases.filter((r) => r.version !== VERSION);
+
+  // Prepend new release
+  releasesData.releases.unshift(newRelease);
+  releasesData.latestVersion = VERSION;
+
+  // Upload updated releases.json
+  await s3Client.send(
+    new PutObjectCommand({
+      Bucket: BUCKET,
+      Key: 'releases.json',
+      Body: JSON.stringify(releasesData, null, 2),
+      ContentType: 'application/json',
+      CacheControl: 'public, max-age=60',
+    })
+  );
+
+  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);
+  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

@@ -0,0 +1,77 @@
+name: E2E Tests
+
+on:
+  pull_request:
+    branches:
+      - '*'
+  push:
+    branches:
+      - main
+      - master
+
+jobs:
+  e2e:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup project
+        uses: ./.github/actions/setup-project
+        with:
+          check-lockfile: 'true'
+          rebuild-node-pty-path: 'apps/server'
+
+      - name: Install Playwright browsers
+        run: npx playwright install --with-deps chromium
+        working-directory: apps/ui
+
+      - name: Build server
+        run: npm run build --workspace=apps/server
+
+      - name: Start backend server
+        run: npm run start --workspace=apps/server &
+        env:
+          PORT: 3008
+          NODE_ENV: test
+
+      - name: Wait for backend server
+        run: |
+          echo "Waiting for backend server to be ready..."
+          for i in {1..30}; do
+            if curl -s http://localhost:3008/api/health > /dev/null 2>&1; then
+              echo "Backend server is ready!"
+              exit 0
+            fi
+            echo "Waiting... ($i/30)"
+            sleep 1
+          done
+          echo "Backend server failed to start!"
+          exit 1
+
+      - name: Run E2E tests
+        # 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
+          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/ui/playwright-report/
+          retention-days: 7
+
+      - name: Upload test results
+        uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: 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

@@ -0,0 +1,26 @@
+name: PR Build Check
+
+on:
+  pull_request:
+    branches:
+      - '*'
+  push:
+    branches:
+      - main
+      - master
+
+jobs:
+  build:
+    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 build:electron (dir only - faster CI)
+        run: npm run build:electron:dir

.github/workflows/release.yml

@@ -1,82 +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
-          - os: windows-latest
-            name: Windows
-          - os: ubuntu-latest
-            name: Linux
-
+        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
+      - name: Extract version from tag
+        id: version
+        shell: bash
+        run: |
+          # 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: Update package.json version
+        shell: bash
+        run: |
+          node apps/ui/scripts/update-version.mjs "${{ steps.version.outputs.version }}"
+
+      - name: Setup project
+        uses: ./.github/actions/setup-project
         with:
-          node-version: '20'
-          cache: 'npm'
-          cache-dependency-path: app/package-lock.json
+          check-lockfile: 'true'
 
-      - name: Install dependencies
-        working-directory: ./app
-        run: npm ci
-
-      - name: Build Electron App (macOS)
+      - name: Build Electron app (macOS)
         if: matrix.os == 'macos-latest'
-        working-directory: ./app
+        shell: bash
+        run: npm run build:electron:mac --workspace=apps/ui
         env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: npm run build:electron -- --mac --x64 --arm64
+          CSC_IDENTITY_AUTO_DISCOVERY: false
 
-      - name: Build Electron App (Windows)
+      - name: Build Electron app (Windows)
         if: matrix.os == 'windows-latest'
-        working-directory: ./app
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: npm run build:electron -- --win --x64
+        shell: bash
+        run: npm run build:electron:win --workspace=apps/ui
 
-      - name: Build Electron App (Linux)
+      - name: Build Electron app (Linux)
         if: matrix.os == 'ubuntu-latest'
-        working-directory: ./app
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: npm run build:electron -- --linux --x64
+        shell: bash
+        run: npm run build:electron:linux --workspace=apps/ui
 
-      - name: Upload Release Assets
-        uses: softprops/action-gh-release@v1
+      - name: Upload macOS artifacts
+        if: matrix.os == 'macos-latest'
+        uses: actions/upload-artifact@v4
+        with:
+          name: macos-builds
+          path: apps/ui/release/*.{dmg,zip}
+          retention-days: 30
+
+      - name: Upload Windows artifacts
+        if: matrix.os == 'windows-latest'
+        uses: actions/upload-artifact@v4
+        with:
+          name: windows-builds
+          path: apps/ui/release/*.exe
+          retention-days: 30
+
+      - name: Upload Linux artifacts
+        if: matrix.os == 'ubuntu-latest'
+        uses: actions/upload-artifact@v4
+        with:
+          name: linux-builds
+          path: apps/ui/release/*.{AppImage,deb}
+          retention-days: 30
+
+  upload:
+    needs: build
+    runs-on: ubuntu-latest
+    if: github.event.release.draft == false
+
+    steps:
+      - name: Download macOS artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: macos-builds
+          path: artifacts/macos-builds
+
+      - name: Download Windows artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: windows-builds
+          path: artifacts/windows-builds
+
+      - name: Download Linux artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: linux-builds
+          path: artifacts/linux-builds
+
+      - name: Upload to GitHub Release
+        uses: softprops/action-gh-release@v2
         with:
-          tag_name: ${{ github.event.inputs.version || github.ref_name }}
           files: |
-            app/dist/*.exe
-            app/dist/*.dmg
-            app/dist/*.AppImage
-            app/dist/*.zip
-            app/dist/*.deb
-            app/dist/*.rpm
-          draft: false
-          prerelease: false
+            artifacts/macos-builds/*
+            artifacts/windows-builds/*
+            artifacts/linux-builds/*
         env:
           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

@@ -0,0 +1,44 @@
+name: Test Suite
+
+on:
+  pull_request:
+    branches:
+      - '*'
+  push:
+    branches:
+      - main
+      - master
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup project
+        uses: ./.github/actions/setup-project
+        with:
+          check-lockfile: 'true'
+          rebuild-node-pty-path: 'apps/server'
+
+      - 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
+        env:
+          NODE_ENV: test
+
+      # - name: Upload coverage reports
+      #   uses: codecov/codecov-action@v4
+      #   if: always()
+      #   with:
+      #     files: ./apps/server/coverage/coverage-final.json
+      #     flags: server
+      #     name: server-coverage
+      #   env:
+      #     CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.gitignore

@@ -1,2 +1,82 @@
-#added by trueheads > will remove once supercombo adds multi-os support
+#added by trueheads > will remove once supercombo adds multi-os support
 launch.sh
+
+# Dependencies
+node_modules/
+
+# Build outputs
+dist/
+build/
+out/
+.next/
+.turbo/
+
+# Automaker
+.automaker/images/
+.automaker/
+/.automaker/*
+/.automaker/
+
+.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

.husky/pre-commit

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

.npmrc

@@ -0,0 +1,16 @@
+# Cross-platform compatibility for Tailwind CSS v4 and lightningcss
+# These packages use platform-specific optional dependencies that npm
+# automatically resolves based on your OS (macOS, Linux, Windows, WSL)
+#
+# IMPORTANT: When switching platforms or getting platform mismatch errors:
+# 1. Delete node_modules: rm -rf node_modules apps/*/node_modules
+# 2. Run: npm install
+#
+# In CI/CD: Use "npm install" instead of "npm ci" to allow npm to resolve
+# the correct platform-specific binaries at install time.
+
+# Include bindings for all platforms in package-lock.json to support CI/CD
+# This ensures Linux, macOS, and Windows bindings are all present
+# NOTE: Only enable when regenerating package-lock.json, then comment out to keep installs fast
+# supportedArchitectures.os=linux,darwin,win32
+# supportedArchitectures.cpu=x64,arm64

.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"
+}

DISCLAIMER.md

@@ -19,30 +19,57 @@ While we have made efforts to review this codebase for security vulnerabilities
 ## Recommendations
 
 ### 1. Review the Code First
+
 Before running Automaker, we strongly recommend reviewing the source code yourself to understand what operations it performs and ensure you are comfortable with its behavior.
 
 ### 2. Use Sandboxing (Highly Recommended)
+
 **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. Instead, consider:
 
 - **Docker**: Run Automaker in a Docker container to isolate it from your host system
 - **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:
+
 - Create a dedicated user account with limited permissions
 - Only grant access to specific project directories
 - Avoid running with administrator/root privileges
 - Keep sensitive files and credentials outside of project directories
 
 ### 4. Monitor Activity
+
 - Review the agent's actions in the output logs
 - Pay attention to file modifications and command executions
 - Stop the agent immediately if you notice unexpected behavior
 
-## No Warranty
+## No Warranty & Limitation of Liability
 
-This software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the software or the use or other dealings in the software.
+THE SOFTWARE UTILIZES ARTIFICIAL INTELLIGENCE TO GENERATE CODE, EXECUTE COMMANDS, AND INTERACT WITH YOUR FILE SYSTEM. YOU ACKNOWLEDGE THAT AI SYSTEMS CAN BE UNPREDICTABLE, MAY GENERATE INCORRECT, INSECURE, OR DESTRUCTIVE CODE, AND MAY TAKE ACTIONS THAT COULD DAMAGE YOUR SYSTEM, FILES, OR HARDWARE.
+
+This software is provided "as is", without warranty of any kind, express or implied. In no event shall the authors or copyright holders be liable for any claim, damages, or other liability, including but not limited to hardware damage, data loss, financial loss, or business interruption, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the software or the use or other dealings in the software.
 
 ## Acknowledgment
 

LICENSE

@@ -1,21 +1,141 @@
-MIT License
+AUTOMAKER LICENSE AGREEMENT
 
-Copyright (c) 2025 Cody Seibert
+This License Agreement ("Agreement") is entered into between you ("Licensee") and the copyright holders of Automaker ("Licensor"). By using, copying, modifying, downloading, cloning, or distributing the Software (as defined below), you agree to be bound by the terms of this Agreement.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+1. DEFINITIONS
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+"Software" means the Automaker software, including all source code, object code, documentation, and related materials.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+"Generated Files" means files created by the Software during normal operation to store internal state, configuration, or working data, including but not limited to app_spec.txt, feature.json, and similar files generated by the Software. Generated Files are not considered part of the Software for the purposes of this license and are not subject to the restrictions herein.
+
+"Derivative Work" means any work that is based on, derived from, or incorporates the Software or any substantial portion of it, including but not limited to modifications, forks, adaptations, translations, or any altered version of the Software.
+
+"Monetization" means any activity that generates revenue, income, or commercial benefit from the Software itself or any Derivative Work, including but not limited to:
+
+- Reselling, redistributing, or sublicensing the Software, any Derivative Work, or any substantial portion thereof
+- Including the Software, any Derivative Work, or substantial portions thereof in a product or service that you sell or distribute
+- Offering the Software, any Derivative Work, or substantial portions thereof as a standalone product or service for sale
+- Hosting the Software or any Derivative Work as a service (whether free or paid) for use by others, including cloud hosting, Software-as-a-Service (SaaS), or any other form of hosted access for third parties
+- Extracting, reselling, redistributing, or sublicensing any prompts, context, or other instructional content bundled within the Software
+- Creating, distributing, or selling modified versions, forks, or Derivative Works of the Software
+
+Monetization does NOT include:
+
+- Using the Software internally within your organization, regardless of whether your organization is for-profit
+- Using the Software to build products or services that generate revenue, as long as you are not reselling or redistributing the Software itself
+- Using the Software to provide services for which fees are charged, as long as the Software itself is not being resold or redistributed
+- Hosting the Software anywhere for personal use by a single developer, as long as the Software is not made accessible to others
+
+"Core Contributors" means the following individuals who are granted perpetual, royalty-free licenses:
+
+- Cody Seibert (webdevcody)
+- SuperComboGamer (SCG)
+- Kacper Lachowicz (Shironex, Shirone)
+- Ben Scott (trueheads)
+
+2. GRANT OF LICENSE
+
+Subject to the terms and conditions of this Agreement, Licensor hereby grants to Licensee a non-exclusive, non-transferable license to use, copy, modify, and distribute the Software, provided that:
+
+a) Licensee may freely clone, install, and use the Software locally or within an organization for the purpose of building, developing, and maintaining other products, software, or services. There are no restrictions on the products you build _using_ the Software.
+
+b) Licensee may run the Software on personal or organizational infrastructure for internal use.
+
+c) Core Contributors are each individually granted a perpetual, worldwide, royalty-free, non-exclusive license to use, copy, modify, distribute, and sublicense the Software for any purpose, including Monetization, without payment of any fees or royalties. Each Core Contributor may exercise these rights independently and does not require permission, consent, or approval from any other Core Contributor to Monetize the Software in any way they see fit.
+
+d) Commercial licenses for the Software may be discussed and issued to external parties or companies seeking to use the Software for financial gain or Monetization purposes. Core Contributors already have full rights under section 2(c) and do not require commercial licenses. Any commercial license issued to external parties shall require a unanimous vote by all Core Contributors and shall be granted in writing and signed by all Core Contributors.
+
+e) The list of individuals defined as "Core Contributors" in Section 1 shall be amended to reflect any revocation or reinstatement of status made under this section.
+
+3. RESTRICTIONS
+
+Licensee may NOT:
+
+- Engage in any Monetization of the Software or any Derivative Work without explicit written permission from all Core Contributors
+- Resell, redistribute, or sublicense the Software, any Derivative Work, or any substantial portion thereof
+- Create, distribute, or sell modified versions, forks, or Derivative Works of the Software for any commercial purpose
+- Include the Software, any Derivative Work, or substantial portions thereof in a product or service that you sell or distribute
+- Offer the Software, any Derivative Work, or substantial portions thereof as a standalone product or service for sale
+- Extract, resell, redistribute, or sublicense any prompts, context, or other instructional content bundled within the Software
+- Host the Software or any Derivative Work as a service (whether free or paid) for use by others (except Core Contributors)
+- Remove or alter any copyright notices or license terms
+- Use the Software in any manner that violates applicable laws or regulations
+
+Licensee MAY:
+
+- Use the Software internally within their organization (commercial or non-profit)
+- Use the Software to build other commercial products (products that do NOT contain the Software or Derivative Works)
+- Modify the Software for internal use within their organization (commercial or non-profit)
+
+4. CORE CONTRIBUTOR STATUS MANAGEMENT
+
+a) Core Contributor status may be revoked indefinitely by the remaining Core Contributors if:
+
+- A Core Contributor cannot be reached for a period of one (1) month through reasonable means of communication (including but not limited to email, Discord, GitHub, or other project communication channels)
+- AND the Core Contributor has not contributed to the project during that one-month period. For purposes of this section, "contributed" means at least one of the following activities:
+  - Discussing the Software through project communication channels
+  - Committing code changes to the project repository
+  - Submitting bug fixes or patches
+  - Participating in project-related discussions or decision-making
+
+b) Revocation of Core Contributor status requires a unanimous vote by all other Core Contributors (excluding the Core Contributor whose status is being considered for revocation).
+
+c) Upon revocation of Core Contributor status, the individual shall no longer be considered a Core Contributor and shall lose the rights granted under section 2(c) of this Agreement. However, any Contributions made prior to revocation shall remain subject to the terms of section 5 (CONTRIBUTIONS AND RIGHTS ASSIGNMENT).
+
+d) A revoked Core Contributor may be reinstated to Core Contributor status with a unanimous vote by all current Core Contributors. Upon reinstatement, the individual shall regain all rights granted under section 2(c) of this Agreement.
+
+5. CONTRIBUTIONS AND RIGHTS ASSIGNMENT
+
+By submitting, pushing, or contributing any code, documentation, pull requests, issues, or other materials ("Contributions") to the Automaker project, you agree to the following terms without reservation:
+
+a) **Full Ownership Transfer & Rights Grant:** You hereby assign to the Core Contributors all right, title, and interest in and to your Contributions, including all copyrights, patents, and other intellectual property rights. If such assignment is not effective under applicable law, you grant the Core Contributors an unrestricted, perpetual, worldwide, non-exclusive, royalty-free, fully paid-up, irrevocable, sublicensable, and transferable license to use, reproduce, modify, adapt, publish, translate, create derivative works from, distribute, perform, display, and otherwise exploit your Contributions in any manner they see fit, including for any commercial purpose or Monetization.
+
+b) **No Take-Backs:** You understand and agree that this grant of rights is irrevocable ("no take-backs"). You cannot revoke, rescind, or terminate this grant of rights once your Contribution has been submitted.
+
+c) **Waiver of Moral Rights:** You waive any "moral rights" or other rights with respect to attribution of authorship or integrity of materials regarding your Contributions that you may have under any applicable law.
+
+d) **Right to Contribute:** You represent and warrant that you are the original author of the Contributions, or that you have sufficient rights to grant the rights conveyed by this section, and that your Contributions do not infringe upon the rights of any third party.
+
+6. TERMINATION
+
+This license will terminate automatically if Licensee breaches any term of this Agreement. Upon termination, Licensee must immediately cease all use of the Software and destroy all copies in their possession.
+
+7. HIGH RISK DISCLAIMER AND LIMITATION OF LIABILITY
+
+a) **AI RISKS:** THE SOFTWARE UTILIZES ARTIFICIAL INTELLIGENCE TO GENERATE CODE, EXECUTE COMMANDS, AND INTERACT WITH YOUR FILE SYSTEM. YOU ACKNOWLEDGE THAT AI SYSTEMS CAN BE UNPREDICTABLE, MAY GENERATE INCORRECT, INSECURE, OR DESTRUCTIVE CODE, AND MAY TAKE ACTIONS THAT COULD DAMAGE YOUR SYSTEM, FILES, OR HARDWARE.
+
+b) **USE AT YOUR OWN RISK:** YOU AGREE THAT YOUR USE OF THE SOFTWARE IS SOLELY AT YOUR OWN RISK. THE CORE CONTRIBUTORS AND LICENSOR DO NOT GUARANTEE THAT THE SOFTWARE OR ANY CODE GENERATED BY IT WILL BE SAFE, BUG-FREE, OR FUNCTIONAL.
+
+c) **NO WARRANTY:** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT.
+
+d) **LIMITATION OF LIABILITY:** IN NO EVENT SHALL THE CORE CONTRIBUTORS, LICENSORS, OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE, INCLUDING BUT NOT LIMITED TO:
+
+- DAMAGE TO HARDWARE OR COMPUTER SYSTEMS
+- DATA LOSS OR CORRUPTION
+- GENERATION OF BAD, VULNERABLE, OR MALICIOUS CODE
+- FINANCIAL LOSSES
+- BUSINESS INTERRUPTION
+
+8. LICENSE AMENDMENTS
+
+Any amendment, modification, or update to this License Agreement must be agreed upon unanimously by all Core Contributors. No changes to this Agreement shall be effective unless all Core Contributors have provided their written consent or approval through a unanimous vote.
+
+9. CONTACT
+
+For inquiries regarding this license or permissions for Monetization, please contact the Core Contributors through the official project channels:
+
+- Agentic Jumpstart Discord: https://discord.gg/JUDWZDN3VT
+- Website: https://automaker.app
+- Email: automakerapp@gmail.com
+
+Any permission for Monetization requires the unanimous written consent of all Core Contributors.
+
+10. GOVERNING LAW
+
+This Agreement shall be governed by and construed in accordance with the laws of the State of Tennessee, USA, without regard to conflict of law principles.
+
+By using the Software, you acknowledge that you have read this Agreement, understand it, and agree to be bound by its terms and conditions.
+
+---
+
+Copyright (c) 2025 Automaker Core Contributors

README.md

@@ -1,6 +1,71 @@
+<p align="center">
+  <img src="apps/ui/public/readme_logo.png" alt="Automaker Logo" height="80" />
+</p>
+
+> **[!TIP]**
+>
+> **Learn more about Agentic Coding!**
+>
+> 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-gh).
+
 # Automaker
 
-Automaker is an autonomous AI development studio that helps you build software faster using AI-powered agents. It provides a visual Kanban board interface to manage features, automatically assigns AI agents to implement them, and tracks progress through an intuitive workflow from backlog to verified completion.
+**Stop typing code. Start directing AI agents.**
+
+<details open>
+<summary><h2>Table of Contents</h2></summary>
+
+- [What Makes Automaker Different?](#what-makes-automaker-different)
+  - [The Workflow](#the-workflow)
+  - [Powered by Claude Code](#powered-by-claude-code)
+  - [Why This Matters](#why-this-matters)
+- [Security Disclaimer](#security-disclaimer)
+- [Community & Support](#community--support)
+- [Getting Started](#getting-started)
+  - [Prerequisites](#prerequisites)
+  - [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)
+- [Features](#features)
+- [Tech Stack](#tech-stack)
+- [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 UI](https://i.imgur.com/jdwKydM.png)
+
+## What Makes Automaker Different?
+
+Traditional development tools help you write code. Automaker helps you **orchestrate AI agents** to build entire features autonomously. Think of it as having a team of AI developers working for you—you define what needs to be built, and Automaker handles the implementation.
+
+### The Workflow
+
+1. **Add Features** - Describe features you want built (with text, images, or screenshots)
+2. **Move to "In Progress"** - Automaker automatically assigns an AI agent to implement the feature
+3. **Watch It Build** - See real-time progress as the agent writes code, runs tests, and makes changes
+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
+
+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.
+
+### 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.
 
 ---
 
@@ -14,60 +79,141 @@ Automaker is an autonomous AI development studio that helps you build software f
 >
 > **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)**
+> **[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
 
 ---
 
 ## Getting Started
 
-**Step 1:** Clone this repository:
+### Prerequisites
+
+- Node.js 18+
+- npm
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) installed and authenticated
+
+### Quick Start
 
 ```bash
-git clone git@github.com:AutoMaker-Org/automaker.git
+# 1. Clone the repo
+git clone https://github.com/AutoMaker-Org/automaker.git
 cd automaker
-```
 
-**Step 2:** Install dependencies:
-
-```bash
+# 2. Install dependencies
 npm install
+
+# 3. Build local shared packages
+npm run build:packages
+
+# 4. Run Automaker (pick your mode)
+npm run dev
+# Then choose your run mode when prompted, or use specific commands below
 ```
 
-**Step 3:** Run the Claude Code setup token command:
+## How to Run
+
+### Development Mode
+
+Start Automaker in development mode:
 
 ```bash
-claude setup-token
+npm run dev
 ```
 
-> **⚠️ Warning:** This command will print your token to your terminal. Be careful if you're streaming or sharing your screen, as the token will be visible to anyone watching.
+This will prompt you to choose your run mode, or you can specify a mode directly:
 
-**Step 4:** Export the Claude Code OAuth token in your shell:
-
-```bash
-export CLAUDE_CODE_OAUTH_TOKEN="your-token-here"
-```
-
-**Step 5:** Start the development server:
+#### Electron Desktop App (Recommended)
 
 ```bash
+# Standard development mode
 npm run dev:electron
+
+# With DevTools open automatically
+npm run dev:electron:debug
+
+# For WSL (Windows Subsystem for Linux)
+npm run dev:electron:wsl
+
+# For WSL with GPU acceleration
+npm run dev:electron:wsl:gpu
 ```
 
-This will start both the Next.js development server and the Electron application.
-
-**Step 6:** MOST IMPORANT: Run the Following after all is setup
+#### Web Browser Mode
 
 ```bash
-echo "W"
-echo "W"
-echo "W"
-echo "W"
-echo "W"
-echo "W"
-echo "W"
-echo "W"
+# Run in web browser (http://localhost:3007)
+npm run dev:web
 ```
 
+### Building for Production
+
+```bash
+# Build Next.js app
+npm run build
+
+# Build Electron app for distribution
+npm run build:electron
+```
+
+### Running Production Build
+
+```bash
+# Start production Next.js server
+npm run start
+```
+
+### Testing
+
+```bash
+# Run tests headless
+npm run test
+
+# Run tests with browser visible
+npm run test:headed
+```
+
+### Linting
+
+```bash
+# Run ESLint
+npm run lint
+```
+
+### Authentication Options
+
+Automaker supports multiple authentication methods (in order of priority):
+
+| Method           | Environment Variable | Description                     |
+| ---------------- | -------------------- | ------------------------------- |
+| API Key (env)    | `ANTHROPIC_API_KEY`  | Anthropic API key               |
+| API Key (stored) | —                    | Anthropic API key stored in app |
+
+### Persistent Setup (Optional)
+
+Add to your `~/.bashrc` or `~/.zshrc`:
+
+```bash
+export ANTHROPIC_API_KEY="YOUR_API_KEY_HERE"
+```
+
+Then restart your terminal or run `source ~/.bashrc`.
+
 ## Features
 
 - 📋 **Kanban Board** - Visual drag-and-drop board to manage features through backlog, in progress, waiting approval, and verified stages
@@ -105,4 +251,24 @@ To learn more about Next.js, take a look at the following resources:
 
 ## License
 
-See [LICENSE](../LICENSE) for details.
+This project is licensed under the **Automaker License Agreement**. See [LICENSE](LICENSE) for the full text.
+
+**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:**
+  - By contributing to this repository, you grant the Core Contributors full, irrevocable rights to your code (copyright assignment).
+
+**Core Contributors** (Cody Seibert (webdevcody), SuperComboGamer (SCG), Kacper Lachowicz (Shironex, Shirone), and Ben Scott (trueheads)) are granted perpetual, royalty-free licenses for any use, including monetization.

app/README.md

@@ -1,108 +0,0 @@
-# Automaker
-
-Automaker is an autonomous AI development studio that helps you build software faster using AI-powered agents. It provides a visual Kanban board interface to manage features, automatically assigns AI agents to implement them, and tracks progress through an intuitive workflow from backlog to verified completion.
-
----
-
-> **[!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)**
-
----
-
-## Getting Started
-
-**Step 1:** Clone this repository:
-
-```bash
-git clone git@github.com:AutoMaker-Org/automaker.git
-cd automaker
-```
-
-**Step 2:** Install dependencies:
-
-```bash
-npm install
-```
-
-**Step 3:** Run the Claude Code setup token command:
-
-```bash
-claude setup-token
-```
-
-> **⚠️ Warning:** This command will print your token to your terminal. Be careful if you're streaming or sharing your screen, as the token will be visible to anyone watching.
-
-**Step 4:** Export the Claude Code OAuth token in your shell:
-
-```bash
-export CLAUDE_CODE_OAUTH_TOKEN="your-token-here"
-```
-
-**Step 5:** Start the development server:
-
-```bash
-npm run dev:electron
-```
-
-This will start both the Next.js development server and the Electron application.
-
-**Step 6:** MOST IMPORANT: Run the Following after all is setup
-
-```bash
-echo "W"
-echo "W"
-echo "W"
-echo "W"
-echo "W"
-echo "W"
-echo "W"
-echo "W"
-```
-
-## Features
-
-- 📋 **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
-
-## 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
-
-## Learn More
-
-To learn more about Next.js, take a look at the following resources:
-
-- [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.
-
-## License
-
-See [LICENSE](../LICENSE) for details.

app/electron/.eslintrc.js

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

app/electron/agent-service.js

@@ -1,695 +0,0 @@
-const { query, AbortError } = require("@anthropic-ai/claude-agent-sdk");
-const path = require("path");
-const fs = require("fs/promises");
-
-/**
- * Agent Service - Runs Claude agents in the Electron main process
- * This service survives Next.js restarts and maintains conversation state
- */
-class AgentService {
-  constructor() {
-    this.sessions = new Map(); // sessionId -> { messages, isRunning, abortController }
-    this.stateDir = null; // Will be set when app is ready
-  }
-
-  /**
-   * Initialize the service with app data directory
-   */
-  async initialize(appDataPath) {
-    this.stateDir = path.join(appDataPath, "agent-sessions");
-    this.metadataFile = path.join(appDataPath, "sessions-metadata.json");
-    await fs.mkdir(this.stateDir, { recursive: true });
-    console.log("[AgentService] Initialized with state dir:", this.stateDir);
-  }
-
-  /**
-   * Start or resume a conversation
-   */
-  async startConversation({ sessionId, workingDirectory }) {
-    console.log("[AgentService] Starting conversation:", sessionId);
-
-    // Initialize session if it doesn't exist
-    if (!this.sessions.has(sessionId)) {
-      const messages = await this.loadSession(sessionId);
-
-      this.sessions.set(sessionId, {
-        messages,
-        isRunning: false,
-        abortController: null,
-        workingDirectory: workingDirectory || process.cwd(),
-      });
-    }
-
-    const session = this.sessions.get(sessionId);
-    return {
-      success: true,
-      messages: session.messages,
-      sessionId,
-    };
-  }
-
-  /**
-   * Send a message to the agent and stream responses
-   */
-  async sendMessage({
-    sessionId,
-    message,
-    workingDirectory,
-    imagePaths,
-    sendToRenderer,
-  }) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new Error(`Session ${sessionId} not found`);
-    }
-
-    if (session.isRunning) {
-      throw new Error("Agent is already processing a message");
-    }
-
-    // Read images from temp files and convert to base64 for storage
-    const images = [];
-    if (imagePaths && imagePaths.length > 0) {
-      const fs = require("fs/promises");
-      const path = require("path");
-
-      for (const imagePath of imagePaths) {
-        try {
-          const imageBuffer = await fs.readFile(imagePath);
-          const base64Data = imageBuffer.toString("base64");
-
-          // Determine media type from file extension
-          const ext = path.extname(imagePath).toLowerCase();
-          const mimeTypeMap = {
-            ".jpg": "image/jpeg",
-            ".jpeg": "image/jpeg",
-            ".png": "image/png",
-            ".gif": "image/gif",
-            ".webp": "image/webp",
-          };
-          const mediaType = mimeTypeMap[ext] || "image/png";
-
-          images.push({
-            data: base64Data,
-            mimeType: mediaType,
-            filename: path.basename(imagePath),
-          });
-
-          console.log(
-            `[AgentService] Loaded image from ${imagePath} for storage`
-          );
-        } catch (error) {
-          console.error(
-            `[AgentService] Failed to load image from ${imagePath}:`,
-            error
-          );
-        }
-      }
-    }
-
-    // Add user message to conversation with base64 images
-    const userMessage = {
-      id: this.generateId(),
-      role: "user",
-      content: message,
-      images: images.length > 0 ? images : undefined,
-      timestamp: new Date().toISOString(),
-    };
-
-    session.messages.push(userMessage);
-    session.isRunning = true;
-    session.abortController = new AbortController();
-
-    // Send initial user message to renderer
-    sendToRenderer({
-      type: "message",
-      message: userMessage,
-    });
-
-    // Save state with base64 images
-    await this.saveSession(sessionId, session.messages);
-
-    try {
-      // Configure Claude Agent SDK options
-      const options = {
-        // model: "claude-sonnet-4-20250514",
-        model: "claude-opus-4-5-20251101",
-        systemPrompt: this.getSystemPrompt(),
-        maxTurns: 20,
-        cwd: workingDirectory || session.workingDirectory,
-        allowedTools: [
-          "Read",
-          "Write",
-          "Edit",
-          "Glob",
-          "Grep",
-          "Bash",
-          "WebSearch",
-          "WebFetch",
-        ],
-        permissionMode: "acceptEdits",
-        sandbox: {
-          enabled: true,
-          autoAllowBashIfSandboxed: true,
-        },
-        abortController: session.abortController,
-      };
-
-      // Build prompt content with text and images
-      let promptContent = message;
-
-      // If there are images, create a content array
-      if (imagePaths && imagePaths.length > 0) {
-        const contentBlocks = [];
-
-        // Add text block
-        if (message && message.trim()) {
-          contentBlocks.push({
-            type: "text",
-            text: message,
-          });
-        }
-
-        // Add image blocks
-        const fs = require("fs");
-        for (const imagePath of imagePaths) {
-          try {
-            const imageBuffer = fs.readFileSync(imagePath);
-            const base64Data = imageBuffer.toString("base64");
-            const ext = path.extname(imagePath).toLowerCase();
-            const mimeTypeMap = {
-              ".jpg": "image/jpeg",
-              ".jpeg": "image/jpeg",
-              ".png": "image/png",
-              ".gif": "image/gif",
-              ".webp": "image/webp",
-            };
-            const mediaType = mimeTypeMap[ext] || "image/png";
-
-            contentBlocks.push({
-              type: "image",
-              source: {
-                type: "base64",
-                media_type: mediaType,
-                data: base64Data,
-              },
-            });
-          } catch (error) {
-            console.error(
-              `[AgentService] Failed to load image ${imagePath}:`,
-              error
-            );
-          }
-        }
-
-        // Use content blocks if we have images
-        if (
-          contentBlocks.length > 1 ||
-          (contentBlocks.length === 1 && contentBlocks[0].type === "image")
-        ) {
-          promptContent = contentBlocks;
-        }
-      }
-
-      // Build payload for the SDK
-      const promptPayload = Array.isArray(promptContent)
-        ? (async function* () {
-            yield {
-              type: "user",
-              session_id: "",
-              message: {
-                role: "user",
-                content: promptContent,
-              },
-              parent_tool_use_id: null,
-            };
-          })()
-        : promptContent;
-
-      // Send the query via the SDK (conversation state handled by the SDK)
-      const stream = query({ prompt: promptPayload, options });
-
-      let currentAssistantMessage = null;
-      let responseText = "";
-      const toolUses = [];
-
-      // Stream responses from the SDK
-      for await (const msg of stream) {
-        if (msg.type === "assistant") {
-          if (msg.message.content) {
-            for (const block of msg.message.content) {
-              if (block.type === "text") {
-                responseText += block.text;
-
-                // Create or update assistant message
-                if (!currentAssistantMessage) {
-                  currentAssistantMessage = {
-                    id: this.generateId(),
-                    role: "assistant",
-                    content: responseText,
-                    timestamp: new Date().toISOString(),
-                  };
-                  session.messages.push(currentAssistantMessage);
-                } else {
-                  currentAssistantMessage.content = responseText;
-                }
-
-                // Stream to renderer
-                sendToRenderer({
-                  type: "stream",
-                  messageId: currentAssistantMessage.id,
-                  content: responseText,
-                  isComplete: false,
-                });
-              } else if (block.type === "tool_use") {
-                const toolUse = {
-                  name: block.name,
-                  input: block.input,
-                };
-                toolUses.push(toolUse);
-
-                // Send tool use notification
-                sendToRenderer({
-                  type: "tool_use",
-                  tool: toolUse,
-                });
-              }
-            }
-          }
-        } else if (msg.type === "result") {
-          if (msg.subtype === "success" && msg.result) {
-            // Use the final result
-            if (currentAssistantMessage) {
-              currentAssistantMessage.content = msg.result;
-              responseText = msg.result;
-            }
-          }
-
-          // Send completion
-          sendToRenderer({
-            type: "complete",
-            messageId: currentAssistantMessage?.id,
-            content: responseText,
-            toolUses,
-          });
-        }
-      }
-
-      // Save final state
-      await this.saveSession(sessionId, session.messages);
-
-      session.isRunning = false;
-      session.abortController = null;
-
-      return {
-        success: true,
-        message: currentAssistantMessage,
-      };
-    } catch (error) {
-      if (error instanceof AbortError || error?.name === "AbortError") {
-        console.log("[AgentService] Query aborted");
-        session.isRunning = false;
-        session.abortController = null;
-        return { success: false, aborted: true };
-      }
-
-      console.error("[AgentService] Error:", error);
-
-      session.isRunning = false;
-      session.abortController = null;
-
-      // Add error message
-      const errorMessage = {
-        id: this.generateId(),
-        role: "assistant",
-        content: `Error: ${error.message}`,
-        timestamp: new Date().toISOString(),
-        isError: true,
-      };
-
-      session.messages.push(errorMessage);
-      await this.saveSession(sessionId, session.messages);
-
-      sendToRenderer({
-        type: "error",
-        error: error.message,
-        message: errorMessage,
-      });
-
-      throw error;
-    }
-  }
-
-  /**
-   * Get conversation history
-   */
-  getHistory(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      return { success: false, error: "Session not found" };
-    }
-
-    return {
-      success: true,
-      messages: session.messages,
-      isRunning: session.isRunning,
-    };
-  }
-
-  /**
-   * Stop current agent execution
-   */
-  async stopExecution(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      return { success: false, error: "Session not found" };
-    }
-
-    if (session.abortController) {
-      session.abortController.abort();
-      session.isRunning = false;
-      session.abortController = null;
-    }
-
-    return { success: true };
-  }
-
-  /**
-   * Clear conversation history
-   */
-  async clearSession(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      session.messages = [];
-      session.isRunning = false;
-      await this.saveSession(sessionId, []);
-    }
-
-    return { success: true };
-  }
-
-  /**
-   * Load session from disk
-   */
-  async loadSession(sessionId) {
-    if (!this.stateDir) return [];
-
-    const sessionFile = path.join(this.stateDir, `${sessionId}.json`);
-
-    try {
-      const data = await fs.readFile(sessionFile, "utf-8");
-      const parsed = JSON.parse(data);
-      console.log(
-        `[AgentService] Loaded ${parsed.length} messages for ${sessionId}`
-      );
-      return parsed;
-    } catch (error) {
-      // Session doesn't exist yet
-      return [];
-    }
-  }
-
-  /**
-   * Save session to disk
-   */
-  async saveSession(sessionId, messages) {
-    if (!this.stateDir) return;
-
-    const sessionFile = path.join(this.stateDir, `${sessionId}.json`);
-
-    try {
-      await fs.writeFile(
-        sessionFile,
-        JSON.stringify(messages, null, 2),
-        "utf-8"
-      );
-      console.log(
-        `[AgentService] Saved ${messages.length} messages for ${sessionId}`
-      );
-
-      // Update timestamp
-      await this.updateSessionTimestamp(sessionId);
-    } catch (error) {
-      console.error("[AgentService] Failed to save session:", error);
-    }
-  }
-
-  /**
-   * Get system prompt
-   */
-  getSystemPrompt() {
-    return `You are an AI assistant helping users build software. You are part of the Automaker application,
-which is designed to help developers plan, design, and implement software projects autonomously.
-
-**🚨 CRITICAL FILE PROTECTION 🚨**
-
-THE FOLLOWING FILE IS ABSOLUTELY FORBIDDEN FROM DIRECT MODIFICATION:
-- .automaker/feature_list.json
-
-**YOU MUST NEVER:**
-- Use the Write tool on .automaker/feature_list.json
-- Use the Edit tool on .automaker/feature_list.json
-- Use any Bash command that writes to .automaker/feature_list.json
-- Attempt to read and rewrite .automaker/feature_list.json
-
-**CATASTROPHIC CONSEQUENCES:**
-Directly modifying .automaker/feature_list.json can erase all project features permanently.
-This file is managed by specialized tools only. NEVER touch it directly.
-
-Your role is to:
-- Help users define their project requirements and specifications
-- Ask clarifying questions to better understand their needs
-- Suggest technical approaches and architectures
-- Guide them through the development process
-- Be conversational and helpful
-- Write, edit, and modify code files as requested (EXCEPT .automaker/feature_list.json)
-- Execute commands and tests
-- Search and analyze the codebase
-
-When discussing projects, help users think through:
-- Core functionality and features
-- Technical stack choices
-- Data models and architecture
-- User experience considerations
-- Testing strategies
-
-You have full access to the codebase and can:
-- Read files to understand existing code (including .automaker/feature_list.json for viewing only)
-- Write new files (NEVER .automaker/feature_list.json)
-- Edit existing files (NEVER .automaker/feature_list.json)
-- Run bash commands (but never commands that modify .automaker/feature_list.json)
-- Search for code patterns
-- Execute tests and builds
-
-IMPORTANT: When making file changes, be aware that the Next.js development server may restart.
-This is normal and expected. Your conversation state is preserved across these restarts.`;
-  }
-
-  /**
-   * Generate unique ID
-   */
-  generateId() {
-    return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-  }
-
-  // ============================================================================
-  // Session Management
-  // ============================================================================
-
-  /**
-   * Load all session metadata
-   */
-  async loadMetadata() {
-    if (!this.metadataFile) return {};
-
-    try {
-      const data = await fs.readFile(this.metadataFile, "utf-8");
-      return JSON.parse(data);
-    } catch (error) {
-      return {};
-    }
-  }
-
-  /**
-   * Save session metadata
-   */
-  async saveMetadata(metadata) {
-    if (!this.metadataFile) return;
-
-    try {
-      await fs.writeFile(
-        this.metadataFile,
-        JSON.stringify(metadata, null, 2),
-        "utf-8"
-      );
-    } catch (error) {
-      console.error("[AgentService] Failed to save metadata:", error);
-    }
-  }
-
-  /**
-   * List all sessions
-   */
-  async listSessions({ includeArchived = false } = {}) {
-    const metadata = await this.loadMetadata();
-    const sessions = [];
-
-    for (const [sessionId, meta] of Object.entries(metadata)) {
-      if (!includeArchived && meta.isArchived) continue;
-
-      const messages = await this.loadSession(sessionId);
-      const lastMessage = messages[messages.length - 1];
-
-      sessions.push({
-        id: sessionId,
-        name: meta.name || sessionId,
-        projectPath: meta.projectPath || "",
-        createdAt: meta.createdAt,
-        updatedAt: meta.updatedAt,
-        messageCount: messages.length,
-        isArchived: meta.isArchived || false,
-        tags: meta.tags || [],
-        preview: lastMessage?.content.substring(0, 100) || "",
-      });
-    }
-
-    // Sort by most recently updated
-    sessions.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
-
-    return sessions;
-  }
-
-  /**
-   * Create a new session
-   */
-  async createSession({ name, projectPath, workingDirectory }) {
-    const sessionId = `session_${Date.now()}_${Math.random()
-      .toString(36)
-      .substring(2, 11)}`;
-
-    const metadata = await this.loadMetadata();
-    metadata[sessionId] = {
-      name,
-      projectPath,
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-      isArchived: false,
-      tags: [],
-    };
-
-    await this.saveMetadata(metadata);
-
-    this.sessions.set(sessionId, {
-      messages: [],
-      isRunning: false,
-      abortController: null,
-      workingDirectory: workingDirectory || projectPath,
-    });
-
-    await this.saveSession(sessionId, []);
-
-    return {
-      success: true,
-      sessionId,
-      session: metadata[sessionId],
-    };
-  }
-
-  /**
-   * Update session metadata
-   */
-  async updateSession({ sessionId, name, tags }) {
-    const metadata = await this.loadMetadata();
-
-    if (!metadata[sessionId]) {
-      return { success: false, error: "Session not found" };
-    }
-
-    if (name !== undefined) metadata[sessionId].name = name;
-    if (tags !== undefined) metadata[sessionId].tags = tags;
-    metadata[sessionId].updatedAt = new Date().toISOString();
-
-    await this.saveMetadata(metadata);
-
-    return { success: true };
-  }
-
-  /**
-   * Archive a session
-   */
-  async archiveSession(sessionId) {
-    const metadata = await this.loadMetadata();
-
-    if (!metadata[sessionId]) {
-      return { success: false, error: "Session not found" };
-    }
-
-    metadata[sessionId].isArchived = true;
-    metadata[sessionId].updatedAt = new Date().toISOString();
-
-    await this.saveMetadata(metadata);
-
-    return { success: true };
-  }
-
-  /**
-   * Unarchive a session
-   */
-  async unarchiveSession(sessionId) {
-    const metadata = await this.loadMetadata();
-
-    if (!metadata[sessionId]) {
-      return { success: false, error: "Session not found" };
-    }
-
-    metadata[sessionId].isArchived = false;
-    metadata[sessionId].updatedAt = new Date().toISOString();
-
-    await this.saveMetadata(metadata);
-
-    return { success: true };
-  }
-
-  /**
-   * Delete a session permanently
-   */
-  async deleteSession(sessionId) {
-    const metadata = await this.loadMetadata();
-
-    if (!metadata[sessionId]) {
-      return { success: false, error: "Session not found" };
-    }
-
-    // Remove from metadata
-    delete metadata[sessionId];
-    await this.saveMetadata(metadata);
-
-    // Remove from memory
-    this.sessions.delete(sessionId);
-
-    // Delete session file
-    const sessionFile = path.join(this.stateDir, `${sessionId}.json`);
-    try {
-      await fs.unlink(sessionFile);
-    } catch (error) {
-      console.warn("[AgentService] Failed to delete session file:", error);
-    }
-
-    return { success: true };
-  }
-
-  /**
-   * Update session metadata when messages change
-   */
-  async updateSessionTimestamp(sessionId) {
-    const metadata = await this.loadMetadata();
-
-    if (metadata[sessionId]) {
-      metadata[sessionId].updatedAt = new Date().toISOString();
-      await this.saveMetadata(metadata);
-    }
-  }
-}
-
-// Export singleton instance
-module.exports = new AgentService();

app/electron/preload.js

@@ -1,311 +0,0 @@
-const { contextBridge, ipcRenderer } = require("electron");
-
-// Expose protected methods that allow the renderer process to use
-// the ipcRenderer without exposing the entire object
-contextBridge.exposeInMainWorld("electronAPI", {
-  // IPC test
-  ping: () => ipcRenderer.invoke("ping"),
-
-  // Dialog APIs
-  openDirectory: () => ipcRenderer.invoke("dialog:openDirectory"),
-  openFile: (options) => ipcRenderer.invoke("dialog:openFile", options),
-
-  // File system APIs
-  readFile: (filePath) => ipcRenderer.invoke("fs:readFile", filePath),
-  writeFile: (filePath, content) =>
-    ipcRenderer.invoke("fs:writeFile", filePath, content),
-  mkdir: (dirPath) => ipcRenderer.invoke("fs:mkdir", dirPath),
-  readdir: (dirPath) => ipcRenderer.invoke("fs:readdir", dirPath),
-  exists: (filePath) => ipcRenderer.invoke("fs:exists", filePath),
-  stat: (filePath) => ipcRenderer.invoke("fs:stat", filePath),
-  deleteFile: (filePath) => ipcRenderer.invoke("fs:deleteFile", filePath),
-  trashItem: (filePath) => ipcRenderer.invoke("fs:trashItem", filePath),
-
-  // App APIs
-  getPath: (name) => ipcRenderer.invoke("app:getPath", name),
-  saveImageToTemp: (data, filename, mimeType, projectPath) =>
-    ipcRenderer.invoke("app:saveImageToTemp", { data, filename, mimeType, projectPath }),
-
-  // Agent APIs
-  agent: {
-    // Start or resume a conversation
-    start: (sessionId, workingDirectory) =>
-      ipcRenderer.invoke("agent:start", { sessionId, workingDirectory }),
-
-    // Send a message to the agent
-    send: (sessionId, message, workingDirectory, imagePaths) =>
-      ipcRenderer.invoke("agent:send", { sessionId, message, workingDirectory, imagePaths }),
-
-    // Get conversation history
-    getHistory: (sessionId) =>
-      ipcRenderer.invoke("agent:getHistory", { sessionId }),
-
-    // Stop current execution
-    stop: (sessionId) =>
-      ipcRenderer.invoke("agent:stop", { sessionId }),
-
-    // Clear conversation
-    clear: (sessionId) =>
-      ipcRenderer.invoke("agent:clear", { sessionId }),
-
-    // Subscribe to streaming events
-    onStream: (callback) => {
-      const subscription = (_, data) => callback(data);
-      ipcRenderer.on("agent:stream", subscription);
-      // Return unsubscribe function
-      return () => ipcRenderer.removeListener("agent:stream", subscription);
-    },
-  },
-
-  // Session Management APIs
-  sessions: {
-    // List all sessions
-    list: (includeArchived) =>
-      ipcRenderer.invoke("sessions:list", { includeArchived }),
-
-    // Create a new session
-    create: (name, projectPath, workingDirectory) =>
-      ipcRenderer.invoke("sessions:create", { name, projectPath, workingDirectory }),
-
-    // Update session metadata
-    update: (sessionId, name, tags) =>
-      ipcRenderer.invoke("sessions:update", { sessionId, name, tags }),
-
-    // Archive a session
-    archive: (sessionId) =>
-      ipcRenderer.invoke("sessions:archive", { sessionId }),
-
-    // Unarchive a session
-    unarchive: (sessionId) =>
-      ipcRenderer.invoke("sessions:unarchive", { sessionId }),
-
-    // Delete a session permanently
-    delete: (sessionId) =>
-      ipcRenderer.invoke("sessions:delete", { sessionId }),
-  },
-
-  // Auto Mode API
-  autoMode: {
-    // Start auto mode
-    start: (projectPath, maxConcurrency) =>
-      ipcRenderer.invoke("auto-mode:start", { projectPath, maxConcurrency }),
-
-    // Stop auto mode
-    stop: () => ipcRenderer.invoke("auto-mode:stop"),
-
-    // Get auto mode status
-    status: () => ipcRenderer.invoke("auto-mode:status"),
-
-    // Run a specific feature
-    runFeature: (projectPath, featureId, useWorktrees) =>
-      ipcRenderer.invoke("auto-mode:run-feature", { projectPath, featureId, useWorktrees }),
-
-    // Verify a specific feature by running its tests
-    verifyFeature: (projectPath, featureId) =>
-      ipcRenderer.invoke("auto-mode:verify-feature", { projectPath, featureId }),
-
-    // Resume a specific feature with previous context
-    resumeFeature: (projectPath, featureId) =>
-      ipcRenderer.invoke("auto-mode:resume-feature", { projectPath, featureId }),
-
-    // Check if context file exists for a feature
-    contextExists: (projectPath, featureId) =>
-      ipcRenderer.invoke("auto-mode:context-exists", { projectPath, featureId }),
-
-    // Analyze a new project - kicks off an agent to analyze codebase
-    analyzeProject: (projectPath) =>
-      ipcRenderer.invoke("auto-mode:analyze-project", { projectPath }),
-
-    // Stop a specific feature
-    stopFeature: (featureId) =>
-      ipcRenderer.invoke("auto-mode:stop-feature", { featureId }),
-
-    // Follow-up on a feature with additional prompt
-    followUpFeature: (projectPath, featureId, prompt, imagePaths) =>
-      ipcRenderer.invoke("auto-mode:follow-up-feature", { projectPath, featureId, prompt, imagePaths }),
-
-    // Commit changes for a feature
-    commitFeature: (projectPath, featureId) =>
-      ipcRenderer.invoke("auto-mode:commit-feature", { projectPath, featureId }),
-
-    // Listen for auto mode events
-    onEvent: (callback) => {
-      const subscription = (_, data) => callback(data);
-      ipcRenderer.on("auto-mode:event", subscription);
-
-      // Return unsubscribe function
-      return () => {
-        ipcRenderer.removeListener("auto-mode:event", subscription);
-      };
-    },
-  },
-
-  // Claude CLI Detection API
-  checkClaudeCli: () => ipcRenderer.invoke("claude:check-cli"),
-
-  // Codex CLI Detection API
-  checkCodexCli: () => ipcRenderer.invoke("codex:check-cli"),
-
-  // Model Management APIs
-  model: {
-    // Get all available models from all providers
-    getAvailable: () => ipcRenderer.invoke("model:get-available"),
-
-    // Check all provider installation status
-    checkProviders: () => ipcRenderer.invoke("model:check-providers"),
-  },
-
-  // OpenAI API
-  testOpenAIConnection: (apiKey) =>
-    ipcRenderer.invoke("openai:test-connection", { apiKey }),
-
-  // Worktree Management APIs
-  worktree: {
-    // Revert feature changes by removing the worktree
-    revertFeature: (projectPath, featureId) =>
-      ipcRenderer.invoke("worktree:revert-feature", { projectPath, featureId }),
-
-    // Merge feature worktree changes back to main branch
-    mergeFeature: (projectPath, featureId, options) =>
-      ipcRenderer.invoke("worktree:merge-feature", { projectPath, featureId, options }),
-
-    // Get worktree info for a feature
-    getInfo: (projectPath, featureId) =>
-      ipcRenderer.invoke("worktree:get-info", { projectPath, featureId }),
-
-    // Get worktree status (changed files, commits)
-    getStatus: (projectPath, featureId) =>
-      ipcRenderer.invoke("worktree:get-status", { projectPath, featureId }),
-
-    // List all feature worktrees
-    list: (projectPath) =>
-      ipcRenderer.invoke("worktree:list", { projectPath }),
-
-    // Get file diffs for a feature worktree
-    getDiffs: (projectPath, featureId) =>
-      ipcRenderer.invoke("worktree:get-diffs", { projectPath, featureId }),
-
-    // Get diff for a specific file in a worktree
-    getFileDiff: (projectPath, featureId, filePath) =>
-      ipcRenderer.invoke("worktree:get-file-diff", { projectPath, featureId, filePath }),
-  },
-
-  // Git Operations APIs (for non-worktree operations)
-  git: {
-    // Get file diffs for the main project
-    getDiffs: (projectPath) =>
-      ipcRenderer.invoke("git:get-diffs", { projectPath }),
-
-    // Get diff for a specific file in the main project
-    getFileDiff: (projectPath, filePath) =>
-      ipcRenderer.invoke("git:get-file-diff", { projectPath, filePath }),
-  },
-
-  // Feature Suggestions API
-  suggestions: {
-    // Generate feature suggestions
-    generate: (projectPath) =>
-      ipcRenderer.invoke("suggestions:generate", { projectPath }),
-
-    // Stop generating suggestions
-    stop: () => ipcRenderer.invoke("suggestions:stop"),
-
-    // Get suggestions status
-    status: () => ipcRenderer.invoke("suggestions:status"),
-
-    // Listen for suggestions events
-    onEvent: (callback) => {
-      const subscription = (_, data) => callback(data);
-      ipcRenderer.on("suggestions:event", subscription);
-
-      // Return unsubscribe function
-      return () => {
-        ipcRenderer.removeListener("suggestions:event", subscription);
-      };
-    },
-  },
-
-  // Spec Regeneration API
-  specRegeneration: {
-    // Create initial app spec for a new project
-    create: (projectPath, projectOverview, generateFeatures = true) =>
-      ipcRenderer.invoke("spec-regeneration:create", { projectPath, projectOverview, generateFeatures }),
-
-    // Regenerate the app spec
-    generate: (projectPath, projectDefinition) =>
-      ipcRenderer.invoke("spec-regeneration:generate", { projectPath, projectDefinition }),
-
-    // Stop regenerating spec
-    stop: () => ipcRenderer.invoke("spec-regeneration:stop"),
-
-    // Get regeneration status
-    status: () => ipcRenderer.invoke("spec-regeneration:status"),
-
-    // Listen for regeneration events
-    onEvent: (callback) => {
-      const subscription = (_, data) => callback(data);
-      ipcRenderer.on("spec-regeneration:event", subscription);
-
-      // Return unsubscribe function
-      return () => {
-        ipcRenderer.removeListener("spec-regeneration:event", subscription);
-      };
-    },
-  },
-
-  // Setup & CLI Management API
-  setup: {
-    // Get comprehensive Claude CLI status
-    getClaudeStatus: () => ipcRenderer.invoke("setup:claude-status"),
-
-    // Get comprehensive Codex CLI status
-    getCodexStatus: () => ipcRenderer.invoke("setup:codex-status"),
-
-    // Install Claude CLI
-    installClaude: () => ipcRenderer.invoke("setup:install-claude"),
-
-    // Install Codex CLI
-    installCodex: () => ipcRenderer.invoke("setup:install-codex"),
-
-    // Authenticate Claude CLI
-    authClaude: () => ipcRenderer.invoke("setup:auth-claude"),
-
-    // Authenticate Codex CLI with optional API key
-    authCodex: (apiKey) => ipcRenderer.invoke("setup:auth-codex", { apiKey }),
-
-    // Store API key securely
-    storeApiKey: (provider, apiKey) =>
-      ipcRenderer.invoke("setup:store-api-key", { provider, apiKey }),
-
-    // Get stored API keys status
-    getApiKeys: () => ipcRenderer.invoke("setup:get-api-keys"),
-
-    // Configure Codex MCP server for a project
-    configureCodexMcp: (projectPath) =>
-      ipcRenderer.invoke("setup:configure-codex-mcp", { projectPath }),
-
-    // Get platform information
-    getPlatform: () => ipcRenderer.invoke("setup:get-platform"),
-
-    // Listen for installation progress
-    onInstallProgress: (callback) => {
-      const subscription = (_, data) => callback(data);
-      ipcRenderer.on("setup:install-progress", subscription);
-      return () => {
-        ipcRenderer.removeListener("setup:install-progress", subscription);
-      };
-    },
-
-    // Listen for auth progress
-    onAuthProgress: (callback) => {
-      const subscription = (_, data) => callback(data);
-      ipcRenderer.on("setup:auth-progress", subscription);
-      return () => {
-        ipcRenderer.removeListener("setup:auth-progress", subscription);
-      };
-    },
-  },
-});
-
-// Also expose a flag to detect if we're in Electron
-contextBridge.exposeInMainWorld("isElectron", true);

app/electron/services/claude-cli-detector.js

@@ -1,421 +0,0 @@
-const { execSync, spawn } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-/**
- * Claude CLI Detector
- *
- * Authentication options:
- * 1. OAuth Token (Subscription): User runs `claude setup-token` and provides the token to the app
- * 2. API Key (Pay-per-use): User provides their Anthropic API key directly
- */
-class ClaudeCliDetector {
-  /**
-   * Check if Claude Code CLI is installed and accessible
-   * @returns {Object} { installed: boolean, path: string|null, version: string|null, method: 'cli'|'none' }
-   */
-  /**
-   * Try to get updated PATH from shell config files
-   * This helps detect CLI installations that modify shell config but haven't updated the current process PATH
-   */
-  static getUpdatedPathFromShellConfig() {
-    const homeDir = os.homedir();
-    const shell = process.env.SHELL || '/bin/bash';
-    const shellName = path.basename(shell);
-    
-    // Common shell config files
-    const configFiles = [];
-    if (shellName.includes('zsh')) {
-      configFiles.push(path.join(homeDir, '.zshrc'));
-      configFiles.push(path.join(homeDir, '.zshenv'));
-      configFiles.push(path.join(homeDir, '.zprofile'));
-    } else if (shellName.includes('bash')) {
-      configFiles.push(path.join(homeDir, '.bashrc'));
-      configFiles.push(path.join(homeDir, '.bash_profile'));
-      configFiles.push(path.join(homeDir, '.profile'));
-    }
-    
-    // Also check common locations
-    const commonPaths = [
-      path.join(homeDir, '.local', 'bin'),
-      path.join(homeDir, '.cargo', 'bin'),
-      '/usr/local/bin',
-      '/opt/homebrew/bin',
-      path.join(homeDir, 'bin'),
-    ];
-    
-    // Try to extract PATH additions from config files
-    for (const configFile of configFiles) {
-      if (fs.existsSync(configFile)) {
-        try {
-          const content = fs.readFileSync(configFile, 'utf-8');
-          // Look for PATH exports that might include claude installation paths
-          const pathMatches = content.match(/export\s+PATH=["']?([^"'\n]+)["']?/g);
-          if (pathMatches) {
-            for (const match of pathMatches) {
-              const pathValue = match.replace(/export\s+PATH=["']?/, '').replace(/["']?$/, '');
-              const paths = pathValue.split(':').filter(p => p && !p.includes('$'));
-              commonPaths.push(...paths);
-            }
-          }
-        } catch (error) {
-          // Ignore errors reading config files
-        }
-      }
-    }
-    
-    return [...new Set(commonPaths)]; // Remove duplicates
-  }
-
-  static detectClaudeInstallation() {
-    console.log('[ClaudeCliDetector] Detecting Claude installation...');
-
-    try {
-      // Method 1: Check if 'claude' command is in PATH (Unix)
-      if (process.platform !== 'win32') {
-        try {
-          const claudePath = execSync('which claude 2>/dev/null', { encoding: 'utf-8' }).trim();
-          if (claudePath) {
-            const version = this.getClaudeVersion(claudePath);
-            console.log('[ClaudeCliDetector] Found claude at:', claudePath, 'version:', version);
-            return {
-              installed: true,
-              path: claudePath,
-              version: version,
-              method: 'cli'
-            };
-          }
-        } catch (error) {
-          // CLI not in PATH, continue checking other locations
-        }
-      }
-
-      // Method 2: Check Windows path
-      if (process.platform === 'win32') {
-        try {
-          const claudePath = execSync('where claude 2>nul', { encoding: 'utf-8' }).trim().split('\n')[0];
-          if (claudePath) {
-            const version = this.getClaudeVersion(claudePath);
-            console.log('[ClaudeCliDetector] Found claude at:', claudePath, 'version:', version);
-            return {
-              installed: true,
-              path: claudePath,
-              version: version,
-              method: 'cli'
-            };
-          }
-        } catch (error) {
-          // Not found on Windows
-        }
-      }
-
-      // Method 3: Check for local installation
-      const localClaudePath = path.join(os.homedir(), '.claude', 'local', 'claude');
-      if (fs.existsSync(localClaudePath)) {
-        const version = this.getClaudeVersion(localClaudePath);
-        console.log('[ClaudeCliDetector] Found local claude at:', localClaudePath, 'version:', version);
-        return {
-          installed: true,
-          path: localClaudePath,
-          version: version,
-          method: 'cli-local'
-        };
-      }
-
-      // Method 4: Check common installation locations (including those from shell config)
-      const commonPaths = this.getUpdatedPathFromShellConfig();
-      const binaryNames = ['claude', 'claude-code'];
-      
-      for (const basePath of commonPaths) {
-        for (const binaryName of binaryNames) {
-          const claudePath = path.join(basePath, binaryName);
-          if (fs.existsSync(claudePath)) {
-            try {
-              const version = this.getClaudeVersion(claudePath);
-              console.log('[ClaudeCliDetector] Found claude at:', claudePath, 'version:', version);
-              return {
-                installed: true,
-                path: claudePath,
-                version: version,
-                method: 'cli'
-              };
-            } catch (error) {
-              // File exists but can't get version, might not be executable
-            }
-          }
-        }
-      }
-
-      // Method 5: Try to source shell config and check PATH again (for Unix)
-      if (process.platform !== 'win32') {
-        try {
-          const shell = process.env.SHELL || '/bin/bash';
-          const shellName = path.basename(shell);
-          const homeDir = os.homedir();
-          
-          let sourceCmd = '';
-          if (shellName.includes('zsh')) {
-            sourceCmd = `source ${homeDir}/.zshrc 2>/dev/null && which claude`;
-          } else if (shellName.includes('bash')) {
-            sourceCmd = `source ${homeDir}/.bashrc 2>/dev/null && which claude`;
-          }
-          
-          if (sourceCmd) {
-            const claudePath = execSync(`bash -c "${sourceCmd}"`, { encoding: 'utf-8', timeout: 2000 }).trim();
-            if (claudePath && claudePath.startsWith('/')) {
-              const version = this.getClaudeVersion(claudePath);
-              console.log('[ClaudeCliDetector] Found claude via shell config at:', claudePath, 'version:', version);
-              return {
-                installed: true,
-                path: claudePath,
-                version: version,
-                method: 'cli'
-              };
-            }
-          }
-        } catch (error) {
-          // Failed to source shell config or find claude
-        }
-      }
-
-      console.log('[ClaudeCliDetector] Claude CLI not found');
-      return {
-        installed: false,
-        path: null,
-        version: null,
-        method: 'none'
-      };
-    } catch (error) {
-      console.error('[ClaudeCliDetector] Error detecting Claude installation:', error);
-      return {
-        installed: false,
-        path: null,
-        version: null,
-        method: 'none',
-        error: error.message
-      };
-    }
-  }
-
-  /**
-   * Get Claude CLI version
-   * @param {string} claudePath Path to claude executable
-   * @returns {string|null} Version string or null
-   */
-  static getClaudeVersion(claudePath) {
-    try {
-      const version = execSync(`"${claudePath}" --version 2>/dev/null`, {
-        encoding: 'utf-8',
-        timeout: 5000
-      }).trim();
-      return version || null;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Get authentication status
-   * Checks for:
-   * 1. OAuth token stored in app's credentials (from `claude setup-token`)
-   * 2. API key stored in app's credentials
-   * 3. API key in environment variable
-   *
-   * @param {string} appCredentialsPath Path to app's credentials.json
-   * @returns {Object} Authentication status
-   */
-  static getAuthStatus(appCredentialsPath) {
-    console.log('[ClaudeCliDetector] Checking auth status...');
-
-    const envApiKey = process.env.ANTHROPIC_API_KEY;
-    console.log('[ClaudeCliDetector] Env ANTHROPIC_API_KEY:', !!envApiKey);
-
-    // Check app's stored credentials
-    let storedOAuthToken = null;
-    let storedApiKey = null;
-
-    if (appCredentialsPath && fs.existsSync(appCredentialsPath)) {
-      try {
-        const content = fs.readFileSync(appCredentialsPath, 'utf-8');
-        const credentials = JSON.parse(content);
-        storedOAuthToken = credentials.anthropic_oauth_token || null;
-        storedApiKey = credentials.anthropic || credentials.anthropic_api_key || null;
-        console.log('[ClaudeCliDetector] App credentials:', {
-          hasOAuthToken: !!storedOAuthToken,
-          hasApiKey: !!storedApiKey
-        });
-      } catch (error) {
-        console.error('[ClaudeCliDetector] Error reading app credentials:', error);
-      }
-    }
-
-    // Determine authentication method
-    // Priority: Stored OAuth Token > Stored API Key > Env API Key
-    let authenticated = false;
-    let method = 'none';
-
-    if (storedOAuthToken) {
-      authenticated = true;
-      method = 'oauth_token';
-      console.log('[ClaudeCliDetector] Using stored OAuth token (subscription)');
-    } else if (storedApiKey) {
-      authenticated = true;
-      method = 'api_key';
-      console.log('[ClaudeCliDetector] Using stored API key');
-    } else if (envApiKey) {
-      authenticated = true;
-      method = 'api_key_env';
-      console.log('[ClaudeCliDetector] Using environment API key');
-    } else {
-      console.log('[ClaudeCliDetector] No authentication found');
-    }
-
-    const result = {
-      authenticated,
-      method,
-      hasStoredOAuthToken: !!storedOAuthToken,
-      hasStoredApiKey: !!storedApiKey,
-      hasEnvApiKey: !!envApiKey
-    };
-
-    console.log('[ClaudeCliDetector] Auth status result:', result);
-    return result;
-  }
-
-  /**
-   * Get full status including installation and auth
-   * @param {string} appCredentialsPath Path to app's credentials.json
-   * @returns {Object} Full status
-   */
-  static getFullStatus(appCredentialsPath) {
-    const installation = this.detectClaudeInstallation();
-    const auth = this.getAuthStatus(appCredentialsPath);
-
-    return {
-      success: true,
-      status: installation.installed ? 'installed' : 'not_installed',
-      installed: installation.installed,
-      path: installation.path,
-      version: installation.version,
-      method: installation.method,
-      auth
-    };
-  }
-
-  /**
-   * Get installation commands for different platforms
-   * @returns {Object} Installation commands
-   */
-  static getInstallCommands() {
-    return {
-      macos: 'curl -fsSL https://claude.ai/install.sh | bash',
-      windows: 'irm https://claude.ai/install.ps1 | iex',
-      linux: 'curl -fsSL https://claude.ai/install.sh | bash'
-    };
-  }
-
-  /**
-   * Install Claude CLI using the official script
-   * @param {Function} onProgress Callback for progress updates
-   * @returns {Promise<Object>} Installation result
-   */
-  static async installCli(onProgress) {
-    return new Promise((resolve, reject) => {
-      const platform = process.platform;
-      let command, args;
-
-      if (platform === 'win32') {
-        command = 'powershell';
-        args = ['-Command', 'irm https://claude.ai/install.ps1 | iex'];
-      } else {
-        command = 'bash';
-        args = ['-c', 'curl -fsSL https://claude.ai/install.sh | bash'];
-      }
-
-      console.log('[ClaudeCliDetector] Installing Claude CLI...');
-
-      const proc = spawn(command, args, {
-        stdio: ['pipe', 'pipe', 'pipe'],
-        shell: false
-      });
-
-      let output = '';
-      let errorOutput = '';
-
-      proc.stdout.on('data', (data) => {
-        const text = data.toString();
-        output += text;
-        if (onProgress) {
-          onProgress({ type: 'stdout', data: text });
-        }
-      });
-
-      proc.stderr.on('data', (data) => {
-        const text = data.toString();
-        errorOutput += text;
-        if (onProgress) {
-          onProgress({ type: 'stderr', data: text });
-        }
-      });
-
-      proc.on('close', (code) => {
-        if (code === 0) {
-          console.log('[ClaudeCliDetector] Installation completed successfully');
-          resolve({
-            success: true,
-            output,
-            message: 'Claude CLI installed successfully'
-          });
-        } else {
-          console.error('[ClaudeCliDetector] Installation failed with code:', code);
-          reject({
-            success: false,
-            error: errorOutput || `Installation failed with code ${code}`,
-            output
-          });
-        }
-      });
-
-      proc.on('error', (error) => {
-        console.error('[ClaudeCliDetector] Installation error:', error);
-        reject({
-          success: false,
-          error: error.message,
-          output
-        });
-      });
-    });
-  }
-
-  /**
-   * Get instructions for setup-token command
-   * @returns {Object} Setup token instructions
-   */
-  static getSetupTokenInstructions() {
-    const detection = this.detectClaudeInstallation();
-
-    if (!detection.installed) {
-      return {
-        success: false,
-        error: 'Claude CLI is not installed. Please install it first.',
-        installCommands: this.getInstallCommands()
-      };
-    }
-
-    return {
-      success: true,
-      command: 'claude setup-token',
-      instructions: [
-        '1. Open your terminal',
-        '2. Run: claude setup-token',
-        '3. Follow the prompts to authenticate',
-        '4. Copy the token that is displayed',
-        '5. Paste the token in the field below'
-      ],
-      note: 'This token is from your Claude subscription and allows you to use Claude without API charges.'
-    };
-  }
-}
-
-module.exports = ClaudeCliDetector;

app/electron/services/codex-cli-detector.js

@@ -1,593 +0,0 @@
-const { execSync, spawn } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-/**
- * Codex CLI Detector - Checks if OpenAI Codex CLI is installed
- *
- * Codex CLI is OpenAI's agent CLI tool that allows users to use
- * GPT-5.1 Codex models (gpt-5.1-codex-max, gpt-5.1-codex, etc.)
- * for code generation and agentic tasks.
- */
-class CodexCliDetector {
-  /**
-   * Get the path to Codex config directory
-   * @returns {string} Path to .codex directory
-   */
-  static getConfigDir() {
-    return path.join(os.homedir(), '.codex');
-  }
-
-  /**
-   * Get the path to Codex auth file
-   * @returns {string} Path to auth.json
-   */
-  static getAuthPath() {
-    return path.join(this.getConfigDir(), 'auth.json');
-  }
-
-  /**
-   * Check Codex authentication status
-   * @returns {Object} Authentication status
-   */
-  static checkAuth() {
-    console.log('[CodexCliDetector] Checking auth status...');
-    try {
-      const authPath = this.getAuthPath();
-      const envApiKey = process.env.OPENAI_API_KEY;
-      console.log('[CodexCliDetector] Auth path:', authPath);
-      console.log('[CodexCliDetector] Has env API key:', !!envApiKey);
-
-      // First, try to verify authentication using codex CLI command if available
-      try {
-        const detection = this.detectCodexInstallation();
-        if (detection.installed) {
-          try {
-            // Use 'codex login status' to verify authentication
-            const statusOutput = execSync(`"${detection.path || 'codex'}" login status 2>/dev/null`, { 
-              encoding: 'utf-8',
-              timeout: 5000 
-            });
-            
-            // If command succeeds and shows logged in status
-            if (statusOutput && (statusOutput.includes('Logged in') || statusOutput.includes('Authenticated'))) {
-              const result = {
-                authenticated: true,
-                method: 'cli_verified',
-                hasAuthFile: fs.existsSync(authPath),
-                hasEnvKey: !!envApiKey,
-                authPath
-              };
-              console.log('[CodexCliDetector] Auth result (cli_verified):', result);
-              return result;
-            }
-          } catch (statusError) {
-            // status command failed, continue with file-based check
-          }
-        }
-      } catch (verifyError) {
-        // CLI verification failed, continue with file-based check
-      }
-
-      // Check if auth file exists
-      if (fs.existsSync(authPath)) {
-        const content = fs.readFileSync(authPath, 'utf-8');
-        const auth = JSON.parse(content);
-
-        // Check for token object structure (from codex auth login)
-        // Structure: { token: { Id_token, access_token, refresh_token }, last_refresh: ... }
-        if (auth.token && typeof auth.token === 'object') {
-          const token = auth.token;
-          if (token.Id_token || token.access_token || token.refresh_token || token.id_token) {
-            return {
-              authenticated: true,
-              method: 'auth_file',
-              hasAuthFile: true,
-              hasEnvKey: !!envApiKey,
-              authPath
-            };
-          }
-        }
-
-        // Check for various possible auth fields that codex might use
-        if (auth.api_key || auth.openai_api_key || auth.access_token || auth.apiKey) {
-          return {
-            authenticated: true,
-            method: 'auth_file',
-            hasAuthFile: true,
-            hasEnvKey: !!envApiKey,
-            authPath
-          };
-        }
-
-        // Also check if the file has any meaningful content (non-empty object)
-        const keys = Object.keys(auth);
-        if (keys.length > 0) {
-          // File exists and has content, likely authenticated
-          // Try to verify by checking if codex command works
-          try {
-            const detection = this.detectCodexInstallation();
-            if (detection.installed) {
-              // Try to verify auth by running a simple command
-              try {
-                execSync(`"${detection.path || 'codex'}" --version 2>/dev/null`, { 
-                  encoding: 'utf-8',
-                  timeout: 3000 
-                });
-                // If command succeeds, assume authenticated
-                return {
-                  authenticated: true,
-                  method: 'auth_file',
-                  hasAuthFile: true,
-                  hasEnvKey: !!envApiKey,
-                  authPath
-                };
-              } catch (cmdError) {
-                // Command failed, but file exists - might still be authenticated
-                // Return authenticated if file has content
-                return {
-                  authenticated: true,
-                  method: 'auth_file',
-                  hasAuthFile: true,
-                  hasEnvKey: !!envApiKey,
-                  authPath
-                };
-              }
-            }
-          } catch (verifyError) {
-            // Verification failed, but file exists with content
-            return {
-              authenticated: true,
-              method: 'auth_file',
-              hasAuthFile: true,
-              hasEnvKey: !!envApiKey,
-              authPath
-            };
-          }
-        }
-      }
-
-      // Check environment variable
-      if (envApiKey) {
-        const result = {
-          authenticated: true,
-          method: 'env_var',
-          hasAuthFile: false,
-          hasEnvKey: true,
-          authPath
-        };
-        console.log('[CodexCliDetector] Auth result (env_var):', result);
-        return result;
-      }
-
-      // If auth file exists but we didn't find standard keys, 
-      // check if codex CLI is installed and try to verify auth
-      if (fs.existsSync(authPath)) {
-        try {
-          const detection = this.detectCodexInstallation();
-          if (detection.installed) {
-            // Auth file exists and CLI is installed - likely authenticated
-            // The file existing is a good indicator that login was successful
-            return {
-              authenticated: true,
-              method: 'auth_file',
-              hasAuthFile: true,
-              hasEnvKey: !!envApiKey,
-              authPath
-            };
-          }
-        } catch (verifyError) {
-          // Verification attempt failed, but file exists
-          // Assume authenticated if file exists
-          return {
-            authenticated: true,
-            method: 'auth_file',
-            hasAuthFile: true,
-            hasEnvKey: !!envApiKey,
-            authPath
-          };
-        }
-      }
-
-      const result = {
-        authenticated: false,
-        method: 'none',
-        hasAuthFile: false,
-        hasEnvKey: false,
-        authPath
-      };
-      console.log('[CodexCliDetector] Auth result (not authenticated):', result);
-      return result;
-    } catch (error) {
-      console.error('[CodexCliDetector] Error checking auth:', error);
-      const result = {
-        authenticated: false,
-        method: 'none',
-        error: error.message
-      };
-      console.log('[CodexCliDetector] Auth result (error):', result);
-      return result;
-    }
-  }
-  /**
-   * Check if Codex CLI is installed and accessible
-   * @returns {Object} { installed: boolean, path: string|null, version: string|null, method: 'cli'|'npm'|'brew'|'none' }
-   */
-  static detectCodexInstallation() {
-    try {
-      // Method 1: Check if 'codex' command is in PATH
-      try {
-        const codexPath = execSync('which codex 2>/dev/null', { encoding: 'utf-8' }).trim();
-        if (codexPath) {
-          const version = this.getCodexVersion(codexPath);
-          return {
-            installed: true,
-            path: codexPath,
-            version: version,
-            method: 'cli'
-          };
-        }
-      } catch (error) {
-        // CLI not in PATH, continue checking other methods
-      }
-
-      // Method 2: Check for npm global installation
-      try {
-        const npmListOutput = execSync('npm list -g @openai/codex --depth=0 2>/dev/null', { encoding: 'utf-8' });
-        if (npmListOutput && npmListOutput.includes('@openai/codex')) {
-          // Get the path from npm bin
-          const npmBinPath = execSync('npm bin -g', { encoding: 'utf-8' }).trim();
-          const codexPath = path.join(npmBinPath, 'codex');
-          const version = this.getCodexVersion(codexPath);
-          return {
-            installed: true,
-            path: codexPath,
-            version: version,
-            method: 'npm'
-          };
-        }
-      } catch (error) {
-        // npm global not found
-      }
-
-      // Method 3: Check for Homebrew installation on macOS
-      if (process.platform === 'darwin') {
-        try {
-          const brewList = execSync('brew list --formula 2>/dev/null', { encoding: 'utf-8' });
-          if (brewList.includes('codex')) {
-            const brewPrefixOutput = execSync('brew --prefix codex 2>/dev/null', { encoding: 'utf-8' }).trim();
-            const codexPath = path.join(brewPrefixOutput, 'bin', 'codex');
-            const version = this.getCodexVersion(codexPath);
-            return {
-              installed: true,
-              path: codexPath,
-              version: version,
-              method: 'brew'
-            };
-          }
-        } catch (error) {
-          // Homebrew not found or codex not installed via brew
-        }
-      }
-
-      // Method 4: Check Windows path
-      if (process.platform === 'win32') {
-        try {
-          const codexPath = execSync('where codex 2>nul', { encoding: 'utf-8' }).trim().split('\n')[0];
-          if (codexPath) {
-            const version = this.getCodexVersion(codexPath);
-            return {
-              installed: true,
-              path: codexPath,
-              version: version,
-              method: 'cli'
-            };
-          }
-        } catch (error) {
-          // Not found on Windows
-        }
-      }
-
-      // Method 5: Check common installation paths
-      const commonPaths = [
-        path.join(os.homedir(), '.local', 'bin', 'codex'),
-        path.join(os.homedir(), '.npm-global', 'bin', 'codex'),
-        '/usr/local/bin/codex',
-        '/opt/homebrew/bin/codex',
-      ];
-
-      for (const checkPath of commonPaths) {
-        if (fs.existsSync(checkPath)) {
-          const version = this.getCodexVersion(checkPath);
-          return {
-            installed: true,
-            path: checkPath,
-            version: version,
-            method: 'cli'
-          };
-        }
-      }
-
-      // Method 6: Check if OPENAI_API_KEY is set (can use Codex API directly)
-      if (process.env.OPENAI_API_KEY) {
-        return {
-          installed: false,
-          path: null,
-          version: null,
-          method: 'api-key-only',
-          hasApiKey: true
-        };
-      }
-
-      return {
-        installed: false,
-        path: null,
-        version: null,
-        method: 'none'
-      };
-    } catch (error) {
-      console.error('[CodexCliDetector] Error detecting Codex installation:', error);
-      return {
-        installed: false,
-        path: null,
-        version: null,
-        method: 'none',
-        error: error.message
-      };
-    }
-  }
-
-  /**
-   * Get Codex CLI version from executable path
-   * @param {string} codexPath Path to codex executable
-   * @returns {string|null} Version string or null
-   */
-  static getCodexVersion(codexPath) {
-    try {
-      const version = execSync(`"${codexPath}" --version 2>/dev/null`, { encoding: 'utf-8' }).trim();
-      return version || null;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Get installation info and recommendations
-   * @returns {Object} Installation status and recommendations
-   */
-  static getInstallationInfo() {
-    const detection = this.detectCodexInstallation();
-
-    if (detection.installed) {
-      return {
-        status: 'installed',
-        method: detection.method,
-        version: detection.version,
-        path: detection.path,
-        recommendation: detection.method === 'cli'
-          ? 'Using Codex CLI - ready for GPT-5.1 Codex models'
-          : `Using Codex CLI via ${detection.method} - ready for GPT-5.1 Codex models`
-      };
-    }
-
-    // Not installed but has API key
-    if (detection.method === 'api-key-only') {
-      return {
-        status: 'api_key_only',
-        method: 'api-key-only',
-        recommendation: 'OPENAI_API_KEY detected but Codex CLI not installed. Install Codex CLI for full agentic capabilities.',
-        installCommands: this.getInstallCommands()
-      };
-    }
-
-    return {
-      status: 'not_installed',
-      recommendation: 'Install OpenAI Codex CLI to use GPT-5.1 Codex models for agentic tasks',
-      installCommands: this.getInstallCommands()
-    };
-  }
-
-  /**
-   * Get installation commands for different platforms
-   * @returns {Object} Installation commands by platform
-   */
-  static getInstallCommands() {
-    return {
-      npm: 'npm install -g @openai/codex@latest',
-      macos: 'brew install codex',
-      linux: 'npm install -g @openai/codex@latest',
-      windows: 'npm install -g @openai/codex@latest'
-    };
-  }
-
-  /**
-   * Check if Codex CLI supports a specific model
-   * @param {string} model Model name to check
-   * @returns {boolean} Whether the model is supported
-   */
-  static isModelSupported(model) {
-    const supportedModels = [
-      'gpt-5.1-codex-max',
-      'gpt-5.1-codex',
-      'gpt-5.1-codex-mini',
-      'gpt-5.1'
-    ];
-    return supportedModels.includes(model);
-  }
-
-  /**
-   * Get default model for Codex CLI
-   * @returns {string} Default model name
-   */
-  static getDefaultModel() {
-    return 'gpt-5.1-codex-max';
-  }
-
-  /**
-   * Get comprehensive installation info including auth status
-   * @returns {Object} Full status object
-   */
-  static getFullStatus() {
-    const installation = this.detectCodexInstallation();
-    const auth = this.checkAuth();
-    const info = this.getInstallationInfo();
-
-    return {
-      ...info,
-      auth,
-      installation
-    };
-  }
-
-  /**
-   * Install Codex CLI using npm
-   * @param {Function} onProgress Callback for progress updates
-   * @returns {Promise<Object>} Installation result
-   */
-  static async installCli(onProgress) {
-    return new Promise((resolve, reject) => {
-      const command = 'npm';
-      const args = ['install', '-g', '@openai/codex@latest'];
-
-      const proc = spawn(command, args, {
-        stdio: ['pipe', 'pipe', 'pipe'],
-        shell: true
-      });
-
-      let output = '';
-      let errorOutput = '';
-
-      proc.stdout.on('data', (data) => {
-        const text = data.toString();
-        output += text;
-        if (onProgress) {
-          onProgress({ type: 'stdout', data: text });
-        }
-      });
-
-      proc.stderr.on('data', (data) => {
-        const text = data.toString();
-        errorOutput += text;
-        // npm often outputs progress to stderr
-        if (onProgress) {
-          onProgress({ type: 'stderr', data: text });
-        }
-      });
-
-      proc.on('close', (code) => {
-        if (code === 0) {
-          resolve({
-            success: true,
-            output,
-            message: 'Codex CLI installed successfully'
-          });
-        } else {
-          reject({
-            success: false,
-            error: errorOutput || `Installation failed with code ${code}`,
-            output
-          });
-        }
-      });
-
-      proc.on('error', (error) => {
-        reject({
-          success: false,
-          error: error.message,
-          output
-        });
-      });
-    });
-  }
-
-  /**
-   * Authenticate Codex CLI - opens browser for OAuth or stores API key
-   * @param {string} apiKey Optional API key to store
-   * @param {Function} onProgress Callback for progress updates
-   * @returns {Promise<Object>} Authentication result
-   */
-  static async authenticate(apiKey, onProgress) {
-    return new Promise((resolve, reject) => {
-      const detection = this.detectCodexInstallation();
-
-      if (!detection.installed) {
-        reject({
-          success: false,
-          error: 'Codex CLI is not installed'
-        });
-        return;
-      }
-
-      const codexPath = detection.path || 'codex';
-
-      if (apiKey) {
-        // Store API key directly using codex auth command
-        const proc = spawn(codexPath, ['auth', 'login', '--api-key', apiKey], {
-          stdio: ['pipe', 'pipe', 'pipe'],
-          shell: false
-        });
-
-        let output = '';
-        let errorOutput = '';
-
-        proc.stdout.on('data', (data) => {
-          const text = data.toString();
-          output += text;
-          if (onProgress) {
-            onProgress({ type: 'stdout', data: text });
-          }
-        });
-
-        proc.stderr.on('data', (data) => {
-          const text = data.toString();
-          errorOutput += text;
-          if (onProgress) {
-            onProgress({ type: 'stderr', data: text });
-          }
-        });
-
-        proc.on('close', (code) => {
-          if (code === 0) {
-            resolve({
-              success: true,
-              output,
-              message: 'Codex CLI authenticated successfully'
-            });
-          } else {
-            reject({
-              success: false,
-              error: errorOutput || `Authentication failed with code ${code}`,
-              output
-            });
-          }
-        });
-
-        proc.on('error', (error) => {
-          reject({
-            success: false,
-            error: error.message,
-            output
-          });
-        });
-      } else {
-        // Require manual authentication
-        if (onProgress) {
-          onProgress({
-            type: 'info',
-            data: 'Please run the following command in your terminal to authenticate:\n\ncodex auth login\n\nThen return here to continue setup.'
-          });
-        }
-
-        resolve({
-          success: true,
-          requiresManualAuth: true,
-          command: `${codexPath} auth login`,
-          message: 'Please authenticate Codex CLI manually'
-        });
-      }
-    });
-  }
-}
-
-module.exports = CodexCliDetector;

app/electron/services/codex-config-manager.js

@@ -1,351 +0,0 @@
-/**
- * Codex TOML Configuration Manager
- * 
- * Manages Codex CLI's TOML configuration file to add/update MCP server settings.
- * Codex CLI looks for config at:
- * - ~/.codex/config.toml (user-level)
- * - .codex/config.toml (project-level, takes precedence)
- */
-
-const fs = require('fs/promises');
-const path = require('path');
-const os = require('os');
-
-class CodexConfigManager {
-  constructor() {
-    this.userConfigPath = path.join(os.homedir(), '.codex', 'config.toml');
-    this.projectConfigPath = null; // Will be set per project
-  }
-
-  /**
-   * Set the project path for project-level config
-   */
-  setProjectPath(projectPath) {
-    this.projectConfigPath = path.join(projectPath, '.codex', 'config.toml');
-  }
-
-  /**
-   * Get the effective config path (project-level if exists, otherwise user-level)
-   */
-  async getConfigPath() {
-    if (this.projectConfigPath) {
-      try {
-        await fs.access(this.projectConfigPath);
-        return this.projectConfigPath;
-      } catch (e) {
-        // Project config doesn't exist, fall back to user config
-      }
-    }
-    
-    // Ensure user config directory exists
-    const userConfigDir = path.dirname(this.userConfigPath);
-    try {
-      await fs.mkdir(userConfigDir, { recursive: true });
-    } catch (e) {
-      // Directory might already exist
-    }
-    
-    return this.userConfigPath;
-  }
-
-  /**
-   * Read existing TOML config (simple parser for our needs)
-   */
-  async readConfig(configPath) {
-    try {
-      const content = await fs.readFile(configPath, 'utf-8');
-      return this.parseToml(content);
-    } catch (e) {
-      if (e.code === 'ENOENT') {
-        return {};
-      }
-      throw e;
-    }
-  }
-
-  /**
-   * Simple TOML parser for our specific use case
-   * This is a minimal parser that handles the MCP server config structure
-   */
-  parseToml(content) {
-    const config = {};
-    let currentSection = null;
-    let currentSubsection = null;
-    
-    const lines = content.split('\n');
-    
-    for (const line of lines) {
-      const trimmed = line.trim();
-      
-      // Skip comments and empty lines
-      if (!trimmed || trimmed.startsWith('#')) {
-        continue;
-      }
-      
-      // Section header: [section]
-      const sectionMatch = trimmed.match(/^\[([^\]]+)\]$/);
-      if (sectionMatch) {
-        const sectionName = sectionMatch[1];
-        const parts = sectionName.split('.');
-        
-        if (parts.length === 1) {
-          currentSection = parts[0];
-          currentSubsection = null;
-          if (!config[currentSection]) {
-            config[currentSection] = {};
-          }
-        } else if (parts.length === 2) {
-          currentSection = parts[0];
-          currentSubsection = parts[1];
-          if (!config[currentSection]) {
-            config[currentSection] = {};
-          }
-          if (!config[currentSection][currentSubsection]) {
-            config[currentSection][currentSubsection] = {};
-          }
-        }
-        continue;
-      }
-      
-      // Key-value pair: key = value
-      const kvMatch = trimmed.match(/^([^=]+)=(.+)$/);
-      if (kvMatch) {
-        const key = kvMatch[1].trim();
-        let value = kvMatch[2].trim();
-        
-        // Remove quotes if present
-        if ((value.startsWith('"') && value.endsWith('"')) ||
-            (value.startsWith("'") && value.endsWith("'"))) {
-          value = value.slice(1, -1);
-        }
-        
-        // Parse boolean
-        if (value === 'true') value = true;
-        else if (value === 'false') value = false;
-        // Parse number
-        else if (/^-?\d+$/.test(value)) value = parseInt(value, 10);
-        else if (/^-?\d+\.\d+$/.test(value)) value = parseFloat(value);
-        
-        if (currentSubsection) {
-          if (!config[currentSection][currentSubsection]) {
-            config[currentSection][currentSubsection] = {};
-          }
-          config[currentSection][currentSubsection][key] = value;
-        } else if (currentSection) {
-          if (!config[currentSection]) {
-            config[currentSection] = {};
-          }
-          config[currentSection][key] = value;
-        } else {
-          config[key] = value;
-        }
-      }
-    }
-    
-    return config;
-  }
-
-  /**
-   * Convert config object back to TOML format
-   */
-  stringifyToml(config, indent = 0) {
-    const indentStr = ' '.repeat(indent);
-    let result = '';
-    
-    for (const [key, value] of Object.entries(config)) {
-      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-        // Section
-        result += `${indentStr}[${key}]\n`;
-        result += this.stringifyToml(value, indent);
-      } else {
-        // Key-value
-        let valueStr = value;
-        if (typeof value === 'string') {
-          // Escape quotes and wrap in quotes if needed
-          if (value.includes('"') || value.includes("'") || value.includes(' ')) {
-            valueStr = `"${value.replace(/"/g, '\\"')}"`;
-          }
-        } else if (typeof value === 'boolean') {
-          valueStr = value.toString();
-        }
-        result += `${indentStr}${key} = ${valueStr}\n`;
-      }
-    }
-    
-    return result;
-  }
-
-  /**
-   * Configure the automaker-tools MCP server
-   */
-  async configureMcpServer(projectPath, mcpServerScriptPath) {
-    this.setProjectPath(projectPath);
-    const configPath = await this.getConfigPath();
-    
-    // Read existing config
-    const config = await this.readConfig(configPath);
-    
-    // Ensure mcp_servers section exists
-    if (!config.mcp_servers) {
-      config.mcp_servers = {};
-    }
-    
-    // Configure automaker-tools server
-    config.mcp_servers['automaker-tools'] = {
-      command: 'node',
-      args: [mcpServerScriptPath],
-      env: {
-        AUTOMAKER_PROJECT_PATH: projectPath
-      },
-      startup_timeout_sec: 10,
-      tool_timeout_sec: 60,
-      enabled_tools: ['UpdateFeatureStatus']
-    };
-    
-    // Ensure experimental_use_rmcp_client is enabled (if needed)
-    if (!config.experimental_use_rmcp_client) {
-      config.experimental_use_rmcp_client = true;
-    }
-    
-    // Write config back
-    await this.writeConfig(configPath, config);
-    
-    console.log(`[CodexConfigManager] Configured automaker-tools MCP server in ${configPath}`);
-    return configPath;
-  }
-
-  /**
-   * Write config to TOML file
-   */
-  async writeConfig(configPath, config) {
-    let content = '';
-    
-    // Write top-level keys first (preserve existing non-MCP config)
-    for (const [key, value] of Object.entries(config)) {
-      if (key === 'mcp_servers' || key === 'experimental_use_rmcp_client') {
-        continue; // Handle these separately
-      }
-      if (typeof value !== 'object') {
-        content += `${key} = ${this.formatValue(value)}\n`;
-      }
-    }
-    
-    // Write experimental flag if enabled
-    if (config.experimental_use_rmcp_client) {
-      if (content && !content.endsWith('\n\n')) {
-        content += '\n';
-      }
-      content += `experimental_use_rmcp_client = true\n`;
-    }
-    
-    // Write mcp_servers section
-    if (config.mcp_servers && Object.keys(config.mcp_servers).length > 0) {
-      if (content && !content.endsWith('\n\n')) {
-        content += '\n';
-      }
-      
-      for (const [serverName, serverConfig] of Object.entries(config.mcp_servers)) {
-        content += `\n[mcp_servers.${serverName}]\n`;
-        
-        // Write command first
-        if (serverConfig.command) {
-          content += `command = "${this.escapeTomlString(serverConfig.command)}"\n`;
-        }
-        
-        // Write args
-        if (serverConfig.args && Array.isArray(serverConfig.args)) {
-          const argsStr = serverConfig.args.map(a => `"${this.escapeTomlString(a)}"`).join(', ');
-          content += `args = [${argsStr}]\n`;
-        }
-        
-        // Write timeouts (must be before env subsection)
-        if (serverConfig.startup_timeout_sec !== undefined) {
-          content += `startup_timeout_sec = ${serverConfig.startup_timeout_sec}\n`;
-        }
-        
-        if (serverConfig.tool_timeout_sec !== undefined) {
-          content += `tool_timeout_sec = ${serverConfig.tool_timeout_sec}\n`;
-        }
-        
-        // Write enabled_tools (must be before env subsection - at server level, not env level)
-        if (serverConfig.enabled_tools && Array.isArray(serverConfig.enabled_tools)) {
-          const toolsStr = serverConfig.enabled_tools.map(t => `"${this.escapeTomlString(t)}"`).join(', ');
-          content += `enabled_tools = [${toolsStr}]\n`;
-        }
-        
-        // Write env section last (as a separate subsection)
-        // IMPORTANT: In TOML, once we start [mcp_servers.server_name.env], 
-        // everything after belongs to that subsection until a new section starts
-        if (serverConfig.env && typeof serverConfig.env === 'object' && Object.keys(serverConfig.env).length > 0) {
-          content += `\n[mcp_servers.${serverName}.env]\n`;
-          for (const [envKey, envValue] of Object.entries(serverConfig.env)) {
-            content += `${envKey} = "${this.escapeTomlString(String(envValue))}"\n`;
-          }
-        }
-      }
-    }
-    
-    // Ensure directory exists
-    const configDir = path.dirname(configPath);
-    await fs.mkdir(configDir, { recursive: true });
-    
-    // Write file
-    await fs.writeFile(configPath, content, 'utf-8');
-  }
-
-  /**
-   * Escape special characters in TOML strings
-   */
-  escapeTomlString(str) {
-    return str
-      .replace(/\\/g, '\\\\')
-      .replace(/"/g, '\\"')
-      .replace(/\n/g, '\\n')
-      .replace(/\r/g, '\\r')
-      .replace(/\t/g, '\\t');
-  }
-
-  /**
-   * Format a value for TOML output
-   */
-  formatValue(value) {
-    if (typeof value === 'string') {
-      // Escape quotes
-      const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-      return `"${escaped}"`;
-    } else if (typeof value === 'boolean') {
-      return value.toString();
-    } else if (typeof value === 'number') {
-      return value.toString();
-    }
-    return `"${String(value)}"`;
-  }
-
-  /**
-   * Remove automaker-tools MCP server configuration
-   */
-  async removeMcpServer(projectPath) {
-    this.setProjectPath(projectPath);
-    const configPath = await this.getConfigPath();
-    
-    try {
-      const config = await this.readConfig(configPath);
-      
-      if (config.mcp_servers && config.mcp_servers['automaker-tools']) {
-        delete config.mcp_servers['automaker-tools'];
-        
-        // If no more MCP servers, remove the section
-        if (Object.keys(config.mcp_servers).length === 0) {
-          delete config.mcp_servers;
-        }
-        
-        await this.writeConfig(configPath, config);
-        console.log(`[CodexConfigManager] Removed automaker-tools MCP server from ${configPath}`);
-      }
-    } catch (e) {
-      console.error(`[CodexConfigManager] Error removing MCP server config:`, e);
-    }
-  }
-}
-
-module.exports = new CodexConfigManager();

app/electron/services/codex-executor.js

@@ -1,610 +0,0 @@
-/**
- * Codex CLI Execution Wrapper
- *
- * This module handles spawning and managing Codex CLI processes
- * for executing OpenAI model queries.
- */
-
-const { spawn } = require('child_process');
-const { EventEmitter } = require('events');
-const readline = require('readline');
-const path = require('path');
-const CodexCliDetector = require('./codex-cli-detector');
-const codexConfigManager = require('./codex-config-manager');
-
-/**
- * Message types from Codex CLI JSON output
- */
-const CODEX_EVENT_TYPES = {
-  THREAD_STARTED: 'thread.started',
-  ITEM_STARTED: 'item.started',
-  ITEM_COMPLETED: 'item.completed',
-  THREAD_COMPLETED: 'thread.completed',
-  ERROR: 'error'
-};
-
-/**
- * Codex Executor - Manages Codex CLI process execution
- */
-class CodexExecutor extends EventEmitter {
-  constructor() {
-    super();
-    this.currentProcess = null;
-    this.codexPath = null;
-  }
-
-  /**
-   * Find and cache the Codex CLI path
-   * @returns {string|null} Path to codex executable
-   */
-  findCodexPath() {
-    if (this.codexPath) {
-      return this.codexPath;
-    }
-
-    const installation = CodexCliDetector.detectCodexInstallation();
-    if (installation.installed && installation.path) {
-      this.codexPath = installation.path;
-      return this.codexPath;
-    }
-
-    return null;
-  }
-
-  /**
-   * Execute a Codex CLI query
-   * @param {Object} options Execution options
-   * @param {string} options.prompt The prompt to execute
-   * @param {string} options.model Model to use (default: gpt-5.1-codex-max)
-   * @param {string} options.cwd Working directory
-   * @param {string} options.systemPrompt System prompt (optional, will be prepended to prompt)
-   * @param {number} options.maxTurns Not used - Codex CLI doesn't support this parameter
-   * @param {string[]} options.allowedTools Not used - Codex CLI doesn't support this parameter
-   * @param {Object} options.env Environment variables
-   * @param {Object} options.mcpServers MCP servers configuration (for configuring Codex TOML)
-   * @returns {AsyncGenerator} Generator yielding messages
-   */
-  async *execute(options) {
-    const {
-      prompt,
-      model = 'gpt-5.1-codex-max',
-      cwd = process.cwd(),
-      systemPrompt,
-      maxTurns, // Not used by Codex CLI
-      allowedTools, // Not used by Codex CLI
-      env = {},
-      mcpServers = null
-    } = options;
-
-    const codexPath = this.findCodexPath();
-    if (!codexPath) {
-      yield {
-        type: 'error',
-        error: 'Codex CLI not found. Please install it with: npm install -g @openai/codex@latest'
-      };
-      return;
-    }
-
-    // Configure MCP server if provided
-    if (mcpServers && mcpServers['automaker-tools']) {
-      try {
-        // Get the absolute path to the MCP server script
-        const mcpServerScriptPath = path.resolve(__dirname, 'mcp-server-stdio.js');
-        
-        // Verify the script exists
-        const fs = require('fs');
-        if (!fs.existsSync(mcpServerScriptPath)) {
-          console.warn(`[CodexExecutor] MCP server script not found at ${mcpServerScriptPath}, skipping MCP configuration`);
-        } else {
-          // Configure Codex TOML to use the MCP server
-          await codexConfigManager.configureMcpServer(cwd, mcpServerScriptPath);
-          console.log('[CodexExecutor] Configured automaker-tools MCP server for Codex CLI');
-        }
-      } catch (error) {
-        console.error('[CodexExecutor] Failed to configure MCP server:', error);
-        // Continue execution even if MCP config fails - Codex will work without MCP tools
-      }
-    }
-
-    // Combine system prompt with main prompt if provided
-    // Codex CLI doesn't support --system-prompt argument, so we prepend it to the prompt
-    let combinedPrompt = prompt;
-    console.log('[CodexExecutor] Original prompt length:', prompt?.length || 0);
-    if (systemPrompt) {
-      combinedPrompt = `${systemPrompt}\n\n---\n\n${prompt}`;
-      console.log('[CodexExecutor] System prompt prepended to main prompt');
-      console.log('[CodexExecutor] System prompt length:', systemPrompt.length);
-      console.log('[CodexExecutor] Combined prompt length:', combinedPrompt.length);
-    }
-
-    // Build command arguments
-    // Note: maxTurns and allowedTools are not supported by Codex CLI
-    console.log('[CodexExecutor] Building command arguments...');
-    const args = this.buildArgs({
-      prompt: combinedPrompt,
-      model
-    });
-
-    console.log('[CodexExecutor] Executing command:', codexPath);
-    console.log('[CodexExecutor] Number of args:', args.length);
-    console.log('[CodexExecutor] Args (without prompt):', args.slice(0, -1).join(' '));
-    console.log('[CodexExecutor] Prompt length in args:', args[args.length - 1]?.length || 0);
-    console.log('[CodexExecutor] Prompt preview (first 200 chars):', args[args.length - 1]?.substring(0, 200));
-    console.log('[CodexExecutor] Working directory:', cwd);
-
-    // Spawn the process
-    const processEnv = {
-      ...process.env,
-      ...env,
-      // Ensure OPENAI_API_KEY is available
-      OPENAI_API_KEY: env.OPENAI_API_KEY || process.env.OPENAI_API_KEY
-    };
-
-    // Log API key status (without exposing the key)
-    if (processEnv.OPENAI_API_KEY) {
-      console.log('[CodexExecutor] OPENAI_API_KEY is set (length:', processEnv.OPENAI_API_KEY.length, ')');
-    } else {
-      console.warn('[CodexExecutor] WARNING: OPENAI_API_KEY is not set!');
-    }
-
-    console.log('[CodexExecutor] Spawning process...');
-    const proc = spawn(codexPath, args, {
-      cwd,
-      env: processEnv,
-      stdio: ['pipe', 'pipe', 'pipe']
-    });
-
-    this.currentProcess = proc;
-    console.log('[CodexExecutor] Process spawned with PID:', proc.pid);
-
-    // Track process events
-    proc.on('error', (error) => {
-      console.error('[CodexExecutor] Process error:', error);
-    });
-
-    proc.on('spawn', () => {
-      console.log('[CodexExecutor] Process spawned successfully');
-    });
-
-    // Collect stderr output as it comes in
-    let stderr = '';
-    let hasOutput = false;
-    let stdoutChunks = [];
-    let stderrChunks = [];
-    
-    proc.stderr.on('data', (data) => {
-      const errorText = data.toString();
-      stderr += errorText;
-      stderrChunks.push(errorText);
-      hasOutput = true;
-      console.error('[CodexExecutor] stderr chunk received (', data.length, 'bytes):', errorText.substring(0, 200));
-    });
-
-    proc.stderr.on('end', () => {
-      console.log('[CodexExecutor] stderr stream ended. Total chunks:', stderrChunks.length, 'Total length:', stderr.length);
-    });
-
-    proc.stdout.on('data', (data) => {
-      const text = data.toString();
-      stdoutChunks.push(text);
-      hasOutput = true;
-      console.log('[CodexExecutor] stdout chunk received (', data.length, 'bytes):', text.substring(0, 200));
-    });
-
-    proc.stdout.on('end', () => {
-      console.log('[CodexExecutor] stdout stream ended. Total chunks:', stdoutChunks.length);
-    });
-
-    // Create readline interface for parsing JSONL output
-    console.log('[CodexExecutor] Creating readline interface...');
-    const rl = readline.createInterface({
-      input: proc.stdout,
-      crlfDelay: Infinity
-    });
-
-    // Track accumulated content for converting to Claude format
-    let accumulatedText = '';
-    let toolUses = [];
-    let lastOutputTime = Date.now();
-    const OUTPUT_TIMEOUT = 30000; // 30 seconds timeout for no output
-    let lineCount = 0;
-    let jsonParseErrors = 0;
-
-    // Set up timeout check
-    const checkTimeout = setInterval(() => {
-      const timeSinceLastOutput = Date.now() - lastOutputTime;
-      if (timeSinceLastOutput > OUTPUT_TIMEOUT && !hasOutput) {
-        console.warn('[CodexExecutor] No output received for', timeSinceLastOutput, 'ms. Process still alive:', !proc.killed);
-      }
-    }, 5000);
-
-    console.log('[CodexExecutor] Starting to read lines from stdout...');
-
-    // Process stdout line by line (JSONL format)
-    try {
-      for await (const line of rl) {
-        hasOutput = true;
-        lastOutputTime = Date.now();
-        lineCount++;
-        
-        console.log('[CodexExecutor] Line', lineCount, 'received (length:', line.length, '):', line.substring(0, 100));
-        
-        if (!line.trim()) {
-          console.log('[CodexExecutor] Skipping empty line');
-          continue;
-        }
-
-        try {
-          const event = JSON.parse(line);
-          console.log('[CodexExecutor] Successfully parsed JSON event. Type:', event.type, 'Keys:', Object.keys(event));
-          
-          const convertedMsg = this.convertToClaudeFormat(event);
-          console.log('[CodexExecutor] Converted message:', convertedMsg ? { type: convertedMsg.type } : 'null');
-
-          if (convertedMsg) {
-            // Accumulate text content
-            if (convertedMsg.type === 'assistant' && convertedMsg.message?.content) {
-              for (const block of convertedMsg.message.content) {
-                if (block.type === 'text') {
-                  accumulatedText += block.text;
-                  console.log('[CodexExecutor] Accumulated text block (total length:', accumulatedText.length, ')');
-                } else if (block.type === 'tool_use') {
-                  toolUses.push(block);
-                  console.log('[CodexExecutor] Tool use detected:', block.name);
-                }
-              }
-            }
-            console.log('[CodexExecutor] Yielding message of type:', convertedMsg.type);
-            yield convertedMsg;
-          } else {
-            console.log('[CodexExecutor] Converted message is null, skipping');
-          }
-        } catch (parseError) {
-          jsonParseErrors++;
-          // Non-JSON output, yield as text
-          console.log('[CodexExecutor] JSON parse error (', jsonParseErrors, 'total):', parseError.message);
-          console.log('[CodexExecutor] Non-JSON line content:', line.substring(0, 200));
-          yield {
-            type: 'assistant',
-            message: {
-              content: [{ type: 'text', text: line + '\n' }]
-            }
-          };
-        }
-      }
-      
-      console.log('[CodexExecutor] Finished reading all lines. Total lines:', lineCount, 'JSON errors:', jsonParseErrors);
-    } catch (readError) {
-      console.error('[CodexExecutor] Error reading from readline:', readError);
-      throw readError;
-    } finally {
-      clearInterval(checkTimeout);
-      console.log('[CodexExecutor] Cleaned up timeout checker');
-    }
-
-    // Handle process completion
-    console.log('[CodexExecutor] Waiting for process to close...');
-    const exitCode = await new Promise((resolve) => {
-      proc.on('close', (code, signal) => {
-        console.log('[CodexExecutor] Process closed with code:', code, 'signal:', signal);
-        resolve(code);
-      });
-    });
-
-    this.currentProcess = null;
-    console.log('[CodexExecutor] Process completed. Exit code:', exitCode, 'Has output:', hasOutput, 'Stderr length:', stderr.length);
-
-    // Wait a bit for any remaining stderr data to be collected
-    console.log('[CodexExecutor] Waiting 200ms for any remaining stderr data...');
-    await new Promise(resolve => setTimeout(resolve, 200));
-    console.log('[CodexExecutor] Final stderr length:', stderr.length, 'Final stdout chunks:', stdoutChunks.length);
-
-    if (exitCode !== 0) {
-      const errorMessage = stderr.trim() 
-        ? `Codex CLI exited with code ${exitCode}.\n\nError output:\n${stderr}`
-        : `Codex CLI exited with code ${exitCode}. No error output captured.`;
-      
-      console.error('[CodexExecutor] Process failed with exit code', exitCode);
-      console.error('[CodexExecutor] Error message:', errorMessage);
-      console.error('[CodexExecutor] Stderr chunks:', stderrChunks.length, 'Stdout chunks:', stdoutChunks.length);
-      
-      yield {
-        type: 'error',
-        error: errorMessage
-      };
-    } else if (!hasOutput && !stderr) {
-      // Process exited successfully but produced no output - might be API key issue
-      const warningMessage = 'Codex CLI completed but produced no output. This might indicate:\n' +
-        '- Missing or invalid OPENAI_API_KEY\n' +
-        '- Codex CLI configuration issue\n' +
-        '- The process completed without generating any response\n\n' +
-        `Debug info: Exit code ${exitCode}, stdout chunks: ${stdoutChunks.length}, stderr chunks: ${stderrChunks.length}, lines read: ${lineCount}`;
-      
-      console.warn('[CodexExecutor] No output detected:', warningMessage);
-      console.warn('[CodexExecutor] Stdout chunks:', stdoutChunks);
-      console.warn('[CodexExecutor] Stderr chunks:', stderrChunks);
-      
-      yield {
-        type: 'error',
-        error: warningMessage
-      };
-    } else {
-      console.log('[CodexExecutor] Process completed successfully. Exit code:', exitCode, 'Lines processed:', lineCount);
-    }
-  }
-
-  /**
-   * Build command arguments for Codex CLI
-   * Only includes supported arguments based on Codex CLI help:
-   * - --model: Model to use
-   * - --json: JSON output format
-   * - --full-auto: Non-interactive automatic execution
-   * 
-   * Note: Codex CLI does NOT support:
-   * - --system-prompt (system prompt is prepended to main prompt)
-   * - --max-turns (not available in CLI)
-   * - --tools (not available in CLI)
-   * 
-   * @param {Object} options Options
-   * @returns {string[]} Command arguments
-   */
-  buildArgs(options) {
-    const { prompt, model } = options;
-
-    console.log('[CodexExecutor] buildArgs called with model:', model, 'prompt length:', prompt?.length || 0);
-
-    const args = ['exec'];
-
-    // Add model (required for most use cases)
-    if (model) {
-      args.push('--model', model);
-      console.log('[CodexExecutor] Added model argument:', model);
-    }
-
-    // Add JSON output flag for structured parsing
-    args.push('--json');
-    console.log('[CodexExecutor] Added --json flag');
-
-    // Add full-auto mode (non-interactive)
-    // This enables automatic execution with workspace-write sandbox
-    args.push('--full-auto');
-    console.log('[CodexExecutor] Added --full-auto flag');
-
-    // Add the prompt at the end
-    args.push(prompt);
-    console.log('[CodexExecutor] Added prompt (length:', prompt?.length || 0, ')');
-
-    console.log('[CodexExecutor] Final args count:', args.length);
-    return args;
-  }
-
-  /**
-   * Map Claude tool names to Codex tool names
-   * @param {string[]} tools Array of tool names
-   * @returns {string[]} Mapped tool names
-   */
-  mapToolsToCodex(tools) {
-    const toolMap = {
-      'Read': 'read',
-      'Write': 'write',
-      'Edit': 'edit',
-      'Bash': 'bash',
-      'Glob': 'glob',
-      'Grep': 'grep',
-      'WebSearch': 'web-search',
-      'WebFetch': 'web-fetch'
-    };
-
-    return tools
-      .map(tool => toolMap[tool] || tool.toLowerCase())
-      .filter(tool => tool); // Remove undefined
-  }
-
-  /**
-   * Convert Codex JSONL event to Claude SDK message format
-   * @param {Object} event Codex event object
-   * @returns {Object|null} Claude-format message or null
-   */
-  convertToClaudeFormat(event) {
-    console.log('[CodexExecutor] Converting event:', JSON.stringify(event).substring(0, 200));
-    const { type, data, item, thread_id } = event;
-
-    switch (type) {
-      case CODEX_EVENT_TYPES.THREAD_STARTED:
-      case 'thread.started':
-        // Session initialization
-        return {
-          type: 'session_start',
-          sessionId: thread_id || data?.thread_id || event.thread_id
-        };
-
-      case CODEX_EVENT_TYPES.ITEM_COMPLETED:
-      case 'item.completed':
-        // Codex uses 'item' field, not 'data'
-        return this.convertItemCompleted(item || data);
-
-      case CODEX_EVENT_TYPES.ITEM_STARTED:
-      case 'item.started':
-        // Convert item.started events - these indicate tool/command usage
-        const startedItem = item || data;
-        if (startedItem?.type === 'command_execution' && startedItem?.command) {
-          return {
-            type: 'assistant',
-            message: {
-              content: [{
-                type: 'tool_use',
-                name: 'bash',
-                input: { command: startedItem.command }
-              }]
-            }
-          };
-        }
-        // For other item.started types, return null (we'll show the completed version)
-        return null;
-
-      case CODEX_EVENT_TYPES.THREAD_COMPLETED:
-      case 'thread.completed':
-        return {
-          type: 'complete',
-          sessionId: thread_id || data?.thread_id || event.thread_id
-        };
-
-      case CODEX_EVENT_TYPES.ERROR:
-      case 'error':
-        return {
-          type: 'error',
-          error: data?.message || item?.message || event.message || 'Unknown error from Codex CLI'
-        };
-
-      case 'turn.started':
-        // Turn started - just a marker, no need to convert
-        return null;
-
-      default:
-        // Pass through other events
-        console.log('[CodexExecutor] Unhandled event type:', type);
-        return null;
-    }
-  }
-
-  /**
-   * Convert item.completed event to Claude format
-   * @param {Object} item Event item data
-   * @returns {Object|null} Claude-format message
-   */
-  convertItemCompleted(item) {
-    if (!item) {
-      console.log('[CodexExecutor] convertItemCompleted: item is null/undefined');
-      return null;
-    }
-
-    const itemType = item.type || item.item_type;
-    console.log('[CodexExecutor] convertItemCompleted: itemType =', itemType, 'item keys:', Object.keys(item));
-
-    switch (itemType) {
-      case 'reasoning':
-        // Thinking/reasoning output - Codex uses 'text' field
-        const reasoningText = item.text || item.content || '';
-        console.log('[CodexExecutor] Converting reasoning, text length:', reasoningText.length);
-        return {
-          type: 'assistant',
-          message: {
-            content: [{
-              type: 'thinking',
-              thinking: reasoningText
-            }]
-          }
-        };
-
-      case 'agent_message':
-      case 'message':
-        // Assistant text message
-        const messageText = item.content || item.text || '';
-        console.log('[CodexExecutor] Converting message, text length:', messageText.length);
-        return {
-          type: 'assistant',
-          message: {
-            content: [{
-              type: 'text',
-              text: messageText
-            }]
-          }
-        };
-
-      case 'command_execution':
-        // Command execution - show both the command and its output
-        const command = item.command || '';
-        const output = item.aggregated_output || item.output || '';
-        console.log('[CodexExecutor] Converting command_execution, command:', command.substring(0, 50), 'output length:', output.length);
-        
-        // Return as text message showing the command and output
-        return {
-          type: 'assistant',
-          message: {
-            content: [{
-              type: 'text',
-              text: `\`\`\`bash\n${command}\n\`\`\`\n\n${output}`
-            }]
-          }
-        };
-
-      case 'tool_use':
-        // Tool use
-        return {
-          type: 'assistant',
-          message: {
-            content: [{
-              type: 'tool_use',
-              name: item.tool || item.command || 'unknown',
-              input: item.input || item.args || {}
-            }]
-          }
-        };
-
-      case 'tool_result':
-        // Tool result
-        return {
-          type: 'tool_result',
-          tool_use_id: item.tool_use_id,
-          content: item.output || item.result
-        };
-
-      case 'todo_list':
-        // Todo list - convert to text format
-        const todos = item.items || [];
-        const todoText = todos.map((t, i) => `${i + 1}. ${t.text || t}`).join('\n');
-        console.log('[CodexExecutor] Converting todo_list, items:', todos.length);
-        return {
-          type: 'assistant',
-          message: {
-            content: [{
-              type: 'text',
-              text: `**Todo List:**\n${todoText}`
-            }]
-          }
-        };
-
-      default:
-        // Generic text output
-        const text = item.text || item.content || item.aggregated_output;
-        if (text) {
-          console.log('[CodexExecutor] Converting default item type, text length:', text.length);
-          return {
-            type: 'assistant',
-            message: {
-              content: [{
-                type: 'text',
-                text: String(text)
-              }]
-            }
-          };
-        }
-        console.log('[CodexExecutor] convertItemCompleted: No text content found, returning null');
-        return null;
-    }
-  }
-
-  /**
-   * Abort current execution
-   */
-  abort() {
-    if (this.currentProcess) {
-      console.log('[CodexExecutor] Aborting current process');
-      this.currentProcess.kill('SIGTERM');
-      this.currentProcess = null;
-    }
-  }
-
-  /**
-   * Check if execution is in progress
-   * @returns {boolean} Whether execution is in progress
-   */
-  isRunning() {
-    return this.currentProcess !== null;
-  }
-}
-
-// Singleton instance
-const codexExecutor = new CodexExecutor();
-
-module.exports = codexExecutor;

app/electron/services/context-manager.js

@@ -1,400 +0,0 @@
-const path = require("path");
-const fs = require("fs/promises");
-
-/**
- * Context Manager - Handles reading, writing, and deleting context files for features
- */
-class ContextManager {
-  /**
-   * Write output to feature context file
-   */
-  async writeToContextFile(projectPath, featureId, content) {
-    if (!projectPath) return;
-
-    try {
-      const contextDir = path.join(projectPath, ".automaker", "agents-context");
-
-      // Ensure directory exists
-      try {
-        await fs.access(contextDir);
-      } catch {
-        await fs.mkdir(contextDir, { recursive: true });
-      }
-
-      const filePath = path.join(contextDir, `${featureId}.md`);
-
-      // Append to existing file or create new one
-      try {
-        const existing = await fs.readFile(filePath, "utf-8");
-        await fs.writeFile(filePath, existing + content, "utf-8");
-      } catch {
-        await fs.writeFile(filePath, content, "utf-8");
-      }
-    } catch (error) {
-      console.error("[ContextManager] Failed to write to context file:", error);
-    }
-  }
-
-  /**
-   * Read context file for a feature
-   */
-  async readContextFile(projectPath, featureId) {
-    try {
-      const contextPath = path.join(
-        projectPath,
-        ".automaker",
-        "agents-context",
-        `${featureId}.md`
-      );
-      const content = await fs.readFile(contextPath, "utf-8");
-      return content;
-    } catch (error) {
-      console.log(`[ContextManager] No context file found for ${featureId}`);
-      return null;
-    }
-  }
-
-  /**
-   * Delete agent context file for a feature
-   */
-  async deleteContextFile(projectPath, featureId) {
-    if (!projectPath) return;
-
-    try {
-      const contextPath = path.join(
-        projectPath,
-        ".automaker",
-        "agents-context",
-        `${featureId}.md`
-      );
-      await fs.unlink(contextPath);
-      console.log(
-        `[ContextManager] Deleted agent context for feature ${featureId}`
-      );
-    } catch (error) {
-      // File might not exist, which is fine
-      if (error.code !== "ENOENT") {
-        console.error("[ContextManager] Failed to delete context file:", error);
-      }
-    }
-  }
-
-  /**
-   * Read the memory.md file containing lessons learned and common issues
-   * Returns formatted string to inject into prompts
-   */
-  async getMemoryContent(projectPath) {
-    if (!projectPath) return "";
-
-    try {
-      const memoryPath = path.join(projectPath, ".automaker", "memory.md");
-
-      // Check if file exists
-      try {
-        await fs.access(memoryPath);
-      } catch {
-        // File doesn't exist, return empty string
-        return "";
-      }
-
-      const content = await fs.readFile(memoryPath, "utf-8");
-
-      if (!content.trim()) {
-        return "";
-      }
-
-      return `
-**🧠 Agent Memory - Previous Lessons Learned:**
-
-The following memory file contains lessons learned from previous agent runs, including common issues and their solutions. Review this carefully to avoid repeating past mistakes.
-
-<agent-memory>
-${content}
-</agent-memory>
-
-**IMPORTANT:** If you encounter a new issue that took significant debugging effort to resolve, add it to the memory file at \`.automaker/memory.md\` in a concise format:
-- Issue title
-- Problem description (1-2 sentences)
-- Solution/fix (with code example if helpful)
-
-This helps future agent runs avoid the same pitfalls.
-`;
-    } catch (error) {
-      console.error("[ContextManager] Failed to read memory file:", error);
-      return "";
-    }
-  }
-
-  /**
-   * List context files from .automaker/context/ directory and get previews
-   * Returns a formatted string with file names and first 50 lines of each file
-   */
-  async getContextFilesPreview(projectPath) {
-    if (!projectPath) return "";
-
-    try {
-      const contextDir = path.join(projectPath, ".automaker", "context");
-
-      // Check if directory exists
-      try {
-        await fs.access(contextDir);
-      } catch {
-        // Directory doesn't exist, return empty string
-        return "";
-      }
-
-      // Read directory contents
-      const entries = await fs.readdir(contextDir, { withFileTypes: true });
-      const files = entries
-        .filter((entry) => entry.isFile())
-        .map((entry) => entry.name)
-        .sort();
-
-      if (files.length === 0) {
-        return "";
-      }
-
-      // Build preview string
-      const previews = [];
-      previews.push(`\n**📁 Context Files Available:**\n`);
-      previews.push(
-        `The following context files are available in \`.automaker/context/\` directory.`
-      );
-      previews.push(
-        `These files contain additional context that may be relevant to your work.`
-      );
-      previews.push(
-        `You can read them in full using the Read tool if needed.\n`
-      );
-
-      for (const fileName of files) {
-        try {
-          const filePath = path.join(contextDir, fileName);
-          const content = await fs.readFile(filePath, "utf-8");
-          const lines = content.split("\n");
-          const previewLines = lines.slice(0, 50);
-          const preview = previewLines.join("\n");
-          const hasMore = lines.length > 50;
-
-          previews.push(`\n**File: ${fileName}**`);
-          if (hasMore) {
-            previews.push(
-              `(Showing first 50 of ${lines.length} lines - use Read tool to see full content)`
-            );
-          }
-          previews.push(`\`\`\``);
-          previews.push(preview);
-          previews.push(`\`\`\`\n`);
-        } catch (error) {
-          console.error(
-            `[ContextManager] Failed to read context file ${fileName}:`,
-            error
-          );
-          previews.push(`\n**File: ${fileName}** (Error reading file)\n`);
-        }
-      }
-
-      return previews.join("\n");
-    } catch (error) {
-      console.error("[ContextManager] Failed to list context files:", error);
-      return "";
-    }
-  }
-
-  /**
-   * Save the initial git state before a feature starts executing
-   * This captures all files that were already modified before the AI agent started
-   * @param {string} projectPath - Path to the project
-   * @param {string} featureId - Feature ID
-   * @returns {Promise<{modifiedFiles: string[], untrackedFiles: string[]}>}
-   */
-  async saveInitialGitState(projectPath, featureId) {
-    if (!projectPath) return { modifiedFiles: [], untrackedFiles: [] };
-
-    try {
-      const { execSync } = require("child_process");
-      const contextDir = path.join(projectPath, ".automaker", "agents-context");
-
-      // Ensure directory exists
-      try {
-        await fs.access(contextDir);
-      } catch {
-        await fs.mkdir(contextDir, { recursive: true });
-      }
-
-      // Get list of modified files (both staged and unstaged)
-      let modifiedFiles = [];
-      try {
-        const modifiedOutput = execSync("git diff --name-only HEAD", {
-          cwd: projectPath,
-          encoding: "utf-8",
-        }).trim();
-        if (modifiedOutput) {
-          modifiedFiles = modifiedOutput.split("\n").filter(Boolean);
-        }
-      } catch (error) {
-        console.log("[ContextManager] No modified files or git error:", error.message);
-      }
-
-      // Get list of untracked files
-      let untrackedFiles = [];
-      try {
-        const untrackedOutput = execSync("git ls-files --others --exclude-standard", {
-          cwd: projectPath,
-          encoding: "utf-8",
-        }).trim();
-        if (untrackedOutput) {
-          untrackedFiles = untrackedOutput.split("\n").filter(Boolean);
-        }
-      } catch (error) {
-        console.log("[ContextManager] Error getting untracked files:", error.message);
-      }
-
-      // Save the initial state to a JSON file
-      const stateFile = path.join(contextDir, `${featureId}-git-state.json`);
-      const state = {
-        timestamp: new Date().toISOString(),
-        modifiedFiles,
-        untrackedFiles,
-      };
-
-      await fs.writeFile(stateFile, JSON.stringify(state, null, 2), "utf-8");
-      console.log(`[ContextManager] Saved initial git state for ${featureId}:`, {
-        modifiedCount: modifiedFiles.length,
-        untrackedCount: untrackedFiles.length,
-      });
-
-      return state;
-    } catch (error) {
-      console.error("[ContextManager] Failed to save initial git state:", error);
-      return { modifiedFiles: [], untrackedFiles: [] };
-    }
-  }
-
-  /**
-   * Get the initial git state saved before a feature started executing
-   * @param {string} projectPath - Path to the project
-   * @param {string} featureId - Feature ID
-   * @returns {Promise<{modifiedFiles: string[], untrackedFiles: string[], timestamp: string} | null>}
-   */
-  async getInitialGitState(projectPath, featureId) {
-    if (!projectPath) return null;
-
-    try {
-      const stateFile = path.join(
-        projectPath,
-        ".automaker",
-        "agents-context",
-        `${featureId}-git-state.json`
-      );
-      const content = await fs.readFile(stateFile, "utf-8");
-      return JSON.parse(content);
-    } catch (error) {
-      console.log(`[ContextManager] No initial git state found for ${featureId}`);
-      return null;
-    }
-  }
-
-  /**
-   * Delete the git state file for a feature
-   * @param {string} projectPath - Path to the project
-   * @param {string} featureId - Feature ID
-   */
-  async deleteGitStateFile(projectPath, featureId) {
-    if (!projectPath) return;
-
-    try {
-      const stateFile = path.join(
-        projectPath,
-        ".automaker",
-        "agents-context",
-        `${featureId}-git-state.json`
-      );
-      await fs.unlink(stateFile);
-      console.log(`[ContextManager] Deleted git state file for ${featureId}`);
-    } catch (error) {
-      // File might not exist, which is fine
-      if (error.code !== "ENOENT") {
-        console.error("[ContextManager] Failed to delete git state file:", error);
-      }
-    }
-  }
-
-  /**
-   * Calculate which files were changed during the AI session
-   * by comparing current git state with the saved initial state
-   * @param {string} projectPath - Path to the project
-   * @param {string} featureId - Feature ID
-   * @returns {Promise<{newFiles: string[], modifiedFiles: string[]}>}
-   */
-  async getFilesChangedDuringSession(projectPath, featureId) {
-    if (!projectPath) return { newFiles: [], modifiedFiles: [] };
-
-    try {
-      const { execSync } = require("child_process");
-
-      // Get initial state
-      const initialState = await this.getInitialGitState(projectPath, featureId);
-
-      // Get current state
-      let currentModified = [];
-      try {
-        const modifiedOutput = execSync("git diff --name-only HEAD", {
-          cwd: projectPath,
-          encoding: "utf-8",
-        }).trim();
-        if (modifiedOutput) {
-          currentModified = modifiedOutput.split("\n").filter(Boolean);
-        }
-      } catch (error) {
-        console.log("[ContextManager] No modified files or git error");
-      }
-
-      let currentUntracked = [];
-      try {
-        const untrackedOutput = execSync("git ls-files --others --exclude-standard", {
-          cwd: projectPath,
-          encoding: "utf-8",
-        }).trim();
-        if (untrackedOutput) {
-          currentUntracked = untrackedOutput.split("\n").filter(Boolean);
-        }
-      } catch (error) {
-        console.log("[ContextManager] Error getting untracked files");
-      }
-
-      if (!initialState) {
-        // No initial state - all current changes are considered from this session
-        console.log("[ContextManager] No initial state found, returning all current changes");
-        return {
-          newFiles: currentUntracked,
-          modifiedFiles: currentModified,
-        };
-      }
-
-      // Calculate files that are new since the session started
-      const initialModifiedSet = new Set(initialState.modifiedFiles || []);
-      const initialUntrackedSet = new Set(initialState.untrackedFiles || []);
-
-      // New files = current untracked - initial untracked
-      const newFiles = currentUntracked.filter(f => !initialUntrackedSet.has(f));
-
-      // Modified files = current modified - initial modified
-      const modifiedFiles = currentModified.filter(f => !initialModifiedSet.has(f));
-
-      console.log(`[ContextManager] Files changed during session for ${featureId}:`, {
-        newFilesCount: newFiles.length,
-        modifiedFilesCount: modifiedFiles.length,
-        newFiles,
-        modifiedFiles,
-      });
-
-      return { newFiles, modifiedFiles };
-    } catch (error) {
-      console.error("[ContextManager] Failed to calculate changed files:", error);
-      return { newFiles: [], modifiedFiles: [] };
-    }
-  }
-}
-
-module.exports = new ContextManager();

app/electron/services/feature-loader.js

@@ -1,238 +0,0 @@
-const path = require("path");
-const fs = require("fs/promises");
-
-/**
- * Feature Loader - Handles loading and selecting features from feature_list.json
- */
-class FeatureLoader {
-  /**
-   * Load features from .automaker/feature_list.json
-   */
-  async loadFeatures(projectPath) {
-    const featuresPath = path.join(
-      projectPath,
-      ".automaker",
-      "feature_list.json"
-    );
-
-    try {
-      const content = await fs.readFile(featuresPath, "utf-8");
-      const features = JSON.parse(content);
-
-      // Ensure each feature has an ID
-      return features.map((f, index) => ({
-        ...f,
-        id: f.id || `feature-${index}-${Date.now()}`,
-      }));
-    } catch (error) {
-      console.error("[FeatureLoader] Failed to load features:", error);
-      return [];
-    }
-  }
-
-  /**
-   * Update feature status in .automaker/feature_list.json
-   * @param {string} featureId - The ID of the feature to update
-   * @param {string} status - The new status
-   * @param {string} projectPath - Path to the project
-   * @param {string} [summary] - Optional summary of what was done
-   * @param {string} [error] - Optional error message if feature errored
-   */
-  async updateFeatureStatus(featureId, status, projectPath, summary, error) {
-    const featuresPath = path.join(
-      projectPath,
-      ".automaker",
-      "feature_list.json"
-    );
-
-    // 🛡️ SAFETY: Create backup before any modification
-    const backupPath = path.join(
-      projectPath,
-      ".automaker",
-      "feature_list.backup.json"
-    );
-
-    try {
-      const originalContent = await fs.readFile(featuresPath, "utf-8");
-      await fs.writeFile(backupPath, originalContent, "utf-8");
-      console.log(`[FeatureLoader] Created backup at ${backupPath}`);
-    } catch (error) {
-      console.warn(`[FeatureLoader] Could not create backup: ${error.message}`);
-    }
-
-    const features = await this.loadFeatures(projectPath);
-
-    // 🛡️ VALIDATION: Ensure we loaded features successfully
-    if (!Array.isArray(features)) {
-      throw new Error("CRITICAL: features is not an array - aborting to prevent data loss");
-    }
-
-    if (features.length === 0) {
-      console.warn(`[FeatureLoader] WARNING: Feature list is empty. This may indicate corruption.`);
-      // Try to restore from backup
-      try {
-        const backupContent = await fs.readFile(backupPath, "utf-8");
-        const backupFeatures = JSON.parse(backupContent);
-        if (Array.isArray(backupFeatures) && backupFeatures.length > 0) {
-          console.log(`[FeatureLoader] Restored ${backupFeatures.length} features from backup`);
-          // Use backup features instead
-          features.length = 0;
-          features.push(...backupFeatures);
-        }
-      } catch (backupError) {
-        console.error(`[FeatureLoader] Could not restore from backup: ${backupError.message}`);
-      }
-    }
-
-    const feature = features.find((f) => f.id === featureId);
-
-    if (!feature) {
-      console.error(`[FeatureLoader] Feature ${featureId} not found`);
-      return;
-    }
-
-    // Update the status field
-    feature.status = status;
-
-    // Update the summary field if provided
-    if (summary) {
-      feature.summary = summary;
-    }
-
-    // Update the error field (set or clear)
-    if (error) {
-      feature.error = error;
-    } else {
-      // Clear any previous error when status changes without error
-      delete feature.error;
-    }
-
-    // Save back to file
-    const toSave = features.map((f) => {
-      const featureData = {
-        id: f.id,
-        category: f.category,
-        description: f.description,
-        steps: f.steps,
-        status: f.status,
-      };
-      // Preserve optional fields if they exist
-      if (f.skipTests !== undefined) {
-        featureData.skipTests = f.skipTests;
-      }
-      if (f.images !== undefined) {
-        featureData.images = f.images;
-      }
-      if (f.imagePaths !== undefined) {
-        featureData.imagePaths = f.imagePaths;
-      }
-      if (f.startedAt !== undefined) {
-        featureData.startedAt = f.startedAt;
-      }
-      if (f.summary !== undefined) {
-        featureData.summary = f.summary;
-      }
-      if (f.model !== undefined) {
-        featureData.model = f.model;
-      }
-      if (f.thinkingLevel !== undefined) {
-        featureData.thinkingLevel = f.thinkingLevel;
-      }
-      if (f.error !== undefined) {
-        featureData.error = f.error;
-      }
-      // Preserve worktree info
-      if (f.worktreePath !== undefined) {
-        featureData.worktreePath = f.worktreePath;
-      }
-      if (f.branchName !== undefined) {
-        featureData.branchName = f.branchName;
-      }
-      return featureData;
-    });
-
-    // 🛡️ FINAL VALIDATION: Ensure we're not writing an empty array
-    if (!Array.isArray(toSave) || toSave.length === 0) {
-      throw new Error("CRITICAL: Attempted to save empty feature list - aborting to prevent data loss");
-    }
-
-    await fs.writeFile(featuresPath, JSON.stringify(toSave, null, 2), "utf-8");
-    console.log(`[FeatureLoader] Updated feature ${featureId}: status=${status}${summary ? `, summary="${summary}"` : ""}`);
-    console.log(`[FeatureLoader] Successfully saved ${toSave.length} features to feature_list.json`);
-  }
-
-  /**
-   * Select the next feature to implement
-   * Prioritizes: earlier features in the list that are not verified or waiting_approval
-   */
-  selectNextFeature(features) {
-    // Find first feature that is in backlog or in_progress status
-    // Skip verified and waiting_approval (which needs user input)
-    return features.find((f) => f.status !== "verified" && f.status !== "waiting_approval");
-  }
-
-  /**
-   * Update worktree info for a feature
-   * @param {string} featureId - The ID of the feature to update
-   * @param {string} projectPath - Path to the project
-   * @param {string|null} worktreePath - Path to the worktree (null to clear)
-   * @param {string|null} branchName - Name of the feature branch (null to clear)
-   */
-  async updateFeatureWorktree(featureId, projectPath, worktreePath, branchName) {
-    const featuresPath = path.join(
-      projectPath,
-      ".automaker",
-      "feature_list.json"
-    );
-
-    const features = await this.loadFeatures(projectPath);
-
-    if (!Array.isArray(features) || features.length === 0) {
-      console.error("[FeatureLoader] Cannot update worktree: feature list is empty");
-      return;
-    }
-
-    const feature = features.find((f) => f.id === featureId);
-
-    if (!feature) {
-      console.error(`[FeatureLoader] Feature ${featureId} not found`);
-      return;
-    }
-
-    // Update or clear worktree info
-    if (worktreePath) {
-      feature.worktreePath = worktreePath;
-      feature.branchName = branchName;
-    } else {
-      delete feature.worktreePath;
-      delete feature.branchName;
-    }
-
-    // Save back to file (reuse the same mapping logic)
-    const toSave = features.map((f) => {
-      const featureData = {
-        id: f.id,
-        category: f.category,
-        description: f.description,
-        steps: f.steps,
-        status: f.status,
-      };
-      if (f.skipTests !== undefined) featureData.skipTests = f.skipTests;
-      if (f.images !== undefined) featureData.images = f.images;
-      if (f.imagePaths !== undefined) featureData.imagePaths = f.imagePaths;
-      if (f.startedAt !== undefined) featureData.startedAt = f.startedAt;
-      if (f.summary !== undefined) featureData.summary = f.summary;
-      if (f.model !== undefined) featureData.model = f.model;
-      if (f.thinkingLevel !== undefined) featureData.thinkingLevel = f.thinkingLevel;
-      if (f.error !== undefined) featureData.error = f.error;
-      if (f.worktreePath !== undefined) featureData.worktreePath = f.worktreePath;
-      if (f.branchName !== undefined) featureData.branchName = f.branchName;
-      return featureData;
-    });
-
-    await fs.writeFile(featuresPath, JSON.stringify(toSave, null, 2), "utf-8");
-    console.log(`[FeatureLoader] Updated feature ${featureId}: worktreePath=${worktreePath}, branchName=${branchName}`);
-  }
-}
-
-module.exports = new FeatureLoader();

app/electron/services/feature-suggestions-service.js

@@ -1,269 +0,0 @@
-const { query, AbortError } = require("@anthropic-ai/claude-agent-sdk");
-const promptBuilder = require("./prompt-builder");
-
-/**
- * Feature Suggestions Service - Analyzes project and generates feature suggestions
- */
-class FeatureSuggestionsService {
-  constructor() {
-    this.runningAnalysis = null;
-  }
-
-  /**
-   * Generate feature suggestions by analyzing the project
-   */
-  async generateSuggestions(projectPath, sendToRenderer, execution) {
-    console.log(
-      `[FeatureSuggestions] Generating suggestions for: ${projectPath}`
-    );
-
-    try {
-      const abortController = new AbortController();
-      execution.abortController = abortController;
-
-      const options = {
-        model: "claude-sonnet-4-20250514",
-        systemPrompt: this.getSystemPrompt(),
-        maxTurns: 50,
-        cwd: projectPath,
-        allowedTools: ["Read", "Glob", "Grep", "Bash"],
-        permissionMode: "acceptEdits",
-        sandbox: {
-          enabled: true,
-          autoAllowBashIfSandboxed: true,
-        },
-        abortController: abortController,
-      };
-
-      const prompt = this.buildAnalysisPrompt();
-
-      sendToRenderer({
-        type: "suggestions_progress",
-        content: "Starting project analysis...\n",
-      });
-
-      const currentQuery = query({ prompt, options });
-      execution.query = currentQuery;
-
-      let fullResponse = "";
-      for await (const msg of currentQuery) {
-        if (!execution.isActive()) break;
-
-        if (msg.type === "assistant" && msg.message?.content) {
-          for (const block of msg.message.content) {
-            if (block.type === "text") {
-              fullResponse += block.text;
-              sendToRenderer({
-                type: "suggestions_progress",
-                content: block.text,
-              });
-            } else if (block.type === "tool_use") {
-              sendToRenderer({
-                type: "suggestions_tool",
-                tool: block.name,
-                input: block.input,
-              });
-            }
-          }
-        }
-      }
-
-      execution.query = null;
-      execution.abortController = null;
-
-      // Parse the suggestions from the response
-      const suggestions = this.parseSuggestions(fullResponse);
-
-      sendToRenderer({
-        type: "suggestions_complete",
-        suggestions: suggestions,
-      });
-
-      return {
-        success: true,
-        suggestions: suggestions,
-      };
-    } catch (error) {
-      if (error instanceof AbortError || error?.name === "AbortError") {
-        console.log("[FeatureSuggestions] Analysis aborted");
-        if (execution) {
-          execution.abortController = null;
-          execution.query = null;
-        }
-        return {
-          success: false,
-          message: "Analysis aborted",
-          suggestions: [],
-        };
-      }
-
-      console.error(
-        "[FeatureSuggestions] Error generating suggestions:",
-        error
-      );
-      if (execution) {
-        execution.abortController = null;
-        execution.query = null;
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Parse suggestions from the LLM response
-   * Looks for JSON array in the response
-   */
-  parseSuggestions(response) {
-    try {
-      // Try to find JSON array in the response
-      // Look for ```json ... ``` blocks first
-      const jsonBlockMatch = response.match(/```json\s*([\s\S]*?)```/);
-      if (jsonBlockMatch) {
-        const parsed = JSON.parse(jsonBlockMatch[1].trim());
-        if (Array.isArray(parsed)) {
-          return this.validateSuggestions(parsed);
-        }
-      }
-
-      // Try to find a raw JSON array
-      const jsonArrayMatch = response.match(/\[\s*\{[\s\S]*\}\s*\]/);
-      if (jsonArrayMatch) {
-        const parsed = JSON.parse(jsonArrayMatch[0]);
-        if (Array.isArray(parsed)) {
-          return this.validateSuggestions(parsed);
-        }
-      }
-
-      console.warn(
-        "[FeatureSuggestions] Could not parse suggestions from response"
-      );
-      return [];
-    } catch (error) {
-      console.error("[FeatureSuggestions] Error parsing suggestions:", error);
-      return [];
-    }
-  }
-
-  /**
-   * Validate and normalize suggestions
-   */
-  validateSuggestions(suggestions) {
-    return suggestions
-      .filter((s) => s && typeof s === "object")
-      .map((s, index) => ({
-        id: `suggestion-${Date.now()}-${index}`,
-        category: s.category || "Uncategorized",
-        description: s.description || s.title || "No description",
-        steps: Array.isArray(s.steps) ? s.steps : [],
-        priority: typeof s.priority === "number" ? s.priority : index + 1,
-        reasoning: s.reasoning || "",
-      }))
-      .sort((a, b) => a.priority - b.priority);
-  }
-
-  /**
-   * Get the system prompt for feature suggestion analysis
-   */
-  getSystemPrompt() {
-    return `You are an expert software architect and product manager. Your job is to analyze a codebase and suggest missing features that would improve the application.
-
-You should:
-1. Thoroughly analyze the project structure, code, and any existing documentation
-2. Identify what the application does and what features it currently has (look at the .automaker/app_spec.txt file as well if it exists)
-3. Generate a comprehensive list of missing features that would be valuable to users
-4. Prioritize features by impact and complexity
-5. Provide clear, actionable descriptions and implementation steps
-
-When analyzing, look at:
-- README files and documentation
-- Package.json, cargo.toml, or similar config files for tech stack
-- Source code structure and organization
-- Existing features and their implementation patterns
-- Common patterns in similar applications
-- User experience improvements
-- Developer experience improvements
-- Performance optimizations
-- Security enhancements
-
-You have access to file reading and search tools. Use them to understand the codebase.`;
-  }
-
-  /**
-   * Build the prompt for analyzing the project
-   */
-  buildAnalysisPrompt() {
-    return `Analyze this project and generate a list of suggested features that are missing or would improve the application.
-
-**Your Task:**
-
-1. First, explore the project structure:
-   - Read README.md, package.json, or similar config files
-   - Scan the source code directory structure
-   - Identify the tech stack and frameworks used
-   - Look at existing features and how they're implemented
-
-2. Identify what the application does:
-   - What is the main purpose?
-   - What features are already implemented?
-   - What patterns and conventions are used?
-
-3. Generate feature suggestions:
-   - Think about what's missing compared to similar applications
-   - Consider user experience improvements
-   - Consider developer experience improvements
-   - Think about performance, security, and reliability
-   - Consider testing and documentation improvements
-
-4. **CRITICAL: Output your suggestions as a JSON array** at the end of your response, formatted like this:
-
-\`\`\`json
-[
-  {
-    "category": "User Experience",
-    "description": "Add dark mode support with system preference detection",
-    "steps": [
-      "Create a ThemeProvider context to manage theme state",
-      "Add a toggle component in the settings or header",
-      "Implement CSS variables for theme colors",
-      "Add localStorage persistence for user preference"
-    ],
-    "priority": 1,
-    "reasoning": "Dark mode is a standard feature that improves accessibility and user comfort"
-  },
-  {
-    "category": "Performance",
-    "description": "Implement lazy loading for heavy components",
-    "steps": [
-      "Identify components that are heavy or rarely used",
-      "Use React.lazy() and Suspense for code splitting",
-      "Add loading states for lazy-loaded components"
-    ],
-    "priority": 2,
-    "reasoning": "Improves initial load time and reduces bundle size"
-  }
-]
-\`\`\`
-
-**Important Guidelines:**
-- Generate at least 10-20 feature suggestions
-- Order them by priority (1 = highest priority)
-- Each feature should have clear, actionable steps
-- Categories should be meaningful (e.g., "User Experience", "Performance", "Security", "Testing", "Documentation", "Developer Experience", "Accessibility", etc.)
-- Be specific about what files might need to be created or modified
-- Consider the existing tech stack and patterns when suggesting implementation steps
-
-Begin by exploring the project structure.`;
-  }
-
-  /**
-   * Stop the current analysis
-   */
-  stop() {
-    if (this.runningAnalysis && this.runningAnalysis.abortController) {
-      this.runningAnalysis.abortController.abort();
-    }
-    this.runningAnalysis = null;
-  }
-}
-
-module.exports = new FeatureSuggestionsService();

app/electron/services/feature-verifier.js

@@ -1,185 +0,0 @@
-const { query, AbortError } = require("@anthropic-ai/claude-agent-sdk");
-const promptBuilder = require("./prompt-builder");
-const contextManager = require("./context-manager");
-const featureLoader = require("./feature-loader");
-const mcpServerFactory = require("./mcp-server-factory");
-
-/**
- * Feature Verifier - Handles feature verification by running tests
- */
-class FeatureVerifier {
-  /**
-   * Verify feature tests (runs tests and checks if they pass)
-   */
-  async verifyFeatureTests(feature, projectPath, sendToRenderer, execution) {
-    console.log(
-      `[FeatureVerifier] Verifying tests for: ${feature.description}`
-    );
-
-    try {
-      const verifyMsg = `\n✅ Verifying tests for: ${feature.description}\n`;
-      await contextManager.writeToContextFile(
-        projectPath,
-        feature.id,
-        verifyMsg
-      );
-
-      sendToRenderer({
-        type: "auto_mode_phase",
-        featureId: feature.id,
-        phase: "verification",
-        message: `Verifying tests for: ${feature.description}`,
-      });
-
-      const abortController = new AbortController();
-      execution.abortController = abortController;
-
-      // Create custom MCP server with UpdateFeatureStatus tool
-      const featureToolsServer = mcpServerFactory.createFeatureToolsServer(
-        featureLoader.updateFeatureStatus.bind(featureLoader),
-        projectPath
-      );
-
-      const options = {
-        model: "claude-opus-4-5-20251101",
-        systemPrompt: await promptBuilder.getVerificationPrompt(projectPath),
-        maxTurns: 1000,
-        cwd: projectPath,
-        mcpServers: {
-          "automaker-tools": featureToolsServer,
-        },
-        allowedTools: [
-          "Read",
-          "Write",
-          "Edit",
-          "Glob",
-          "Grep",
-          "Bash",
-          "mcp__automaker-tools__UpdateFeatureStatus",
-        ],
-        permissionMode: "acceptEdits",
-        sandbox: {
-          enabled: true,
-          autoAllowBashIfSandboxed: true,
-        },
-        abortController: abortController,
-      };
-
-      const prompt = await promptBuilder.buildVerificationPrompt(
-        feature,
-        projectPath
-      );
-
-      const runningTestsMsg =
-        "Running Playwright tests to verify feature implementation...\n";
-      await contextManager.writeToContextFile(
-        projectPath,
-        feature.id,
-        runningTestsMsg
-      );
-
-      sendToRenderer({
-        type: "auto_mode_progress",
-        featureId: feature.id,
-        content: runningTestsMsg,
-      });
-
-      const currentQuery = query({ prompt, options });
-      execution.query = currentQuery;
-
-      let responseText = "";
-      for await (const msg of currentQuery) {
-        // Check if this specific feature was aborted
-        if (!execution.isActive()) break;
-
-        if (msg.type === "assistant" && msg.message?.content) {
-          for (const block of msg.message.content) {
-            if (block.type === "text") {
-              responseText += block.text;
-
-              await contextManager.writeToContextFile(
-                projectPath,
-                feature.id,
-                block.text
-              );
-
-              sendToRenderer({
-                type: "auto_mode_progress",
-                featureId: feature.id,
-                content: block.text,
-              });
-            } else if (block.type === "tool_use") {
-              const toolMsg = `\n🔧 Tool: ${block.name}\n`;
-              await contextManager.writeToContextFile(
-                projectPath,
-                feature.id,
-                toolMsg
-              );
-
-              sendToRenderer({
-                type: "auto_mode_tool",
-                featureId: feature.id,
-                tool: block.name,
-                input: block.input,
-              });
-            }
-          }
-        }
-      }
-
-      execution.query = null;
-      execution.abortController = null;
-
-      // Re-load features to check if it was marked as verified or waiting_approval (for skipTests)
-      const updatedFeatures = await featureLoader.loadFeatures(projectPath);
-      const updatedFeature = updatedFeatures.find((f) => f.id === feature.id);
-      // For skipTests features, waiting_approval is also considered a success
-      const passes =
-        updatedFeature?.status === "verified" ||
-        (updatedFeature?.skipTests &&
-          updatedFeature?.status === "waiting_approval");
-
-      const finalMsg = passes
-        ? "✓ Verification successful: All tests passed\n"
-        : "✗ Tests failed or not all passing - feature remains in progress\n";
-
-      await contextManager.writeToContextFile(
-        projectPath,
-        feature.id,
-        finalMsg
-      );
-
-      sendToRenderer({
-        type: "auto_mode_progress",
-        featureId: feature.id,
-        content: finalMsg,
-      });
-
-      return {
-        passes,
-        message: responseText.substring(0, 500),
-      };
-    } catch (error) {
-      if (error instanceof AbortError || error?.name === "AbortError") {
-        console.log("[FeatureVerifier] Verification aborted");
-        if (execution) {
-          execution.abortController = null;
-          execution.query = null;
-        }
-        return {
-          passes: false,
-          message: "Verification aborted",
-        };
-      }
-
-      console.error("[FeatureVerifier] Error verifying feature:", error);
-      if (execution) {
-        execution.abortController = null;
-        execution.query = null;
-      }
-      throw error;
-    }
-  }
-}
-
-module.exports = new FeatureVerifier();

app/electron/services/mcp-server-factory.js

@@ -1,76 +0,0 @@
-const { createSdkMcpServer, tool } = require("@anthropic-ai/claude-agent-sdk");
-const { z } = require("zod");
-const featureLoader = require("./feature-loader");
-
-/**
- * MCP Server Factory - Creates custom MCP servers with tools
- */
-class McpServerFactory {
-  /**
-   * Create a custom MCP server with the UpdateFeatureStatus tool
-   * This tool allows Claude Code to safely update feature status without
-   * directly modifying the feature_list.json file, preventing race conditions
-   * and accidental state restoration.
-   */
-  createFeatureToolsServer(updateFeatureStatusCallback, projectPath) {
-    return createSdkMcpServer({
-      name: "automaker-tools",
-      version: "1.0.0",
-      tools: [
-        tool(
-          "UpdateFeatureStatus",
-          "Update the status of a feature in the feature list. Use this tool instead of directly modifying feature_list.json to safely update feature status. IMPORTANT: If the feature has skipTests=true, you should NOT mark it as verified - instead it will automatically go to waiting_approval status for manual review. Always include a summary of what was done.",
-          {
-            featureId: z.string().describe("The ID of the feature to update"),
-            status: z.enum(["backlog", "in_progress", "verified"]).describe("The new status for the feature. Note: If skipTests=true, verified will be converted to waiting_approval automatically."),
-            summary: z.string().optional().describe("A brief summary of what was implemented/changed. This will be displayed on the Kanban card. Example: 'Added dark mode toggle. Modified: settings.tsx, theme-provider.tsx'")
-          },
-          async (args) => {
-            try {
-              console.log(`[McpServerFactory] UpdateFeatureStatus tool called: featureId=${args.featureId}, status=${args.status}, summary=${args.summary || "(none)"}`);
-
-              // Load the feature to check skipTests flag
-              const features = await featureLoader.loadFeatures(projectPath);
-              const feature = features.find((f) => f.id === args.featureId);
-
-              if (!feature) {
-                throw new Error(`Feature ${args.featureId} not found`);
-              }
-
-              // If agent tries to mark as verified but feature has skipTests=true, convert to waiting_approval
-              let finalStatus = args.status;
-              if (args.status === "verified" && feature.skipTests === true) {
-                console.log(`[McpServerFactory] Feature ${args.featureId} has skipTests=true, converting verified -> waiting_approval`);
-                finalStatus = "waiting_approval";
-              }
-
-              // Call the provided callback to update feature status with summary
-              await updateFeatureStatusCallback(args.featureId, finalStatus, projectPath, args.summary);
-
-              const statusMessage = finalStatus !== args.status
-                ? `Successfully updated feature ${args.featureId} to status "${finalStatus}" (converted from "${args.status}" because skipTests=true)${args.summary ? ` with summary: "${args.summary}"` : ""}`
-                : `Successfully updated feature ${args.featureId} to status "${finalStatus}"${args.summary ? ` with summary: "${args.summary}"` : ""}`;
-
-              return {
-                content: [{
-                  type: "text",
-                  text: statusMessage
-                }]
-              };
-            } catch (error) {
-              console.error("[McpServerFactory] UpdateFeatureStatus tool error:", error);
-              return {
-                content: [{
-                  type: "text",
-                  text: `Failed to update feature status: ${error.message}`
-                }]
-              };
-            }
-          }
-        )
-      ]
-    });
-  }
-}
-
-module.exports = new McpServerFactory();

app/electron/services/mcp-server-stdio.js

@@ -1,347 +0,0 @@
-#!/usr/bin/env node
-/**
- * Standalone STDIO MCP Server for Automaker Tools
- * 
- * This script runs as a standalone process and communicates via JSON-RPC 2.0
- * over stdin/stdout. It implements the MCP protocol to expose the UpdateFeatureStatus
- * tool to Codex CLI.
- * 
- * Environment variables:
- * - AUTOMAKER_PROJECT_PATH: Path to the project directory
- * - AUTOMAKER_IPC_CHANNEL: IPC channel name for callback communication (optional, uses default)
- */
-
-const readline = require('readline');
-const path = require('path');
-
-// Redirect all console.log output to stderr to avoid polluting MCP stdout
-const originalConsoleLog = console.log;
-console.log = (...args) => {
-  console.error(...args);
-};
-
-// Set up readline interface for line-by-line JSON-RPC input
-// IMPORTANT: Use a separate output stream for readline to avoid interfering with JSON-RPC stdout
-// We'll write JSON-RPC responses directly to stdout, not through readline
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: null, // Don't use stdout for readline output
-  terminal: false
-});
-
-let initialized = false;
-let projectPath = null;
-let ipcChannel = null;
-
-// Get configuration from environment
-projectPath = process.env.AUTOMAKER_PROJECT_PATH || process.cwd();
-ipcChannel = process.env.AUTOMAKER_IPC_CHANNEL || 'mcp:update-feature-status';
-
-// Load dependencies (these will be available in the Electron app context)
-let featureLoader;
-let electron;
-
-// Try to load Electron IPC if available (when running from Electron app)
-try {
-  // In Electron, we can use IPC directly
-  if (typeof require !== 'undefined') {
-    // Check if we're in Electron context
-    const electronModule = require('electron');
-    if (electronModule && electronModule.ipcMain) {
-      electron = electronModule;
-    }
-  }
-} catch (e) {
-  // Not in Electron context, will use alternative method
-}
-
-// Load feature loader
-// Try multiple paths since this script might be run from different contexts
-try {
-  // First try relative path (when run from electron/services/)
-  featureLoader = require('./feature-loader');
-} catch (e) {
-  try {
-    // Try absolute path resolution
-    const featureLoaderPath = path.resolve(__dirname, 'feature-loader.js');
-    delete require.cache[require.resolve(featureLoaderPath)];
-    featureLoader = require(featureLoaderPath);
-  } catch (e2) {
-    // If still fails, try from parent directory
-    try {
-      featureLoader = require(path.join(__dirname, '..', 'services', 'feature-loader'));
-    } catch (e3) {
-      console.error('[McpServerStdio] Error loading feature-loader:', e3.message);
-      console.error('[McpServerStdio] Tried paths:', [
-        './feature-loader',
-        path.resolve(__dirname, 'feature-loader.js'),
-        path.join(__dirname, '..', 'services', 'feature-loader')
-      ]);
-      process.exit(1);
-    }
-  }
-}
-
-/**
- * Send JSON-RPC response
- * CRITICAL: Must write directly to stdout, not via console.log
- * MCP protocol requires ONLY JSON-RPC messages on stdout
- */
-function sendResponse(id, result, error = null) {
-  const response = {
-    jsonrpc: '2.0',
-    id
-  };
-  
-  if (error) {
-    response.error = error;
-  } else {
-    response.result = result;
-  }
-  
-  // Write directly to stdout with newline (MCP uses line-delimited JSON)
-  process.stdout.write(JSON.stringify(response) + '\n');
-}
-
-/**
- * Send JSON-RPC notification
- * CRITICAL: Must write directly to stdout, not via console.log
- */
-function sendNotification(method, params) {
-  const notification = {
-    jsonrpc: '2.0',
-    method,
-    params
-  };
-  
-  // Write directly to stdout with newline (MCP uses line-delimited JSON)
-  process.stdout.write(JSON.stringify(notification) + '\n');
-}
-
-/**
- * Handle MCP initialize request
- */
-async function handleInitialize(params, id) {
-  initialized = true;
-  
-  sendResponse(id, {
-    protocolVersion: '2024-11-05',
-    capabilities: {
-      tools: {}
-    },
-    serverInfo: {
-      name: 'automaker-tools',
-      version: '1.0.0'
-    }
-  });
-}
-
-/**
- * Handle tools/list request
- */
-async function handleToolsList(params, id) {
-  sendResponse(id, {
-    tools: [
-      {
-        name: 'UpdateFeatureStatus',
-        description: 'Update the status of a feature in the feature list. Use this tool instead of directly modifying feature_list.json to safely update feature status. IMPORTANT: If the feature has skipTests=true, you should NOT mark it as verified - instead it will automatically go to waiting_approval status for manual review. Always include a summary of what was done.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            featureId: {
-              type: 'string',
-              description: 'The ID of the feature to update'
-            },
-            status: {
-              type: 'string',
-              enum: ['backlog', 'in_progress', 'verified'],
-              description: 'The new status for the feature. Note: If skipTests=true, verified will be converted to waiting_approval automatically.'
-            },
-            summary: {
-              type: 'string',
-              description: 'A brief summary of what was implemented/changed. This will be displayed on the Kanban card. Example: "Added dark mode toggle. Modified: settings.tsx, theme-provider.tsx"'
-            }
-          },
-          required: ['featureId', 'status']
-        }
-      }
-    ]
-  });
-}
-
-/**
- * Handle tools/call request
- */
-async function handleToolsCall(params, id) {
-  const { name, arguments: args } = params;
-  
-  if (name !== 'UpdateFeatureStatus') {
-    sendResponse(id, null, {
-      code: -32601,
-      message: `Unknown tool: ${name}`
-    });
-    return;
-  }
-  
-  try {
-    const { featureId, status, summary } = args;
-    
-    if (!featureId || !status) {
-      sendResponse(id, null, {
-        code: -32602,
-        message: 'Missing required parameters: featureId and status are required'
-      });
-      return;
-    }
-    
-    // Load the feature to check skipTests flag
-    const features = await featureLoader.loadFeatures(projectPath);
-    const feature = features.find((f) => f.id === featureId);
-    
-    if (!feature) {
-      sendResponse(id, null, {
-        code: -32602,
-        message: `Feature ${featureId} not found`
-      });
-      return;
-    }
-    
-    // If agent tries to mark as verified but feature has skipTests=true, convert to waiting_approval
-    let finalStatus = status;
-    if (status === 'verified' && feature.skipTests === true) {
-      finalStatus = 'waiting_approval';
-    }
-    
-    // Call the update callback via IPC or direct call
-    // Since we're in a separate process, we need to use IPC to communicate back
-    // For now, we'll call the feature loader directly since it has the update method
-    await featureLoader.updateFeatureStatus(featureId, finalStatus, projectPath, summary);
-    
-    const statusMessage = finalStatus !== status
-      ? `Successfully updated feature ${featureId} to status "${finalStatus}" (converted from "${status}" because skipTests=true)${summary ? ` with summary: "${summary}"` : ''}`
-      : `Successfully updated feature ${featureId} to status "${finalStatus}"${summary ? ` with summary: "${summary}"` : ''}`;
-    
-    sendResponse(id, {
-      content: [
-        {
-          type: 'text',
-          text: statusMessage
-        }
-      ]
-    });
-  } catch (error) {
-    console.error('[McpServerStdio] UpdateFeatureStatus error:', error);
-    sendResponse(id, null, {
-      code: -32603,
-      message: `Failed to update feature status: ${error.message}`
-    });
-  }
-}
-
-/**
- * Handle JSON-RPC request
- */
-async function handleRequest(line) {
-  let request;
-  
-  try {
-    request = JSON.parse(line);
-  } catch (e) {
-    sendResponse(null, null, {
-      code: -32700,
-      message: 'Parse error'
-    });
-    return;
-  }
-  
-  // Validate JSON-RPC 2.0 structure
-  if (request.jsonrpc !== '2.0') {
-    sendResponse(request.id || null, null, {
-      code: -32600,
-      message: 'Invalid Request'
-    });
-    return;
-  }
-  
-  const { method, params, id } = request;
-  
-  // Handle notifications (no id)
-  if (id === undefined) {
-    // Handle notifications if needed
-    return;
-  }
-  
-  // Handle requests
-  try {
-    switch (method) {
-      case 'initialize':
-        await handleInitialize(params, id);
-        break;
-        
-      case 'tools/list':
-        if (!initialized) {
-          sendResponse(id, null, {
-            code: -32002,
-            message: 'Server not initialized'
-          });
-          return;
-        }
-        await handleToolsList(params, id);
-        break;
-        
-      case 'tools/call':
-        if (!initialized) {
-          sendResponse(id, null, {
-            code: -32002,
-            message: 'Server not initialized'
-          });
-          return;
-        }
-        await handleToolsCall(params, id);
-        break;
-        
-      default:
-        sendResponse(id, null, {
-          code: -32601,
-          message: `Method not found: ${method}`
-        });
-    }
-  } catch (error) {
-    console.error('[McpServerStdio] Error handling request:', error);
-    sendResponse(id, null, {
-      code: -32603,
-      message: `Internal error: ${error.message}`
-    });
-  }
-}
-
-// Process stdin line by line
-rl.on('line', async (line) => {
-  if (!line.trim()) {
-    return;
-  }
-  
-  await handleRequest(line);
-});
-
-// Handle errors
-rl.on('error', (error) => {
-  console.error('[McpServerStdio] Readline error:', error);
-  process.exit(1);
-});
-
-// Handle process termination
-process.on('SIGTERM', () => {
-  rl.close();
-  process.exit(0);
-});
-
-process.on('SIGINT', () => {
-  rl.close();
-  process.exit(0);
-});
-
-// Log startup
-console.error('[McpServerStdio] Starting MCP server for automaker-tools');
-console.error(`[McpServerStdio] Project path: ${projectPath}`);
-console.error(`[McpServerStdio] IPC channel: ${ipcChannel}`);

app/electron/services/model-provider.js

@@ -1,524 +0,0 @@
-/**
- * Model Provider Abstraction Layer
- *
- * This module provides an abstract interface for model providers (Claude, Codex, etc.)
- * allowing the application to use different AI models through a unified API.
- */
-
-/**
- * Base class for model providers
- * Concrete implementations should extend this class
- */
-class ModelProvider {
-  constructor(config = {}) {
-    this.config = config;
-    this.name = 'base';
-  }
-
-  /**
-   * Get provider name
-   * @returns {string} Provider name
-   */
-  getName() {
-    return this.name;
-  }
-
-  /**
-   * Execute a query with the model provider
-   * @param {Object} options Query options
-   * @param {string} options.prompt The prompt to send
-   * @param {string} options.model The model to use
-   * @param {string} options.systemPrompt System prompt
-   * @param {string} options.cwd Working directory
-   * @param {number} options.maxTurns Maximum turns
-   * @param {string[]} options.allowedTools Allowed tools
-   * @param {Object} options.mcpServers MCP servers configuration
-   * @param {AbortController} options.abortController Abort controller
-   * @param {Object} options.thinking Thinking configuration
-   * @returns {AsyncGenerator} Async generator yielding messages
-   */
-  async *executeQuery(options) {
-    throw new Error('executeQuery must be implemented by subclass');
-  }
-
-  /**
-   * Detect if this provider's CLI/SDK is installed
-   * @returns {Promise<Object>} Installation status
-   */
-  async detectInstallation() {
-    throw new Error('detectInstallation must be implemented by subclass');
-  }
-
-  /**
-   * Get list of available models for this provider
-   * @returns {Array<Object>} Array of model definitions
-   */
-  getAvailableModels() {
-    throw new Error('getAvailableModels must be implemented by subclass');
-  }
-
-  /**
-   * Validate provider configuration
-   * @returns {Object} Validation result { valid: boolean, errors: string[] }
-   */
-  validateConfig() {
-    throw new Error('validateConfig must be implemented by subclass');
-  }
-
-  /**
-   * Get the full model string for a model key
-   * @param {string} modelKey Short model key (e.g., 'opus', 'gpt-5.1-codex')
-   * @returns {string} Full model string
-   */
-  getModelString(modelKey) {
-    throw new Error('getModelString must be implemented by subclass');
-  }
-
-  /**
-   * Check if provider supports a specific feature
-   * @param {string} feature Feature name (e.g., 'thinking', 'tools', 'streaming')
-   * @returns {boolean} Whether the feature is supported
-   */
-  supportsFeature(feature) {
-    return false;
-  }
-}
-
-/**
- * Claude Provider - Uses Anthropic Claude Agent SDK
- */
-class ClaudeProvider extends ModelProvider {
-  constructor(config = {}) {
-    super(config);
-    this.name = 'claude';
-    this.sdk = null;
-  }
-
-  /**
-   * Try to load credentials from the app's own credentials.json file.
-   * This is where we store OAuth tokens and API keys that users enter in the setup wizard.
-   * Returns { oauthToken, apiKey } or null values if not found.
-   */
-  loadTokenFromAppCredentials() {
-    try {
-      const fs = require('fs');
-      const path = require('path');
-      const { app } = require('electron');
-      const credentialsPath = path.join(app.getPath('userData'), 'credentials.json');
-
-      if (!fs.existsSync(credentialsPath)) {
-        console.log('[ClaudeProvider] App credentials file does not exist:', credentialsPath);
-        return { oauthToken: null, apiKey: null };
-      }
-
-      const raw = fs.readFileSync(credentialsPath, 'utf-8');
-      const parsed = JSON.parse(raw);
-
-      // Check for OAuth token first (from claude setup-token), then API key
-      const oauthToken = parsed.anthropic_oauth_token || null;
-      const apiKey = parsed.anthropic || parsed.anthropic_api_key || null;
-
-      console.log('[ClaudeProvider] App credentials check - OAuth token:', !!oauthToken, ', API key:', !!apiKey);
-      return { oauthToken, apiKey };
-    } catch (err) {
-      console.warn('[ClaudeProvider] Failed to read app credentials:', err?.message);
-      return { oauthToken: null, apiKey: null };
-    }
-  }
-
-  /**
-   * Try to load a Claude OAuth token from the local CLI config (~/.claude/config.json).
-   * Returns the token string or null if not found.
-   * NOTE: Claude's credentials.json is encrypted, so we only try config.json
-   */
-  loadTokenFromCliConfig() {
-    try {
-      const fs = require('fs');
-      const path = require('path');
-      const configPath = path.join(require('os').homedir(), '.claude', 'config.json');
-      if (!fs.existsSync(configPath)) {
-        return null;
-      }
-      const raw = fs.readFileSync(configPath, 'utf-8');
-      const parsed = JSON.parse(raw);
-      // CLI config stores token as oauth_token (newer) or token (older)
-      return parsed.oauth_token || parsed.token || null;
-    } catch (err) {
-      console.warn('[ClaudeProvider] Failed to read CLI config token:', err?.message);
-      return null;
-    }
-  }
-
-  ensureAuthEnv() {
-    // If API key or token already present in environment, keep as-is.
-    if (process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_CODE_OAUTH_TOKEN) {
-      console.log('[ClaudeProvider] Auth already present in environment');
-      return true;
-    }
-
-    // Priority 1: Try to load from app's own credentials (setup wizard)
-    const appCredentials = this.loadTokenFromAppCredentials();
-    if (appCredentials.oauthToken) {
-      process.env.CLAUDE_CODE_OAUTH_TOKEN = appCredentials.oauthToken;
-      console.log('[ClaudeProvider] Loaded CLAUDE_CODE_OAUTH_TOKEN from app credentials');
-      return true;
-    }
-    if (appCredentials.apiKey) {
-      process.env.ANTHROPIC_API_KEY = appCredentials.apiKey;
-      console.log('[ClaudeProvider] Loaded ANTHROPIC_API_KEY from app credentials');
-      return true;
-    }
-
-    // Priority 2: Try to hydrate from CLI login config (legacy)
-    const token = this.loadTokenFromCliConfig();
-    if (token) {
-      process.env.CLAUDE_CODE_OAUTH_TOKEN = token;
-      console.log('[ClaudeProvider] Loaded CLAUDE_CODE_OAUTH_TOKEN from ~/.claude/config.json');
-      return true;
-    }
-
-    // Check if CLI is installed but not logged in
-    try {
-      const claudeCliDetector = require('./claude-cli-detector');
-      const detection = claudeCliDetector.detectClaudeInstallation();
-      if (detection.installed && detection.method === 'cli') {
-        console.error('[ClaudeProvider] Claude CLI is installed but not authenticated. Use the setup wizard or set ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN environment variable.');
-      } else {
-        console.error('[ClaudeProvider] No Anthropic auth found. Use the setup wizard or set ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN.');
-      }
-    } catch (err) {
-      console.error('[ClaudeProvider] No Anthropic auth found. Use the setup wizard or set ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN.');
-    }
-    return false;
-  }
-
-  /**
-   * Lazily load the Claude SDK
-   */
-  loadSdk() {
-    if (!this.sdk) {
-      this.sdk = require('@anthropic-ai/claude-agent-sdk');
-    }
-    return this.sdk;
-  }
-
-  async *executeQuery(options) {
-    // Ensure we have auth; fall back to app credentials or CLI login token if available.
-    if (!this.ensureAuthEnv()) {
-      // Check if CLI is installed to provide better error message
-      let msg = 'Missing Anthropic auth. Go to Settings > Setup to configure your Claude authentication.';
-      try {
-        const claudeCliDetector = require('./claude-cli-detector');
-        const detection = claudeCliDetector.detectClaudeInstallation();
-        if (detection.installed && detection.method === 'cli') {
-          msg = 'Claude CLI is installed but not authenticated. Go to Settings > Setup to provide your subscription token (from `claude setup-token`) or API key.';
-        } else {
-          msg = 'Missing Anthropic auth. Go to Settings > Setup to configure your Claude authentication, or set ANTHROPIC_API_KEY environment variable.';
-        }
-      } catch (err) {
-        // Fallback to default message
-      }
-      console.error(`[ClaudeProvider] ${msg}`);
-      yield { type: 'error', error: msg };
-      return;
-    }
-
-    const { query } = this.loadSdk();
-
-    const sdkOptions = {
-      model: options.model,
-      systemPrompt: options.systemPrompt,
-      maxTurns: options.maxTurns || 1000,
-      cwd: options.cwd,
-      mcpServers: options.mcpServers,
-      allowedTools: options.allowedTools,
-      permissionMode: options.permissionMode || 'acceptEdits',
-      sandbox: options.sandbox,
-      abortController: options.abortController,
-    };
-
-    // Add thinking configuration if enabled
-    if (options.thinking) {
-      sdkOptions.thinking = options.thinking;
-    }
-
-    const currentQuery = query({ prompt: options.prompt, options: sdkOptions });
-
-    for await (const msg of currentQuery) {
-      yield msg;
-    }
-  }
-
-  async detectInstallation() {
-    const claudeCliDetector = require('./claude-cli-detector');
-    return claudeCliDetector.getInstallationInfo();
-  }
-
-  getAvailableModels() {
-    return [
-      {
-        id: 'haiku',
-        name: 'Claude Haiku',
-        modelString: 'claude-haiku-4-5',
-        provider: 'claude',
-        description: 'Fast and efficient for simple tasks',
-        tier: 'basic'
-      },
-      {
-        id: 'sonnet',
-        name: 'Claude Sonnet',
-        modelString: 'claude-sonnet-4-20250514',
-        provider: 'claude',
-        description: 'Balanced performance and capabilities',
-        tier: 'standard'
-      },
-      {
-        id: 'opus',
-        name: 'Claude Opus 4.5',
-        modelString: 'claude-opus-4-5-20251101',
-        provider: 'claude',
-        description: 'Most capable model for complex tasks',
-        tier: 'premium'
-      }
-    ];
-  }
-
-  validateConfig() {
-    const errors = [];
-
-    // Ensure auth is available (try to auto-load from app credentials or CLI config)
-    this.ensureAuthEnv();
-
-    if (!process.env.CLAUDE_CODE_OAUTH_TOKEN && !process.env.ANTHROPIC_API_KEY) {
-      errors.push('No Claude authentication found. Go to Settings > Setup to configure your subscription token or API key.');
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-
-  getModelString(modelKey) {
-    const modelMap = {
-      haiku: 'claude-haiku-4-5',
-      sonnet: 'claude-sonnet-4-20250514',
-      opus: 'claude-opus-4-5-20251101'
-    };
-    return modelMap[modelKey] || modelMap.opus;
-  }
-
-  supportsFeature(feature) {
-    const supportedFeatures = ['thinking', 'tools', 'streaming', 'mcp'];
-    return supportedFeatures.includes(feature);
-  }
-}
-
-/**
- * Codex Provider - Uses OpenAI Codex CLI
- */
-class CodexProvider extends ModelProvider {
-  constructor(config = {}) {
-    super(config);
-    this.name = 'codex';
-  }
-
-  async *executeQuery(options) {
-    const codexExecutor = require('./codex-executor');
-
-    // Validate that we're not receiving a Claude model string
-    if (options.model && options.model.startsWith('claude-')) {
-      const errorMsg = `Codex provider cannot use Claude model '${options.model}'. Codex only supports OpenAI models (gpt-5.1-codex-max, gpt-5.1-codex, gpt-5.1-codex-mini, gpt-5.1).`;
-      console.error(`[CodexProvider] ${errorMsg}`);
-      yield {
-        type: 'error',
-        error: errorMsg
-      };
-      return;
-    }
-
-    const executeOptions = {
-      prompt: options.prompt,
-      model: options.model,
-      cwd: options.cwd,
-      systemPrompt: options.systemPrompt,
-      maxTurns: options.maxTurns || 20,
-      allowedTools: options.allowedTools,
-      mcpServers: options.mcpServers, // Pass MCP servers config to executor
-      env: {
-        ...process.env,
-        OPENAI_API_KEY: process.env.OPENAI_API_KEY
-      }
-    };
-
-    // Execute and yield results
-    const generator = codexExecutor.execute(executeOptions);
-    for await (const msg of generator) {
-      yield msg;
-    }
-  }
-
-  async detectInstallation() {
-    const codexCliDetector = require('./codex-cli-detector');
-    return codexCliDetector.getInstallationInfo();
-  }
-
-  getAvailableModels() {
-    return [
-      {
-        id: 'gpt-5.1-codex-max',
-        name: 'GPT-5.1 Codex Max',
-        modelString: 'gpt-5.1-codex-max',
-        provider: 'codex',
-        description: 'Latest flagship - deep and fast reasoning for coding',
-        tier: 'premium',
-        default: true
-      },
-      {
-        id: 'gpt-5.1-codex',
-        name: 'GPT-5.1 Codex',
-        modelString: 'gpt-5.1-codex',
-        provider: 'codex',
-        description: 'Optimized for code generation',
-        tier: 'standard'
-      },
-      {
-        id: 'gpt-5.1-codex-mini',
-        name: 'GPT-5.1 Codex Mini',
-        modelString: 'gpt-5.1-codex-mini',
-        provider: 'codex',
-        description: 'Faster and cheaper option',
-        tier: 'basic'
-      },
-      {
-        id: 'gpt-5.1',
-        name: 'GPT-5.1',
-        modelString: 'gpt-5.1',
-        provider: 'codex',
-        description: 'Broad world knowledge with strong reasoning',
-        tier: 'standard'
-      }
-    ];
-  }
-
-  validateConfig() {
-    const errors = [];
-    const codexCliDetector = require('./codex-cli-detector');
-    const installation = codexCliDetector.detectCodexInstallation();
-
-    if (!installation.installed && !process.env.OPENAI_API_KEY) {
-      errors.push('Codex CLI not installed and no OPENAI_API_KEY found.');
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-
-  getModelString(modelKey) {
-    // Codex models use the key directly as the model string
-    const modelMap = {
-      'gpt-5.1-codex-max': 'gpt-5.1-codex-max',
-      'gpt-5.1-codex': 'gpt-5.1-codex',
-      'gpt-5.1-codex-mini': 'gpt-5.1-codex-mini',
-      'gpt-5.1': 'gpt-5.1'
-    };
-    return modelMap[modelKey] || 'gpt-5.1-codex-max';
-  }
-
-  supportsFeature(feature) {
-    const supportedFeatures = ['tools', 'streaming'];
-    return supportedFeatures.includes(feature);
-  }
-}
-
-/**
- * Model Provider Factory
- * Creates the appropriate provider based on model or provider name
- */
-class ModelProviderFactory {
-  static providers = {
-    claude: ClaudeProvider,
-    codex: CodexProvider
-  };
-
-  /**
-   * Get provider for a specific model
-   * @param {string} modelId Model ID (e.g., 'opus', 'gpt-5.1-codex')
-   * @returns {ModelProvider} Provider instance
-   */
-  static getProviderForModel(modelId) {
-    // Check if it's a Claude model
-    const claudeModels = ['haiku', 'sonnet', 'opus'];
-    if (claudeModels.includes(modelId)) {
-      return new ClaudeProvider();
-    }
-
-    // Check if it's a Codex/OpenAI model
-    const codexModels = [
-      'gpt-5.1-codex-max', 'gpt-5.1-codex', 'gpt-5.1-codex-mini', 'gpt-5.1'
-    ];
-    if (codexModels.includes(modelId)) {
-      return new CodexProvider();
-    }
-
-    // Default to Claude
-    return new ClaudeProvider();
-  }
-
-  /**
-   * Get provider by name
-   * @param {string} providerName Provider name ('claude' or 'codex')
-   * @returns {ModelProvider} Provider instance
-   */
-  static getProvider(providerName) {
-    const ProviderClass = this.providers[providerName];
-    if (!ProviderClass) {
-      throw new Error(`Unknown provider: ${providerName}`);
-    }
-    return new ProviderClass();
-  }
-
-  /**
-   * Get all available providers
-   * @returns {string[]} List of provider names
-   */
-  static getAvailableProviders() {
-    return Object.keys(this.providers);
-  }
-
-  /**
-   * Get all available models across all providers
-   * @returns {Array<Object>} All available models
-   */
-  static getAllModels() {
-    const allModels = [];
-    for (const providerName of this.getAvailableProviders()) {
-      const provider = this.getProvider(providerName);
-      const models = provider.getAvailableModels();
-      allModels.push(...models);
-    }
-    return allModels;
-  }
-
-  /**
-   * Check installation status for all providers
-   * @returns {Promise<Object>} Installation status for each provider
-   */
-  static async checkAllProviders() {
-    const status = {};
-    for (const providerName of this.getAvailableProviders()) {
-      const provider = this.getProvider(providerName);
-      status[providerName] = await provider.detectInstallation();
-    }
-    return status;
-  }
-}
-
-module.exports = {
-  ModelProvider,
-  ClaudeProvider,
-  CodexProvider,
-  ModelProviderFactory
-};

app/electron/services/model-registry.js

@@ -1,320 +0,0 @@
-/**
- * Model Registry - Centralized model definitions and metadata
- *
- * This module provides a central registry of all available models
- * across different providers (Claude, Codex/OpenAI).
- */
-
-/**
- * Model Categories
- */
-const MODEL_CATEGORIES = {
-  CLAUDE: 'claude',
-  OPENAI: 'openai',
-  CODEX: 'codex'
-};
-
-/**
- * Model Tiers (capability levels)
- */
-const MODEL_TIERS = {
-  BASIC: 'basic',      // Fast, cheap, simple tasks
-  STANDARD: 'standard', // Balanced performance
-  PREMIUM: 'premium'    // Most capable, complex tasks
-};
-
-const CODEX_MODEL_IDS = [
-  'gpt-5.1-codex-max',
-  'gpt-5.1-codex',
-  'gpt-5.1-codex-mini',
-  'gpt-5.1'
-];
-
-/**
- * All available models with full metadata
- */
-const MODELS = {
-  // Claude Models
-  haiku: {
-    id: 'haiku',
-    name: 'Claude Haiku',
-    modelString: 'claude-haiku-4-5',
-    provider: 'claude',
-    category: MODEL_CATEGORIES.CLAUDE,
-    tier: MODEL_TIERS.BASIC,
-    description: 'Fast and efficient for simple tasks',
-    capabilities: ['code', 'text', 'tools'],
-    maxTokens: 8192,
-    contextWindow: 200000,
-    supportsThinking: true,
-    requiresAuth: 'CLAUDE_CODE_OAUTH_TOKEN'
-  },
-  sonnet: {
-    id: 'sonnet',
-    name: 'Claude Sonnet',
-    modelString: 'claude-sonnet-4-20250514',
-    provider: 'claude',
-    category: MODEL_CATEGORIES.CLAUDE,
-    tier: MODEL_TIERS.STANDARD,
-    description: 'Balanced performance and capabilities',
-    capabilities: ['code', 'text', 'tools', 'analysis'],
-    maxTokens: 8192,
-    contextWindow: 200000,
-    supportsThinking: true,
-    requiresAuth: 'CLAUDE_CODE_OAUTH_TOKEN'
-  },
-  opus: {
-    id: 'opus',
-    name: 'Claude Opus 4.5',
-    modelString: 'claude-opus-4-5-20251101',
-    provider: 'claude',
-    category: MODEL_CATEGORIES.CLAUDE,
-    tier: MODEL_TIERS.PREMIUM,
-    description: 'Most capable model for complex tasks',
-    capabilities: ['code', 'text', 'tools', 'analysis', 'reasoning'],
-    maxTokens: 8192,
-    contextWindow: 200000,
-    supportsThinking: true,
-    requiresAuth: 'CLAUDE_CODE_OAUTH_TOKEN',
-    default: true
-  },
-
-  // OpenAI GPT-5.1 Codex Models
-  'gpt-5.1-codex-max': {
-    id: 'gpt-5.1-codex-max',
-    name: 'GPT-5.1 Codex Max',
-    modelString: 'gpt-5.1-codex-max',
-    provider: 'codex',
-    category: MODEL_CATEGORIES.OPENAI,
-    tier: MODEL_TIERS.PREMIUM,
-    description: 'Latest flagship - deep and fast reasoning for coding',
-    capabilities: ['code', 'text', 'tools', 'reasoning'],
-    maxTokens: 32768,
-    contextWindow: 128000,
-    supportsThinking: false,
-    requiresAuth: 'OPENAI_API_KEY',
-    codexDefault: true
-  },
-  'gpt-5.1-codex': {
-    id: 'gpt-5.1-codex',
-    name: 'GPT-5.1 Codex',
-    modelString: 'gpt-5.1-codex',
-    provider: 'codex',
-    category: MODEL_CATEGORIES.OPENAI,
-    tier: MODEL_TIERS.STANDARD,
-    description: 'Optimized for code generation',
-    capabilities: ['code', 'text', 'tools'],
-    maxTokens: 32768,
-    contextWindow: 128000,
-    supportsThinking: false,
-    requiresAuth: 'OPENAI_API_KEY'
-  },
-  'gpt-5.1-codex-mini': {
-    id: 'gpt-5.1-codex-mini',
-    name: 'GPT-5.1 Codex Mini',
-    modelString: 'gpt-5.1-codex-mini',
-    provider: 'codex',
-    category: MODEL_CATEGORIES.OPENAI,
-    tier: MODEL_TIERS.BASIC,
-    description: 'Faster and cheaper option',
-    capabilities: ['code', 'text'],
-    maxTokens: 16384,
-    contextWindow: 128000,
-    supportsThinking: false,
-    requiresAuth: 'OPENAI_API_KEY'
-  },
-  'gpt-5.1': {
-    id: 'gpt-5.1',
-    name: 'GPT-5.1',
-    modelString: 'gpt-5.1',
-    provider: 'codex',
-    category: MODEL_CATEGORIES.OPENAI,
-    tier: MODEL_TIERS.STANDARD,
-    description: 'Broad world knowledge with strong reasoning',
-    capabilities: ['code', 'text', 'reasoning'],
-    maxTokens: 32768,
-    contextWindow: 128000,
-    supportsThinking: false,
-    requiresAuth: 'OPENAI_API_KEY'
-  }
-};
-
-/**
- * Model Registry class for querying and managing models
- */
-class ModelRegistry {
-  /**
-   * Get all registered models
-   * @returns {Object} All models
-   */
-  static getAllModels() {
-    return MODELS;
-  }
-
-  /**
-   * Get model by ID
-   * @param {string} modelId Model ID
-   * @returns {Object|null} Model definition or null
-   */
-  static getModel(modelId) {
-    return MODELS[modelId] || null;
-  }
-
-  /**
-   * Get models by provider
-   * @param {string} provider Provider name ('claude' or 'codex')
-   * @returns {Object[]} Array of models for the provider
-   */
-  static getModelsByProvider(provider) {
-    return Object.values(MODELS).filter(m => m.provider === provider);
-  }
-
-  /**
-   * Get models by category
-   * @param {string} category Category name
-   * @returns {Object[]} Array of models in the category
-   */
-  static getModelsByCategory(category) {
-    return Object.values(MODELS).filter(m => m.category === category);
-  }
-
-  /**
-   * Get models by tier
-   * @param {string} tier Tier name
-   * @returns {Object[]} Array of models in the tier
-   */
-  static getModelsByTier(tier) {
-    return Object.values(MODELS).filter(m => m.tier === tier);
-  }
-
-  /**
-   * Get default model for a provider
-   * @param {string} provider Provider name
-   * @returns {Object|null} Default model or null
-   */
-  static getDefaultModel(provider = 'claude') {
-    const models = this.getModelsByProvider(provider);
-    if (provider === 'claude') {
-      return models.find(m => m.default) || models[0];
-    }
-    if (provider === 'codex') {
-      return models.find(m => m.codexDefault) || models[0];
-    }
-    return models[0];
-  }
-
-  /**
-   * Get model string (full model name) for a model ID
-   * @param {string} modelId Model ID
-   * @returns {string} Full model string
-   */
-  static getModelString(modelId) {
-    const model = this.getModel(modelId);
-    return model ? model.modelString : modelId;
-  }
-
-  /**
-   * Determine provider for a model ID
-   * @param {string} modelId Model ID
-   * @returns {string} Provider name ('claude' or 'codex')
-   */
-  static getProviderForModel(modelId) {
-    const model = this.getModel(modelId);
-    if (model) {
-      return model.provider;
-    }
-
-    // Fallback detection for models not explicitly registered (keeps legacy Codex IDs working)
-    if (CODEX_MODEL_IDS.includes(modelId)) {
-      return 'codex';
-    }
-
-    return 'claude';
-  }
-
-  /**
-   * Check if a model is a Claude model
-   * @param {string} modelId Model ID
-   * @returns {boolean} Whether it's a Claude model
-   */
-  static isClaudeModel(modelId) {
-    return this.getProviderForModel(modelId) === 'claude';
-  }
-
-  /**
-   * Check if a model is a Codex/OpenAI model
-   * @param {string} modelId Model ID
-   * @returns {boolean} Whether it's a Codex model
-   */
-  static isCodexModel(modelId) {
-    return this.getProviderForModel(modelId) === 'codex';
-  }
-
-  /**
-   * Get models grouped by provider for UI display
-   * @returns {Object} Models grouped by provider
-   */
-  static getModelsGroupedByProvider() {
-    return {
-      claude: this.getModelsByProvider('claude'),
-      codex: this.getModelsByProvider('codex')
-    };
-  }
-
-  /**
-   * Get all model IDs as an array
-   * @returns {string[]} Array of model IDs
-   */
-  static getAllModelIds() {
-    return Object.keys(MODELS);
-  }
-
-  /**
-   * Check if model supports a specific capability
-   * @param {string} modelId Model ID
-   * @param {string} capability Capability name
-   * @returns {boolean} Whether the model supports the capability
-   */
-  static modelSupportsCapability(modelId, capability) {
-    const model = this.getModel(modelId);
-    return model ? model.capabilities.includes(capability) : false;
-  }
-
-  /**
-   * Check if model supports extended thinking
-   * @param {string} modelId Model ID
-   * @returns {boolean} Whether the model supports thinking
-   */
-  static modelSupportsThinking(modelId) {
-    const model = this.getModel(modelId);
-    return model ? model.supportsThinking : false;
-  }
-
-  /**
-   * Get required authentication for a model
-   * @param {string} modelId Model ID
-   * @returns {string|null} Required auth env variable name
-   */
-  static getRequiredAuth(modelId) {
-    const model = this.getModel(modelId);
-    return model ? model.requiresAuth : null;
-  }
-
-  /**
-   * Check if authentication is available for a model
-   * @param {string} modelId Model ID
-   * @returns {boolean} Whether auth is available
-   */
-  static hasAuthForModel(modelId) {
-    const authVar = this.getRequiredAuth(modelId);
-    if (!authVar) return false;
-    return !!process.env[authVar];
-  }
-}
-
-module.exports = {
-  MODEL_CATEGORIES,
-  MODEL_TIERS,
-  MODELS,
-  ModelRegistry
-};

app/electron/services/project-analyzer.js

@@ -1,112 +0,0 @@
-const { query, AbortError } = require("@anthropic-ai/claude-agent-sdk");
-const promptBuilder = require("./prompt-builder");
-
-/**
- * Project Analyzer - Scans codebase and updates app_spec.txt
- */
-class ProjectAnalyzer {
-  /**
-   * Run the project analysis using Claude Agent SDK
-   */
-  async runProjectAnalysis(projectPath, analysisId, sendToRenderer, execution) {
-    console.log(`[ProjectAnalyzer] Running project analysis for: ${projectPath}`);
-
-    try {
-      sendToRenderer({
-        type: "auto_mode_phase",
-        featureId: analysisId,
-        phase: "planning",
-        message: "Scanning project structure...",
-      });
-
-      const abortController = new AbortController();
-      execution.abortController = abortController;
-
-      const options = {
-        model: "claude-sonnet-4-20250514",
-        systemPrompt: promptBuilder.getProjectAnalysisSystemPrompt(),
-        maxTurns: 50,
-        cwd: projectPath,
-        allowedTools: ["Read", "Write", "Edit", "Glob", "Grep", "Bash"],
-        permissionMode: "acceptEdits",
-        sandbox: {
-          enabled: true,
-          autoAllowBashIfSandboxed: true,
-        },
-        abortController: abortController,
-      };
-
-      const prompt = promptBuilder.buildProjectAnalysisPrompt(projectPath);
-
-      sendToRenderer({
-        type: "auto_mode_progress",
-        featureId: analysisId,
-        content: "Starting project analysis...\n",
-      });
-
-      const currentQuery = query({ prompt, options });
-      execution.query = currentQuery;
-
-      let responseText = "";
-      for await (const msg of currentQuery) {
-        if (!execution.isActive()) break;
-
-        if (msg.type === "assistant" && msg.message?.content) {
-          for (const block of msg.message.content) {
-            if (block.type === "text") {
-              responseText += block.text;
-              sendToRenderer({
-                type: "auto_mode_progress",
-                featureId: analysisId,
-                content: block.text,
-              });
-            } else if (block.type === "tool_use") {
-              sendToRenderer({
-                type: "auto_mode_tool",
-                featureId: analysisId,
-                tool: block.name,
-                input: block.input,
-              });
-            }
-          }
-        }
-      }
-
-      execution.query = null;
-      execution.abortController = null;
-
-      sendToRenderer({
-        type: "auto_mode_phase",
-        featureId: analysisId,
-        phase: "verification",
-        message: "Project analysis complete",
-      });
-
-      return {
-        success: true,
-        message: "Project analyzed successfully",
-      };
-    } catch (error) {
-      if (error instanceof AbortError || error?.name === "AbortError") {
-        console.log("[ProjectAnalyzer] Project analysis aborted");
-        if (execution) {
-          execution.abortController = null;
-          execution.query = null;
-        }
-        return {
-          success: false,
-          message: "Analysis aborted",
-        };
-      }
-
-      console.error("[ProjectAnalyzer] Error in project analysis:", error);
-      if (execution) {
-        execution.abortController = null;
-        execution.query = null;
-      }
-      throw error;
-    }
-  }
-}
-
-module.exports = new ProjectAnalyzer();

app/electron/services/prompt-builder.js

@@ -1,842 +0,0 @@
-const contextManager = require("./context-manager");
-
-/**
- * Prompt Builder - Generates prompts for different agent tasks
- */
-class PromptBuilder {
-  /**
-   * Build the prompt for implementing a specific feature
-   */
-  async buildFeaturePrompt(feature, projectPath) {
-    const skipTestsNote = feature.skipTests
-      ? `\n**⚠️ IMPORTANT - Manual Testing Mode:**\nThis feature has skipTests=true, which means:\n- DO NOT commit changes automatically\n- DO NOT mark as verified - it will automatically go to "waiting_approval" status\n- The user will manually review and commit the changes\n- Just implement the feature and mark it as verified (it will be converted to waiting_approval)\n`
-      : "";
-
-    let imagesNote = "";
-    if (feature.imagePaths && feature.imagePaths.length > 0) {
-      const imagesList = feature.imagePaths
-        .map(
-          (img, idx) =>
-            `   ${idx + 1}. ${img.filename} (${img.mimeType})\n      Path: ${
-              img.path
-            }`
-        )
-        .join("\n");
-
-      imagesNote = `\n**📎 Context Images Attached:**\nThe user has attached ${feature.imagePaths.length} image(s) for context. These images are provided both visually (in the initial message) and as files you can read:
-
-${imagesList}
-
-You can use the Read tool to view these images at any time during implementation. Review them carefully before implementing.\n`;
-    }
-
-    // Get context files preview
-    const contextFilesPreview = await contextManager.getContextFilesPreview(
-      projectPath
-    );
-
-    // Get memory content (lessons learned from previous runs)
-    const memoryContent = await contextManager.getMemoryContent(projectPath);
-
-    // Build mode header for this feature
-    const modeHeader = feature.skipTests
-      ? `**🔨 MODE: Manual Review (No Automated Tests)**
-This feature is set for manual review - focus on clean implementation without automated tests.`
-      : `**🧪 MODE: Test-Driven Development (TDD)**
-This feature requires automated Playwright tests to verify the implementation.`;
-
-    return `You are working on a feature implementation task.
-
-${modeHeader}
-${memoryContent}
-**Current Feature to Implement:**
-
-ID: ${feature.id}
-Category: ${feature.category}
-Description: ${feature.description}
-${skipTestsNote}${imagesNote}${contextFilesPreview}
-**Steps to Complete:**
-${feature.steps.map((step, i) => `${i + 1}. ${step}`).join("\n")}
-
-**Your Task:**
-
-1. Read the project files to understand the current codebase structure
-2. Implement the feature according to the description and steps
-${
-  feature.skipTests
-    ? "3. Test the implementation manually (no automated tests needed for skipTests features)"
-    : "3. Write Playwright tests to verify the feature works correctly\n4. Run the tests and ensure they pass\n5. **DELETE the test file(s) you created** - tests are only for immediate verification"
-}
-${
-  feature.skipTests ? "4" : "6"
-}. **CRITICAL: Use the UpdateFeatureStatus tool to mark this feature as verified** - DO NOT manually edit .automaker/feature_list.json
-${
-  feature.skipTests
-    ? "5. **DO NOT commit changes** - the user will review and commit manually"
-    : "7. Commit your changes with git"
-}
-
-**IMPORTANT - Updating Feature Status:**
-
-When you have completed the feature${
-      feature.skipTests ? "" : " and all tests pass"
-    }, you MUST use the \`mcp__automaker-tools__UpdateFeatureStatus\` tool to update the feature status:
-- Call the tool with: featureId="${feature.id}" and status="verified"
-- **You can also include a summary parameter** to describe what was done: summary="Brief summary of changes"
-- **DO NOT manually edit the .automaker/feature_list.json file** - this can cause race conditions
-- The UpdateFeatureStatus tool safely updates the feature status without risk of corrupting other data
-- **If skipTests=true, the tool will automatically convert "verified" to "waiting_approval"** - this is correct behavior
-
-**IMPORTANT - Feature Summary (REQUIRED):**
-
-When calling UpdateFeatureStatus, you MUST include a summary parameter that describes:
-- What files were modified/created
-- What functionality was added or changed
-- Any notable implementation decisions
-
-Example:
-\`\`\`
-UpdateFeatureStatus(featureId="${
-      feature.id
-    }", status="verified", summary="Added dark mode toggle to settings. Modified: settings.tsx, theme-provider.tsx. Created new useTheme hook.")
-\`\`\`
-
-The summary will be displayed on the Kanban card so the user can see what was done without checking the code.
-
-**Important Guidelines:**
-
-- Focus ONLY on implementing this specific feature
-- Write clean, production-quality code
-- Add proper error handling
-${
-  feature.skipTests
-    ? "- Skip automated testing (skipTests=true) - user will manually verify"
-    : "- Write comprehensive Playwright tests\n- Ensure all existing tests still pass\n- Mark the feature as passing only when all tests are green\n- **CRITICAL: Delete test files after verification** - tests accumulate and become brittle"
-}
-- **CRITICAL: Use UpdateFeatureStatus tool instead of editing feature_list.json directly**
-- **CRITICAL: Always include a summary when marking feature as verified**
-${
-  feature.skipTests
-    ? "- **DO NOT commit changes** - user will review and commit manually"
-    : "- Make a git commit when complete"
-}
-
-**Testing Utilities (CRITICAL):**
-
-1. **Create/maintain tests/utils.ts** - Add helper functions for finding elements and common test operations
-2. **Use utilities in tests** - Import and use helper functions instead of repeating selectors
-3. **Add utilities as needed** - When you write a test, if you need a new helper, add it to utils.ts
-4. **Update utilities when functionality changes** - If you modify components, update corresponding utilities
-
-Example utilities to add:
-- getByTestId(page, testId) - Find elements by data-testid
-- getButtonByText(page, text) - Find buttons by text
-- clickElement(page, testId) - Click an element by test ID
-- fillForm(page, formData) - Fill form fields
-- waitForElement(page, testId) - Wait for element to appear
-
-This makes future tests easier to write and maintain!
-
-**Test Deletion Policy:**
-After tests pass, delete them immediately:
-\`\`\`bash
-rm tests/[feature-name].spec.ts
-\`\`\`
-
-Begin by reading the project structure and then implementing the feature.`;
-  }
-
-  /**
-   * Build the prompt for verifying a specific feature
-   */
-  async buildVerificationPrompt(feature, projectPath) {
-    const skipTestsNote = feature.skipTests
-      ? `\n**⚠️ IMPORTANT - Manual Testing Mode:**\nThis feature has skipTests=true, which means:\n- DO NOT commit changes automatically\n- DO NOT mark as verified - it will automatically go to "waiting_approval" status\n- The user will manually review and commit the changes\n- Just implement the feature and mark it as verified (it will be converted to waiting_approval)\n`
-      : "";
-
-    let imagesNote = "";
-    if (feature.imagePaths && feature.imagePaths.length > 0) {
-      const imagesList = feature.imagePaths
-        .map(
-          (img, idx) =>
-            `   ${idx + 1}. ${img.filename} (${img.mimeType})\n      Path: ${
-              img.path
-            }`
-        )
-        .join("\n");
-
-      imagesNote = `\n**📎 Context Images Attached:**\nThe user has attached ${feature.imagePaths.length} image(s) for context. These images are provided both visually (in the initial message) and as files you can read:
-
-${imagesList}
-
-You can use the Read tool to view these images at any time during implementation. Review them carefully before implementing.\n`;
-    }
-
-    // Get context files preview
-    const contextFilesPreview = await contextManager.getContextFilesPreview(
-      projectPath
-    );
-
-    // Get memory content (lessons learned from previous runs)
-    const memoryContent = await contextManager.getMemoryContent(projectPath);
-
-    // Build mode header for this feature
-    const modeHeader = feature.skipTests
-      ? `**🔨 MODE: Manual Review (No Automated Tests)**
-This feature is set for manual review - focus on completing implementation without automated tests.`
-      : `**🧪 MODE: Test-Driven Development (TDD)**
-This feature requires automated Playwright tests to verify the implementation.`;
-
-    return `You are implementing and verifying a feature until it is complete and working correctly.
-
-${modeHeader}
-${memoryContent}
-
-**Feature to Implement/Verify:**
-
-ID: ${feature.id}
-Category: ${feature.category}
-Description: ${feature.description}
-Current Status: ${feature.status}
-${skipTestsNote}${imagesNote}${contextFilesPreview}
-**Steps that should be implemented:**
-${feature.steps.map((step, i) => `${i + 1}. ${step}`).join("\n")}
-
-**Your Task:**
-
-1. Read the project files to understand the current implementation
-2. If the feature is not fully implemented, continue implementing it
-${
-  feature.skipTests
-    ? "3. Test the implementation manually (no automated tests needed for skipTests features)"
-    : `3. Write or update Playwright tests to verify the feature works correctly
-4. Run the Playwright tests: npx playwright test tests/[feature-name].spec.ts
-5. Check if all tests pass
-6. **If ANY tests fail:**
-   - Analyze the test failures and error messages
-   - Fix the implementation code to make the tests pass
-   - Update test utilities in tests/utils.ts if needed
-   - Re-run the tests to verify the fixes
-   - **REPEAT this process until ALL tests pass**
-7. **If ALL tests pass:**
-   - **DELETE the test file(s) for this feature** - tests are only for immediate verification`
-}
-${
-  feature.skipTests ? "4" : "8"
-}. **CRITICAL: Use the UpdateFeatureStatus tool to mark this feature as verified** - DO NOT manually edit .automaker/feature_list.json
-${
-  feature.skipTests
-    ? "5. **DO NOT commit changes** - the user will review and commit manually"
-    : "9. Explain what was implemented/fixed and that all tests passed\n10. Commit your changes with git"
-}
-
-**IMPORTANT - Updating Feature Status:**
-
-When you have completed the feature${
-      feature.skipTests ? "" : " and all tests pass"
-    }, you MUST use the \`mcp__automaker-tools__UpdateFeatureStatus\` tool to update the feature status:
-- Call the tool with: featureId="${feature.id}" and status="verified"
-- **You can also include a summary parameter** to describe what was done: summary="Brief summary of changes"
-- **DO NOT manually edit the .automaker/feature_list.json file** - this can cause race conditions
-- The UpdateFeatureStatus tool safely updates the feature status without risk of corrupting other data
-- **If skipTests=true, the tool will automatically convert "verified" to "waiting_approval"** - this is correct behavior
-
-**IMPORTANT - Feature Summary (REQUIRED):**
-
-When calling UpdateFeatureStatus, you MUST include a summary parameter that describes:
-- What files were modified/created
-- What functionality was added or changed
-- Any notable implementation decisions
-
-Example:
-\`\`\`
-UpdateFeatureStatus(featureId="${
-      feature.id
-    }", status="verified", summary="Added dark mode toggle to settings. Modified: settings.tsx, theme-provider.tsx. Created new useTheme hook.")
-\`\`\`
-
-The summary will be displayed on the Kanban card so the user can see what was done without checking the code.
-
-**Testing Utilities:**
-- Check if tests/utils.ts exists and is being used
-- If utilities are outdated due to functionality changes, update them
-- Add new utilities as needed for this feature's tests
-- Ensure test utilities stay in sync with code changes
-
-**Test Deletion Policy:**
-After tests pass, delete them immediately:
-\`\`\`bash
-rm tests/[feature-name].spec.ts
-\`\`\`
-
-**Important:**
-${
-  feature.skipTests
-    ? "- Skip automated testing (skipTests=true) - user will manually verify\n- **DO NOT commit changes** - user will review and commit manually"
-    : "- **CONTINUE IMPLEMENTING until all tests pass** - don't stop at the first failure\n- Only mark as verified if Playwright tests pass\n- **CRITICAL: Delete test files after they pass** - tests should not accumulate\n- Update test utilities if functionality changed\n- Make a git commit when the feature is complete\n- Be thorough and persistent in fixing issues"
-}
-- **CRITICAL: Use UpdateFeatureStatus tool instead of editing feature_list.json directly**
-- **CRITICAL: Always include a summary when marking feature as verified**
-
-Begin by reading the project structure and understanding what needs to be implemented or fixed.`;
-  }
-
-  /**
-   * Build prompt for resuming feature with previous context
-   */
-  async buildResumePrompt(feature, previousContext, projectPath) {
-    const skipTestsNote = feature.skipTests
-      ? `\n**⚠️ IMPORTANT - Manual Testing Mode:**\nThis feature has skipTests=true, which means:\n- DO NOT commit changes automatically\n- DO NOT mark as verified - it will automatically go to "waiting_approval" status\n- The user will manually review and commit the changes\n- Just implement the feature and mark it as verified (it will be converted to waiting_approval)\n`
-      : "";
-
-    // For resume, check both followUpImages and imagePaths
-    const imagePaths = feature.followUpImages || feature.imagePaths;
-    let imagesNote = "";
-    if (imagePaths && imagePaths.length > 0) {
-      const imagesList = imagePaths
-        .map((img, idx) => {
-          // Handle both FeatureImagePath objects and simple path strings
-          const path = typeof img === "string" ? img : img.path;
-          const filename =
-            typeof img === "string" ? path.split("/").pop() : img.filename;
-          const mimeType = typeof img === "string" ? "image/*" : img.mimeType;
-          return `   ${
-            idx + 1
-          }. ${filename} (${mimeType})\n      Path: ${path}`;
-        })
-        .join("\n");
-
-      imagesNote = `\n**📎 Context Images Attached:**\nThe user has attached ${imagePaths.length} image(s) for context. These images are provided both visually (in the initial message) and as files you can read:
-
-${imagesList}
-
-You can use the Read tool to view these images at any time. Review them carefully.\n`;
-    }
-
-    // Get context files preview
-    const contextFilesPreview = await contextManager.getContextFilesPreview(
-      projectPath
-    );
-
-    // Get memory content (lessons learned from previous runs)
-    const memoryContent = await contextManager.getMemoryContent(projectPath);
-
-    // Build mode header for this feature
-    const modeHeader = feature.skipTests
-      ? `**🔨 MODE: Manual Review (No Automated Tests)**
-This feature is set for manual review - focus on clean implementation without automated tests.`
-      : `**🧪 MODE: Test-Driven Development (TDD)**
-This feature requires automated Playwright tests to verify the implementation.`;
-
-    return `You are resuming work on a feature implementation that was previously started.
-
-${modeHeader}
-${memoryContent}
-**Current Feature:**
-
-ID: ${feature.id}
-Category: ${feature.category}
-Description: ${feature.description}
-${skipTestsNote}${imagesNote}${contextFilesPreview}
-**Steps to Complete:**
-${feature.steps.map((step, i) => `${i + 1}. ${step}`).join("\n")}
-
-**Previous Work Context:**
-
-${previousContext || "No previous context available - this is a fresh start."}
-
-**Your Task:**
-
-Continue where you left off and complete the feature implementation:
-
-1. Review the previous work context above to understand what has been done
-2. Continue implementing the feature according to the description and steps
-${
-  feature.skipTests
-    ? "3. Test the implementation manually (no automated tests needed for skipTests features)"
-    : "3. Write Playwright tests to verify the feature works correctly (if not already done)\n4. Run the tests and ensure they pass\n5. **DELETE the test file(s) you created** - tests are only for immediate verification"
-}
-${
-  feature.skipTests ? "4" : "6"
-}. **CRITICAL: Use the UpdateFeatureStatus tool to mark this feature as verified** - DO NOT manually edit .automaker/feature_list.json
-${
-  feature.skipTests
-    ? "5. **DO NOT commit changes** - the user will review and commit manually"
-    : "7. Commit your changes with git"
-}
-
-**IMPORTANT - Updating Feature Status:**
-
-When you have completed the feature${
-      feature.skipTests ? "" : " and all tests pass"
-    }, you MUST use the \`mcp__automaker-tools__UpdateFeatureStatus\` tool to update the feature status:
-- Call the tool with: featureId="${feature.id}" and status="verified"
-- **You can also include a summary parameter** to describe what was done: summary="Brief summary of changes"
-- **DO NOT manually edit the .automaker/feature_list.json file** - this can cause race conditions
-- The UpdateFeatureStatus tool safely updates the feature status without risk of corrupting other data
-- **If skipTests=true, the tool will automatically convert "verified" to "waiting_approval"** - this is correct behavior
-
-**IMPORTANT - Feature Summary (REQUIRED):**
-
-When calling UpdateFeatureStatus, you MUST include a summary parameter that describes:
-- What files were modified/created
-- What functionality was added or changed
-- Any notable implementation decisions
-
-Example:
-\`\`\`
-UpdateFeatureStatus(featureId="${
-      feature.id
-    }", status="verified", summary="Added dark mode toggle to settings. Modified: settings.tsx, theme-provider.tsx. Created new useTheme hook.")
-\`\`\`
-
-The summary will be displayed on the Kanban card so the user can see what was done without checking the code.
-
-**Important Guidelines:**
-
-- Review what was already done in the previous context
-- Don't redo work that's already complete - continue from where it left off
-- Focus on completing any remaining tasks
-${
-  feature.skipTests
-    ? "- Skip automated testing (skipTests=true) - user will manually verify"
-    : "- Write comprehensive Playwright tests if not already done\n- Ensure all tests pass before marking as verified\n- **CRITICAL: Delete test files after verification**"
-}
-- **CRITICAL: Use UpdateFeatureStatus tool instead of editing feature_list.json directly**
-- **CRITICAL: Always include a summary when marking feature as verified**
-${
-  feature.skipTests
-    ? "- **DO NOT commit changes** - user will review and commit manually"
-    : "- Make a git commit when complete"
-}
-
-Begin by assessing what's been done and what remains to be completed.`;
-  }
-
-  /**
-   * Build the prompt for project analysis
-   */
-  buildProjectAnalysisPrompt(projectPath) {
-    return `You are analyzing a new project that was just opened in Automaker, an autonomous AI development studio.
-
-**Your Task:**
-
-Analyze this project's codebase and update the .automaker/app_spec.txt file with accurate information about:
-
-1. **Project Name** - Detect the name from package.json, README, or directory name
-2. **Overview** - Brief description of what the project does
-3. **Technology Stack** - Languages, frameworks, libraries detected
-4. **Core Capabilities** - Main features and functionality
-5. **Implemented Features** - What features are already built
-6. **Implementation Roadmap** - Break down remaining work into phases with individual features
-
-**Steps to Follow:**
-
-1. First, explore the project structure:
-   - Look at package.json, cargo.toml, go.mod, requirements.txt, etc. for tech stack
-   - Check README.md for project description
-   - List key directories (src, lib, components, etc.)
-
-2. Identify the tech stack:
-   - Frontend framework (React, Vue, Next.js, etc.)
-   - Backend framework (Express, FastAPI, etc.)
-   - Database (if any config files exist)
-   - Testing framework
-   - Build tools
-
-3. Update .automaker/app_spec.txt with your findings in this format:
-   \`\`\`xml
-   <project_specification>
-     <project_name>Detected Name</project_name>
-
-     <overview>
-       Clear description of what this project does based on your analysis.
-     </overview>
-
-     <technology_stack>
-       <frontend>
-         <framework>Framework Name</framework>
-         <!-- Add detected technologies -->
-       </frontend>
-       <backend>
-         <!-- If applicable -->
-       </backend>
-       <database>
-         <!-- If applicable -->
-       </database>
-       <testing>
-         <!-- Testing frameworks detected -->
-       </testing>
-     </technology_stack>
-
-     <core_capabilities>
-       <!-- List main features/capabilities you found -->
-     </core_capabilities>
-
-     <implemented_features>
-       <!-- List specific features that appear to be implemented -->
-     </implemented_features>
-
-     <implementation_roadmap>
-       <phase_1_foundation>
-         <!-- List foundational features to build first -->
-       </phase_1_foundation>
-       <phase_2_core_logic>
-         <!-- List core logic features -->
-       </phase_2_core_logic>
-       <phase_3_polish>
-         <!-- List polish and enhancement features -->
-       </phase_3_polish>
-     </implementation_roadmap>
-   </project_specification>
-   \`\`\`
-
-4. **IMPORTANT - Generate Feature List:**
-   After writing the app_spec.txt, you MUST update .automaker/feature_list.json with features from the implementation_roadmap section:
-   - Read the app_spec.txt you just created
-   - For EVERY feature in each phase of the implementation_roadmap, create an entry
-   - Write ALL features to .automaker/feature_list.json
-
-   The feature_list.json format should be:
-   \`\`\`json
-   [
-     {
-       "id": "feature-<timestamp>-<index>",
-       "category": "<phase name, e.g., 'Phase 1: Foundation'>",
-       "description": "<feature description>",
-       "status": "backlog",
-       "steps": ["Step 1", "Step 2", "..."],
-       "skipTests": true
-     }
-   ]
-   \`\`\`
-
-   Generate unique IDs using the current timestamp and index (e.g., "feature-1234567890-0", "feature-1234567890-1", etc.)
-
-5. Ensure .automaker/context/ directory exists
-
-6. Ensure .automaker/agents-context/ directory exists
-
-**Important:**
-- Be concise but accurate
-- Only include information you can verify from the codebase
-- If unsure about something, note it as "to be determined"
-- Don't make up features that don't exist
-- Include EVERY feature from the roadmap in feature_list.json - do not skip any
-
-Begin by exploring the project structure.`;
-  }
-
-  /**
-   * Get the system prompt for coding agent
-   * @param {string} projectPath - Path to the project
-   * @param {boolean} isTDD - Whether this is Test-Driven Development mode (skipTests=false)
-   */
-  async getCodingPrompt(projectPath, isTDD = true) {
-    // Get context files preview
-    const contextFilesPreview = projectPath
-      ? await contextManager.getContextFilesPreview(projectPath)
-      : "";
-
-    // Get memory content (lessons learned from previous runs)
-    const memoryContent = projectPath
-      ? await contextManager.getMemoryContent(projectPath)
-      : "";
-
-    // Build mode-specific instructions
-    const modeHeader = isTDD
-      ? `**🧪 MODE: Test-Driven Development (TDD)**
-You are implementing features using TDD methodology. This means:
-- Write Playwright tests BEFORE or alongside implementation
-- Run tests frequently to verify your work
-- Tests are your validation mechanism
-- Delete tests after they pass (they're for immediate verification only)`
-      : `**🔨 MODE: Manual Review (No Automated Tests)**
-You are implementing features for manual user review. This means:
-- Focus on clean, working implementation
-- NO automated test writing required
-- User will manually verify the implementation
-- DO NOT commit changes - user will review and commit`;
-
-    return `You are an AI coding agent working autonomously to implement features.
-
-${modeHeader}
-${memoryContent}
-
-**🚨 CRITICAL FILE PROTECTION - READ THIS FIRST 🚨**
-
-THE FOLLOWING FILE IS ABSOLUTELY FORBIDDEN FROM DIRECT MODIFICATION:
-- .automaker/feature_list.json
-
-**YOU MUST NEVER:**
-- Use the Write tool on feature_list.json
-- Use the Edit tool on feature_list.json
-- Use any Bash command that writes to feature_list.json (echo, sed, awk, etc.)
-- Attempt to read and rewrite feature_list.json
-- UNDER ANY CIRCUMSTANCES touch this file directly
-
-**CATASTROPHIC CONSEQUENCES:**
-Directly modifying feature_list.json can:
-- Erase all project features permanently
-- Corrupt the project state beyond recovery
-- Destroy hours/days of planning work
-- This is a FIREABLE OFFENSE - you will be terminated if you do this
-
-**THE ONLY WAY to update features:**
-Use the mcp__automaker-tools__UpdateFeatureStatus tool with featureId, status, and summary parameters.
-
-${contextFilesPreview}
-
-Your role is to:
-- Implement features exactly as specified
-- Write production-quality code
-- Check if feature.skipTests is true - if so, skip automated testing and don't commit
-- Create comprehensive Playwright tests using testing utilities (only if skipTests is false)
-- Ensure all tests pass before marking features complete (only if skipTests is false)
-- **DELETE test files after successful verification** - tests are only for immediate feature verification (only if skipTests is false)
-- **Use the UpdateFeatureStatus tool to mark features as verified** - NEVER manually edit feature_list.json
-- **Always include a summary parameter when calling UpdateFeatureStatus** - describe what was done
-- Commit working code to git (only if skipTests is false - skipTests features require manual review)
-- Be thorough and detail-oriented
-
-**IMPORTANT - Manual Testing Mode (skipTests=true):**
-If a feature has skipTests=true:
-- DO NOT write automated tests
-- DO NOT commit changes - the user will review and commit manually
-- Still mark the feature as verified using UpdateFeatureStatus - it will automatically convert to "waiting_approval" for manual review
-- The user will manually verify and commit the changes
-
-**IMPORTANT - UpdateFeatureStatus Tool:**
-You have access to the \`mcp__automaker-tools__UpdateFeatureStatus\` tool. When the feature is complete (and all tests pass if skipTests is false), use this tool to update the feature status:
-- Call with featureId, status="verified", and summary="Description of what was done"
-- **DO NOT manually edit .automaker/feature_list.json** - this can cause race conditions and restore old state
-- The tool safely updates the status without corrupting other feature data
-- **If skipTests=true, the tool will automatically convert "verified" to "waiting_approval"** - this is correct
-
-**IMPORTANT - Feature Summary (REQUIRED):**
-When calling UpdateFeatureStatus, you MUST include a summary parameter that describes:
-- What files were modified/created
-- What functionality was added or changed
-- Any notable implementation decisions
-
-Example: summary="Added dark mode toggle. Modified: settings.tsx, theme-provider.tsx. Created useTheme hook."
-
-The summary will be displayed on the Kanban card so the user can quickly see what was done.
-
-**Testing Utilities (CRITICAL):**
-- **Create and maintain tests/utils.ts** with helper functions for finding elements and common operations
-- **Always use utilities in tests** instead of repeating selectors
-- **Add new utilities as you write tests** - if you need a helper, add it to utils.ts
-- **Update utilities when functionality changes** - keep helpers in sync with code changes
-
-This makes future tests easier to write and more maintainable!
-
-**Test Deletion Policy:**
-Tests should NOT accumulate. After a feature is verified:
-1. Run the tests to ensure they pass
-2. Delete the test file for that feature
-3. Use UpdateFeatureStatus tool to mark the feature as "verified"
-
-This prevents test brittleness as the app changes rapidly.
-
-You have full access to:
-- Read and write files
-- Run bash commands
-- Execute tests
-- Delete files (rm command)
-- Make git commits
-- Search and analyze the codebase
-- **UpdateFeatureStatus tool** (mcp__automaker-tools__UpdateFeatureStatus) - Use this to update feature status
-
-**🧠 Learning from Errors - Memory System:**
-
-If you encounter an error or issue that:
-- Took multiple attempts to debug
-- Was caused by a non-obvious codebase quirk
-- Required understanding something specific about this project
-- Could trip up future agent runs
-
-**ADD IT TO MEMORY** by appending to \`.automaker/memory.md\`:
-
-\`\`\`markdown
-### Issue: [Brief Title]
-**Problem:** [1-2 sentence description of the issue]
-**Fix:** [Concise explanation of the solution]
-\`\`\`
-
-Keep entries concise - focus on the essential information needed to avoid the issue in the future. This helps both you and other agents learn from mistakes.
-
-Focus on one feature at a time and complete it fully before finishing. Always delete tests after they pass and use the UpdateFeatureStatus tool.`;
-  }
-
-  /**
-   * Get the system prompt for verification agent
-   * @param {string} projectPath - Path to the project
-   * @param {boolean} isTDD - Whether this is Test-Driven Development mode (skipTests=false)
-   */
-  async getVerificationPrompt(projectPath, isTDD = true) {
-    // Get context files preview
-    const contextFilesPreview = projectPath
-      ? await contextManager.getContextFilesPreview(projectPath)
-      : "";
-
-    // Get memory content (lessons learned from previous runs)
-    const memoryContent = projectPath
-      ? await contextManager.getMemoryContent(projectPath)
-      : "";
-
-    // Build mode-specific instructions
-    const modeHeader = isTDD
-      ? `**🧪 MODE: Test-Driven Development (TDD)**
-You are verifying/completing features using TDD methodology. This means:
-- Run Playwright tests to verify implementation
-- Fix failing tests by updating code
-- Tests are your validation mechanism
-- Delete tests after they pass (they're for immediate verification only)`
-      : `**🔨 MODE: Manual Review (No Automated Tests)**
-You are completing features for manual user review. This means:
-- Focus on clean, working implementation
-- NO automated test writing required
-- User will manually verify the implementation
-- DO NOT commit changes - user will review and commit`;
-
-    return `You are an AI implementation and verification agent focused on completing features and ensuring they work.
-
-${modeHeader}
-${memoryContent}
-**🚨 CRITICAL FILE PROTECTION - READ THIS FIRST 🚨**
-
-THE FOLLOWING FILE IS ABSOLUTELY FORBIDDEN FROM DIRECT MODIFICATION:
-- .automaker/feature_list.json
-
-**YOU MUST NEVER:**
-- Use the Write tool on feature_list.json
-- Use the Edit tool on feature_list.json
-- Use any Bash command that writes to feature_list.json (echo, sed, awk, etc.)
-- Attempt to read and rewrite feature_list.json
-- UNDER ANY CIRCUMSTANCES touch this file directly
-
-**CATASTROPHIC CONSEQUENCES:**
-Directly modifying feature_list.json can:
-- Erase all project features permanently
-- Corrupt the project state beyond recovery
-- Destroy hours/days of planning work
-- This is a FIREABLE OFFENSE - you will be terminated if you do this
-
-**THE ONLY WAY to update features:**
-Use the mcp__automaker-tools__UpdateFeatureStatus tool with featureId, status, and summary parameters.
-
-${contextFilesPreview}
-
-Your role is to:
-- **Continue implementing features until they are complete** - don't stop at the first failure
-- Check if feature.skipTests is true - if so, skip automated testing and don't commit
-- Write or update code to fix failing tests (only if skipTests is false)
-- Run Playwright tests to verify feature implementations (only if skipTests is false)
-- If tests fail, analyze errors and fix the implementation (only if skipTests is false)
-- If other tests fail, verify if those tests are still accurate or should be updated or deleted (only if skipTests is false)
-- Continue rerunning tests and fixing issues until ALL tests pass (only if skipTests is false)
-- **DELETE test files after successful verification** - tests are only for immediate feature verification (only if skipTests is false)
-- **Use the UpdateFeatureStatus tool to mark features as verified** - NEVER manually edit feature_list.json
-- **Always include a summary parameter when calling UpdateFeatureStatus** - describe what was done
-- **Update test utilities (tests/utils.ts) if functionality changed** - keep helpers in sync with code (only if skipTests is false)
-- Commit working code to git (only if skipTests is false - skipTests features require manual review)
-
-**IMPORTANT - Manual Testing Mode (skipTests=true):**
-If a feature has skipTests=true:
-- DO NOT write automated tests
-- DO NOT commit changes - the user will review and commit manually
-- Still mark the feature as verified using UpdateFeatureStatus - it will automatically convert to "waiting_approval" for manual review
-- The user will manually verify and commit the changes
-
-**IMPORTANT - UpdateFeatureStatus Tool:**
-You have access to the \`mcp__automaker-tools__UpdateFeatureStatus\` tool. When the feature is complete (and all tests pass if skipTests is false), use this tool to update the feature status:
-- Call with featureId, status="verified", and summary="Description of what was done"
-- **DO NOT manually edit .automaker/feature_list.json** - this can cause race conditions and restore old state
-- The tool safely updates the status without corrupting other feature data
-- **If skipTests=true, the tool will automatically convert "verified" to "waiting_approval"** - this is correct
-
-**IMPORTANT - Feature Summary (REQUIRED):**
-When calling UpdateFeatureStatus, you MUST include a summary parameter that describes:
-- What files were modified/created
-- What functionality was added or changed
-- Any notable implementation decisions
-
-Example: summary="Fixed login validation. Modified: auth.ts, login-form.tsx. Added password strength check."
-
-The summary will be displayed on the Kanban card so the user can quickly see what was done.
-
-**Testing Utilities:**
-- Check if tests/utils.ts needs updates based on code changes
-- If a component's selectors or behavior changed, update the corresponding utility functions
-- Add new utilities as needed for the feature's tests
-- Ensure utilities remain accurate and helpful for future tests
-
-**Test Deletion Policy:**
-Tests should NOT accumulate. After a feature is verified:
-1. Delete the test file for that feature
-2. Use UpdateFeatureStatus tool to mark the feature as "verified"
-
-This prevents test brittleness as the app changes rapidly.
-
-You have access to:
-- Read and edit files
-- Write new code or modify existing code
-- Run bash commands (especially Playwright tests)
-- Delete files (rm command)
-- Analyze test output
-- Make git commits
-- **UpdateFeatureStatus tool** (mcp__automaker-tools__UpdateFeatureStatus) - Use this to update feature status
-
-**🧠 Learning from Errors - Memory System:**
-
-If you encounter an error or issue that:
-- Took multiple attempts to debug
-- Was caused by a non-obvious codebase quirk
-- Required understanding something specific about this project
-- Could trip up future agent runs
-
-**ADD IT TO MEMORY** by appending to \`.automaker/memory.md\`:
-
-\`\`\`markdown
-### Issue: [Brief Title]
-**Problem:** [1-2 sentence description of the issue]
-**Fix:** [Concise explanation of the solution]
-\`\`\`
-
-Keep entries concise - focus on the essential information needed to avoid the issue in the future. This helps both you and other agents learn from mistakes.
-
-**CRITICAL:** Be persistent and thorough - keep iterating on the implementation until all tests pass. Don't give up after the first failure. Always delete tests after they pass, use the UpdateFeatureStatus tool with a summary, and commit your work.`;
-  }
-
-  /**
-   * Get system prompt for project analysis agent
-   */
-  getProjectAnalysisSystemPrompt() {
-    return `You are a project analysis agent that examines codebases to understand their structure, tech stack, and implemented features.
-
-Your goal is to:
-- Quickly scan and understand project structure
-- Identify programming languages, frameworks, and libraries
-- Detect existing features and capabilities
-- Update the .automaker/app_spec.txt with accurate information
-- Generate a feature list in .automaker/feature_list.json based on the implementation roadmap
-- Ensure all required .automaker files and directories exist
-
-Be efficient - don't read every file, focus on:
-- Configuration files (package.json, tsconfig.json, etc.)
-- Main entry points
-- Directory structure
-- README and documentation
-
-**CRITICAL - Feature List Generation:**
-After creating/updating the app_spec.txt, you MUST also update .automaker/feature_list.json:
-1. Read the app_spec.txt you just wrote
-2. Extract all features from the implementation_roadmap section
-3. Write them to .automaker/feature_list.json in the correct format
-
-You have access to Read, Write, Edit, Glob, Grep, and Bash tools. Use them to explore the structure and write the necessary files.`;
-  }
-}
-
-module.exports = new PromptBuilder();

app/electron/services/spec-regeneration-service.js

@@ -1,519 +0,0 @@
-const { query, AbortError } = require("@anthropic-ai/claude-agent-sdk");
-const fs = require("fs/promises");
-const path = require("path");
-
-/**
- * XML template for app_spec.txt
- */
-const APP_SPEC_XML_TEMPLATE = `<project_specification>
-  <project_name></project_name>
-
-  <overview>
-  </overview>
-
-  <technology_stack>
-    <frontend>
-      <framework></framework>
-      <ui_library></ui_library>
-      <styling></styling>
-      <state_management></state_management>
-      <drag_drop></drag_drop>
-      <icons></icons>
-    </frontend>
-    <desktop_shell>
-      <framework></framework>
-      <language></language>
-      <inter_process_communication></inter_process_communication>
-      <file_system></file_system>
-    </desktop_shell>
-    <ai_engine>
-      <logic_model></logic_model>
-      <design_model></design_model>
-      <orchestration></orchestration>
-    </ai_engine>
-    <testing>
-      <framework></framework>
-      <unit></unit>
-    </testing>
-  </technology_stack>
-
-  <core_capabilities>
-    <project_management>
-    </project_management>
-
-    <intelligent_analysis>
-    </intelligent_analysis>
-
-    <kanban_workflow>
-    </kanban_workflow>
-
-    <autonomous_agent_engine>
-    </autonomous_agent_engine>
-
-    <extensibility>
-    </extensibility>
-  </core_capabilities>
-
-  <ui_layout>
-    <window_structure>
-    </window_structure>
-    <theme>
-    </theme>
-  </ui_layout>
-
-  <development_workflow>
-    <local_testing>
-    </local_testing>
-  </development_workflow>
-
-  <implementation_roadmap>
-    <phase_1_foundation>
-    </phase_1_foundation>
-    <phase_2_core_logic>
-    </phase_2_core_logic>
-    <phase_3_kanban_and_interaction>
-    </phase_3_kanban_and_interaction>
-    <phase_4_polish>
-    </phase_4_polish>
-  </implementation_roadmap>
-</project_specification>`;
-
-/**
- * Spec Regeneration Service - Regenerates app spec based on project description and tech stack
- */
-class SpecRegenerationService {
-  constructor() {
-    this.runningRegeneration = null;
-  }
-
-  /**
-   * Create initial app spec for a new project
-   * @param {string} projectPath - Path to the project
-   * @param {string} projectOverview - User's project description
-   * @param {Function} sendToRenderer - Function to send events to renderer
-   * @param {Object} execution - Execution context with abort controller
-   * @param {boolean} generateFeatures - Whether to generate feature_list.json entries
-   */
-  async createInitialSpec(projectPath, projectOverview, sendToRenderer, execution, generateFeatures = true) {
-    console.log(`[SpecRegeneration] Creating initial spec for: ${projectPath}, generateFeatures: ${generateFeatures}`);
-
-    try {
-      const abortController = new AbortController();
-      execution.abortController = abortController;
-
-      const options = {
-        model: "claude-sonnet-4-20250514",
-        systemPrompt: this.getInitialCreationSystemPrompt(generateFeatures),
-        maxTurns: 50,
-        cwd: projectPath,
-        allowedTools: ["Read", "Write", "Edit", "Glob", "Grep", "Bash"],
-        permissionMode: "acceptEdits",
-        sandbox: {
-          enabled: true,
-          autoAllowBashIfSandboxed: true,
-        },
-        abortController: abortController,
-      };
-
-      const prompt = this.buildInitialCreationPrompt(projectOverview, generateFeatures);
-
-      sendToRenderer({
-        type: "spec_regeneration_progress",
-        content: "Starting project analysis and spec creation...\n",
-      });
-
-      const currentQuery = query({ prompt, options });
-      execution.query = currentQuery;
-
-      let fullResponse = "";
-      for await (const msg of currentQuery) {
-        if (!execution.isActive()) break;
-
-        if (msg.type === "assistant" && msg.message?.content) {
-          for (const block of msg.message.content) {
-            if (block.type === "text") {
-              fullResponse += block.text;
-              sendToRenderer({
-                type: "spec_regeneration_progress",
-                content: block.text,
-              });
-            } else if (block.type === "tool_use") {
-              sendToRenderer({
-                type: "spec_regeneration_tool",
-                tool: block.name,
-                input: block.input,
-              });
-            }
-          }
-        }
-      }
-
-      execution.query = null;
-      execution.abortController = null;
-
-      sendToRenderer({
-        type: "spec_regeneration_complete",
-        message: "Initial spec creation complete!",
-      });
-
-      return {
-        success: true,
-        message: "Initial spec creation complete",
-      };
-    } catch (error) {
-      if (error instanceof AbortError || error?.name === "AbortError") {
-        console.log("[SpecRegeneration] Creation aborted");
-        if (execution) {
-          execution.abortController = null;
-          execution.query = null;
-        }
-        return {
-          success: false,
-          message: "Creation aborted",
-        };
-      }
-
-      console.error("[SpecRegeneration] Error creating initial spec:", error);
-      if (execution) {
-        execution.abortController = null;
-        execution.query = null;
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Get the system prompt for initial spec creation
-   * @param {boolean} generateFeatures - Whether features should be generated
-   */
-  getInitialCreationSystemPrompt(generateFeatures = true) {
-    const featureListInstructions = generateFeatures
-      ? `
-**FEATURE LIST GENERATION**
-
-After creating the app_spec.txt, you MUST also update the .automaker/feature_list.json file with all features from the implementation_roadmap section.
-
-For EACH feature in each phase of the implementation_roadmap:
-1. Read the app_spec.txt you just created
-2. Extract every single feature from each phase (phase_1, phase_2, phase_3, phase_4, etc.)
-3. Write ALL features to .automaker/feature_list.json in order
-
-The feature_list.json format should be:
-\`\`\`json
-[
-  {
-    "id": "feature-<timestamp>-<index>",
-    "category": "<phase name, e.g., 'Phase 1: Foundation'>",
-    "description": "<feature description>",
-    "status": "backlog",
-    "steps": ["Step 1", "Step 2", "..."],
-    "skipTests": true
-  }
-]
-\`\`\`
-
-IMPORTANT: Include EVERY feature from the implementation_roadmap. Do not skip any.`
-      : `
-**CRITICAL FILE PROTECTION**
-
-THE FOLLOWING FILE IS ABSOLUTELY FORBIDDEN FROM DIRECT MODIFICATION:
-- .automaker/feature_list.json
-
-**YOU MUST NEVER:**
-- Use the Write tool on .automaker/feature_list.json
-- Use the Edit tool on .automaker/feature_list.json
-- Use any Bash command that writes to .automaker/feature_list.json`;
-
-    return `You are an expert software architect and product manager. Your job is to analyze an existing codebase and generate a comprehensive application specification based on a user's project overview.
-
-You should:
-1. First, thoroughly analyze the project structure to understand the existing tech stack
-2. Read key configuration files (package.json, tsconfig.json, Cargo.toml, requirements.txt, etc.) to understand dependencies and frameworks
-3. Understand the current architecture and patterns used
-4. Based on the user's project overview, create a comprehensive app specification
-5. Be liberal and comprehensive when defining features - include everything needed for a complete, polished application
-6. Use the XML template format provided
-7. Write the specification to .automaker/app_spec.txt
-
-When analyzing, look at:
-- package.json, cargo.toml, requirements.txt or similar config files for tech stack
-- Source code structure and organization
-- Framework-specific patterns (Next.js, React, Django, etc.)
-- Database configurations and schemas
-- API structures and patterns
-${featureListInstructions}
-
-You CAN and SHOULD modify:
-- .automaker/app_spec.txt (this is your primary target)${generateFeatures ? '\n- .automaker/feature_list.json (to populate features from implementation_roadmap)' : ''}
-
-You have access to file reading, writing, and search tools. Use them to understand the codebase and write the new spec.`;
-  }
-
-  /**
-   * Build the prompt for initial spec creation
-   * @param {string} projectOverview - User's project description
-   * @param {boolean} generateFeatures - Whether to generate feature_list.json entries
-   */
-  buildInitialCreationPrompt(projectOverview, generateFeatures = true) {
-    const featureGenerationStep = generateFeatures
-      ? `
-5. **IMPORTANT - GENERATE FEATURE LIST**: After writing the app_spec.txt:
-   - Read back the app_spec.txt file you just created
-   - Look at the implementation_roadmap section
-   - For EVERY feature listed in each phase (phase_1, phase_2, phase_3, phase_4, etc.), create an entry
-   - Write ALL these features to \`.automaker/feature_list.json\` in the order they appear
-   - Each feature should have: id (feature-timestamp-index), category (phase name), description, status: "backlog", steps array, and skipTests: true
-   - Do NOT skip any features - include every single one from the roadmap`
-      : '';
-
-    return `I need you to create an initial application specification for my project. I haven't set up an app_spec.txt yet, so this will be the first one.
-
-**My Project Overview:**
-${projectOverview}
-
-**Your Task:**
-
-1. First, explore the project to understand the existing tech stack:
-   - Read package.json, Cargo.toml, requirements.txt, or similar config files
-   - Identify all frameworks and libraries being used
-   - Understand the current project structure and architecture
-   - Note any database, authentication, or other infrastructure in use
-
-2. Based on my project overview and the existing tech stack, create a comprehensive app specification using this XML template:
-
-\`\`\`xml
-${APP_SPEC_XML_TEMPLATE}
-\`\`\`
-
-3. Fill out the template with:
-   - **project_name**: Extract from the project or derive from overview
-   - **overview**: A clear description based on my project overview
-   - **technology_stack**: All technologies you discover in the project (fill out the relevant sections, remove irrelevant ones)
-   - **core_capabilities**: List all the major capabilities the app should have based on my overview
-   - **ui_layout**: Describe the UI structure if relevant
-   - **development_workflow**: Note any testing or development patterns
-   - **implementation_roadmap**: Break down the features into phases - be VERY detailed here, listing every feature that needs to be built
-
-4. **IMPORTANT**: Write the complete specification to the file \`.automaker/app_spec.txt\`
-${featureGenerationStep}
-
-**Guidelines:**
-- Be comprehensive! Include ALL features needed for a complete application
-- Only include technology_stack sections that are relevant (e.g., skip desktop_shell if it's a web-only app)
-- Add new sections to core_capabilities as needed for the specific project
-- The implementation_roadmap should reflect logical phases for building out the app - list EVERY feature individually
-- Consider user flows, error states, and edge cases when defining features
-- Each phase should have multiple specific, actionable features
-
-Begin by exploring the project structure.`;
-  }
-
-  /**
-   * Regenerate the app spec based on user's project definition
-   */
-  async regenerateSpec(projectPath, projectDefinition, sendToRenderer, execution) {
-    console.log(`[SpecRegeneration] Regenerating spec for: ${projectPath}`);
-
-    try {
-      const abortController = new AbortController();
-      execution.abortController = abortController;
-
-      const options = {
-        model: "claude-sonnet-4-20250514",
-        systemPrompt: this.getSystemPrompt(),
-        maxTurns: 50,
-        cwd: projectPath,
-        allowedTools: ["Read", "Write", "Edit", "Glob", "Grep", "Bash"],
-        permissionMode: "acceptEdits",
-        sandbox: {
-          enabled: true,
-          autoAllowBashIfSandboxed: true,
-        },
-        abortController: abortController,
-      };
-
-      const prompt = this.buildRegenerationPrompt(projectDefinition);
-
-      sendToRenderer({
-        type: "spec_regeneration_progress",
-        content: "Starting spec regeneration...\n",
-      });
-
-      const currentQuery = query({ prompt, options });
-      execution.query = currentQuery;
-
-      let fullResponse = "";
-      for await (const msg of currentQuery) {
-        if (!execution.isActive()) break;
-
-        if (msg.type === "assistant" && msg.message?.content) {
-          for (const block of msg.message.content) {
-            if (block.type === "text") {
-              fullResponse += block.text;
-              sendToRenderer({
-                type: "spec_regeneration_progress",
-                content: block.text,
-              });
-            } else if (block.type === "tool_use") {
-              sendToRenderer({
-                type: "spec_regeneration_tool",
-                tool: block.name,
-                input: block.input,
-              });
-            }
-          }
-        }
-      }
-
-      execution.query = null;
-      execution.abortController = null;
-
-      sendToRenderer({
-        type: "spec_regeneration_complete",
-        message: "Spec regeneration complete!",
-      });
-
-      return {
-        success: true,
-        message: "Spec regeneration complete",
-      };
-    } catch (error) {
-      if (error instanceof AbortError || error?.name === "AbortError") {
-        console.log("[SpecRegeneration] Regeneration aborted");
-        if (execution) {
-          execution.abortController = null;
-          execution.query = null;
-        }
-        return {
-          success: false,
-          message: "Regeneration aborted",
-        };
-      }
-
-      console.error("[SpecRegeneration] Error regenerating spec:", error);
-      if (execution) {
-        execution.abortController = null;
-        execution.query = null;
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Get the system prompt for spec regeneration
-   */
-  getSystemPrompt() {
-    return `You are an expert software architect and product manager. Your job is to analyze an existing codebase and generate a comprehensive application specification based on a user's project definition.
-
-You should:
-1. First, thoroughly analyze the project structure to understand the existing tech stack
-2. Read key configuration files (package.json, tsconfig.json, etc.) to understand dependencies and frameworks
-3. Understand the current architecture and patterns used
-4. Based on the user's project definition, create a comprehensive app specification that includes ALL features needed to realize their vision
-5. Be liberal and comprehensive when defining features - include everything needed for a complete, polished application
-6. Write the specification to .automaker/app_spec.txt
-
-When analyzing, look at:
-- package.json, cargo.toml, or similar config files for tech stack
-- Source code structure and organization
-- Framework-specific patterns (Next.js, React, etc.)
-- Database configurations and schemas
-- API structures and patterns
-
-**CRITICAL FILE PROTECTION**
-
-THE FOLLOWING FILE IS ABSOLUTELY FORBIDDEN FROM DIRECT MODIFICATION:
-- .automaker/feature_list.json
-
-**YOU MUST NEVER:**
-- Use the Write tool on .automaker/feature_list.json
-- Use the Edit tool on .automaker/feature_list.json
-- Use any Bash command that writes to .automaker/feature_list.json
-
-You CAN and SHOULD modify:
-- .automaker/app_spec.txt (this is your primary target)
-
-You have access to file reading, writing, and search tools. Use them to understand the codebase and write the new spec.`;
-  }
-
-  /**
-   * Build the prompt for regenerating the spec
-   */
-  buildRegenerationPrompt(projectDefinition) {
-    return `I need you to regenerate my application specification based on the following project definition. Be very comprehensive and liberal when defining features - I want a complete, polished application.
-
-**My Project Definition:**
-${projectDefinition}
-
-**Your Task:**
-
-1. First, explore the project to understand the existing tech stack:
-   - Read package.json or similar config files
-   - Identify all frameworks and libraries being used
-   - Understand the current project structure and architecture
-   - Note any database, authentication, or other infrastructure in use
-
-2. Based on my project definition and the existing tech stack, create a comprehensive app specification that includes:
-   - Product Overview: A clear description of what the app does
-   - Tech Stack: All technologies currently in use
-   - Features: A COMPREHENSIVE list of all features needed to realize my vision
-     - Be liberal! Include all features that would make this a complete, production-ready application
-     - Include core features, supporting features, and nice-to-have features
-     - Think about user experience, error handling, edge cases, etc.
-   - Architecture Notes: Any important architectural decisions or patterns
-
-3. **IMPORTANT**: Write the complete specification to the file \`.automaker/app_spec.txt\`
-
-**Format Guidelines for the Spec:**
-
-Use this general structure:
-
-\`\`\`
-# [App Name] - Application Specification
-
-## Product Overview
-[Description of what the app does and its purpose]
-
-## Tech Stack
-- Frontend: [frameworks, libraries]
-- Backend: [frameworks, APIs]
-- Database: [if applicable]
-- Other: [other relevant tech]
-
-## Features
-
-### [Category 1]
-- **[Feature Name]**: [Detailed description of the feature]
-- **[Feature Name]**: [Detailed description]
-...
-
-### [Category 2]
-- **[Feature Name]**: [Detailed description]
-...
-
-## Architecture Notes
-[Any important architectural notes, patterns, or conventions]
-\`\`\`
-
-**Remember:**
-- Be comprehensive! Include ALL features needed for a complete application
-- Consider user flows, error states, loading states, etc.
-- Include authentication, authorization if relevant
-- Think about what would make this a polished, production-ready app
-- The more detailed and complete the spec, the better
-
-Begin by exploring the project structure.`;
-  }
-
-  /**
-   * Stop the current regeneration
-   */
-  stop() {
-    if (this.runningRegeneration && this.runningRegeneration.abortController) {
-      this.runningRegeneration.abortController.abort();
-    }
-    this.runningRegeneration = null;
-  }
-}
-
-module.exports = new SpecRegenerationService();

app/electron/services/worktree-manager.js

@@ -1,576 +0,0 @@
-const path = require("path");
-const fs = require("fs/promises");
-const { exec, spawn } = require("child_process");
-const { promisify } = require("util");
-
-const execAsync = promisify(exec);
-
-/**
- * Worktree Manager - Handles git worktrees for feature isolation
- *
- * This service creates isolated git worktrees for each feature, allowing:
- * - Features to be worked on in isolation without affecting the main branch
- * - Easy rollback/revert by simply deleting the worktree
- * - Checkpointing - user can see changes in the worktree before merging
- */
-class WorktreeManager {
-  constructor() {
-    // Cache for worktree info
-    this.worktreeCache = new Map();
-  }
-
-  /**
-   * Get the base worktree directory path
-   */
-  getWorktreeBasePath(projectPath) {
-    return path.join(projectPath, ".automaker", "worktrees");
-  }
-
-  /**
-   * Generate a safe branch name from feature description
-   */
-  generateBranchName(feature) {
-    // Create a slug from the description
-    const slug = feature.description
-      .toLowerCase()
-      .replace(/[^a-z0-9\s-]/g, "") // Remove special chars
-      .replace(/\s+/g, "-") // Replace spaces with hyphens
-      .substring(0, 40); // Limit length
-
-    // Add feature ID for uniqueness
-    const shortId = feature.id.replace("feature-", "").substring(0, 12);
-    return `feature/${shortId}-${slug}`;
-  }
-
-  /**
-   * Check if the project is a git repository
-   */
-  async isGitRepo(projectPath) {
-    try {
-      await execAsync("git rev-parse --is-inside-work-tree", { cwd: projectPath });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Get the current branch name
-   */
-  async getCurrentBranch(projectPath) {
-    try {
-      const { stdout } = await execAsync("git rev-parse --abbrev-ref HEAD", { cwd: projectPath });
-      return stdout.trim();
-    } catch (error) {
-      console.error("[WorktreeManager] Failed to get current branch:", error);
-      return null;
-    }
-  }
-
-  /**
-   * Check if a branch exists (local or remote)
-   */
-  async branchExists(projectPath, branchName) {
-    try {
-      await execAsync(`git rev-parse --verify ${branchName}`, { cwd: projectPath });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * List all existing worktrees
-   */
-  async listWorktrees(projectPath) {
-    try {
-      const { stdout } = await execAsync("git worktree list --porcelain", { cwd: projectPath });
-      const worktrees = [];
-      const lines = stdout.split("\n");
-
-      let currentWorktree = null;
-      for (const line of lines) {
-        if (line.startsWith("worktree ")) {
-          if (currentWorktree) {
-            worktrees.push(currentWorktree);
-          }
-          currentWorktree = { path: line.replace("worktree ", "") };
-        } else if (line.startsWith("branch ") && currentWorktree) {
-          currentWorktree.branch = line.replace("branch refs/heads/", "");
-        } else if (line.startsWith("HEAD ") && currentWorktree) {
-          currentWorktree.head = line.replace("HEAD ", "");
-        }
-      }
-      if (currentWorktree) {
-        worktrees.push(currentWorktree);
-      }
-
-      return worktrees;
-    } catch (error) {
-      console.error("[WorktreeManager] Failed to list worktrees:", error);
-      return [];
-    }
-  }
-
-  /**
-   * Create a worktree for a feature
-   * @param {string} projectPath - Path to the main project
-   * @param {object} feature - Feature object with id and description
-   * @returns {object} - { success, worktreePath, branchName, error }
-   */
-  async createWorktree(projectPath, feature) {
-    console.log(`[WorktreeManager] Creating worktree for feature: ${feature.id}`);
-
-    // Check if project is a git repo
-    if (!await this.isGitRepo(projectPath)) {
-      return { success: false, error: "Project is not a git repository" };
-    }
-
-    const branchName = this.generateBranchName(feature);
-    const worktreeBasePath = this.getWorktreeBasePath(projectPath);
-    const worktreePath = path.join(worktreeBasePath, branchName.replace("feature/", ""));
-
-    try {
-      // Ensure worktree directory exists
-      await fs.mkdir(worktreeBasePath, { recursive: true });
-
-      // Check if worktree already exists
-      const worktrees = await this.listWorktrees(projectPath);
-      const existingWorktree = worktrees.find(
-        w => w.path === worktreePath || w.branch === branchName
-      );
-
-      if (existingWorktree) {
-        console.log(`[WorktreeManager] Worktree already exists for feature: ${feature.id}`);
-        return {
-          success: true,
-          worktreePath: existingWorktree.path,
-          branchName: existingWorktree.branch,
-          existed: true,
-        };
-      }
-
-      // Get current branch to base the new branch on
-      const baseBranch = await this.getCurrentBranch(projectPath);
-      if (!baseBranch) {
-        return { success: false, error: "Could not determine current branch" };
-      }
-
-      // Check if branch already exists
-      const branchExists = await this.branchExists(projectPath, branchName);
-
-      if (branchExists) {
-        // Use existing branch
-        console.log(`[WorktreeManager] Using existing branch: ${branchName}`);
-        await execAsync(`git worktree add "${worktreePath}" ${branchName}`, { cwd: projectPath });
-      } else {
-        // Create new worktree with new branch
-        console.log(`[WorktreeManager] Creating new branch: ${branchName} based on ${baseBranch}`);
-        await execAsync(`git worktree add -b ${branchName} "${worktreePath}" ${baseBranch}`, { cwd: projectPath });
-      }
-
-      // Copy .automaker directory to worktree (except worktrees directory itself to avoid recursion)
-      const automakerSrc = path.join(projectPath, ".automaker");
-      const automakerDst = path.join(worktreePath, ".automaker");
-
-      try {
-        await fs.mkdir(automakerDst, { recursive: true });
-
-        // Copy feature_list.json
-        const featureListSrc = path.join(automakerSrc, "feature_list.json");
-        const featureListDst = path.join(automakerDst, "feature_list.json");
-        try {
-          const content = await fs.readFile(featureListSrc, "utf-8");
-          await fs.writeFile(featureListDst, content, "utf-8");
-        } catch {
-          // Feature list might not exist yet
-        }
-
-        // Copy app_spec.txt if it exists
-        const appSpecSrc = path.join(automakerSrc, "app_spec.txt");
-        const appSpecDst = path.join(automakerDst, "app_spec.txt");
-        try {
-          const content = await fs.readFile(appSpecSrc, "utf-8");
-          await fs.writeFile(appSpecDst, content, "utf-8");
-        } catch {
-          // App spec might not exist yet
-        }
-
-        // Copy categories.json if it exists
-        const categoriesSrc = path.join(automakerSrc, "categories.json");
-        const categoriesDst = path.join(automakerDst, "categories.json");
-        try {
-          const content = await fs.readFile(categoriesSrc, "utf-8");
-          await fs.writeFile(categoriesDst, content, "utf-8");
-        } catch {
-          // Categories might not exist yet
-        }
-      } catch (error) {
-        console.warn("[WorktreeManager] Failed to copy .automaker directory:", error);
-      }
-
-      // Store worktree info in cache
-      this.worktreeCache.set(feature.id, {
-        worktreePath,
-        branchName,
-        createdAt: new Date().toISOString(),
-        baseBranch,
-      });
-
-      console.log(`[WorktreeManager] Worktree created at: ${worktreePath}`);
-      return {
-        success: true,
-        worktreePath,
-        branchName,
-        baseBranch,
-        existed: false,
-      };
-    } catch (error) {
-      console.error("[WorktreeManager] Failed to create worktree:", error);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Get worktree info for a feature
-   */
-  async getWorktreeInfo(projectPath, featureId) {
-    // Check cache first
-    if (this.worktreeCache.has(featureId)) {
-      return { success: true, ...this.worktreeCache.get(featureId) };
-    }
-
-    // Scan worktrees to find matching one
-    const worktrees = await this.listWorktrees(projectPath);
-    const worktreeBasePath = this.getWorktreeBasePath(projectPath);
-
-    for (const worktree of worktrees) {
-      // Check if this worktree is in our worktree directory
-      if (worktree.path.startsWith(worktreeBasePath)) {
-        // Check if the feature ID is in the branch name
-        const shortId = featureId.replace("feature-", "").substring(0, 12);
-        if (worktree.branch && worktree.branch.includes(shortId)) {
-          const info = {
-            worktreePath: worktree.path,
-            branchName: worktree.branch,
-            head: worktree.head,
-          };
-          this.worktreeCache.set(featureId, info);
-          return { success: true, ...info };
-        }
-      }
-    }
-
-    return { success: false, error: "Worktree not found" };
-  }
-
-  /**
-   * Remove a worktree for a feature
-   * This effectively reverts all changes made by the agent
-   */
-  async removeWorktree(projectPath, featureId, deleteBranch = false) {
-    console.log(`[WorktreeManager] Removing worktree for feature: ${featureId}`);
-
-    const worktreeInfo = await this.getWorktreeInfo(projectPath, featureId);
-    if (!worktreeInfo.success) {
-      console.log(`[WorktreeManager] No worktree found for feature: ${featureId}`);
-      return { success: true, message: "No worktree to remove" };
-    }
-
-    const { worktreePath, branchName } = worktreeInfo;
-
-    try {
-      // Remove the worktree
-      await execAsync(`git worktree remove "${worktreePath}" --force`, { cwd: projectPath });
-      console.log(`[WorktreeManager] Worktree removed: ${worktreePath}`);
-
-      // Optionally delete the branch too
-      if (deleteBranch && branchName) {
-        try {
-          await execAsync(`git branch -D ${branchName}`, { cwd: projectPath });
-          console.log(`[WorktreeManager] Branch deleted: ${branchName}`);
-        } catch (error) {
-          console.warn(`[WorktreeManager] Could not delete branch ${branchName}:`, error.message);
-        }
-      }
-
-      // Remove from cache
-      this.worktreeCache.delete(featureId);
-
-      return { success: true, removedPath: worktreePath, removedBranch: deleteBranch ? branchName : null };
-    } catch (error) {
-      console.error("[WorktreeManager] Failed to remove worktree:", error);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Get status of changes in a worktree
-   */
-  async getWorktreeStatus(worktreePath) {
-    try {
-      const { stdout: statusOutput } = await execAsync("git status --porcelain", { cwd: worktreePath });
-      const { stdout: diffStat } = await execAsync("git diff --stat", { cwd: worktreePath });
-      const { stdout: commitLog } = await execAsync("git log --oneline -10", { cwd: worktreePath });
-
-      const files = statusOutput.trim().split("\n").filter(Boolean);
-      const commits = commitLog.trim().split("\n").filter(Boolean);
-
-      return {
-        success: true,
-        modifiedFiles: files.length,
-        files: files.slice(0, 20), // Limit to 20 files
-        diffStat: diffStat.trim(),
-        recentCommits: commits.slice(0, 5), // Last 5 commits
-      };
-    } catch (error) {
-      console.error("[WorktreeManager] Failed to get worktree status:", error);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Get detailed file diff content for a worktree
-   * Returns unified diff format for all changes
-   */
-  async getFileDiffs(worktreePath) {
-    try {
-      // Get both staged and unstaged diffs
-      const { stdout: unstagedDiff } = await execAsync("git diff --no-color", {
-        cwd: worktreePath,
-        maxBuffer: 10 * 1024 * 1024 // 10MB buffer for large diffs
-      });
-      const { stdout: stagedDiff } = await execAsync("git diff --cached --no-color", {
-        cwd: worktreePath,
-        maxBuffer: 10 * 1024 * 1024
-      });
-
-      // Get list of files with their status
-      const { stdout: statusOutput } = await execAsync("git status --porcelain", { cwd: worktreePath });
-      const files = statusOutput.trim().split("\n").filter(Boolean);
-
-      // Parse file statuses
-      const fileStatuses = files.map(line => {
-        const status = line.substring(0, 2);
-        const filePath = line.substring(3);
-        return {
-          status: status.trim() || 'M',
-          path: filePath,
-          statusText: this.getStatusText(status)
-        };
-      });
-
-      // Combine diffs
-      const combinedDiff = [stagedDiff, unstagedDiff].filter(Boolean).join("\n");
-
-      return {
-        success: true,
-        diff: combinedDiff,
-        files: fileStatuses,
-        hasChanges: files.length > 0
-      };
-    } catch (error) {
-      console.error("[WorktreeManager] Failed to get file diffs:", error);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Get human-readable status text from git status code
-   */
-  getStatusText(status) {
-    const statusMap = {
-      'M': 'Modified',
-      'A': 'Added',
-      'D': 'Deleted',
-      'R': 'Renamed',
-      'C': 'Copied',
-      'U': 'Updated',
-      '?': 'Untracked',
-      '!': 'Ignored'
-    };
-    const firstChar = status.charAt(0);
-    const secondChar = status.charAt(1);
-    return statusMap[firstChar] || statusMap[secondChar] || 'Changed';
-  }
-
-  /**
-   * Get diff for a specific file in a worktree
-   */
-  async getFileDiff(worktreePath, filePath) {
-    try {
-      // Try to get unstaged diff first, then staged if no unstaged changes
-      let diff = '';
-      try {
-        const { stdout } = await execAsync(`git diff --no-color -- "${filePath}"`, {
-          cwd: worktreePath,
-          maxBuffer: 5 * 1024 * 1024
-        });
-        diff = stdout;
-      } catch {
-        // File might be staged
-      }
-
-      if (!diff) {
-        try {
-          const { stdout } = await execAsync(`git diff --cached --no-color -- "${filePath}"`, {
-            cwd: worktreePath,
-            maxBuffer: 5 * 1024 * 1024
-          });
-          diff = stdout;
-        } catch {
-          // File might be untracked, show the content
-        }
-      }
-
-      // If still no diff, might be an untracked file - show the content
-      if (!diff) {
-        try {
-          const fullPath = path.join(worktreePath, filePath);
-          const content = await fs.readFile(fullPath, 'utf-8');
-          diff = `+++ ${filePath} (new file)\n${content.split('\n').map(l => '+' + l).join('\n')}`;
-        } catch {
-          diff = '(Unable to read file content)';
-        }
-      }
-
-      return {
-        success: true,
-        diff,
-        filePath
-      };
-    } catch (error) {
-      console.error(`[WorktreeManager] Failed to get diff for ${filePath}:`, error);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Merge worktree changes back to the main branch
-   */
-  async mergeWorktree(projectPath, featureId, options = {}) {
-    console.log(`[WorktreeManager] Merging worktree for feature: ${featureId}`);
-
-    const worktreeInfo = await this.getWorktreeInfo(projectPath, featureId);
-    if (!worktreeInfo.success) {
-      return { success: false, error: "Worktree not found" };
-    }
-
-    const { branchName, worktreePath } = worktreeInfo;
-    const baseBranch = await this.getCurrentBranch(projectPath);
-
-    try {
-      // First commit any uncommitted changes in the worktree
-      const { stdout: status } = await execAsync("git status --porcelain", { cwd: worktreePath });
-      if (status.trim()) {
-        // There are uncommitted changes - commit them
-        await execAsync("git add -A", { cwd: worktreePath });
-        const commitMsg = options.commitMessage || `feat: complete ${featureId}`;
-        await execAsync(`git commit -m "${commitMsg}"`, { cwd: worktreePath });
-      }
-
-      // Merge the feature branch into the current branch in the main repo
-      if (options.squash) {
-        await execAsync(`git merge --squash ${branchName}`, { cwd: projectPath });
-        const squashMsg = options.squashMessage || `feat: ${featureId} - squashed merge`;
-        await execAsync(`git commit -m "${squashMsg}"`, { cwd: projectPath });
-      } else {
-        await execAsync(`git merge ${branchName} --no-ff -m "Merge ${branchName}"`, { cwd: projectPath });
-      }
-
-      console.log(`[WorktreeManager] Successfully merged ${branchName} into ${baseBranch}`);
-
-      // Optionally cleanup worktree after merge
-      if (options.cleanup) {
-        await this.removeWorktree(projectPath, featureId, true);
-      }
-
-      return {
-        success: true,
-        mergedBranch: branchName,
-        intoBranch: baseBranch,
-      };
-    } catch (error) {
-      console.error("[WorktreeManager] Failed to merge worktree:", error);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Sync changes from main branch to worktree (rebase or merge)
-   */
-  async syncWorktree(projectPath, featureId, method = "rebase") {
-    console.log(`[WorktreeManager] Syncing worktree for feature: ${featureId}`);
-
-    const worktreeInfo = await this.getWorktreeInfo(projectPath, featureId);
-    if (!worktreeInfo.success) {
-      return { success: false, error: "Worktree not found" };
-    }
-
-    const { worktreePath, baseBranch } = worktreeInfo;
-
-    try {
-      if (method === "rebase") {
-        await execAsync(`git rebase ${baseBranch}`, { cwd: worktreePath });
-      } else {
-        await execAsync(`git merge ${baseBranch}`, { cwd: worktreePath });
-      }
-
-      return { success: true, method };
-    } catch (error) {
-      console.error("[WorktreeManager] Failed to sync worktree:", error);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Get list of all feature worktrees
-   */
-  async getAllFeatureWorktrees(projectPath) {
-    const worktrees = await this.listWorktrees(projectPath);
-    const worktreeBasePath = this.getWorktreeBasePath(projectPath);
-
-    return worktrees.filter(w =>
-      w.path.startsWith(worktreeBasePath) &&
-      w.branch &&
-      w.branch.startsWith("feature/")
-    );
-  }
-
-  /**
-   * Cleanup orphaned worktrees (worktrees without matching features)
-   */
-  async cleanupOrphanedWorktrees(projectPath, activeFeatureIds) {
-    console.log("[WorktreeManager] Cleaning up orphaned worktrees...");
-
-    const worktrees = await this.getAllFeatureWorktrees(projectPath);
-    const cleaned = [];
-
-    for (const worktree of worktrees) {
-      // Extract feature ID from branch name
-      const branchParts = worktree.branch.replace("feature/", "").split("-");
-      const shortId = branchParts[0];
-
-      // Check if any active feature has this short ID
-      const hasMatchingFeature = activeFeatureIds.some(id => {
-        const featureShortId = id.replace("feature-", "").substring(0, 12);
-        return featureShortId === shortId;
-      });
-
-      if (!hasMatchingFeature) {
-        console.log(`[WorktreeManager] Removing orphaned worktree: ${worktree.path}`);
-        try {
-          await execAsync(`git worktree remove "${worktree.path}" --force`, { cwd: projectPath });
-          await execAsync(`git branch -D ${worktree.branch}`, { cwd: projectPath });
-          cleaned.push(worktree.path);
-        } catch (error) {
-          console.warn(`[WorktreeManager] Failed to cleanup worktree ${worktree.path}:`, error.message);
-        }
-      }
-    }
-
-    return { success: true, cleaned };
-  }
-}
-
-module.exports = new WorktreeManager();

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;

app/next.config.ts

@@ -1,9 +0,0 @@
-import type { NextConfig } from "next";
-
-const nextConfig: NextConfig = {
-  env: {
-    CLAUDE_CODE_OAUTH_TOKEN: process.env.CLAUDE_CODE_OAUTH_TOKEN || "",
-  },
-};
-
-export default nextConfig;

app/package.json

@@ -1,138 +0,0 @@
-{
-  "name": "automaker",
-  "version": "0.1.0",
-  "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 .\"",
-    "build": "next build",
-    "build:electron": "next build && electron-builder",
-    "start": "next start",
-    "lint": "eslint",
-    "test": "playwright test",
-    "test:headed": "playwright test --headed"
-  },
-  "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.1.61",
-    "@dnd-kit/core": "^6.3.1",
-    "@dnd-kit/sortable": "^10.0.0",
-    "@dnd-kit/utilities": "^3.2.2",
-    "@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-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",
-    "class-variance-authority": "^0.7.1",
-    "clsx": "^2.1.1",
-    "dotenv": "^17.2.3",
-    "lucide-react": "^0.556.0",
-    "next": "16.0.7",
-    "react": "19.2.0",
-    "react-dom": "19.2.0",
-    "react-markdown": "^10.1.0",
-    "sonner": "^2.0.7",
-    "tailwind-merge": "^3.4.0",
-    "zustand": "^5.0.9"
-  },
-  "devDependencies": {
-    "@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.6",
-    "electron-builder": "^26.0.12",
-    "eslint": "^9",
-    "eslint-config-next": "16.0.7",
-    "tailwindcss": "^4",
-    "tw-animate-css": "^1.4.0",
-    "typescript": "^5",
-    "wait-on": "^9.0.3"
-  },
-  "build": {
-    "appId": "com.automaker.app",
-    "productName": "Automaker",
-    "directories": {
-      "output": "dist"
-    },
-    "files": [
-      "electron/**/*",
-      ".next/**/*",
-      "public/**/*",
-      "!node_modules/**/*",
-      "node_modules/@anthropic-ai/**/*"
-    ],
-    "extraResources": [
-      {
-        "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.png"
-    },
-    "win": {
-      "target": [
-        {
-          "target": "nsis",
-          "arch": [
-            "x64"
-          ]
-        }
-      ],
-      "icon": "public/logo.png"
-    },
-    "linux": {
-      "target": [
-        {
-          "target": "AppImage",
-          "arch": [
-            "x64"
-          ]
-        },
-        {
-          "target": "deb",
-          "arch": [
-            "x64"
-          ]
-        }
-      ],
-      "category": "Development",
-      "icon": "public/logo.png"
-    },
-    "nsis": {
-      "oneClick": false,
-      "allowToChangeInstallationDirectory": true,
-      "createDesktopShortcut": true,
-      "createStartMenuShortcut": true
-    }
-  }
-}

app/playwright.config.ts

@@ -1,35 +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,
-        },
-      }),
-});

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,
-  },
-});

app/postcss.config.mjs

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

app/src/app/api/chat/route.ts

@@ -1,172 +0,0 @@
-import {
-  query,
-  Options,
-  SDKAssistantMessage,
-} from "@anthropic-ai/claude-agent-sdk";
-import { NextRequest, NextResponse } from "next/server";
-import path from "path";
-
-const systemPrompt = `You are an AI assistant helping users build software. You are part of the Automaker application,
-which is designed to help developers plan, design, and implement software projects autonomously.
-
-Your role is to:
-- Help users define their project requirements and specifications
-- Ask clarifying questions to better understand their needs
-- Suggest technical approaches and architectures
-- Guide them through the development process
-- Be conversational and helpful
-- Write, edit, and modify code files as requested
-- Execute commands and tests
-- Search and analyze the codebase
-
-When discussing projects, help users think through:
-- Core functionality and features
-- Technical stack choices
-- Data models and architecture
-- User experience considerations
-- Testing strategies
-
-You have full access to the codebase and can:
-- Read files to understand existing code
-- Write new files
-- Edit existing files
-- Run bash commands
-- Search for code patterns
-- Execute tests and builds`;
-
-export async function POST(request: NextRequest) {
-  try {
-    const { messages, workingDirectory } = await request.json();
-
-    console.log(
-      "[API] CLAUDE_CODE_OAUTH_TOKEN present:",
-      !!process.env.CLAUDE_CODE_OAUTH_TOKEN
-    );
-
-    if (!process.env.CLAUDE_CODE_OAUTH_TOKEN) {
-      return NextResponse.json(
-        { error: "CLAUDE_CODE_OAUTH_TOKEN not configured" },
-        { status: 500 }
-      );
-    }
-
-    // Get the last user message
-    const lastMessage = messages[messages.length - 1];
-
-    // Determine working directory - default to parent of app directory
-    const cwd = workingDirectory || path.resolve(process.cwd(), "..");
-
-    console.log("[API] Working directory:", cwd);
-
-    // Create query with options that enable code modification
-    const options: Options = {
-      // model: "claude-sonnet-4-20250514",
-      model: "claude-opus-4-5-20251101",
-      systemPrompt,
-      maxTurns: 20,
-      cwd,
-      // Enable all core tools for code modification
-      allowedTools: [
-        "Read",
-        "Write",
-        "Edit",
-        "Glob",
-        "Grep",
-        "Bash",
-        "WebSearch",
-        "WebFetch",
-      ],
-      // Auto-accept file edits within the working directory
-      permissionMode: "acceptEdits",
-      // Enable sandbox for safer bash execution
-      sandbox: {
-        enabled: true,
-        autoAllowBashIfSandboxed: true,
-      },
-    };
-
-    // Convert message history to SDK format to preserve conversation context
-    // Include both user and assistant messages for full context
-    const sessionId = `api-session-${Date.now()}`;
-    const conversationMessages = messages.map(
-      (msg: { role: string; content: string }) => {
-        if (msg.role === "user") {
-          return {
-            type: "user" as const,
-            message: {
-              role: "user" as const,
-              content: msg.content,
-            },
-            parent_tool_use_id: null,
-            session_id: sessionId,
-          };
-        } else {
-          // Assistant message
-          return {
-            type: "assistant" as const,
-            message: {
-              role: "assistant" as const,
-              content: [
-                {
-                  type: "text" as const,
-                  text: msg.content,
-                },
-              ],
-            },
-            session_id: sessionId,
-          };
-        }
-      }
-    );
-
-    // Execute query with full conversation context
-    const queryResult = query({
-      prompt:
-        conversationMessages.length > 0
-          ? conversationMessages
-          : lastMessage.content,
-      options,
-    });
-
-    let responseText = "";
-    const toolUses: Array<{ name: string; input: unknown }> = [];
-
-    // Collect the response from the async generator
-    for await (const msg of queryResult) {
-      if (msg.type === "assistant") {
-        const assistantMsg = msg as SDKAssistantMessage;
-        if (assistantMsg.message.content) {
-          for (const block of assistantMsg.message.content) {
-            if (block.type === "text") {
-              responseText += block.text;
-            } else if (block.type === "tool_use") {
-              // Track tool usage for transparency
-              toolUses.push({
-                name: block.name,
-                input: block.input,
-              });
-            }
-          }
-        }
-      } else if (msg.type === "result") {
-        if (msg.subtype === "success") {
-          if (msg.result) {
-            responseText = msg.result;
-          }
-        }
-      }
-    }
-
-    return NextResponse.json({
-      content: responseText || "Sorry, I couldn't generate a response.",
-      toolUses: toolUses.length > 0 ? toolUses : undefined,
-    });
-  } catch (error: unknown) {
-    console.error("Claude API error:", error);
-    const errorMessage =
-      error instanceof Error
-        ? error.message
-        : "Failed to get response from Claude";
-    return NextResponse.json({ error: errorMessage }, { status: 500 });
-  }
-}

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 || process.env.CLAUDE_CODE_OAUTH_TOKEN;
-
-    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 }
-    );
-  }
-}

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 }
-    );
-  }
-}

app/src/app/layout.tsx

@@ -1,36 +0,0 @@
-import type { Metadata } from "next";
-import { Geist, Geist_Mono } from "next/font/google";
-import { Toaster } from "sonner";
-import "./globals.css";
-
-const geistSans = Geist({
-  variable: "--font-geist-sans",
-  subsets: ["latin"],
-});
-
-const geistMono = Geist_Mono({
-  variable: "--font-geist-mono",
-  subsets: ["latin"],
-});
-
-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>
-  );
-}

app/src/app/page.tsx

@@ -1,175 +0,0 @@
-"use client";
-
-import { useEffect, useState } 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 { AgentToolsView } from "@/components/views/agent-tools-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 { useAppStore } from "@/store/app-store";
-import { useSetupStore } from "@/store/setup-store";
-import { getElectronAPI, isElectron } from "@/lib/electron";
-
-export default function Home() {
-  const { currentView, setCurrentView, setIpcConnected, theme, currentProject } = useAppStore();
-  const { isFirstRun, setupComplete } = useSetupStore();
-  const [isMounted, setIsMounted] = useState(false);
-
-  // Compute the effective theme: project theme takes priority over global theme
-  // This is reactive because it depends on currentProject and theme from the store
-  const effectiveTheme = currentProject?.theme || theme;
-
-  // Prevent hydration issues
-  useEffect(() => {
-    setIsMounted(true);
-  }, []);
-
-  // 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" || result === "pong (mock)");
-      } catch (error) {
-        console.error("IPC connection failed:", error);
-        setIpcConnected(false);
-      }
-    };
-
-    testConnection();
-  }, [setIpcConnected]);
-
-  // Apply theme class to document (uses effective theme - project-specific or global)
-  useEffect(() => {
-    const root = document.documentElement;
-    root.classList.remove(
-      "dark",
-      "retro",
-      "light",
-      "dracula",
-      "nord",
-      "monokai",
-      "tokyonight",
-      "solarized",
-      "gruvbox",
-      "catppuccin",
-      "onedark",
-      "synthwave"
-    );
-
-    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 === "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]);
-
-  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 "tools":
-        return <AgentToolsView />;
-      case "interview":
-        return <InterviewView />;
-      case "context":
-        return <ContextView />;
-      case "profiles":
-        return <ProfilesView />;
-      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 />
-        {/* Environment indicator */}
-        {isMounted && !isElectron() && (
-          <div className="fixed bottom-4 right-4 px-3 py-1.5 bg-yellow-500/10 text-yellow-500 text-xs rounded-full border border-yellow-500/20 pointer-events-none">
-            Web Mode (Mock IPC)
-          </div>
-        )}
-      </main>
-    );
-  }
-
-  return (
-    <main className="flex h-screen overflow-hidden" data-testid="app-container">
-      <Sidebar />
-      <div className="flex-1 flex flex-col overflow-hidden">{renderView()}</div>
-
-      {/* Environment indicator - only show after mount to prevent hydration issues */}
-      {isMounted && !isElectron() && (
-        <div className="fixed bottom-4 right-4 px-3 py-1.5 bg-yellow-500/10 text-yellow-500 text-xs rounded-full border border-yellow-500/20 pointer-events-none">
-          Web Mode (Mock IPC)
-        </div>
-      )}
-    </main>
-  );
-}

app/src/components/ui/badge.tsx

@@ -1,36 +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-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
-  {
-    variants: {
-      variant: {
-        default:
-          "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
-        secondary:
-          "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
-        destructive:
-          "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
-        outline: "text-foreground",
-      },
-    },
-    defaultVariants: {
-      variant: "default",
-    },
-  }
-);
-
-export interface BadgeProps
-  extends React.HTMLAttributes<HTMLDivElement>,
-    VariantProps<typeof badgeVariants> {}
-
-function Badge({ className, variant, ...props }: BadgeProps) {
-  return (
-    <div className={cn(badgeVariants({ variant }), className)} {...props} />
-  );
-}
-
-export { Badge, badgeVariants };

app/src/components/ui/button.tsx

@@ -1,95 +0,0 @@
-import * as React from "react";
-import { Slot } from "@radix-ui/react-slot";
-import { cva, type VariantProps } from "class-variance-authority";
-
-import { cn } from "@/lib/utils";
-
-const buttonVariants = cva(
-  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all cursor-pointer disabled:pointer-events-none disabled:opacity-50 disabled:cursor-not-allowed [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
-  {
-    variants: {
-      variant: {
-        default: "bg-primary text-primary-foreground hover:bg-primary/90",
-        destructive:
-          "bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
-        outline:
-          "border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50",
-        secondary:
-          "bg-secondary text-secondary-foreground hover:bg-secondary/80",
-        ghost:
-          "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
-        link: "text-primary underline-offset-4 hover:underline",
-        "animated-outline":
-          "relative overflow-hidden rounded-xl hover:bg-transparent shadow-none",
-      },
-      size: {
-        default: "h-9 px-4 py-2 has-[>svg]:px-3",
-        sm: "h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5",
-        lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
-        icon: "size-9",
-        "icon-sm": "size-8",
-        "icon-lg": "size-10",
-      },
-    },
-    defaultVariants: {
-      variant: "default",
-      size: "default",
-    },
-  }
-);
-
-function Button({
-  className,
-  variant,
-  size,
-  asChild = false,
-  children,
-  ...props
-}: React.ComponentProps<"button"> &
-  VariantProps<typeof buttonVariants> & {
-    asChild?: boolean;
-  }) {
-  // Special handling for animated-outline variant
-  if (variant === "animated-outline" && !asChild) {
-    return (
-      <button
-        className={cn(
-          buttonVariants({ variant, size }),
-          "p-[1px]", // Force 1px padding for the gradient border
-          className
-        )}
-        data-slot="button"
-        {...props}
-      >
-        {/* Animated rotating gradient border */}
-        <span className="absolute inset-[-1000%] animate-[spin_2s_linear_infinite] animated-outline-gradient" />
-
-        {/* Inner content container */}
-        <span
-          className={cn(
-            "animated-outline-inner inline-flex h-full w-full cursor-pointer items-center justify-center gap-2 rounded-[10px] px-4 py-1 text-sm font-medium backdrop-blur-3xl transition-all",
-            size === "sm" && "px-3 text-xs gap-1.5",
-            size === "lg" && "px-8",
-            size === "icon" && "p-0 gap-0"
-          )}
-        >
-          {children}
-        </span>
-      </button>
-    );
-  }
-
-  const Comp = asChild ? Slot : "button";
-
-  return (
-    <Comp
-      data-slot="button"
-      className={cn(buttonVariants({ variant, size, className }))}
-      {...props}
-    >
-      {children}
-    </Comp>
-  );
-}
-
-export { Button, buttonVariants };

app/src/components/ui/card.tsx

@@ -1,92 +0,0 @@
-import * as React from "react";
-
-import { cn } from "@/lib/utils";
-
-function Card({ className, ...props }: React.ComponentProps<"div">) {
-  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-sm py-6 shadow-sm",
-        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-2 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", className)}
-      {...props}
-    />
-  );
-}
-
-function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="card-description"
-      className={cn("text-muted-foreground text-sm", 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 px-6 [.border-t]:pt-6", className)}
-      {...props}
-    />
-  );
-}
-
-export {
-  Card,
-  CardHeader,
-  CardFooter,
-  CardTitle,
-  CardAction,
-  CardDescription,
-  CardContent,
-};

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

@@ -1,250 +0,0 @@
-"use client";
-
-import * as React from "react";
-import { useState, useRef, useEffect, useCallback } from "react";
-import { createPortal } from "react-dom";
-import { cn } from "@/lib/utils";
-import { Input } from "./input";
-import { Check, ChevronDown } from "lucide-react";
-
-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 [isOpen, setIsOpen] = useState(false);
-  const [inputValue, setInputValue] = useState(value);
-  const [filteredSuggestions, setFilteredSuggestions] = useState<string[]>([]);
-  const [highlightedIndex, setHighlightedIndex] = useState(-1);
-  const [dropdownPosition, setDropdownPosition] = useState({ top: 0, left: 0, width: 0 });
-  const containerRef = useRef<HTMLDivElement>(null);
-  const inputRef = useRef<HTMLInputElement>(null);
-  const listRef = useRef<HTMLUListElement>(null);
-
-  // Update internal state when value prop changes
-  useEffect(() => {
-    setInputValue(value);
-  }, [value]);
-
-  // Filter suggestions based on input
-  useEffect(() => {
-    const searchTerm = inputValue.toLowerCase().trim();
-    if (searchTerm === "") {
-      setFilteredSuggestions(suggestions);
-    } else {
-      const filtered = suggestions.filter((s) =>
-        s.toLowerCase().includes(searchTerm)
-      );
-      setFilteredSuggestions(filtered);
-    }
-    setHighlightedIndex(-1);
-  }, [inputValue, suggestions]);
-
-  // Update dropdown position when open and handle scroll/resize
-  useEffect(() => {
-    const updatePosition = () => {
-      if (isOpen && containerRef.current) {
-        const rect = containerRef.current.getBoundingClientRect();
-        setDropdownPosition({
-          top: rect.bottom + window.scrollY,
-          left: rect.left + window.scrollX,
-          width: rect.width,
-        });
-      }
-    };
-
-    updatePosition();
-
-    if (isOpen) {
-      window.addEventListener("scroll", updatePosition, true);
-      window.addEventListener("resize", updatePosition);
-      return () => {
-        window.removeEventListener("scroll", updatePosition, true);
-        window.removeEventListener("resize", updatePosition);
-      };
-    }
-  }, [isOpen]);
-
-  // Close dropdown when clicking outside
-  useEffect(() => {
-    const handleClickOutside = (event: MouseEvent) => {
-      if (
-        containerRef.current &&
-        !containerRef.current.contains(event.target as Node) &&
-        listRef.current &&
-        !listRef.current.contains(event.target as Node)
-      ) {
-        setIsOpen(false);
-      }
-    };
-
-    document.addEventListener("mousedown", handleClickOutside);
-    return () => document.removeEventListener("mousedown", handleClickOutside);
-  }, []);
-
-  // Scroll highlighted item into view
-  useEffect(() => {
-    if (highlightedIndex >= 0 && listRef.current) {
-      const items = listRef.current.querySelectorAll("li");
-      const highlightedItem = items[highlightedIndex];
-      if (highlightedItem) {
-        highlightedItem.scrollIntoView({ block: "nearest" });
-      }
-    }
-  }, [highlightedIndex]);
-
-  const handleInputChange = useCallback(
-    (e: React.ChangeEvent<HTMLInputElement>) => {
-      const newValue = e.target.value;
-      setInputValue(newValue);
-      onChange(newValue);
-      setIsOpen(true);
-    },
-    [onChange]
-  );
-
-  const handleSelect = useCallback(
-    (suggestion: string) => {
-      setInputValue(suggestion);
-      onChange(suggestion);
-      setIsOpen(false);
-      inputRef.current?.focus();
-    },
-    [onChange]
-  );
-
-  const handleKeyDown = useCallback(
-    (e: React.KeyboardEvent) => {
-      if (!isOpen) {
-        if (e.key === "ArrowDown" || e.key === "Enter") {
-          e.preventDefault();
-          setIsOpen(true);
-        }
-        return;
-      }
-
-      switch (e.key) {
-        case "ArrowDown":
-          e.preventDefault();
-          setHighlightedIndex((prev) =>
-            prev < filteredSuggestions.length - 1 ? prev + 1 : prev
-          );
-          break;
-        case "ArrowUp":
-          e.preventDefault();
-          setHighlightedIndex((prev) => (prev > 0 ? prev - 1 : -1));
-          break;
-        case "Enter":
-          e.preventDefault();
-          if (highlightedIndex >= 0 && filteredSuggestions[highlightedIndex]) {
-            handleSelect(filteredSuggestions[highlightedIndex]);
-          } else {
-            setIsOpen(false);
-          }
-          break;
-        case "Escape":
-          e.preventDefault();
-          setIsOpen(false);
-          break;
-        case "Tab":
-          setIsOpen(false);
-          break;
-      }
-    },
-    [isOpen, highlightedIndex, filteredSuggestions, handleSelect]
-  );
-
-  const handleFocus = useCallback(() => {
-    setIsOpen(true);
-  }, []);
-
-  return (
-    <div ref={containerRef} className={cn("relative", className)}>
-      <div className="relative">
-        <Input
-          ref={inputRef}
-          value={inputValue}
-          onChange={handleInputChange}
-          onKeyDown={handleKeyDown}
-          onFocus={handleFocus}
-          placeholder={placeholder}
-          disabled={disabled}
-          data-testid={testId}
-          className="pr-8"
-        />
-        <button
-          type="button"
-          className={cn(
-            "absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground transition-colors",
-            disabled && "pointer-events-none opacity-50"
-          )}
-          onClick={() => setIsOpen(!isOpen)}
-          tabIndex={-1}
-        >
-          <ChevronDown
-            className={cn(
-              "h-4 w-4 transition-transform duration-200",
-              isOpen && "rotate-180"
-            )}
-          />
-        </button>
-      </div>
-
-      {isOpen && filteredSuggestions.length > 0 && typeof document !== "undefined" &&
-        createPortal(
-          <ul
-            ref={listRef}
-            className="fixed z-[9999] max-h-60 overflow-auto rounded-md border bg-background p-1 shadow-md animate-in fade-in-0 zoom-in-95"
-            role="listbox"
-            data-testid="category-autocomplete-list"
-            style={{
-              top: dropdownPosition.top,
-              left: dropdownPosition.left,
-              width: dropdownPosition.width,
-            }}
-          >
-            {filteredSuggestions.map((suggestion, index) => (
-              <li
-                key={suggestion}
-                role="option"
-                aria-selected={highlightedIndex === index}
-                className={cn(
-                  "relative flex cursor-pointer select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none transition-colors",
-                  highlightedIndex === index && "bg-accent text-accent-foreground",
-                  inputValue === suggestion && "font-medium"
-                )}
-                onMouseDown={(e) => {
-                  e.preventDefault();
-                  handleSelect(suggestion);
-                }}
-                onMouseEnter={() => setHighlightedIndex(index)}
-                data-testid={`category-option-${suggestion.toLowerCase().replace(/\s+/g, "-")}`}
-              >
-                {inputValue === suggestion && (
-                  <Check className="mr-2 h-4 w-4 text-primary" />
-                )}
-                <span className={cn(inputValue !== suggestion && "ml-6")}>
-                  {suggestion}
-                </span>
-              </li>
-            ))}
-          </ul>,
-          document.body
-        )}
-    </div>
-  );
-}

app/src/components/ui/checkbox.tsx

@@ -1,30 +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";
-
-const Checkbox = React.forwardRef<
-  React.ElementRef<typeof CheckboxPrimitive.Root>,
-  React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>
->(({ className, ...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
-    )}
-    {...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 };

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

@@ -1,407 +0,0 @@
-"use client";
-
-import React, { useState, useRef, useCallback, useEffect } 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);
-
-  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 = async (
-    base64Data: string,
-    filename: string,
-    mimeType: string
-  ): Promise<string | null> => {
-    try {
-      const api = getElectronAPI();
-      // Check if saveImageToTemp method exists
-      if (!api.saveImageToTemp) {
-        // Fallback for mock API - return a mock path in .automaker/images
-        console.log("[DescriptionImageDropZone] Using mock 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;
-    }
-  };
-
-  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]
-  );
-
-  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"
-                    />
-                  ) : (
-                    <ImageIcon className="w-6 h-6 text-muted-foreground" />
-                  )}
-                </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>
-  );
-}

app/src/components/ui/dialog.tsx

@@ -1,157 +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(
-        "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50",
-        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(
-          "bg-background 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 fixed top-[50%] left-[50%] z-50 flex flex-col w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] rounded-lg border shadow-lg duration-200 max-h-[calc(100vh-4rem)]",
-          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(
-              "ring-offset-background focus:ring-ring data-[state=open]:bg-accent data-[state=open]:text-muted-foreground absolute rounded-xs opacity-70 transition-opacity cursor-pointer hover:opacity-100 focus:ring-2 focus:ring-offset-2 focus:outline-hidden disabled:pointer-events-none disabled:cursor-not-allowed [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-              compact ? "top-2 right-2" : "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",
-        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", 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", className)}
-      {...props}
-    />
-  );
-}
-
-export {
-  Dialog,
-  DialogClose,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogOverlay,
-  DialogPortal,
-  DialogTitle,
-  DialogTrigger,
-};

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

@@ -1,198 +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.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}
-  />
-))
-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,
-}

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];
-}

app/src/components/ui/input.tsx

@@ -1,21 +0,0 @@
-import * as React from "react"
-
-import { cn } from "@/lib/utils"
-
-function Input({ className, type, ...props }: React.ComponentProps<"input">) {
-  return (
-    <input
-      type={type}
-      data-slot="input"
-      className={cn(
-        "file:text-foreground placeholder:text-muted-foreground selection:bg-primary selection:text-primary-foreground bg-input border-input h-9 w-full min-w-0 rounded-md border px-3 py-1 text-base shadow-xs transition-[color,box-shadow] outline-none file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
-        "focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]",
-        "aria-invalid:ring-destructive/20 aria-invalid:border-destructive",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export { Input }

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 }

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

@@ -1,272 +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 null;
-  }
-
-  // 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>
-  );
-}

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
- * Styled for dark mode with proper typography
- */
-export function Markdown({ children, className }: MarkdownProps) {
-  return (
-    <div
-      className={cn(
-        "prose prose-sm prose-invert max-w-none",
-        // Headings
-        "[&_h1]:text-xl [&_h1]:text-zinc-200 [&_h1]:font-semibold [&_h1]:mt-4 [&_h1]:mb-2",
-        "[&_h2]:text-lg [&_h2]:text-zinc-200 [&_h2]:font-semibold [&_h2]:mt-4 [&_h2]:mb-2",
-        "[&_h3]:text-base [&_h3]:text-zinc-200 [&_h3]:font-semibold [&_h3]:mt-3 [&_h3]:mb-2",
-        "[&_h4]:text-sm [&_h4]:text-zinc-200 [&_h4]:font-semibold [&_h4]:mt-2 [&_h4]:mb-1",
-        // Paragraphs
-        "[&_p]:text-zinc-300 [&_p]:leading-relaxed [&_p]:my-2",
-        // Lists
-        "[&_ul]:my-2 [&_ul]:pl-4 [&_ol]:my-2 [&_ol]:pl-4",
-        "[&_li]:text-zinc-300 [&_li]:my-0.5",
-        // Code
-        "[&_code]:text-cyan-400 [&_code]:bg-zinc-800/50 [&_code]:px-1.5 [&_code]:py-0.5 [&_code]:rounded [&_code]:text-sm",
-        "[&_pre]:bg-zinc-900/80 [&_pre]:border [&_pre]:border-white/10 [&_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-zinc-200 [&_strong]:font-semibold",
-        // Links
-        "[&_a]:text-blue-400 [&_a]:no-underline hover:[&_a]:underline",
-        // Blockquotes
-        "[&_blockquote]:border-l-2 [&_blockquote]:border-zinc-600 [&_blockquote]:pl-4 [&_blockquote]:text-zinc-400 [&_blockquote]:italic [&_blockquote]:my-2",
-        // Horizontal rules
-        "[&_hr]:border-zinc-700 [&_hr]:my-4",
-        className
-      )}
-    >
-      <ReactMarkdown>{children}</ReactMarkdown>
-    </div>
-  );
-}

app/src/components/ui/sheet.tsx

@@ -1,139 +0,0 @@
-"use client"
-
-import * as React from "react"
-import * as SheetPrimitive from "@radix-ui/react-dialog"
-import { XIcon } from "lucide-react"
-
-import { cn } from "@/lib/utils"
-
-function Sheet({ ...props }: React.ComponentProps<typeof SheetPrimitive.Root>) {
-  return <SheetPrimitive.Root data-slot="sheet" {...props} />
-}
-
-function SheetTrigger({
-  ...props
-}: React.ComponentProps<typeof SheetPrimitive.Trigger>) {
-  return <SheetPrimitive.Trigger data-slot="sheet-trigger" {...props} />
-}
-
-function SheetClose({
-  ...props
-}: React.ComponentProps<typeof SheetPrimitive.Close>) {
-  return <SheetPrimitive.Close data-slot="sheet-close" {...props} />
-}
-
-function SheetPortal({
-  ...props
-}: React.ComponentProps<typeof SheetPrimitive.Portal>) {
-  return <SheetPrimitive.Portal data-slot="sheet-portal" {...props} />
-}
-
-function SheetOverlay({
-  className,
-  ...props
-}: React.ComponentProps<typeof SheetPrimitive.Overlay>) {
-  return (
-    <SheetPrimitive.Overlay
-      data-slot="sheet-overlay"
-      className={cn(
-        "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function SheetContent({
-  className,
-  children,
-  side = "right",
-  ...props
-}: React.ComponentProps<typeof SheetPrimitive.Content> & {
-  side?: "top" | "right" | "bottom" | "left"
-}) {
-  return (
-    <SheetPortal>
-      <SheetOverlay />
-      <SheetPrimitive.Content
-        data-slot="sheet-content"
-        className={cn(
-          "bg-background data-[state=open]:animate-in data-[state=closed]:animate-out fixed z-50 flex flex-col gap-4 shadow-lg transition ease-in-out data-[state=closed]:duration-300 data-[state=open]:duration-500",
-          side === "right" &&
-            "data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right inset-y-0 right-0 h-full w-3/4 border-l sm:max-w-sm",
-          side === "left" &&
-            "data-[state=closed]:slide-out-to-left data-[state=open]:slide-in-from-left inset-y-0 left-0 h-full w-3/4 border-r sm:max-w-sm",
-          side === "top" &&
-            "data-[state=closed]:slide-out-to-top data-[state=open]:slide-in-from-top inset-x-0 top-0 h-auto border-b",
-          side === "bottom" &&
-            "data-[state=closed]:slide-out-to-bottom data-[state=open]:slide-in-from-bottom inset-x-0 bottom-0 h-auto border-t",
-          className
-        )}
-        {...props}
-      >
-        {children}
-        <SheetPrimitive.Close className="ring-offset-background focus:ring-ring data-[state=open]:bg-secondary absolute top-4 right-4 rounded-xs opacity-70 transition-opacity hover:opacity-100 focus:ring-2 focus:ring-offset-2 focus:outline-hidden disabled:pointer-events-none">
-          <XIcon className="size-4" />
-          <span className="sr-only">Close</span>
-        </SheetPrimitive.Close>
-      </SheetPrimitive.Content>
-    </SheetPortal>
-  )
-}
-
-function SheetHeader({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="sheet-header"
-      className={cn("flex flex-col gap-1.5 p-4", className)}
-      {...props}
-    />
-  )
-}
-
-function SheetFooter({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="sheet-footer"
-      className={cn("mt-auto flex flex-col gap-2 p-4", className)}
-      {...props}
-    />
-  )
-}
-
-function SheetTitle({
-  className,
-  ...props
-}: React.ComponentProps<typeof SheetPrimitive.Title>) {
-  return (
-    <SheetPrimitive.Title
-      data-slot="sheet-title"
-      className={cn("text-foreground font-semibold", className)}
-      {...props}
-    />
-  )
-}
-
-function SheetDescription({
-  className,
-  ...props
-}: React.ComponentProps<typeof SheetPrimitive.Description>) {
-  return (
-    <SheetPrimitive.Description
-      data-slot="sheet-description"
-      className={cn("text-muted-foreground text-sm", className)}
-      {...props}
-    />
-  )
-}
-
-export {
-  Sheet,
-  SheetTrigger,
-  SheetClose,
-  SheetContent,
-  SheetHeader,
-  SheetFooter,
-  SheetTitle,
-  SheetDescription,
-}

app/src/components/ui/slider.tsx

@@ -1,27 +0,0 @@
-"use client";
-
-import * as React from "react";
-import * as SliderPrimitive from "@radix-ui/react-slider";
-import { cn } from "@/lib/utils";
-
-const Slider = React.forwardRef<
-  React.ComponentRef<typeof SliderPrimitive.Root>,
-  React.ComponentPropsWithoutRef<typeof SliderPrimitive.Root>
->(({ 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 };

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 }

app/src/components/ui/textarea.tsx

@@ -1,20 +0,0 @@
-import * as React from "react"
-
-import { cn } from "@/lib/utils"
-
-function Textarea({ className, ...props }: React.ComponentProps<"textarea">) {
-  return (
-    <textarea
-      data-slot="textarea"
-      className={cn(
-        "placeholder:text-muted-foreground selection:bg-primary selection:text-primary-foreground dark:bg-input/30 border-input min-h-[80px] w-full min-w-0 rounded-md border bg-transparent px-3 py-2 text-base shadow-xs transition-[color,box-shadow] outline-none disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm resize-none",
-        "focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]",
-        "aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export { Textarea }

app/src/components/ui/tooltip.tsx

@@ -1,32 +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 = 4, ...props }, ref) => (
-  <TooltipPrimitive.Portal>
-    <TooltipPrimitive.Content
-      ref={ref}
-      sideOffset={sideOffset}
-      className={cn(
-        "z-50 overflow-hidden rounded-md border bg-popover px-3 py-1.5 text-sm text-popover-foreground shadow-md animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-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}
-    />
-  </TooltipPrimitive.Portal>
-))
-TooltipContent.displayName = TooltipPrimitive.Content.displayName
-
-export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider }

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

@@ -1,290 +0,0 @@
-"use client";
-
-import { useRef, useCallback, useMemo } from "react";
-import { cn } from "@/lib/utils";
-
-interface XmlSyntaxEditorProps {
-  value: string;
-  onChange: (value: string) => void;
-  placeholder?: string;
-  className?: string;
-  "data-testid"?: string;
-}
-
-// Tokenize XML content into parts for highlighting
-interface Token {
-  type:
-    | "tag-bracket"
-    | "tag-name"
-    | "attribute-name"
-    | "attribute-equals"
-    | "attribute-value"
-    | "text"
-    | "comment"
-    | "cdata"
-    | "doctype";
-  value: string;
-}
-
-function tokenizeXml(text: string): Token[] {
-  const tokens: Token[] = [];
-  let i = 0;
-
-  while (i < text.length) {
-    // Comment: <!-- ... -->
-    if (text.slice(i, i + 4) === "<!--") {
-      const end = text.indexOf("-->", i + 4);
-      if (end !== -1) {
-        tokens.push({ type: "comment", value: text.slice(i, end + 3) });
-        i = end + 3;
-        continue;
-      }
-    }
-
-    // CDATA: <![CDATA[ ... ]]>
-    if (text.slice(i, i + 9) === "<![CDATA[") {
-      const end = text.indexOf("]]>", i + 9);
-      if (end !== -1) {
-        tokens.push({ type: "cdata", value: text.slice(i, end + 3) });
-        i = end + 3;
-        continue;
-      }
-    }
-
-    // DOCTYPE: <!DOCTYPE ... >
-    if (text.slice(i, i + 9).toUpperCase() === "<!DOCTYPE") {
-      const end = text.indexOf(">", i + 9);
-      if (end !== -1) {
-        tokens.push({ type: "doctype", value: text.slice(i, end + 1) });
-        i = end + 1;
-        continue;
-      }
-    }
-
-    // Tag: < ... >
-    if (text[i] === "<") {
-      // Find the end of the tag
-      let tagEnd = i + 1;
-      let inString: string | null = null;
-
-      while (tagEnd < text.length) {
-        const char = text[tagEnd];
-
-        if (inString) {
-          if (char === inString && text[tagEnd - 1] !== "\\") {
-            inString = null;
-          }
-        } else {
-          if (char === '"' || char === "'") {
-            inString = char;
-          } else if (char === ">") {
-            tagEnd++;
-            break;
-          }
-        }
-        tagEnd++;
-      }
-
-      const tagContent = text.slice(i, tagEnd);
-      const tagTokens = tokenizeTag(tagContent);
-      tokens.push(...tagTokens);
-      i = tagEnd;
-      continue;
-    }
-
-    // Text content between tags
-    const nextTag = text.indexOf("<", i);
-    if (nextTag === -1) {
-      tokens.push({ type: "text", value: text.slice(i) });
-      break;
-    } else if (nextTag > i) {
-      tokens.push({ type: "text", value: text.slice(i, nextTag) });
-      i = nextTag;
-    }
-  }
-
-  return tokens;
-}
-
-function tokenizeTag(tag: string): Token[] {
-  const tokens: Token[] = [];
-  let i = 0;
-
-  // Opening bracket (< or </ or <?)
-  if (tag.startsWith("</")) {
-    tokens.push({ type: "tag-bracket", value: "</" });
-    i = 2;
-  } else if (tag.startsWith("<?")) {
-    tokens.push({ type: "tag-bracket", value: "<?" });
-    i = 2;
-  } else {
-    tokens.push({ type: "tag-bracket", value: "<" });
-    i = 1;
-  }
-
-  // Skip whitespace
-  while (i < tag.length && /\s/.test(tag[i])) {
-    tokens.push({ type: "text", value: tag[i] });
-    i++;
-  }
-
-  // Tag name
-  let tagName = "";
-  while (i < tag.length && /[a-zA-Z0-9_:-]/.test(tag[i])) {
-    tagName += tag[i];
-    i++;
-  }
-  if (tagName) {
-    tokens.push({ type: "tag-name", value: tagName });
-  }
-
-  // Attributes and closing
-  while (i < tag.length) {
-    // Skip whitespace
-    if (/\s/.test(tag[i])) {
-      let ws = "";
-      while (i < tag.length && /\s/.test(tag[i])) {
-        ws += tag[i];
-        i++;
-      }
-      tokens.push({ type: "text", value: ws });
-      continue;
-    }
-
-    // Closing bracket
-    if (tag[i] === ">" || tag.slice(i, i + 2) === "/>" || tag.slice(i, i + 2) === "?>") {
-      tokens.push({ type: "tag-bracket", value: tag.slice(i) });
-      break;
-    }
-
-    // Attribute name
-    let attrName = "";
-    while (i < tag.length && /[a-zA-Z0-9_:-]/.test(tag[i])) {
-      attrName += tag[i];
-      i++;
-    }
-    if (attrName) {
-      tokens.push({ type: "attribute-name", value: attrName });
-    }
-
-    // Skip whitespace around =
-    while (i < tag.length && /\s/.test(tag[i])) {
-      tokens.push({ type: "text", value: tag[i] });
-      i++;
-    }
-
-    // Equals sign
-    if (tag[i] === "=") {
-      tokens.push({ type: "attribute-equals", value: "=" });
-      i++;
-    }
-
-    // Skip whitespace after =
-    while (i < tag.length && /\s/.test(tag[i])) {
-      tokens.push({ type: "text", value: tag[i] });
-      i++;
-    }
-
-    // Attribute value
-    if (tag[i] === '"' || tag[i] === "'") {
-      const quote = tag[i];
-      let value = quote;
-      i++;
-      while (i < tag.length && tag[i] !== quote) {
-        value += tag[i];
-        i++;
-      }
-      if (i < tag.length) {
-        value += tag[i];
-        i++;
-      }
-      tokens.push({ type: "attribute-value", value });
-    }
-  }
-
-  return tokens;
-}
-
-export function XmlSyntaxEditor({
-  value,
-  onChange,
-  placeholder,
-  className,
-  "data-testid": testId,
-}: XmlSyntaxEditorProps) {
-  const textareaRef = useRef<HTMLTextAreaElement>(null);
-  const highlightRef = useRef<HTMLDivElement>(null);
-
-  // Sync scroll between textarea and highlight layer
-  const handleScroll = useCallback(() => {
-    if (textareaRef.current && highlightRef.current) {
-      highlightRef.current.scrollTop = textareaRef.current.scrollTop;
-      highlightRef.current.scrollLeft = textareaRef.current.scrollLeft;
-    }
-  }, []);
-
-  // Handle tab key for indentation
-  const handleKeyDown = useCallback(
-    (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
-      if (e.key === "Tab") {
-        e.preventDefault();
-        const textarea = e.currentTarget;
-        const start = textarea.selectionStart;
-        const end = textarea.selectionEnd;
-        const newValue =
-          value.substring(0, start) + "  " + value.substring(end);
-        onChange(newValue);
-        // Reset cursor position after state update
-        requestAnimationFrame(() => {
-          textarea.selectionStart = textarea.selectionEnd = start + 2;
-        });
-      }
-    },
-    [value, onChange]
-  );
-
-  // Memoize the highlighted content
-  const highlightedContent = useMemo(() => {
-    const tokens = tokenizeXml(value);
-
-    return tokens.map((token, index) => {
-      const className = `xml-${token.type}`;
-      // React handles escaping automatically, just render the raw value
-      return (
-        <span key={index} className={className}>
-          {token.value}
-        </span>
-      );
-    });
-  }, [value]);
-
-  return (
-    <div className={cn("relative w-full h-full xml-editor", className)}>
-      {/* Syntax highlighted layer (read-only, behind textarea) */}
-      <div
-        ref={highlightRef}
-        className="absolute inset-0 overflow-auto pointer-events-none font-mono text-sm p-4 whitespace-pre-wrap break-words"
-        aria-hidden="true"
-      >
-        {value ? (
-          <code className="xml-highlight">{highlightedContent}</code>
-        ) : (
-          <span className="text-muted-foreground opacity-50">{placeholder}</span>
-        )}
-      </div>
-
-      {/* Actual textarea (transparent text, handles input) */}
-      <textarea
-        ref={textareaRef}
-        value={value}
-        onChange={(e) => onChange(e.target.value)}
-        onScroll={handleScroll}
-        onKeyDown={handleKeyDown}
-        placeholder=""
-        spellCheck={false}
-        className="absolute inset-0 w-full h-full font-mono text-sm p-4 bg-transparent resize-none focus:outline-none text-transparent caret-foreground selection:bg-primary/30"
-        data-testid={testId}
-      />
-    </div>
-  );
-}

app/src/components/views/agent-view.tsx

@@ -1,804 +0,0 @@
-"use client";
-
-import { useState, useCallback, useRef, useEffect, useMemo } from "react";
-import { useAppStore } from "@/store/app-store";
-import { Card, CardContent } from "@/components/ui/card";
-import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
-import { ImageDropZone } from "@/components/ui/image-drop-zone";
-import {
-  Bot,
-  Send,
-  User,
-  Loader2,
-  Sparkles,
-  Wrench,
-  Trash2,
-  PanelLeftClose,
-  PanelLeft,
-  Paperclip,
-  X,
-} from "lucide-react";
-import { cn } from "@/lib/utils";
-import { useElectronAgent } from "@/hooks/use-electron-agent";
-import { SessionManager } from "@/components/session-manager";
-import { Markdown } from "@/components/ui/markdown";
-import type { ImageAttachment } from "@/store/app-store";
-import {
-  useKeyboardShortcuts,
-  useKeyboardShortcutsConfig,
-  KeyboardShortcut,
-} from "@/hooks/use-keyboard-shortcuts";
-
-export function AgentView() {
-  const { currentProject, setLastSelectedSession, getLastSelectedSession } = useAppStore();
-  const shortcuts = useKeyboardShortcutsConfig();
-  const [input, setInput] = useState("");
-  const [selectedImages, setSelectedImages] = useState<ImageAttachment[]>([]);
-  const [showImageDropZone, setShowImageDropZone] = useState(false);
-  const [currentTool, setCurrentTool] = useState<string | null>(null);
-  const [currentSessionId, setCurrentSessionId] = useState<string | null>(null);
-  const [showSessionManager, setShowSessionManager] = useState(true);
-  const [isDragOver, setIsDragOver] = useState(false);
-
-  // Track if initial session has been loaded
-  const initialSessionLoadedRef = useRef(false);
-
-  // Scroll management for auto-scroll
-  const messagesContainerRef = useRef<HTMLDivElement>(null);
-  const [isUserAtBottom, setIsUserAtBottom] = useState(true);
-
-  // Input ref for auto-focus
-  const inputRef = useRef<HTMLInputElement>(null);
-
-  // Ref for quick create session function from SessionManager
-  const quickCreateSessionRef = useRef<(() => Promise<void>) | null>(null);
-
-  // Use the Electron agent hook (only if we have a session)
-  const {
-    messages,
-    isProcessing,
-    isConnected,
-    sendMessage,
-    clearHistory,
-    error: agentError,
-  } = useElectronAgent({
-    sessionId: currentSessionId || "",
-    workingDirectory: currentProject?.path,
-    onToolUse: (toolName) => {
-      setCurrentTool(toolName);
-      setTimeout(() => setCurrentTool(null), 2000);
-    },
-  });
-
-  // Handle session selection with persistence
-  const handleSelectSession = useCallback((sessionId: string | null) => {
-    setCurrentSessionId(sessionId);
-    // Persist the selection for this project
-    if (currentProject?.path) {
-      setLastSelectedSession(currentProject.path, sessionId);
-    }
-  }, [currentProject?.path, setLastSelectedSession]);
-
-  // Restore last selected session when switching to Agent view or when project changes
-  useEffect(() => {
-    if (!currentProject?.path) {
-      // No project, reset
-      setCurrentSessionId(null);
-      initialSessionLoadedRef.current = false;
-      return;
-    }
-
-    // Only restore once per project
-    if (initialSessionLoadedRef.current) return;
-    initialSessionLoadedRef.current = true;
-
-    const lastSessionId = getLastSelectedSession(currentProject.path);
-    if (lastSessionId) {
-      console.log("[AgentView] Restoring last selected session:", lastSessionId);
-      setCurrentSessionId(lastSessionId);
-    }
-  }, [currentProject?.path, getLastSelectedSession]);
-
-  // Reset initialSessionLoadedRef when project changes
-  useEffect(() => {
-    initialSessionLoadedRef.current = false;
-  }, [currentProject?.path]);
-
-  const handleSend = useCallback(async () => {
-    if ((!input.trim() && selectedImages.length === 0) || isProcessing) return;
-
-    const messageContent = input;
-    const messageImages = selectedImages;
-
-    setInput("");
-    setSelectedImages([]);
-    setShowImageDropZone(false);
-
-    await sendMessage(messageContent, messageImages);
-  }, [input, selectedImages, isProcessing, sendMessage]);
-
-  const handleImagesSelected = useCallback((images: ImageAttachment[]) => {
-    setSelectedImages(images);
-  }, []);
-
-  const toggleImageDropZone = useCallback(() => {
-    setShowImageDropZone(!showImageDropZone);
-  }, [showImageDropZone]);
-
-  // Helper function to convert file to base64
-  const fileToBase64 = useCallback((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);
-    });
-  }, []);
-
-  // Process dropped files
-  const processDroppedFiles = useCallback(
-    async (files: FileList) => {
-      if (isProcessing) return;
-
-      const ACCEPTED_IMAGE_TYPES = [
-        "image/jpeg",
-        "image/jpg",
-        "image/png",
-        "image/gif",
-        "image/webp",
-      ];
-      const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
-      const MAX_FILES = 5;
-
-      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 > MAX_FILE_SIZE) {
-          const maxSizeMB = MAX_FILE_SIZE / (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 >= MAX_FILES) {
-          errors.push(`Maximum ${MAX_FILES} 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);
-      }
-
-      if (newImages.length > 0) {
-        setSelectedImages((prev) => [...prev, ...newImages]);
-      }
-    },
-    [isProcessing, selectedImages, fileToBase64]
-  );
-
-  // Remove individual image
-  const removeImage = useCallback((imageId: string) => {
-    setSelectedImages((prev) => prev.filter((img) => img.id !== imageId));
-  }, []);
-
-  // Drag and drop handlers for the input area
-  const handleDragEnter = useCallback(
-    (e: React.DragEvent) => {
-      e.preventDefault();
-      e.stopPropagation();
-      if (isProcessing || !isConnected) return;
-
-      console.log(
-        "[agent-view] Drag enter types:",
-        Array.from(e.dataTransfer.types)
-      );
-
-      // Check if dragged items contain files
-      if (e.dataTransfer.types.includes("Files")) {
-        setIsDragOver(true);
-      }
-    },
-    [isProcessing, isConnected]
-  );
-
-  const handleDragLeave = useCallback((e: React.DragEvent) => {
-    e.preventDefault();
-    e.stopPropagation();
-
-    // Only set dragOver to false if we're leaving the input container
-    const rect = e.currentTarget.getBoundingClientRect();
-    const x = e.clientX;
-    const y = e.clientY;
-
-    if (x < rect.left || x > rect.right || y < rect.top || y > rect.bottom) {
-      setIsDragOver(false);
-    }
-  }, []);
-
-  const handleDragOver = useCallback((e: React.DragEvent) => {
-    e.preventDefault();
-    e.stopPropagation();
-  }, []);
-
-  const handleDrop = useCallback(
-    async (e: React.DragEvent) => {
-      e.preventDefault();
-      e.stopPropagation();
-      setIsDragOver(false);
-
-      if (isProcessing || !isConnected) return;
-
-      console.log("[agent-view] Drop event:", {
-        filesCount: e.dataTransfer.files.length,
-        itemsCount: e.dataTransfer.items.length,
-        types: Array.from(e.dataTransfer.types),
-      });
-
-      // Check if we have files
-      const files = e.dataTransfer.files;
-      if (files && files.length > 0) {
-        console.log("[agent-view] Processing files from dataTransfer.files");
-        processDroppedFiles(files);
-        return;
-      }
-
-      // Handle file paths (from screenshots or other sources)
-      // This is common on macOS when dragging screenshots
-      const items = e.dataTransfer.items;
-      if (items && items.length > 0) {
-        console.log("[agent-view] Processing items");
-        for (let i = 0; i < items.length; i++) {
-          const item = items[i];
-          console.log(`[agent-view] Item ${i}:`, {
-            kind: item.kind,
-            type: item.type,
-          });
-          if (item.kind === "file") {
-            const file = item.getAsFile();
-            if (file) {
-              console.log("[agent-view] Got file from item:", {
-                name: file.name,
-                type: file.type,
-                size: file.size,
-              });
-              const dataTransfer = new DataTransfer();
-              dataTransfer.items.add(file);
-              processDroppedFiles(dataTransfer.files);
-            }
-          }
-        }
-      }
-    },
-    [isProcessing, isConnected, processDroppedFiles]
-  );
-
-  const handlePaste = useCallback(
-    async (e: React.ClipboardEvent) => {
-      // Check if clipboard contains files
-      const items = e.clipboardData?.items;
-      if (items) {
-        const files: File[] = [];
-
-        for (let i = 0; i < items.length; i++) {
-          const item = items[i];
-          console.log("[agent-view] Paste item:", {
-            kind: item.kind,
-            type: item.type,
-          });
-
-          if (item.kind === "file") {
-            const file = item.getAsFile();
-            if (file && file.type.startsWith("image/")) {
-              e.preventDefault(); // Prevent default paste of file path
-              files.push(file);
-            }
-          }
-        }
-
-        if (files.length > 0) {
-          console.log(
-            "[agent-view] Processing pasted image files:",
-            files.length
-          );
-          const dataTransfer = new DataTransfer();
-          files.forEach((file) => dataTransfer.items.add(file));
-          await processDroppedFiles(dataTransfer.files);
-        }
-      }
-    },
-    [processDroppedFiles]
-  );
-
-  const handleKeyPress = (e: React.KeyboardEvent) => {
-    if (e.key === "Enter" && !e.shiftKey) {
-      e.preventDefault();
-      handleSend();
-    }
-  };
-
-  const handleClearChat = async () => {
-    if (!confirm("Are you sure you want to clear this conversation?")) return;
-    await clearHistory();
-  };
-
-  // Scroll position detection
-  const checkIfUserIsAtBottom = useCallback(() => {
-    const container = messagesContainerRef.current;
-    if (!container) return;
-
-    const threshold = 50; // 50px threshold for "near bottom"
-    const isAtBottom =
-      container.scrollHeight - container.scrollTop - container.clientHeight <=
-      threshold;
-
-    setIsUserAtBottom(isAtBottom);
-  }, []);
-
-  // Scroll to bottom function
-  const scrollToBottom = useCallback((behavior: ScrollBehavior = "smooth") => {
-    const container = messagesContainerRef.current;
-    if (!container) return;
-
-    container.scrollTo({
-      top: container.scrollHeight,
-      behavior: behavior,
-    });
-  }, []);
-
-  // Handle scroll events
-  const handleScroll = useCallback(() => {
-    checkIfUserIsAtBottom();
-  }, [checkIfUserIsAtBottom]);
-
-  // Auto-scroll effect when messages change
-  useEffect(() => {
-    // Only auto-scroll if user was already at bottom
-    if (isUserAtBottom && messages.length > 0) {
-      // Use a small delay to ensure DOM is updated
-      setTimeout(() => {
-        scrollToBottom("smooth");
-      }, 100);
-    }
-  }, [messages, isUserAtBottom, scrollToBottom]);
-
-  // Initial scroll to bottom when session changes
-  useEffect(() => {
-    if (currentSessionId && messages.length > 0) {
-      // Scroll immediately without animation when switching sessions
-      setTimeout(() => {
-        scrollToBottom("auto");
-        setIsUserAtBottom(true);
-      }, 100);
-    }
-  }, [currentSessionId, scrollToBottom]);
-
-  // Auto-focus input when session is selected/changed
-  useEffect(() => {
-    if (currentSessionId && inputRef.current) {
-      // Small delay to ensure UI has updated
-      setTimeout(() => {
-        inputRef.current?.focus();
-      }, 200);
-    }
-  }, [currentSessionId]);
-
-  // Keyboard shortcuts for agent view
-  const agentShortcuts: KeyboardShortcut[] = useMemo(() => {
-    const shortcutsList: KeyboardShortcut[] = [];
-
-    // New session shortcut - only when in agent view with a project
-    if (currentProject) {
-      shortcutsList.push({
-        key: shortcuts.newSession,
-        action: () => {
-          if (quickCreateSessionRef.current) {
-            quickCreateSessionRef.current();
-          }
-        },
-        description: "Create new session",
-      });
-    }
-
-    return shortcutsList;
-  }, [currentProject, shortcuts]);
-
-  // Register keyboard shortcuts
-  useKeyboardShortcuts(agentShortcuts);
-
-  if (!currentProject) {
-    return (
-      <div
-        className="flex-1 flex items-center justify-center"
-        data-testid="agent-view-no-project"
-      >
-        <div className="text-center">
-          <Sparkles className="w-12 h-12 text-muted-foreground mx-auto mb-4" />
-          <h2 className="text-xl font-semibold mb-2">No Project Selected</h2>
-          <p className="text-muted-foreground">
-            Open or create a project to start working with the AI agent.
-          </p>
-        </div>
-      </div>
-    );
-  }
-
-  // Show welcome message if no messages yet
-  const displayMessages =
-    messages.length === 0
-      ? [
-          {
-            id: "welcome",
-            role: "assistant" as const,
-            content:
-              "Hello! I'm the Automaker Agent. I can help you build software autonomously. I can read and modify files in this project, run commands, and execute tests. What would you like to create today?",
-            timestamp: new Date().toISOString(),
-          },
-        ]
-      : messages;
-
-  return (
-    <div
-      className="flex-1 flex overflow-hidden content-bg"
-      data-testid="agent-view"
-    >
-      {/* Session Manager Sidebar */}
-      {showSessionManager && currentProject && (
-        <div className="w-80 border-r flex-shrink-0">
-          <SessionManager
-            currentSessionId={currentSessionId}
-            onSelectSession={handleSelectSession}
-            projectPath={currentProject.path}
-            isCurrentSessionThinking={isProcessing}
-            onQuickCreateRef={quickCreateSessionRef}
-          />
-        </div>
-      )}
-
-      {/* Chat Area */}
-      <div className="flex-1 flex flex-col overflow-hidden">
-        {/* 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">
-            <Button
-              variant="ghost"
-              size="sm"
-              onClick={() => setShowSessionManager(!showSessionManager)}
-              className="h-8 w-8 p-0"
-            >
-              {showSessionManager ? (
-                <PanelLeftClose className="w-4 h-4" />
-              ) : (
-                <PanelLeft className="w-4 h-4" />
-              )}
-            </Button>
-            <Bot className="w-5 h-5 text-primary" />
-            <div>
-              <h1 className="text-xl font-bold">AI Agent</h1>
-              <p className="text-sm text-muted-foreground">
-                {currentProject.name}
-                {currentSessionId && !isConnected && " · Connecting..."}
-              </p>
-            </div>
-          </div>
-
-          {/* Status indicators & actions */}
-          <div className="flex items-center gap-2">
-            {currentTool && (
-              <div className="flex items-center gap-1 text-xs text-muted-foreground bg-muted px-2 py-1 rounded">
-                <Wrench className="w-3 h-3" />
-                <span>{currentTool}</span>
-              </div>
-            )}
-            {agentError && (
-              <span className="text-xs text-destructive">{agentError}</span>
-            )}
-            {currentSessionId && messages.length > 0 && (
-              <Button
-                variant="ghost"
-                size="sm"
-                onClick={handleClearChat}
-                disabled={isProcessing}
-              >
-                <Trash2 className="w-4 h-4 mr-1" />
-                Clear
-              </Button>
-            )}
-          </div>
-        </div>
-
-        {/* Messages */}
-        {!currentSessionId ? (
-          <div
-            className="flex-1 flex items-center justify-center"
-            data-testid="no-session-placeholder"
-          >
-            <div className="text-center">
-              <Bot className="w-12 h-12 text-muted-foreground mx-auto mb-4 opacity-50" />
-              <h2 className="text-lg font-semibold mb-2">
-                No Session Selected
-              </h2>
-              <p className="text-sm text-muted-foreground mb-4">
-                Create or select a session to start chatting
-              </p>
-              <Button
-                onClick={() => setShowSessionManager(true)}
-                variant="outline"
-              >
-                <PanelLeft className="w-4 h-4 mr-2" />
-                {showSessionManager ? "View" : "Show"} Sessions
-              </Button>
-            </div>
-          </div>
-        ) : (
-          <div
-            ref={messagesContainerRef}
-            className="flex-1 overflow-y-auto p-4 space-y-4"
-            data-testid="message-list"
-            onScroll={handleScroll}
-          >
-            {displayMessages.map((message) => (
-              <div
-                key={message.id}
-                className={cn(
-                  "flex gap-3",
-                  message.role === "user" && "flex-row-reverse"
-                )}
-              >
-                <div
-                  className={cn(
-                    "w-8 h-8 rounded-full flex items-center justify-center shrink-0",
-                    message.role === "assistant" ? "bg-primary/10" : "bg-muted"
-                  )}
-                >
-                  {message.role === "assistant" ? (
-                    <Bot className="w-4 h-4 text-primary" />
-                  ) : (
-                    <User className="w-4 h-4" />
-                  )}
-                </div>
-                <Card
-                  className={cn(
-                    "max-w-[80%]",
-                    message.role === "user"
-                      ? "bg-primary text-primary-foreground"
-                      : "border-l-4 border-primary bg-card"
-                  )}
-                >
-                  <CardContent className="p-3">
-                    {message.role === "assistant" ? (
-                      <Markdown className="text-sm text-primary prose-headings:text-primary prose-strong:text-primary prose-code:text-primary">
-                        {message.content}
-                      </Markdown>
-                    ) : (
-                      <p className="text-sm whitespace-pre-wrap">
-                        {message.content}
-                      </p>
-                    )}
-                    <p
-                      className={cn(
-                        "text-xs mt-2",
-                        message.role === "user"
-                          ? "text-primary-foreground/70"
-                          : "text-primary/70"
-                      )}
-                    >
-                      {new Date(message.timestamp).toLocaleTimeString()}
-                    </p>
-                  </CardContent>
-                </Card>
-              </div>
-            ))}
-
-            {isProcessing && (
-              <div className="flex gap-3">
-                <div className="w-8 h-8 rounded-full bg-primary/10 flex items-center justify-center">
-                  <Bot className="w-4 h-4 text-primary" />
-                </div>
-                <Card className="border-l-4 border-primary bg-card">
-                  <CardContent className="p-3">
-                    <div className="flex items-center gap-2">
-                      <Loader2 className="w-4 h-4 animate-spin text-primary" />
-                      <span className="text-sm text-primary">
-                        Thinking...
-                      </span>
-                    </div>
-                  </CardContent>
-                </Card>
-              </div>
-            )}
-          </div>
-        )}
-
-        {/* Input */}
-        {currentSessionId && (
-          <div className="border-t border-border p-4 space-y-3 bg-background">
-            {/* Image Drop Zone (when visible) */}
-            {showImageDropZone && (
-              <ImageDropZone
-                onImagesSelected={handleImagesSelected}
-                images={selectedImages}
-                maxFiles={5}
-                className="mb-3"
-                disabled={isProcessing || !isConnected}
-              />
-            )}
-
-            {/* Text Input and Controls - with drag and drop support */}
-            <div
-              className={cn(
-                "flex gap-2 transition-all duration-200 rounded-lg",
-                isDragOver &&
-                  "bg-primary/10 ring-2 ring-primary ring-offset-2 ring-offset-background"
-              )}
-              onDragEnter={handleDragEnter}
-              onDragLeave={handleDragLeave}
-              onDragOver={handleDragOver}
-              onDrop={handleDrop}
-            >
-              <div className="flex-1 relative">
-                <Input
-                  ref={inputRef}
-                  placeholder={
-                    isDragOver
-                      ? "Drop your images here..."
-                      : "Describe what you want to build..."
-                  }
-                  value={input}
-                  onChange={(e) => setInput(e.target.value)}
-                  onKeyPress={handleKeyPress}
-                  onPaste={handlePaste}
-                  disabled={isProcessing || !isConnected}
-                  data-testid="agent-input"
-                  className={cn(
-                    "bg-input border-border",
-                    selectedImages.length > 0 &&
-                      "border-primary/50 bg-primary/5",
-                    isDragOver &&
-                      "border-primary bg-primary/10"
-                  )}
-                />
-                {selectedImages.length > 0 && !isDragOver && (
-                  <div className="absolute right-2 top-1/2 transform -translate-y-1/2 text-xs text-primary-foreground bg-primary px-2 py-1 rounded">
-                    {selectedImages.length} image
-                    {selectedImages.length > 1 ? "s" : ""}
-                  </div>
-                )}
-                {isDragOver && (
-                  <div className="absolute right-2 top-1/2 transform -translate-y-1/2 text-xs text-primary-foreground bg-primary px-2 py-1 rounded flex items-center gap-1">
-                    <Paperclip className="w-3 h-3" />
-                    Drop here
-                  </div>
-                )}
-              </div>
-
-              {/* Image Attachment Button */}
-              <Button
-                variant="outline"
-                size="default"
-                onClick={toggleImageDropZone}
-                disabled={isProcessing || !isConnected}
-                className={cn(
-                  showImageDropZone &&
-                    "bg-primary/20 text-primary border-primary",
-                  selectedImages.length > 0 && "border-primary"
-                )}
-                title="Attach images"
-              >
-                <Paperclip className="w-4 h-4" />
-              </Button>
-
-              {/* Send Button */}
-              <Button
-                onClick={handleSend}
-                disabled={
-                  (!input.trim() && selectedImages.length === 0) ||
-                  isProcessing ||
-                  !isConnected
-                }
-                data-testid="send-message"
-              >
-                <Send className="w-4 h-4" />
-              </Button>
-            </div>
-
-            {/* Selected Images Preview */}
-            {selectedImages.length > 0 && (
-              <div className="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" : ""} attached
-                  </p>
-                  <button
-                    onClick={() => setSelectedImages([])}
-                    className="text-xs text-muted-foreground hover:text-foreground"
-                    disabled={isProcessing}
-                  >
-                    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 */}
-                      <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"
-                        disabled={isProcessing}
-                      >
-                        <X className="h-3 w-3" />
-                      </button>
-                    </div>
-                  ))}
-                </div>
-              </div>
-            )}
-          </div>
-        )}
-      </div>
-    </div>
-  );
-}
-
-// Helper function to format file size
-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];
-}

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

@@ -1,699 +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,
-} 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";
-
-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);
-
-  // 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]);
-
-  // 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);
-  };
-
-  // 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}
-      >
-        {/* 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" && (
-                    <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>
-                ) : (
-                  <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>
-  );
-}

app/src/components/views/kanban-card.tsx

@@ -1,856 +0,0 @@
-"use client";
-
-import { useState, useEffect, memo } from "react";
-import { useSortable } from "@dnd-kit/sortable";
-import { CSS } from "@dnd-kit/utilities";
-import { cn } from "@/lib/utils";
-import {
-  Card,
-  CardContent,
-  CardDescription,
-  CardHeader,
-  CardTitle,
-} from "@/components/ui/card";
-import { Button } from "@/components/ui/button";
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from "@/components/ui/dialog";
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuTrigger,
-} from "@/components/ui/dropdown-menu";
-import { Feature, useAppStore } from "@/store/app-store";
-import {
-  GripVertical,
-  Edit,
-  CheckCircle2,
-  Circle,
-  Loader2,
-  Trash2,
-  Eye,
-  PlayCircle,
-  RotateCcw,
-  StopCircle,
-  Hand,
-  MessageSquare,
-  GitCommit,
-  Cpu,
-  Wrench,
-  ListTodo,
-  Sparkles,
-  Expand,
-  FileText,
-  MoreVertical,
-  AlertCircle,
-  GitBranch,
-  Undo2,
-  GitMerge,
-} from "lucide-react";
-import { CountUpTimer } from "@/components/ui/count-up-timer";
-import { getElectronAPI } from "@/lib/electron";
-import {
-  parseAgentContext,
-  AgentTaskInfo,
-  formatModelName,
-  DEFAULT_MODEL,
-} from "@/lib/agent-context-parser";
-import { Markdown } from "@/components/ui/markdown";
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipProvider,
-  TooltipTrigger,
-} from "@/components/ui/tooltip";
-
-interface KanbanCardProps {
-  feature: Feature;
-  onEdit: () => void;
-  onDelete: () => void;
-  onViewOutput?: () => void;
-  onVerify?: () => void;
-  onResume?: () => void;
-  onForceStop?: () => void;
-  onManualVerify?: () => void;
-  onMoveBackToInProgress?: () => void;
-  onFollowUp?: () => void;
-  onCommit?: () => void;
-  onRevert?: () => void;
-  onMerge?: () => void;
-  hasContext?: boolean;
-  isCurrentAutoTask?: boolean;
-  shortcutKey?: string;
-  /** Context content for extracting progress info */
-  contextContent?: string;
-  /** Feature summary from agent completion */
-  summary?: string;
-}
-
-export const KanbanCard = memo(function KanbanCard({
-  feature,
-  onEdit,
-  onDelete,
-  onViewOutput,
-  onVerify,
-  onResume,
-  onForceStop,
-  onManualVerify,
-  onMoveBackToInProgress,
-  onFollowUp,
-  onCommit,
-  onRevert,
-  onMerge,
-  hasContext,
-  isCurrentAutoTask,
-  shortcutKey,
-  contextContent,
-  summary,
-}: KanbanCardProps) {
-  const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false);
-  const [isSummaryDialogOpen, setIsSummaryDialogOpen] = useState(false);
-  const [isRevertDialogOpen, setIsRevertDialogOpen] = useState(false);
-  const [agentInfo, setAgentInfo] = useState<AgentTaskInfo | null>(null);
-  const { kanbanCardDetailLevel } = useAppStore();
-
-  // Check if feature has worktree
-  const hasWorktree = !!feature.branchName;
-
-  // Helper functions to check what should be shown based on detail level
-  const showSteps =
-    kanbanCardDetailLevel === "standard" ||
-    kanbanCardDetailLevel === "detailed";
-  const showAgentInfo = kanbanCardDetailLevel === "detailed";
-
-  // Load context file for in_progress, waiting_approval, and verified features
-  useEffect(() => {
-    const loadContext = async () => {
-      // Use provided context or load from file
-      if (contextContent) {
-        const info = parseAgentContext(contextContent);
-        setAgentInfo(info);
-        return;
-      }
-
-      // Only load for non-backlog features
-      if (feature.status === "backlog") {
-        setAgentInfo(null);
-        return;
-      }
-
-      try {
-        const api = getElectronAPI();
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const currentProject = (window as any).__currentProject;
-        if (!currentProject?.path) return;
-
-        const contextPath = `${currentProject.path}/.automaker/agents-context/${feature.id}.md`;
-        const result = await api.readFile(contextPath);
-
-        if (result.success && result.content) {
-          const info = parseAgentContext(result.content);
-          setAgentInfo(info);
-        }
-      } catch {
-        // Context file might not exist
-        console.debug("[KanbanCard] No context file for feature:", feature.id);
-      }
-    };
-
-    loadContext();
-
-    // Reload context periodically while feature is running
-    if (isCurrentAutoTask) {
-      const interval = setInterval(loadContext, 3000);
-      return () => clearInterval(interval);
-    }
-  }, [feature.id, feature.status, contextContent, isCurrentAutoTask]);
-
-  const handleDeleteClick = (e: React.MouseEvent) => {
-    e.stopPropagation();
-    setIsDeleteDialogOpen(true);
-  };
-
-  const handleConfirmDelete = () => {
-    setIsDeleteDialogOpen(false);
-    onDelete();
-  };
-
-  const handleCancelDelete = () => {
-    setIsDeleteDialogOpen(false);
-  };
-
-  // Dragging logic:
-  // - Backlog items can always be dragged
-  // - skipTests items can be dragged even when in_progress or verified (unless currently running)
-  // - waiting_approval items can always be dragged (to allow manual verification via drag)
-  // - Non-skipTests (TDD) items in progress or verified cannot be dragged
-  const isDraggable =
-    feature.status === "backlog" ||
-    feature.status === "waiting_approval" ||
-    (feature.skipTests && !isCurrentAutoTask);
-  const {
-    attributes,
-    listeners,
-    setNodeRef,
-    transform,
-    transition,
-    isDragging,
-  } = useSortable({
-    id: feature.id,
-    disabled: !isDraggable,
-  });
-
-  const style = {
-    transform: CSS.Transform.toString(transform),
-    transition,
-  };
-
-  return (
-    <Card
-      ref={setNodeRef}
-      style={style}
-      className={cn(
-        "cursor-grab active:cursor-grabbing transition-all backdrop-blur-sm border-border relative kanban-card-content",
-        isDragging && "opacity-50 scale-105 shadow-lg",
-        isCurrentAutoTask &&
-          "border-running-indicator border-2 shadow-running-indicator/50 shadow-lg animate-pulse",
-        feature.error &&
-          !isCurrentAutoTask &&
-          "border-red-500 border-2 shadow-red-500/30 shadow-lg"
-      )}
-      data-testid={`kanban-card-${feature.id}`}
-      {...attributes}
-    >
-      {/* Shortcut key badge for in-progress cards */}
-      {shortcutKey && (
-        <div
-          className="absolute top-2 left-2 px-1.5 py-0.5 text-[10px] font-mono rounded bg-brand-500/10 border border-brand-500/30 text-brand-400/70 z-10"
-          data-testid={`shortcut-key-${feature.id}`}
-        >
-          {shortcutKey}
-        </div>
-      )}
-      {/* Skip Tests indicator badge */}
-      {feature.skipTests && !feature.error && (
-        <div
-          className={cn(
-            "absolute px-1.5 py-0.5 text-[10px] font-medium rounded flex items-center gap-1 z-10",
-            shortcutKey ? "top-2 left-10" : "top-2 left-2",
-            "bg-orange-500/20 border border-orange-500/50 text-orange-400"
-          )}
-          data-testid={`skip-tests-badge-${feature.id}`}
-          title="Manual verification required"
-        >
-          <Hand className="w-3 h-3" />
-          <span>Manual</span>
-        </div>
-      )}
-      {/* Error indicator badge */}
-      {feature.error && (
-        <div
-          className={cn(
-            "absolute px-1.5 py-0.5 text-[10px] font-medium rounded flex items-center gap-1 z-10",
-            shortcutKey ? "top-2 left-10" : "top-2 left-2",
-            "bg-red-500/20 border border-red-500/50 text-red-400"
-          )}
-          data-testid={`error-badge-${feature.id}`}
-          title={feature.error}
-        >
-          <AlertCircle className="w-3 h-3" />
-          <span>Errored</span>
-        </div>
-      )}
-      {/* Branch badge - show when feature has a worktree */}
-      {hasWorktree && !isCurrentAutoTask && (
-        <TooltipProvider delayDuration={300}>
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <div
-                className={cn(
-                  "absolute px-1.5 py-0.5 text-[10px] font-medium rounded flex items-center gap-1 z-10 cursor-default",
-                  "bg-purple-500/20 border border-purple-500/50 text-purple-400",
-                  // Position below error badge if present, otherwise use normal position
-                  feature.error || feature.skipTests
-                    ? "top-8 left-2"
-                    : shortcutKey
-                      ? "top-2 left-10"
-                      : "top-2 left-2"
-                )}
-                data-testid={`branch-badge-${feature.id}`}
-              >
-                <GitBranch className="w-3 h-3 shrink-0" />
-                <span className="truncate max-w-[80px]">{feature.branchName?.replace("feature/", "")}</span>
-              </div>
-            </TooltipTrigger>
-            <TooltipContent side="bottom" className="max-w-[300px]">
-              <p className="font-mono text-xs break-all">{feature.branchName}</p>
-            </TooltipContent>
-          </Tooltip>
-        </TooltipProvider>
-      )}
-      <CardHeader
-        className={cn(
-          "p-3 pb-2 block", // Reset grid layout to block for custom kanban card layout
-          // Add extra top padding when badges are present to prevent text overlap
-          (feature.skipTests || feature.error || shortcutKey) && "pt-10",
-          // Add even more top padding when both badges and branch are shown
-          hasWorktree && (feature.skipTests || feature.error) && "pt-14"
-        )}
-      >
-        {isCurrentAutoTask && (
-          <div className="absolute top-2 right-2 flex items-center justify-center gap-2 bg-running-indicator/20 border border-running-indicator rounded px-2 py-0.5">
-            <Loader2 className="w-4 h-4 text-running-indicator animate-spin" />
-            {feature.startedAt && (
-              <CountUpTimer
-                startedAt={feature.startedAt}
-                className="text-running-indicator"
-              />
-            )}
-          </div>
-        )}
-        {!isCurrentAutoTask && (
-          <div className="absolute top-2 right-2">
-            <DropdownMenu>
-              <DropdownMenuTrigger asChild>
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  className="h-6 w-6 p-0 hover:bg-white/10"
-                  onClick={(e) => e.stopPropagation()}
-                  data-testid={`menu-${feature.id}`}
-                >
-                  <MoreVertical className="w-4 h-4" />
-                </Button>
-              </DropdownMenuTrigger>
-              <DropdownMenuContent align="end">
-                <DropdownMenuItem
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    onEdit();
-                  }}
-                  data-testid={`edit-feature-${feature.id}`}
-                >
-                  <Edit className="w-3 h-3 mr-2" />
-                  Edit
-                </DropdownMenuItem>
-                {onViewOutput && feature.status !== "backlog" && (
-                  <DropdownMenuItem
-                    onClick={(e) => {
-                      e.stopPropagation();
-                      onViewOutput();
-                    }}
-                    data-testid={`view-logs-${feature.id}`}
-                  >
-                    <FileText className="w-3 h-3 mr-2" />
-                    Logs
-                  </DropdownMenuItem>
-                )}
-                <DropdownMenuItem
-                  className="text-destructive focus:text-destructive"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    handleDeleteClick(e as unknown as React.MouseEvent);
-                  }}
-                  data-testid={`delete-feature-${feature.id}`}
-                >
-                  <Trash2 className="w-3 h-3 mr-2" />
-                  Delete
-                </DropdownMenuItem>
-              </DropdownMenuContent>
-            </DropdownMenu>
-          </div>
-        )}
-        <div className="flex items-start gap-2">
-          {isDraggable && (
-            <div
-              {...listeners}
-              className="mt-0.5 touch-none cursor-grab"
-              data-testid={`drag-handle-${feature.id}`}
-            >
-              <GripVertical className="w-4 h-4 text-muted-foreground" />
-            </div>
-          )}
-          <div className="flex-1 min-w-0 overflow-hidden">
-            <CardTitle className="text-sm leading-tight break-words hyphens-auto line-clamp-3 overflow-hidden">
-              {feature.description}
-            </CardTitle>
-            <CardDescription className="text-xs mt-1 truncate">
-              {feature.category}
-            </CardDescription>
-          </div>
-        </div>
-      </CardHeader>
-      <CardContent className="p-3 pt-0">
-        {/* Steps Preview - Show in Standard and Detailed modes */}
-        {showSteps && feature.steps.length > 0 && (
-          <div className="mb-3 space-y-1">
-            {feature.steps.slice(0, 3).map((step, index) => (
-              <div
-                key={index}
-                className="flex items-start gap-2 text-xs text-muted-foreground"
-              >
-                {feature.status === "verified" ? (
-                  <CheckCircle2 className="w-3 h-3 mt-0.5 text-green-500 shrink-0" />
-                ) : (
-                  <Circle className="w-3 h-3 mt-0.5 shrink-0" />
-                )}
-                <span className="break-words hyphens-auto line-clamp-2 leading-relaxed">{step}</span>
-              </div>
-            ))}
-            {feature.steps.length > 3 && (
-              <p className="text-xs text-muted-foreground pl-5">
-                +{feature.steps.length - 3} more steps
-              </p>
-            )}
-          </div>
-        )}
-
-        {/* Agent Info Panel - shows for in_progress, waiting_approval, verified */}
-        {/* Detailed mode: Show all agent info */}
-        {showAgentInfo && feature.status !== "backlog" && agentInfo && (
-          <div className="mb-3 space-y-2 overflow-hidden">
-            {/* Model & Phase */}
-            <div className="flex items-center gap-2 text-xs flex-wrap">
-              <div className="flex items-center gap-1 text-cyan-400">
-                <Cpu className="w-3 h-3" />
-                <span className="font-medium">
-                  {formatModelName(feature.model ?? DEFAULT_MODEL)}
-                </span>
-              </div>
-              {agentInfo.currentPhase && (
-                <div
-                  className={cn(
-                    "px-1.5 py-0.5 rounded text-[10px] font-medium",
-                    agentInfo.currentPhase === "planning" &&
-                      "bg-blue-500/20 text-blue-400",
-                    agentInfo.currentPhase === "action" &&
-                      "bg-amber-500/20 text-amber-400",
-                    agentInfo.currentPhase === "verification" &&
-                      "bg-green-500/20 text-green-400"
-                  )}
-                >
-                  {agentInfo.currentPhase}
-                </div>
-              )}
-            </div>
-
-            {/* Task List Progress (if todos found) */}
-            {agentInfo.todos.length > 0 && (
-              <div className="space-y-1">
-                <div className="flex items-center gap-1 text-[10px] text-muted-foreground">
-                  <ListTodo className="w-3 h-3" />
-                  <span>
-                    {
-                      agentInfo.todos.filter((t) => t.status === "completed")
-                        .length
-                    }
-                    /{agentInfo.todos.length} tasks
-                  </span>
-                </div>
-                <div className="space-y-0.5 max-h-16 overflow-y-auto">
-                  {agentInfo.todos.slice(0, 3).map((todo, idx) => (
-                    <div
-                      key={idx}
-                      className="flex items-center gap-1.5 text-[10px]"
-                    >
-                      {todo.status === "completed" ? (
-                        <CheckCircle2 className="w-2.5 h-2.5 text-green-500 shrink-0" />
-                      ) : todo.status === "in_progress" ? (
-                        <Loader2 className="w-2.5 h-2.5 text-amber-400 animate-spin shrink-0" />
-                      ) : (
-                        <Circle className="w-2.5 h-2.5 text-muted-foreground shrink-0" />
-                      )}
-                      <span
-                        className={cn(
-                          "break-words hyphens-auto line-clamp-2 leading-relaxed",
-                          todo.status === "completed" &&
-                            "text-muted-foreground line-through",
-                          todo.status === "in_progress" && "text-amber-400",
-                          todo.status === "pending" && "text-foreground-secondary"
-                        )}
-                      >
-                        {todo.content}
-                      </span>
-                    </div>
-                  ))}
-                  {agentInfo.todos.length > 3 && (
-                    <p className="text-[10px] text-muted-foreground pl-4">
-                      +{agentInfo.todos.length - 3} more
-                    </p>
-                  )}
-                </div>
-              </div>
-            )}
-
-            {/* Summary for waiting_approval and verified - prioritize feature.summary from UpdateFeatureStatus */}
-            {(feature.status === "waiting_approval" ||
-              feature.status === "verified") && (
-              <>
-                {(feature.summary || summary || agentInfo.summary) && (
-                  <div className="space-y-1 pt-1 border-t border-border-glass overflow-hidden">
-                    <div className="flex items-center justify-between gap-2">
-                      <div className="flex items-center gap-1 text-[10px] text-green-400 min-w-0">
-                        <Sparkles className="w-3 h-3 shrink-0" />
-                        <span className="truncate">Summary</span>
-                      </div>
-                      <button
-                        onClick={(e) => {
-                          e.stopPropagation();
-                          setIsSummaryDialogOpen(true);
-                        }}
-                        className="p-0.5 rounded hover:bg-accent transition-colors text-muted-foreground hover:text-foreground shrink-0"
-                        title="View full summary"
-                        data-testid={`expand-summary-${feature.id}`}
-                      >
-                        <Expand className="w-3 h-3" />
-                      </button>
-                    </div>
-                    <p className="text-[10px] text-foreground-secondary line-clamp-3 break-words hyphens-auto leading-relaxed overflow-hidden">
-                      {feature.summary || summary || agentInfo.summary}
-                    </p>
-                  </div>
-                )}
-                {/* Show tool count even without summary */}
-                {!feature.summary &&
-                  !summary &&
-                  !agentInfo.summary &&
-                  agentInfo.toolCallCount > 0 && (
-                    <div className="flex items-center gap-2 text-[10px] text-muted-foreground pt-1 border-t border-border-glass">
-                      <span className="flex items-center gap-1">
-                        <Wrench className="w-2.5 h-2.5" />
-                        {agentInfo.toolCallCount} tool calls
-                      </span>
-                      {agentInfo.todos.length > 0 && (
-                        <span className="flex items-center gap-1">
-                          <CheckCircle2 className="w-2.5 h-2.5 text-green-500" />
-                          {
-                            agentInfo.todos.filter(
-                              (t) => t.status === "completed"
-                            ).length
-                          }{" "}
-                          tasks done
-                        </span>
-                      )}
-                    </div>
-                  )}
-              </>
-            )}
-          </div>
-        )}
-
-        {/* Actions */}
-        <div className="flex gap-2">
-          {isCurrentAutoTask && (
-            <>
-              {onViewOutput && (
-                <Button
-                  variant="default"
-                  size="sm"
-                  className="flex-1 h-7 text-xs bg-action-view hover:bg-action-view-hover"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    onViewOutput();
-                  }}
-                  data-testid={`view-output-${feature.id}`}
-                >
-                  <FileText className="w-3 h-3 mr-1" />
-                  Logs
-                </Button>
-              )}
-              {onForceStop && (
-                <Button
-                  variant="destructive"
-                  size="sm"
-                  className="h-7 text-xs"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    onForceStop();
-                  }}
-                  data-testid={`force-stop-${feature.id}`}
-                >
-                  <StopCircle className="w-3 h-3 mr-1" />
-                  Stop
-                </Button>
-              )}
-            </>
-          )}
-          {!isCurrentAutoTask && feature.status === "in_progress" && (
-            <>
-              {/* skipTests features show manual verify button */}
-              {feature.skipTests && onManualVerify ? (
-                <Button
-                  variant="default"
-                  size="sm"
-                  className="flex-1 h-7 text-xs bg-primary hover:bg-primary/90"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    onManualVerify();
-                  }}
-                  data-testid={`manual-verify-${feature.id}`}
-                >
-                  <CheckCircle2 className="w-3 h-3 mr-1" />
-                  Verify
-                </Button>
-              ) : hasContext && onResume ? (
-                <Button
-                  variant="default"
-                  size="sm"
-                  className="flex-1 h-7 text-xs bg-action-verify hover:bg-action-verify-hover"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    onResume();
-                  }}
-                  data-testid={`resume-feature-${feature.id}`}
-                >
-                  <RotateCcw className="w-3 h-3 mr-1" />
-                  Resume
-                </Button>
-              ) : onVerify ? (
-                <Button
-                  variant="default"
-                  size="sm"
-                  className="flex-1 h-7 text-xs bg-action-verify hover:bg-action-verify-hover"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    onVerify();
-                  }}
-                  data-testid={`verify-feature-${feature.id}`}
-                >
-                  <PlayCircle className="w-3 h-3 mr-1" />
-                  Resume
-                </Button>
-              ) : null}
-              {onViewOutput && !feature.skipTests && (
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  className="h-7 text-xs"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    onViewOutput();
-                  }}
-                  data-testid={`view-output-inprogress-${feature.id}`}
-                >
-                  <FileText className="w-3 h-3 mr-1" />
-                  Logs
-                </Button>
-              )}
-            </>
-          )}
-          {!isCurrentAutoTask && feature.status === "verified" && (
-            <>
-              {/* Logs button if context exists */}
-              {hasContext && onViewOutput && (
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  className="h-7 text-xs"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    onViewOutput();
-                  }}
-                  data-testid={`view-output-verified-${feature.id}`}
-                >
-                  <FileText className="w-3 h-3 mr-1" />
-                  Logs
-                </Button>
-              )}
-            </>
-          )}
-          {!isCurrentAutoTask && feature.status === "waiting_approval" && (
-            <>
-              {/* Revert button - only show when worktree exists (icon only to save space) */}
-              {hasWorktree && onRevert && (
-                <TooltipProvider delayDuration={300}>
-                  <Tooltip>
-                    <TooltipTrigger asChild>
-                      <Button
-                        variant="ghost"
-                        size="sm"
-                        className="h-7 w-7 p-0 text-red-400 hover:text-red-300 hover:bg-red-500/20 shrink-0"
-                        onClick={(e) => {
-                          e.stopPropagation();
-                          setIsRevertDialogOpen(true);
-                        }}
-                        data-testid={`revert-${feature.id}`}
-                      >
-                        <Undo2 className="w-3.5 h-3.5" />
-                      </Button>
-                    </TooltipTrigger>
-                    <TooltipContent side="top">
-                      <p>Revert changes</p>
-                    </TooltipContent>
-                  </Tooltip>
-                </TooltipProvider>
-              )}
-              {/* Follow-up prompt button */}
-              {onFollowUp && (
-                <Button
-                  variant="secondary"
-                  size="sm"
-                  className="flex-1 h-7 text-xs min-w-0"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    onFollowUp();
-                  }}
-                  data-testid={`follow-up-${feature.id}`}
-                >
-                  <MessageSquare className="w-3 h-3 mr-1 shrink-0" />
-                  <span className="truncate">Follow-up</span>
-                </Button>
-              )}
-              {/* Merge button - only show when worktree exists */}
-              {hasWorktree && onMerge && (
-                <Button
-                  variant="default"
-                  size="sm"
-                  className="flex-1 h-7 text-xs bg-purple-600 hover:bg-purple-700 min-w-0"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    onMerge();
-                  }}
-                  data-testid={`merge-${feature.id}`}
-                  title="Merge changes into main branch"
-                >
-                  <GitMerge className="w-3 h-3 mr-1 shrink-0" />
-                  <span className="truncate">Merge</span>
-                </Button>
-              )}
-              {/* Commit and verify button - show when no worktree */}
-              {!hasWorktree && onCommit && (
-                <Button
-                  variant="default"
-                  size="sm"
-                  className="flex-1 h-7 text-xs"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    onCommit();
-                  }}
-                  data-testid={`commit-${feature.id}`}
-                >
-                  <GitCommit className="w-3 h-3 mr-1" />
-                  Commit
-                </Button>
-              )}
-            </>
-          )}
-        </div>
-      </CardContent>
-
-      {/* Delete Confirmation Dialog */}
-      <Dialog open={isDeleteDialogOpen} onOpenChange={setIsDeleteDialogOpen}>
-        <DialogContent data-testid="delete-confirmation-dialog">
-          <DialogHeader>
-            <DialogTitle>Delete Feature</DialogTitle>
-            <DialogDescription>
-              Are you sure you want to delete this feature? This action cannot
-              be undone.
-            </DialogDescription>
-          </DialogHeader>
-          <DialogFooter>
-            <Button
-              variant="ghost"
-              onClick={handleCancelDelete}
-              data-testid="cancel-delete-button"
-            >
-              Cancel
-            </Button>
-            <Button
-              variant="destructive"
-              onClick={handleConfirmDelete}
-              data-testid="confirm-delete-button"
-            >
-              Delete
-            </Button>
-          </DialogFooter>
-        </DialogContent>
-      </Dialog>
-
-      {/* Summary Modal */}
-      <Dialog open={isSummaryDialogOpen} onOpenChange={setIsSummaryDialogOpen}>
-        <DialogContent
-          className="max-w-4xl max-h-[80vh] overflow-hidden flex flex-col"
-          data-testid={`summary-dialog-${feature.id}`}
-        >
-          <DialogHeader>
-            <DialogTitle className="flex items-center gap-2">
-              <Sparkles className="w-5 h-5 text-green-400" />
-              Implementation Summary
-            </DialogTitle>
-            <DialogDescription className="text-sm" title={feature.description}>
-              {feature.description.length > 100
-                ? `${feature.description.slice(0, 100)}...`
-                : feature.description}
-            </DialogDescription>
-          </DialogHeader>
-          <div className="flex-1 overflow-y-auto p-4 bg-card rounded-lg border border-border">
-            <Markdown>
-              {feature.summary ||
-                summary ||
-                agentInfo?.summary ||
-                "No summary available"}
-            </Markdown>
-          </div>
-          <DialogFooter>
-            <Button
-              variant="ghost"
-              onClick={() => setIsSummaryDialogOpen(false)}
-              data-testid="close-summary-button"
-            >
-              Close
-            </Button>
-          </DialogFooter>
-        </DialogContent>
-      </Dialog>
-
-      {/* Revert Confirmation Dialog */}
-      <Dialog open={isRevertDialogOpen} onOpenChange={setIsRevertDialogOpen}>
-        <DialogContent data-testid="revert-confirmation-dialog">
-          <DialogHeader>
-            <DialogTitle className="flex items-center gap-2 text-red-400">
-              <Undo2 className="w-5 h-5" />
-              Revert Changes
-            </DialogTitle>
-            <DialogDescription>
-              This will discard all changes made by the agent and move the feature back to the backlog.
-              {feature.branchName && (
-                <span className="block mt-2 font-medium">
-                  Branch <code className="bg-muted px-1 py-0.5 rounded">{feature.branchName}</code> will be deleted.
-                </span>
-              )}
-              <span className="block mt-2 text-red-400 font-medium">
-                This action cannot be undone.
-              </span>
-            </DialogDescription>
-          </DialogHeader>
-          <DialogFooter>
-            <Button
-              variant="ghost"
-              onClick={() => setIsRevertDialogOpen(false)}
-              data-testid="cancel-revert-button"
-            >
-              Cancel
-            </Button>
-            <Button
-              variant="destructive"
-              onClick={() => {
-                setIsRevertDialogOpen(false);
-                onRevert?.();
-              }}
-              data-testid="confirm-revert-button"
-            >
-              <Undo2 className="w-4 h-4 mr-2" />
-              Revert Changes
-            </Button>
-          </DialogFooter>
-        </DialogContent>
-      </Dialog>
-    </Card>
-  );
-});

app/src/components/views/kanban-column.tsx

@@ -1,52 +0,0 @@
-"use client";
-
-import { memo } from "react";
-import { useDroppable } from "@dnd-kit/core";
-import { cn } from "@/lib/utils";
-import type { ReactNode } from "react";
-
-interface KanbanColumnProps {
-  id: string;
-  title: string;
-  color: string;
-  count: number;
-  children: ReactNode;
-  headerAction?: ReactNode;
-}
-
-export const KanbanColumn = memo(function KanbanColumn({
-  id,
-  title,
-  color,
-  count,
-  children,
-  headerAction,
-}: KanbanColumnProps) {
-  const { setNodeRef, isOver } = useDroppable({ id });
-
-  return (
-    <div
-      ref={setNodeRef}
-      className={cn(
-        "flex flex-col h-full rounded-lg bg-card backdrop-blur-sm border border-border transition-colors w-72",
-        isOver && "bg-accent"
-      )}
-      data-testid={`kanban-column-${id}`}
-    >
-      {/* Column Header */}
-      <div className="flex items-center gap-2 p-3 border-b border-border">
-        <div className={cn("w-3 h-3 rounded-full", color)} />
-        <h3 className="font-medium text-sm flex-1">{title}</h3>
-        {headerAction}
-        <span className="text-xs text-muted-foreground bg-background px-2 py-0.5 rounded-full">
-          {count}
-        </span>
-      </div>
-
-      {/* Column Content */}
-      <div className="flex-1 overflow-y-auto p-2 space-y-2">
-        {children}
-      </div>
-    </div>
-  );
-});

app/src/components/views/profiles-view.tsx

@@ -1,718 +0,0 @@
-"use client";
-
-import { useState, useMemo, useCallback, useEffect } from "react";
-import {
-  useAppStore,
-  AIProfile,
-  AgentModel,
-  ThinkingLevel,
-  ModelProvider,
-} from "@/store/app-store";
-import { Button } from "@/components/ui/button";
-import { HotkeyButton } from "@/components/ui/hotkey-button";
-import { Input } from "@/components/ui/input";
-import { Label } from "@/components/ui/label";
-import { Textarea } from "@/components/ui/textarea";
-import { cn, modelSupportsThinking } from "@/lib/utils";
-import {
-  useKeyboardShortcuts,
-  useKeyboardShortcutsConfig,
-  KeyboardShortcut,
-} from "@/hooks/use-keyboard-shortcuts";
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from "@/components/ui/dialog";
-import {
-  UserCircle,
-  Plus,
-  Pencil,
-  Trash2,
-  Brain,
-  Zap,
-  Scale,
-  Cpu,
-  Rocket,
-  Sparkles,
-  GripVertical,
-  Lock,
-  Check,
-} from "lucide-react";
-import { toast } from "sonner";
-import {
-  DndContext,
-  DragEndEvent,
-  PointerSensor,
-  useSensor,
-  useSensors,
-  closestCenter,
-} from "@dnd-kit/core";
-import {
-  SortableContext,
-  useSortable,
-  verticalListSortingStrategy,
-} from "@dnd-kit/sortable";
-import { CSS } from "@dnd-kit/utilities";
-
-// Icon mapping for profiles
-const PROFILE_ICONS: Record<
-  string,
-  React.ComponentType<{ className?: string }>
-> = {
-  Brain,
-  Zap,
-  Scale,
-  Cpu,
-  Rocket,
-  Sparkles,
-};
-
-// Available icons for selection
-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
-const CLAUDE_MODELS: { id: AgentModel; label: string }[] = [
-  { id: "haiku", label: "Claude Haiku" },
-  { id: "sonnet", label: "Claude Sonnet" },
-  { id: "opus", label: "Claude Opus" },
-];
-
-const CODEX_MODELS: { id: AgentModel; label: string }[] = [
-  { id: "gpt-5.1-codex-max", label: "GPT-5.1 Codex Max" },
-  { id: "gpt-5.1-codex", label: "GPT-5.1 Codex" },
-  { id: "gpt-5.1-codex-mini", label: "GPT-5.1 Codex Mini" },
-  { id: "gpt-5.1", label: "GPT-5.1" },
-];
-
-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" },
-];
-
-// Helper to determine provider from model
-function getProviderFromModel(model: AgentModel): ModelProvider {
-  if (model.startsWith("gpt")) {
-    return "codex";
-  }
-  return "claude";
-}
-
-// Sortable Profile Card Component
-function SortableProfileCard({
-  profile,
-  onEdit,
-  onDelete,
-}: {
-  profile: AIProfile;
-  onEdit: () => void;
-  onDelete: () => void;
-}) {
-  const {
-    attributes,
-    listeners,
-    setNodeRef,
-    transform,
-    transition,
-    isDragging,
-  } = useSortable({ id: profile.id });
-
-  const style = {
-    transform: CSS.Transform.toString(transform),
-    transition,
-    opacity: isDragging ? 0.5 : 1,
-  };
-
-  const IconComponent = profile.icon ? PROFILE_ICONS[profile.icon] : Brain;
-  const isCodex = profile.provider === "codex";
-
-  return (
-    <div
-      ref={setNodeRef}
-      style={style}
-      className={cn(
-        "group relative flex items-start gap-4 p-4 rounded-xl border bg-card transition-all",
-        isDragging && "shadow-lg",
-        profile.isBuiltIn
-          ? "border-border/50"
-          : "border-border hover:border-primary/50 hover:shadow-sm"
-      )}
-      data-testid={`profile-card-${profile.id}`}
-    >
-      {/* Drag Handle */}
-      <button
-        {...attributes}
-        {...listeners}
-        className="p-1 rounded hover:bg-accent cursor-grab active:cursor-grabbing flex-shrink-0 mt-1"
-        data-testid={`profile-drag-handle-${profile.id}`}
-        onClick={(e) => e.stopPropagation()}
-      >
-        <GripVertical className="h-4 w-4 text-muted-foreground" />
-      </button>
-
-      {/* Icon */}
-      <div
-        className={cn(
-          "flex-shrink-0 w-10 h-10 rounded-lg flex items-center justify-center",
-          isCodex ? "bg-emerald-500/10" : "bg-primary/10"
-        )}
-      >
-        {IconComponent && (
-          <IconComponent
-            className={cn(
-              "w-5 h-5",
-              isCodex ? "text-emerald-500" : "text-primary"
-            )}
-          />
-        )}
-      </div>
-
-      {/* Content */}
-      <div className="flex-1 min-w-0">
-        <div className="flex items-center gap-2">
-          <h3 className="font-semibold text-foreground">{profile.name}</h3>
-          {profile.isBuiltIn && (
-            <span className="flex items-center gap-1 text-[10px] px-1.5 py-0.5 rounded-full bg-muted text-muted-foreground">
-              <Lock className="w-2.5 h-2.5" />
-              Built-in
-            </span>
-          )}
-        </div>
-        <p className="text-sm text-muted-foreground mt-0.5 line-clamp-2">
-          {profile.description}
-        </p>
-        <div className="flex items-center gap-2 mt-2 flex-wrap">
-          <span
-            className={cn(
-              "text-xs px-2 py-0.5 rounded-full border",
-              isCodex
-                ? "border-emerald-500/30 text-emerald-600 dark:text-emerald-400 bg-emerald-500/10"
-                : "border-primary/30 text-primary bg-primary/10"
-            )}
-          >
-            {profile.model}
-          </span>
-          {profile.thinkingLevel !== "none" && (
-            <span className="text-xs px-2 py-0.5 rounded-full border border-amber-500/30 text-amber-600 dark:text-amber-400 bg-amber-500/10">
-              {profile.thinkingLevel}
-            </span>
-          )}
-        </div>
-      </div>
-
-      {/* Actions */}
-      {!profile.isBuiltIn && (
-        <div className="flex items-center gap-1 opacity-0 group-hover:opacity-100 transition-opacity">
-          <Button
-            variant="ghost"
-            size="sm"
-            onClick={onEdit}
-            className="h-8 w-8 p-0"
-            data-testid={`edit-profile-${profile.id}`}
-          >
-            <Pencil className="w-4 h-4" />
-          </Button>
-          <Button
-            variant="ghost"
-            size="sm"
-            onClick={onDelete}
-            className="h-8 w-8 p-0 text-destructive hover:text-destructive"
-            data-testid={`delete-profile-${profile.id}`}
-          >
-            <Trash2 className="w-4 h-4" />
-          </Button>
-        </div>
-      )}
-    </div>
-  );
-}
-
-// Profile Form Component
-function ProfileForm({
-  profile,
-  onSave,
-  onCancel,
-  isEditing,
-  hotkeyActive,
-}: {
-  profile: Partial<AIProfile>;
-  onSave: (profile: Omit<AIProfile, "id">) => void;
-  onCancel: () => void;
-  isEditing: boolean;
-  hotkeyActive: boolean;
-}) {
-  const [formData, setFormData] = useState({
-    name: profile.name || "",
-    description: profile.description || "",
-    model: profile.model || ("opus" as AgentModel),
-    thinkingLevel: profile.thinkingLevel || ("none" as ThinkingLevel),
-    icon: profile.icon || "Brain",
-  });
-
-  const provider = getProviderFromModel(formData.model);
-  const supportsThinking = modelSupportsThinking(formData.model);
-
-  const handleModelChange = (model: AgentModel) => {
-    const newProvider = getProviderFromModel(model);
-    setFormData({
-      ...formData,
-      model,
-      // Reset thinking level when switching to Codex (doesn't support thinking)
-      thinkingLevel: newProvider === "codex" ? "none" : formData.thinkingLevel,
-    });
-  };
-
-  const handleSubmit = () => {
-    if (!formData.name.trim()) {
-      toast.error("Please enter a profile name");
-      return;
-    }
-
-    onSave({
-      name: formData.name.trim(),
-      description: formData.description.trim(),
-      model: formData.model,
-      thinkingLevel: supportsThinking ? formData.thinkingLevel : "none",
-      provider,
-      isBuiltIn: false,
-      icon: formData.icon,
-    });
-  };
-
-  return (
-    <div className="space-y-4">
-      {/* Name */}
-      <div className="space-y-2">
-        <Label htmlFor="profile-name">Profile Name</Label>
-        <Input
-          id="profile-name"
-          value={formData.name}
-          onChange={(e) => setFormData({ ...formData, name: e.target.value })}
-          placeholder="e.g., Heavy Task, Quick Fix"
-          data-testid="profile-name-input"
-        />
-      </div>
-
-      {/* Description */}
-      <div className="space-y-2">
-        <Label htmlFor="profile-description">Description</Label>
-        <Textarea
-          id="profile-description"
-          value={formData.description}
-          onChange={(e) =>
-            setFormData({ ...formData, description: e.target.value })
-          }
-          placeholder="Describe when to use this profile..."
-          rows={2}
-          data-testid="profile-description-input"
-        />
-      </div>
-
-      {/* Icon Selection */}
-      <div className="space-y-2">
-        <Label>Icon</Label>
-        <div className="flex gap-2 flex-wrap">
-          {ICON_OPTIONS.map(({ name, icon: Icon }) => (
-            <button
-              key={name}
-              type="button"
-              onClick={() => setFormData({ ...formData, icon: name })}
-              className={cn(
-                "w-10 h-10 rounded-lg flex items-center justify-center border transition-colors",
-                formData.icon === name
-                  ? "bg-primary text-primary-foreground border-primary"
-                  : "bg-background hover:bg-accent border-input"
-              )}
-              data-testid={`icon-select-${name}`}
-            >
-              <Icon className="w-5 h-5" />
-            </button>
-          ))}
-        </div>
-      </div>
-
-      {/* Model Selection - Claude */}
-      <div className="space-y-2">
-        <Label className="flex items-center gap-2">
-          <Brain className="w-4 h-4 text-primary" />
-          Claude Models
-        </Label>
-        <div className="flex gap-2 flex-wrap">
-          {CLAUDE_MODELS.map(({ id, label }) => (
-            <button
-              key={id}
-              type="button"
-              onClick={() => handleModelChange(id)}
-              className={cn(
-                "flex-1 min-w-[100px] px-3 py-2 rounded-md border text-sm font-medium transition-colors",
-                formData.model === id
-                  ? "bg-primary text-primary-foreground border-primary"
-                  : "bg-background hover:bg-accent border-input"
-              )}
-              data-testid={`model-select-${id}`}
-            >
-              {label.replace("Claude ", "")}
-            </button>
-          ))}
-        </div>
-      </div>
-
-      {/* Model Selection - Codex */}
-      <div className="space-y-2">
-        <Label className="flex items-center gap-2">
-          <Zap className="w-4 h-4 text-emerald-500" />
-          Codex Models
-        </Label>
-        <div className="flex gap-2 flex-wrap">
-          {CODEX_MODELS.map(({ id, label }) => (
-            <button
-              key={id}
-              type="button"
-              onClick={() => handleModelChange(id)}
-              className={cn(
-                "flex-1 min-w-[100px] px-3 py-2 rounded-md border text-sm font-medium transition-colors",
-                formData.model === id
-                  ? "bg-emerald-600 text-white border-emerald-500"
-                  : "bg-background hover:bg-accent border-input"
-              )}
-              data-testid={`model-select-${id}`}
-            >
-              {label.replace("GPT-5.1 ", "").replace("Codex ", "")}
-            </button>
-          ))}
-        </div>
-      </div>
-
-      {/* Thinking Level - Only for Claude models */}
-      {supportsThinking && (
-        <div className="space-y-2">
-          <Label className="flex items-center gap-2">
-            <Brain className="w-4 h-4 text-amber-500" />
-            Thinking Level
-          </Label>
-          <div className="flex gap-2 flex-wrap">
-            {THINKING_LEVELS.map(({ id, label }) => (
-              <button
-                key={id}
-                type="button"
-                onClick={() => {
-                  setFormData({ ...formData, thinkingLevel: id });
-                  if (id === "ultrathink") {
-                    toast.warning("Ultrathink uses extensive reasoning", {
-                      description:
-                        "Best for complex architecture, migrations, or deep debugging (~$0.48/task).",
-                      duration: 4000,
-                    });
-                  }
-                }}
-                className={cn(
-                  "flex-1 min-w-[70px] px-3 py-2 rounded-md border text-sm font-medium transition-colors",
-                  formData.thinkingLevel === id
-                    ? "bg-amber-500 text-white border-amber-400"
-                    : "bg-background hover:bg-accent border-input"
-                )}
-                data-testid={`thinking-select-${id}`}
-              >
-                {label}
-              </button>
-            ))}
-          </div>
-          <p className="text-xs text-muted-foreground">
-            Higher levels give more time to reason through complex problems.
-          </p>
-        </div>
-      )}
-
-      {/* Actions */}
-      <DialogFooter className="pt-4">
-        <Button variant="ghost" onClick={onCancel}>
-          Cancel
-        </Button>
-        <HotkeyButton
-          onClick={handleSubmit}
-          hotkey={{ key: "Enter", cmdCtrl: true }}
-          hotkeyActive={hotkeyActive}
-          data-testid="save-profile-button"
-        >
-          {isEditing ? "Save Changes" : "Create Profile"}
-        </HotkeyButton>
-      </DialogFooter>
-    </div>
-  );
-}
-
-export function ProfilesView() {
-  const {
-    aiProfiles,
-    addAIProfile,
-    updateAIProfile,
-    removeAIProfile,
-    reorderAIProfiles,
-  } = useAppStore();
-  const shortcuts = useKeyboardShortcutsConfig();
-
-  const [showAddDialog, setShowAddDialog] = useState(false);
-  const [editingProfile, setEditingProfile] = useState<AIProfile | null>(null);
-
-  // Sensors for drag-and-drop
-  const sensors = useSensors(
-    useSensor(PointerSensor, {
-      activationConstraint: {
-        distance: 5,
-      },
-    })
-  );
-
-  // Separate built-in and custom profiles
-  const builtInProfiles = useMemo(
-    () => aiProfiles.filter((p) => p.isBuiltIn),
-    [aiProfiles]
-  );
-  const customProfiles = useMemo(
-    () => aiProfiles.filter((p) => !p.isBuiltIn),
-    [aiProfiles]
-  );
-
-  const handleDragEnd = useCallback(
-    (event: DragEndEvent) => {
-      const { active, over } = event;
-
-      if (over && active.id !== over.id) {
-        const oldIndex = aiProfiles.findIndex((p) => p.id === active.id);
-        const newIndex = aiProfiles.findIndex((p) => p.id === over.id);
-
-        if (oldIndex !== -1 && newIndex !== -1) {
-          reorderAIProfiles(oldIndex, newIndex);
-        }
-      }
-    },
-    [aiProfiles, reorderAIProfiles]
-  );
-
-  const handleAddProfile = (profile: Omit<AIProfile, "id">) => {
-    addAIProfile(profile);
-    setShowAddDialog(false);
-    toast.success("Profile created", {
-      description: `Created "${profile.name}" profile`,
-    });
-  };
-
-  const handleUpdateProfile = (profile: Omit<AIProfile, "id">) => {
-    if (editingProfile) {
-      updateAIProfile(editingProfile.id, profile);
-      setEditingProfile(null);
-      toast.success("Profile updated", {
-        description: `Updated "${profile.name}" profile`,
-      });
-    }
-  };
-
-  const handleDeleteProfile = (profile: AIProfile) => {
-    if (profile.isBuiltIn) return;
-
-    removeAIProfile(profile.id);
-    toast.success("Profile deleted", {
-      description: `Deleted "${profile.name}" profile`,
-    });
-  };
-
-  // Build keyboard shortcuts for profiles view
-  const profilesShortcuts: KeyboardShortcut[] = useMemo(() => {
-    const shortcutsList: KeyboardShortcut[] = [];
-
-    // Add profile shortcut - when in profiles view
-    shortcutsList.push({
-      key: shortcuts.addProfile,
-      action: () => setShowAddDialog(true),
-      description: "Create new profile",
-    });
-
-    return shortcutsList;
-  }, [shortcuts]);
-
-  // Register keyboard shortcuts for profiles view
-  useKeyboardShortcuts(profilesShortcuts);
-
-  return (
-    <div
-      className="flex-1 flex flex-col overflow-hidden content-bg"
-      data-testid="profiles-view"
-    >
-      {/* Header Section */}
-      <div className="shrink-0 border-b border-border bg-glass backdrop-blur-md">
-        <div className="px-8 py-6">
-          <div className="flex items-center justify-between">
-            <div className="flex items-center gap-3">
-              <div className="w-10 h-10 rounded-xl bg-linear-to-br from-brand-500 to-brand-600 shadow-lg shadow-brand-500/20 flex items-center justify-center">
-                <UserCircle className="w-5 h-5 text-primary-foreground" />
-              </div>
-              <div>
-                <h1 className="text-2xl font-bold text-foreground">
-                  AI Profiles
-                </h1>
-                <p className="text-sm text-muted-foreground">
-                  Create and manage model configuration presets
-                </p>
-              </div>
-            </div>
-            <HotkeyButton
-              onClick={() => setShowAddDialog(true)}
-              hotkey={shortcuts.addProfile}
-              hotkeyActive={false}
-              data-testid="add-profile-button"
-            >
-              <Plus className="w-4 h-4 mr-2" />
-              New Profile
-            </HotkeyButton>
-          </div>
-        </div>
-      </div>
-
-      {/* Content */}
-      <div className="flex-1 overflow-y-auto p-8">
-        <div className="max-w-4xl mx-auto space-y-8">
-          {/* Custom Profiles Section */}
-          <div>
-            <div className="flex items-center gap-2 mb-4">
-              <h2 className="text-lg font-semibold text-foreground">
-                Custom Profiles
-              </h2>
-              <span className="text-xs px-2 py-0.5 rounded-full bg-primary/10 text-primary">
-                {customProfiles.length}
-              </span>
-            </div>
-            {customProfiles.length === 0 ? (
-              <div className="rounded-xl border border-dashed border-border p-8 text-center">
-                <Sparkles className="w-10 h-10 text-muted-foreground mx-auto mb-3 opacity-50" />
-                <p className="text-muted-foreground">
-                  No custom profiles yet. Create one to get started!
-                </p>
-                <Button
-                  variant="outline"
-                  className="mt-4"
-                  onClick={() => setShowAddDialog(true)}
-                >
-                  <Plus className="w-4 h-4 mr-2" />
-                  Create Profile
-                </Button>
-              </div>
-            ) : (
-              <DndContext
-                sensors={sensors}
-                collisionDetection={closestCenter}
-                onDragEnd={handleDragEnd}
-              >
-                <SortableContext
-                  items={customProfiles.map((p) => p.id)}
-                  strategy={verticalListSortingStrategy}
-                >
-                  <div className="space-y-3">
-                    {customProfiles.map((profile) => (
-                      <SortableProfileCard
-                        key={profile.id}
-                        profile={profile}
-                        onEdit={() => setEditingProfile(profile)}
-                        onDelete={() => handleDeleteProfile(profile)}
-                      />
-                    ))}
-                  </div>
-                </SortableContext>
-              </DndContext>
-            )}
-          </div>
-
-          {/* Built-in Profiles Section */}
-          <div>
-            <div className="flex items-center gap-2 mb-4">
-              <h2 className="text-lg font-semibold text-foreground">
-                Built-in Profiles
-              </h2>
-              <span className="text-xs px-2 py-0.5 rounded-full bg-muted text-muted-foreground">
-                {builtInProfiles.length}
-              </span>
-            </div>
-            <p className="text-sm text-muted-foreground mb-4">
-              Pre-configured profiles for common use cases. These cannot be
-              edited or deleted.
-            </p>
-            <DndContext
-              sensors={sensors}
-              collisionDetection={closestCenter}
-              onDragEnd={handleDragEnd}
-            >
-              <SortableContext
-                items={builtInProfiles.map((p) => p.id)}
-                strategy={verticalListSortingStrategy}
-              >
-                <div className="space-y-3">
-                  {builtInProfiles.map((profile) => (
-                    <SortableProfileCard
-                      key={profile.id}
-                      profile={profile}
-                      onEdit={() => {}}
-                      onDelete={() => {}}
-                    />
-                  ))}
-                </div>
-              </SortableContext>
-            </DndContext>
-          </div>
-        </div>
-      </div>
-
-      {/* Add Profile Dialog */}
-      <Dialog open={showAddDialog} onOpenChange={setShowAddDialog}>
-        <DialogContent data-testid="add-profile-dialog">
-          <DialogHeader>
-            <DialogTitle>Create New Profile</DialogTitle>
-            <DialogDescription>
-              Define a reusable model configuration preset.
-            </DialogDescription>
-          </DialogHeader>
-          <ProfileForm
-            profile={{}}
-            onSave={handleAddProfile}
-            onCancel={() => setShowAddDialog(false)}
-            isEditing={false}
-            hotkeyActive={showAddDialog}
-          />
-        </DialogContent>
-      </Dialog>
-
-      {/* Edit Profile Dialog */}
-      <Dialog
-        open={!!editingProfile}
-        onOpenChange={() => setEditingProfile(null)}
-      >
-        <DialogContent data-testid="edit-profile-dialog">
-          <DialogHeader>
-            <DialogTitle>Edit Profile</DialogTitle>
-            <DialogDescription>Modify your profile settings.</DialogDescription>
-          </DialogHeader>
-          {editingProfile && (
-            <ProfileForm
-              profile={editingProfile}
-              onSave={handleUpdateProfile}
-              onCancel={() => setEditingProfile(null)}
-              isEditing={true}
-              hotkeyActive={!!editingProfile}
-            />
-          )}
-        </DialogContent>
-      </Dialog>
-    </div>
-  );
-}

app/src/components/views/spec-view.tsx

@@ -1,437 +0,0 @@
-"use client";
-
-import { useEffect, useState, useCallback } 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 {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from "@/components/ui/dialog";
-import { Save, RefreshCw, FileText, Sparkles, Loader2, FilePlus2 } from "lucide-react";
-import { Checkbox } from "@/components/ui/checkbox";
-import { XmlSyntaxEditor } from "@/components/ui/xml-syntax-editor";
-import type { SpecRegenerationEvent } from "@/types/electron";
-
-export function SpecView() {
-  const { currentProject, appSpec, setAppSpec } = useAppStore();
-  const [isLoading, setIsLoading] = useState(true);
-  const [isSaving, setIsSaving] = useState(false);
-  const [hasChanges, setHasChanges] = useState(false);
-  const [specExists, setSpecExists] = useState(true);
-
-  // Regeneration state
-  const [showRegenerateDialog, setShowRegenerateDialog] = useState(false);
-  const [projectDefinition, setProjectDefinition] = useState("");
-  const [isRegenerating, setIsRegenerating] = useState(false);
-
-  // Create spec state
-  const [showCreateDialog, setShowCreateDialog] = useState(false);
-  const [projectOverview, setProjectOverview] = useState("");
-  const [isCreating, setIsCreating] = useState(false);
-  const [generateFeatures, setGenerateFeatures] = useState(true);
-
-  // Load spec from file
-  const loadSpec = useCallback(async () => {
-    if (!currentProject) return;
-
-    setIsLoading(true);
-    try {
-      const api = getElectronAPI();
-      const result = await api.readFile(
-        `${currentProject.path}/.automaker/app_spec.txt`
-      );
-
-      if (result.success && result.content) {
-        setAppSpec(result.content);
-        setSpecExists(true);
-        setHasChanges(false);
-      } else {
-        // File doesn't exist
-        setAppSpec("");
-        setSpecExists(false);
-      }
-    } catch (error) {
-      console.error("Failed to load spec:", error);
-      setSpecExists(false);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [currentProject, setAppSpec]);
-
-  useEffect(() => {
-    loadSpec();
-  }, [loadSpec]);
-
-  // Subscribe to spec regeneration events
-  useEffect(() => {
-    const api = getElectronAPI();
-    if (!api.specRegeneration) return;
-
-    const unsubscribe = api.specRegeneration.onEvent((event: SpecRegenerationEvent) => {
-      console.log("[SpecView] Regeneration event:", event.type);
-
-      if (event.type === "spec_regeneration_complete") {
-        setIsRegenerating(false);
-        setIsCreating(false);
-        setShowRegenerateDialog(false);
-        setShowCreateDialog(false);
-        setProjectDefinition("");
-        setProjectOverview("");
-        // Reload the spec to show the new content
-        loadSpec();
-      } else if (event.type === "spec_regeneration_error") {
-        setIsRegenerating(false);
-        setIsCreating(false);
-        console.error("[SpecView] Regeneration error:", event.error);
-      }
-    });
-
-    return () => {
-      unsubscribe();
-    };
-  }, [loadSpec]);
-
-  // Save spec to file
-  const saveSpec = async () => {
-    if (!currentProject) return;
-
-    setIsSaving(true);
-    try {
-      const api = getElectronAPI();
-      await api.writeFile(
-        `${currentProject.path}/.automaker/app_spec.txt`,
-        appSpec
-      );
-      setHasChanges(false);
-    } catch (error) {
-      console.error("Failed to save spec:", error);
-    } finally {
-      setIsSaving(false);
-    }
-  };
-
-  const handleChange = (value: string) => {
-    setAppSpec(value);
-    setHasChanges(true);
-  };
-
-  const handleRegenerate = async () => {
-    if (!currentProject || !projectDefinition.trim()) return;
-
-    setIsRegenerating(true);
-    try {
-      const api = getElectronAPI();
-      if (!api.specRegeneration) {
-        console.error("[SpecView] Spec regeneration not available");
-        setIsRegenerating(false);
-        return;
-      }
-      const result = await api.specRegeneration.generate(
-        currentProject.path,
-        projectDefinition.trim()
-      );
-
-      if (!result.success) {
-        console.error("[SpecView] Failed to start regeneration:", result.error);
-        setIsRegenerating(false);
-      }
-      // If successful, we'll wait for the events to update the state
-    } catch (error) {
-      console.error("[SpecView] Failed to regenerate spec:", error);
-      setIsRegenerating(false);
-    }
-  };
-
-  const handleCreateSpec = async () => {
-    if (!currentProject || !projectOverview.trim()) return;
-
-    setIsCreating(true);
-    setShowCreateDialog(false);
-    try {
-      const api = getElectronAPI();
-      if (!api.specRegeneration) {
-        console.error("[SpecView] Spec regeneration not available");
-        setIsCreating(false);
-        return;
-      }
-      const result = await api.specRegeneration.create(
-        currentProject.path,
-        projectOverview.trim(),
-        generateFeatures
-      );
-
-      if (!result.success) {
-        console.error("[SpecView] Failed to start spec creation:", result.error);
-        setIsCreating(false);
-      }
-      // If successful, we'll wait for the events to update the state
-    } catch (error) {
-      console.error("[SpecView] Failed to create spec:", error);
-      setIsCreating(false);
-    }
-  };
-
-  if (!currentProject) {
-    return (
-      <div
-        className="flex-1 flex items-center justify-center"
-        data-testid="spec-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="spec-view-loading"
-      >
-        <RefreshCw className="w-6 h-6 animate-spin text-muted-foreground" />
-      </div>
-    );
-  }
-
-  // Show empty state when no spec exists (isCreating is handled by bottom-right indicator in sidebar)
-  if (!specExists) {
-    return (
-      <div
-        className="flex-1 flex flex-col overflow-hidden content-bg"
-        data-testid="spec-view-empty"
-      >
-        {/* 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">
-            <FileText className="w-5 h-5 text-muted-foreground" />
-            <div>
-              <h1 className="text-xl font-bold">App Specification</h1>
-              <p className="text-sm text-muted-foreground">
-                {currentProject.path}/.automaker/app_spec.txt
-              </p>
-            </div>
-          </div>
-        </div>
-
-        {/* Empty State */}
-        <div className="flex-1 flex items-center justify-center p-8">
-          <div className="text-center max-w-md">
-            <div className="mb-6 flex justify-center">
-              <div className="p-4 rounded-full bg-primary/10">
-                <FilePlus2 className="w-12 h-12 text-primary" />
-              </div>
-            </div>
-            <h2 className="text-2xl font-semibold mb-3">No App Specification Found</h2>
-            <p className="text-muted-foreground mb-6">
-              Create an app specification to help our system understand your project.
-              We&apos;ll analyze your codebase and generate a comprehensive spec based on your description.
-            </p>
-            <Button
-              size="lg"
-              onClick={() => setShowCreateDialog(true)}
-            >
-              <FilePlus2 className="w-5 h-5 mr-2" />
-              Create app_spec
-            </Button>
-          </div>
-        </div>
-
-        {/* Create Dialog */}
-        <Dialog open={showCreateDialog} onOpenChange={setShowCreateDialog}>
-          <DialogContent className="max-w-2xl">
-            <DialogHeader>
-              <DialogTitle>Create App Specification</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) => setProjectOverview(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="generate-features"
-                  checked={generateFeatures}
-                  onCheckedChange={(checked) => setGenerateFeatures(checked === true)}
-                />
-                <div className="space-y-1">
-                  <label
-                    htmlFor="generate-features"
-                    className="text-sm font-medium cursor-pointer"
-                  >
-                    Generate feature list
-                  </label>
-                  <p className="text-xs text-muted-foreground">
-                    Automatically populate feature_list.json with all features from the
-                    implementation roadmap after the spec is generated.
-                  </p>
-                </div>
-              </div>
-            </div>
-
-            <DialogFooter>
-              <Button
-                variant="ghost"
-                onClick={() => setShowCreateDialog(false)}
-              >
-                Cancel
-              </Button>
-              <HotkeyButton
-                onClick={handleCreateSpec}
-                disabled={!projectOverview.trim()}
-                hotkey={{ key: "Enter", cmdCtrl: true }}
-                hotkeyActive={showCreateDialog}
-              >
-                <Sparkles className="w-4 h-4 mr-2" />
-                Generate Spec
-              </HotkeyButton>
-            </DialogFooter>
-          </DialogContent>
-        </Dialog>
-      </div>
-    );
-  }
-
-  return (
-    <div
-      className="flex-1 flex flex-col overflow-hidden content-bg"
-      data-testid="spec-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">
-          <FileText className="w-5 h-5 text-muted-foreground" />
-          <div>
-            <h1 className="text-xl font-bold">App Specification</h1>
-            <p className="text-sm text-muted-foreground">
-              {currentProject.path}/.automaker/app_spec.txt
-            </p>
-          </div>
-        </div>
-        <div className="flex gap-2">
-          <Button
-            size="sm"
-            variant="outline"
-            onClick={() => setShowRegenerateDialog(true)}
-            disabled={isRegenerating}
-            data-testid="regenerate-spec"
-          >
-            {isRegenerating ? (
-              <Loader2 className="w-4 h-4 mr-2 animate-spin" />
-            ) : (
-              <Sparkles className="w-4 h-4 mr-2" />
-            )}
-            {isRegenerating ? "Regenerating..." : "Regenerate"}
-          </Button>
-          <Button
-            size="sm"
-            onClick={saveSpec}
-            disabled={!hasChanges || isSaving}
-            data-testid="save-spec"
-          >
-            <Save className="w-4 h-4 mr-2" />
-            {isSaving ? "Saving..." : hasChanges ? "Save Changes" : "Saved"}
-          </Button>
-        </div>
-      </div>
-
-      {/* Editor */}
-      <div className="flex-1 p-4 overflow-hidden">
-        <Card className="h-full overflow-hidden">
-          <XmlSyntaxEditor
-            value={appSpec}
-            onChange={handleChange}
-            placeholder="Write your app specification here..."
-            data-testid="spec-editor"
-          />
-        </Card>
-      </div>
-
-      {/* Regenerate Dialog */}
-      <Dialog open={showRegenerateDialog} onOpenChange={setShowRegenerateDialog}>
-        <DialogContent className="max-w-2xl">
-          <DialogHeader>
-            <DialogTitle>Regenerate App Specification</DialogTitle>
-            <DialogDescription className="text-muted-foreground">
-              We will regenerate your app spec based on a short project definition and the
-              current tech stack found in your project. The agent will analyze your codebase
-              to understand your existing technologies 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">
-                Describe your project
-              </label>
-              <p className="text-xs text-muted-foreground">
-                Provide a clear description of what your app should do. Be as detailed as you
-                want - the more context you provide, the more comprehensive the spec will be.
-              </p>
-              <textarea
-                className="w-full h-40 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={projectDefinition}
-                onChange={(e) => setProjectDefinition(e.target.value)}
-                placeholder="e.g., A task management app where users can create projects, add tasks with due dates, assign tasks to team members, track progress with a kanban board, and receive notifications for upcoming deadlines..."
-                disabled={isRegenerating}
-              />
-            </div>
-          </div>
-
-          <DialogFooter>
-            <Button
-              variant="ghost"
-              onClick={() => setShowRegenerateDialog(false)}
-              disabled={isRegenerating}
-            >
-              Cancel
-            </Button>
-            <HotkeyButton
-              onClick={handleRegenerate}
-              disabled={!projectDefinition.trim() || isRegenerating}
-              hotkey={{ key: "Enter", cmdCtrl: true }}
-              hotkeyActive={showRegenerateDialog}
-            >
-              {isRegenerating ? (
-                <>
-                  <Loader2 className="w-4 h-4 mr-2 animate-spin" />
-                  Regenerating...
-                </>
-              ) : (
-                <>
-                  <Sparkles className="w-4 h-4 mr-2" />
-                  Regenerate Spec
-                </>
-              )}
-            </HotkeyButton>
-          </DialogFooter>
-        </DialogContent>
-      </Dialog>
-    </div>
-  );
-}

app/src/components/views/welcome-view.tsx

@@ -1,619 +0,0 @@
-"use client";
-
-import { useState, useCallback } from "react";
-import { Button } from "@/components/ui/button";
-import { HotkeyButton } from "@/components/ui/hotkey-button";
-import { Input } from "@/components/ui/input";
-import { Label } from "@/components/ui/label";
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from "@/components/ui/dialog";
-import {
-  Card,
-  CardContent,
-  CardDescription,
-  CardHeader,
-  CardTitle,
-} from "@/components/ui/card";
-import { useAppStore } from "@/store/app-store";
-import { getElectronAPI } from "@/lib/electron";
-import { initializeProject } from "@/lib/project-init";
-import {
-  FolderOpen,
-  Plus,
-  Folder,
-  Clock,
-  Sparkles,
-  MessageSquare,
-  ChevronDown,
-  Loader2,
-} from "lucide-react";
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuTrigger,
-} from "@/components/ui/dropdown-menu";
-import { toast } from "sonner";
-
-export function WelcomeView() {
-  const { projects, addProject, setCurrentProject, setCurrentView } =
-    useAppStore();
-  const [showNewProjectDialog, setShowNewProjectDialog] = useState(false);
-  const [newProjectName, setNewProjectName] = useState("");
-  const [newProjectPath, setNewProjectPath] = useState("");
-  const [isCreating, setIsCreating] = useState(false);
-  const [isOpening, setIsOpening] = useState(false);
-  const [showInitDialog, setShowInitDialog] = useState(false);
-  const [isAnalyzing, setIsAnalyzing] = useState(false);
-  const [initStatus, setInitStatus] = useState<{
-    isNewProject: boolean;
-    createdFiles: string[];
-    projectName: string;
-    projectPath: string;
-  } | null>(null);
-
-  /**
-   * Kick off project analysis agent to analyze the codebase
-   */
-  const analyzeProject = useCallback(async (projectPath: string) => {
-    const api = getElectronAPI();
-
-    if (!api.autoMode?.analyzeProject) {
-      console.log("[Welcome] Auto mode API not available, skipping analysis");
-      return;
-    }
-
-    setIsAnalyzing(true);
-    try {
-      console.log("[Welcome] Starting project analysis for:", projectPath);
-      const result = await api.autoMode.analyzeProject(projectPath);
-
-      if (result.success) {
-        toast.success("Project analyzed", {
-          description: "AI agent has analyzed your project structure",
-        });
-      } else {
-        console.error("[Welcome] Project analysis failed:", result.error);
-      }
-    } catch (error) {
-      console.error("[Welcome] Failed to analyze project:", error);
-    } finally {
-      setIsAnalyzing(false);
-    }
-  }, []);
-
-  /**
-   * Initialize project and optionally kick off project analysis agent
-   */
-  const initializeAndOpenProject = useCallback(
-    async (path: string, name: string) => {
-      setIsOpening(true);
-      try {
-        // Initialize the .automaker directory structure
-        const initResult = await initializeProject(path);
-
-        if (!initResult.success) {
-          toast.error("Failed to initialize project", {
-            description: initResult.error || "Unknown error occurred",
-          });
-          return;
-        }
-
-        const project = {
-          id: `project-${Date.now()}`,
-          name,
-          path,
-          lastOpened: new Date().toISOString(),
-        };
-
-        addProject(project);
-        setCurrentProject(project);
-
-        // Show initialization dialog if files were created
-        if (initResult.createdFiles && initResult.createdFiles.length > 0) {
-          setInitStatus({
-            isNewProject: initResult.isNewProject,
-            createdFiles: initResult.createdFiles,
-            projectName: name,
-            projectPath: path,
-          });
-          setShowInitDialog(true);
-
-          // Kick off agent to analyze the project and update app_spec.txt
-          console.log(
-            "[Welcome] Project initialized, created files:",
-            initResult.createdFiles
-          );
-          console.log("[Welcome] Kicking off project analysis agent...");
-
-          // Start analysis in background (don't await, let it run async)
-          analyzeProject(path);
-        } else {
-          toast.success("Project opened", {
-            description: `Opened ${name}`,
-          });
-        }
-      } catch (error) {
-        console.error("[Welcome] Failed to open project:", error);
-        toast.error("Failed to open project", {
-          description: error instanceof Error ? error.message : "Unknown error",
-        });
-      } finally {
-        setIsOpening(false);
-      }
-    },
-    [addProject, setCurrentProject, analyzeProject]
-  );
-
-  const handleOpenProject = useCallback(async () => {
-    const api = getElectronAPI();
-    const result = await api.openDirectory();
-
-    if (!result.canceled && result.filePaths[0]) {
-      const path = result.filePaths[0];
-      const name = path.split("/").pop() || "Untitled Project";
-      await initializeAndOpenProject(path, name);
-    }
-  }, [initializeAndOpenProject]);
-
-  /**
-   * Handle clicking on a recent project
-   */
-  const handleRecentProjectClick = useCallback(
-    async (project: { id: string; name: string; path: string }) => {
-      await initializeAndOpenProject(project.path, project.name);
-    },
-    [initializeAndOpenProject]
-  );
-
-  const handleNewProject = () => {
-    setNewProjectName("");
-    setNewProjectPath("");
-    setShowNewProjectDialog(true);
-  };
-
-  const handleInteractiveMode = () => {
-    setCurrentView("interview");
-  };
-
-  const handleSelectDirectory = async () => {
-    const api = getElectronAPI();
-    const result = await api.openDirectory();
-
-    if (!result.canceled && result.filePaths[0]) {
-      setNewProjectPath(result.filePaths[0]);
-    }
-  };
-
-  const handleCreateProject = async () => {
-    if (!newProjectName || !newProjectPath) return;
-
-    setIsCreating(true);
-    try {
-      const api = getElectronAPI();
-      const projectPath = `${newProjectPath}/${newProjectName}`;
-
-      // Create project directory
-      await api.mkdir(projectPath);
-
-      // Initialize .automaker directory with all necessary files
-      const initResult = await initializeProject(projectPath);
-
-      if (!initResult.success) {
-        toast.error("Failed to initialize project", {
-          description: initResult.error || "Unknown error occurred",
-        });
-        return;
-      }
-
-      // Update the app_spec.txt with the project name
-      await api.writeFile(
-        `${projectPath}/.automaker/app_spec.txt`,
-        `<project_specification>
-  <project_name>${newProjectName}</project_name>
-
-  <overview>
-    Describe your project here. This file will be analyzed by an AI agent
-    to understand your project structure and tech stack.
-  </overview>
-
-  <technology_stack>
-    <!-- The AI agent will fill this in after analyzing your project -->
-  </technology_stack>
-
-  <core_capabilities>
-    <!-- List core features and capabilities -->
-  </core_capabilities>
-
-  <implemented_features>
-    <!-- The AI agent will populate this based on code analysis -->
-  </implemented_features>
-</project_specification>`
-      );
-
-      const project = {
-        id: `project-${Date.now()}`,
-        name: newProjectName,
-        path: projectPath,
-        lastOpened: new Date().toISOString(),
-      };
-
-      addProject(project);
-      setCurrentProject(project);
-      setShowNewProjectDialog(false);
-
-      toast.success("Project created", {
-        description: `Created ${newProjectName} with .automaker directory`,
-      });
-
-      // Set init status to show the dialog
-      setInitStatus({
-        isNewProject: true,
-        createdFiles: initResult.createdFiles || [],
-        projectName: newProjectName,
-        projectPath: projectPath,
-      });
-      setShowInitDialog(true);
-    } catch (error) {
-      console.error("Failed to create project:", error);
-      toast.error("Failed to create project", {
-        description: error instanceof Error ? error.message : "Unknown error",
-      });
-    } finally {
-      setIsCreating(false);
-    }
-  };
-
-  const recentProjects = [...projects]
-    .sort((a, b) => {
-      const dateA = a.lastOpened ? new Date(a.lastOpened).getTime() : 0;
-      const dateB = b.lastOpened ? new Date(b.lastOpened).getTime() : 0;
-      return dateB - dateA;
-    })
-    .slice(0, 5);
-
-  return (
-    <div className="flex-1 flex flex-col content-bg" data-testid="welcome-view">
-      {/* Header Section */}
-      <div className="flex-shrink-0 border-b border-border bg-glass backdrop-blur-md">
-        <div className="px-8 py-6">
-          <div className="flex items-center gap-3 mb-2">
-            <div className="w-10 h-10 rounded-xl flex items-center justify-center">
-              <img src="/logo.png" alt="Automaker Logo" className="w-10 h-10" />
-            </div>
-            <div>
-              <h1 className="text-2xl font-bold text-foreground">
-                Welcome to Automaker
-              </h1>
-              <p className="text-sm text-muted-foreground">
-                Your autonomous AI development studio
-              </p>
-            </div>
-          </div>
-        </div>
-      </div>
-
-      {/* Content Area */}
-      <div className="flex-1 overflow-y-auto p-8">
-        <div className="max-w-6xl mx-auto">
-          {/* Quick Actions */}
-          <div className="grid grid-cols-1 md:grid-cols-2 gap-6 mb-12">
-            <div
-              className="group relative overflow-hidden rounded-xl border border-border bg-card backdrop-blur-md hover:bg-card/70 hover:border-border-glass transition-all duration-200"
-              data-testid="new-project-card"
-            >
-              <div className="absolute inset-0 bg-gradient-to-br from-brand-500/5 to-purple-600/5 opacity-0 group-hover:opacity-100 transition-opacity"></div>
-              <div className="relative p-6">
-                <div className="flex items-start gap-4 mb-4">
-                  <div className="w-12 h-12 rounded-lg bg-linear-to-br from-brand-500 to-brand-600 shadow-lg shadow-brand-500/20 flex items-center justify-center group-hover:scale-110 transition-transform">
-                    <Plus className="w-6 h-6 text-white" />
-                  </div>
-                  <div className="flex-1">
-                    <h3 className="text-lg font-semibold text-foreground mb-1">
-                      New Project
-                    </h3>
-                    <p className="text-sm text-muted-foreground">
-                      Create a new project from scratch with AI-powered
-                      development
-                    </p>
-                  </div>
-                </div>
-                <DropdownMenu>
-                  <DropdownMenuTrigger asChild>
-                    <Button
-                      className="w-full bg-linear-to-r from-brand-500 to-brand-600 hover:from-brand-600 hover:to-brand-600 text-primary-foreground border-0"
-                      data-testid="create-new-project"
-                    >
-                      <Plus className="w-4 h-4 mr-2" />
-                      Create Project
-                      <ChevronDown className="w-4 h-4 ml-2" />
-                    </Button>
-                  </DropdownMenuTrigger>
-                  <DropdownMenuContent align="end" className="w-56">
-                    <DropdownMenuItem
-                      onClick={handleNewProject}
-                      data-testid="quick-setup-option"
-                    >
-                      <Plus className="w-4 h-4 mr-2" />
-                      Quick Setup
-                    </DropdownMenuItem>
-                    <DropdownMenuItem
-                      onClick={handleInteractiveMode}
-                      data-testid="interactive-mode-option"
-                    >
-                      <MessageSquare className="w-4 h-4 mr-2" />
-                      Interactive Mode
-                    </DropdownMenuItem>
-                  </DropdownMenuContent>
-                </DropdownMenu>
-              </div>
-            </div>
-
-            <div
-              className="group relative overflow-hidden rounded-xl border border-border bg-card backdrop-blur-md hover:bg-card/70 hover:border-border-glass transition-all duration-200 cursor-pointer"
-              onClick={handleOpenProject}
-              data-testid="open-project-card"
-            >
-              <div className="absolute inset-0 bg-gradient-to-br from-blue-500/5 to-cyan-600/5 opacity-0 group-hover:opacity-100 transition-opacity"></div>
-              <div className="relative p-6">
-                <div className="flex items-start gap-4 mb-4">
-                  <div className="w-12 h-12 rounded-lg bg-muted border border-border flex items-center justify-center group-hover:scale-110 transition-transform">
-                    <FolderOpen className="w-6 h-6 text-muted-foreground group-hover:text-foreground transition-colors" />
-                  </div>
-                  <div className="flex-1">
-                    <h3 className="text-lg font-semibold text-foreground mb-1">
-                      Open Project
-                    </h3>
-                    <p className="text-sm text-muted-foreground">
-                      Open an existing project folder to continue working
-                    </p>
-                  </div>
-                </div>
-                <Button
-                  variant="secondary"
-                  className="w-full bg-secondary hover:bg-secondary/80 text-foreground border border-border hover:border-border-glass"
-                  data-testid="open-existing-project"
-                >
-                  <FolderOpen className="w-4 h-4 mr-2" />
-                  Browse Folder
-                </Button>
-              </div>
-            </div>
-          </div>
-
-          {/* Recent Projects */}
-          {recentProjects.length > 0 && (
-            <div>
-              <div className="flex items-center gap-2 mb-4">
-                <Clock className="w-5 h-5 text-muted-foreground" />
-                <h2 className="text-lg font-semibold text-foreground">
-                  Recent Projects
-                </h2>
-              </div>
-              <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
-                {recentProjects.map((project) => (
-                  <div
-                    key={project.id}
-                    className="group relative overflow-hidden rounded-xl border border-border bg-card backdrop-blur-md hover:bg-card/70 hover:border-brand-500/50 transition-all duration-200 cursor-pointer"
-                    onClick={() => handleRecentProjectClick(project)}
-                    data-testid={`recent-project-${project.id}`}
-                  >
-                    <div className="absolute inset-0 bg-gradient-to-br from-brand-500/0 to-purple-600/0 group-hover:from-brand-500/5 group-hover:to-purple-600/5 transition-all"></div>
-                    <div className="relative p-4">
-                      <div className="flex items-start gap-3">
-                        <div className="w-10 h-10 rounded-lg bg-muted border border-border flex items-center justify-center group-hover:border-brand-500/50 transition-colors">
-                          <Folder className="w-5 h-5 text-muted-foreground group-hover:text-brand-500 transition-colors" />
-                        </div>
-                        <div className="flex-1 min-w-0">
-                          <p className="font-medium text-foreground truncate group-hover:text-brand-500 transition-colors">
-                            {project.name}
-                          </p>
-                          <p className="text-xs text-muted-foreground/70 truncate mt-0.5">
-                            {project.path}
-                          </p>
-                          {project.lastOpened && (
-                            <p className="text-xs text-muted-foreground mt-1">
-                              {new Date(
-                                project.lastOpened
-                              ).toLocaleDateString()}
-                            </p>
-                          )}
-                        </div>
-                      </div>
-                    </div>
-                  </div>
-                ))}
-              </div>
-            </div>
-          )}
-
-          {/* Empty State for No Projects */}
-          {recentProjects.length === 0 && (
-            <div className="flex flex-col items-center justify-center py-12 text-center">
-              <div className="w-16 h-16 rounded-2xl bg-muted border border-border flex items-center justify-center mb-4">
-                <Sparkles className="w-8 h-8 text-muted-foreground" />
-              </div>
-              <h3 className="text-lg font-semibold text-foreground mb-2">
-                No projects yet
-              </h3>
-              <p className="text-sm text-zinc-400 max-w-md">
-                Get started by creating a new project or opening an existing one
-              </p>
-            </div>
-          )}
-        </div>
-      </div>
-
-      {/* New Project Dialog */}
-      <Dialog
-        open={showNewProjectDialog}
-        onOpenChange={setShowNewProjectDialog}
-      >
-        <DialogContent
-          className="bg-card border-border"
-          data-testid="new-project-dialog"
-        >
-          <DialogHeader>
-            <DialogTitle className="text-foreground">
-              Create New Project
-            </DialogTitle>
-            <DialogDescription className="text-muted-foreground">
-              Set up a new project directory with initial configuration files.
-            </DialogDescription>
-          </DialogHeader>
-          <div className="space-y-4 py-4">
-            <div className="space-y-2">
-              <Label htmlFor="project-name" className="text-foreground">
-                Project Name
-              </Label>
-              <Input
-                id="project-name"
-                placeholder="my-awesome-project"
-                value={newProjectName}
-                onChange={(e) => setNewProjectName(e.target.value)}
-                className="bg-input border-border text-foreground placeholder:text-muted-foreground"
-                data-testid="project-name-input"
-              />
-            </div>
-            <div className="space-y-2">
-              <Label htmlFor="project-path" className="text-foreground">
-                Parent Directory
-              </Label>
-              <div className="flex gap-2">
-                <Input
-                  id="project-path"
-                  placeholder="/path/to/projects"
-                  value={newProjectPath}
-                  onChange={(e) => setNewProjectPath(e.target.value)}
-                  className="flex-1 bg-input border-border text-foreground placeholder:text-muted-foreground"
-                  data-testid="project-path-input"
-                />
-                <Button
-                  variant="secondary"
-                  onClick={handleSelectDirectory}
-                  className="bg-secondary hover:bg-secondary/80 text-foreground border border-border"
-                  data-testid="browse-directory"
-                >
-                  Browse
-                </Button>
-              </div>
-            </div>
-          </div>
-          <DialogFooter>
-            <Button
-              variant="ghost"
-              onClick={() => setShowNewProjectDialog(false)}
-              className="text-muted-foreground hover:text-foreground hover:bg-accent"
-            >
-              Cancel
-            </Button>
-            <HotkeyButton
-              onClick={handleCreateProject}
-              disabled={!newProjectName || !newProjectPath || isCreating}
-              className="bg-gradient-to-r from-brand-500 to-brand-600 hover:from-brand-600 hover:to-brand-600 text-white border-0"
-              hotkey={{ key: "Enter", cmdCtrl: true }}
-              hotkeyActive={showNewProjectDialog}
-              data-testid="confirm-create-project"
-            >
-              {isCreating ? "Creating..." : "Create Project"}
-            </HotkeyButton>
-          </DialogFooter>
-        </DialogContent>
-      </Dialog>
-
-      {/* Project Initialization Dialog */}
-      <Dialog open={showInitDialog} onOpenChange={setShowInitDialog}>
-        <DialogContent
-          className="bg-card border-border"
-          data-testid="project-init-dialog"
-        >
-          <DialogHeader>
-            <DialogTitle className="text-foreground flex items-center gap-2">
-              <Sparkles className="w-5 h-5 text-brand-500" />
-              {initStatus?.isNewProject
-                ? "Project Initialized"
-                : "Project Updated"}
-            </DialogTitle>
-            <DialogDescription className="text-muted-foreground">
-              {initStatus?.isNewProject
-                ? `Created .automaker directory structure for ${initStatus?.projectName}`
-                : `Updated missing files in .automaker for ${initStatus?.projectName}`}
-            </DialogDescription>
-          </DialogHeader>
-          <div className="py-4">
-            <div className="space-y-2">
-              <p className="text-sm text-foreground font-medium">
-                Created files:
-              </p>
-              <ul className="space-y-1.5">
-                {initStatus?.createdFiles.map((file) => (
-                  <li
-                    key={file}
-                    className="flex items-center gap-2 text-sm text-muted-foreground"
-                  >
-                    <div className="w-1.5 h-1.5 rounded-full bg-green-500" />
-                    <code className="text-xs bg-muted px-2 py-0.5 rounded">
-                      {file}
-                    </code>
-                  </li>
-                ))}
-              </ul>
-            </div>
-
-            {initStatus?.isNewProject && (
-              <div className="mt-4 p-3 rounded-lg bg-muted/50 border border-border-glass">
-                {isAnalyzing ? (
-                  <div className="flex items-center gap-2">
-                    <Loader2 className="w-4 h-4 text-brand-500 animate-spin" />
-                    <p className="text-sm text-brand-400">
-                      AI agent is analyzing your project structure...
-                    </p>
-                  </div>
-                ) : (
-                  <p className="text-sm text-muted-foreground">
-                    <span className="text-brand-400">Tip:</span> Edit the{" "}
-                    <code className="text-xs bg-muted px-1.5 py-0.5 rounded">
-                      app_spec.txt
-                    </code>{" "}
-                    file to describe your project. The AI agent will use this to
-                    understand your project structure.
-                  </p>
-                )}
-              </div>
-            )}
-          </div>
-          <DialogFooter>
-            <Button
-              onClick={() => setShowInitDialog(false)}
-              className="bg-gradient-to-r from-brand-500 to-brand-600 hover:from-brand-600 hover:to-brand-600 text-white border-0"
-              data-testid="close-init-dialog"
-            >
-              Get Started
-            </Button>
-          </DialogFooter>
-        </DialogContent>
-      </Dialog>
-
-      {/* Loading overlay when opening project */}
-      {isOpening && (
-        <div
-          className="fixed inset-0 z-50 flex items-center justify-center bg-background/80 backdrop-blur-sm"
-          data-testid="project-opening-overlay"
-        >
-          <div className="flex flex-col items-center gap-3 p-6 rounded-xl bg-card border border-border">
-            <Loader2 className="w-8 h-8 text-brand-500 animate-spin" />
-            <p className="text-foreground font-medium">
-              Initializing project...
-            </p>
-          </div>
-        </div>
-      )}
-    </div>
-  );
-}

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

@@ -1,267 +0,0 @@
-import { useEffect, useCallback, useMemo } from "react";
-import { useShallow } from "zustand/react/shallow";
-import { useAppStore } from "@/store/app-store";
-import { getElectronAPI, type AutoModeEvent } from "@/lib/electron";
-
-/**
- * Hook for managing auto mode (scoped per project)
- */
-export function useAutoMode() {
-  const {
-    autoModeByProject,
-    setAutoModeRunning,
-    addRunningTask,
-    removeRunningTask,
-    clearRunningTasks,
-    currentProject,
-    addAutoModeActivity,
-    maxConcurrency,
-  } = 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,
-    }))
-  );
-
-  // 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
-  useEffect(() => {
-    const api = getElectronAPI();
-    if (!api?.autoMode || !projectId) return;
-
-    const unsubscribe = api.autoMode.onEvent((event: AutoModeEvent) => {
-      console.log("[AutoMode Event]", event);
-
-      // Events include projectId from backend, use it to scope updates
-      // Fall back to current projectId if not provided in event
-      const eventProjectId = event.projectId ?? projectId;
-
-      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_complete":
-          // All features completed for this project
-          setAutoModeRunning(eventProjectId, false);
-          clearRunningTasks(eventProjectId);
-          console.log("[AutoMode] All features completed!");
-          break;
-
-        case "auto_mode_error":
-          console.error("[AutoMode Error]", event.error);
-          if (event.featureId && event.error) {
-            addAutoModeActivity({
-              featureId: event.featureId,
-              type: "error",
-              message: event.error,
-            });
-          }
-          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,
-  ]);
-
-  // 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();
-
-      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,
-  };
-}

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

@@ -1,107 +0,0 @@
-"use client";
-
-import { useEffect, useCallback } from "react";
-import { useAppStore } from "@/store/app-store";
-
-export interface KeyboardShortcut {
-  key: string;
-  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 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;
-}
-
-/**
- * Hook to manage keyboard shortcuts
- * Shortcuts won't fire when user is typing in inputs, textareas, or when dialogs are open
- */
-export function useKeyboardShortcuts(shortcuts: KeyboardShortcut[]) {
-  const handleKeyDown = useCallback(
-    (event: KeyboardEvent) => {
-      // Don't trigger shortcuts when typing in inputs
-      if (isInputFocused()) {
-        return;
-      }
-
-      // Don't trigger if any modifier keys are pressed (except for specific combos we want)
-      if (event.ctrlKey || event.altKey || event.metaKey) {
-        return;
-      }
-
-      // Find matching shortcut
-      const matchingShortcut = shortcuts.find(
-        (shortcut) => shortcut.key.toLowerCase() === event.key.toLowerCase()
-      );
-
-      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;
-}