Merge branch 'main' of github.com:webdevcody/automaker

.automaker/feature_list.json

@@ -51,5 +51,25 @@
     "description": "So i want to improve the look of the view of agent output modal its just plain text and im thinking to parse it better and kinda make it look like the last image of coolify logs nice colorded and somehow grouped into some types of info / debug so in our case like prompt / tool call etc",
     "steps": [],
     "status": "verified"
+  },
+  {
+    "id": "feature-1765318148517-715isvwwb",
+    "category": "Kanban",
+    "description": "When agent finish work the cards is moved either to waiting approval or into verified one But mostly its include some type of summary at the end i want you to modify our prompts and ui so when its in both states we can see the feature summary of what was done / modified instead of relying on going to code editor to see what got changed etc.",
+    "steps": [],
+    "status": "verified",
+    "startedAt": "2025-12-09T22:09:13.684Z",
+    "imagePaths": [],
+    "skipTests": true
+  },
+  {
+    "id": "feature-1765319491258-x933j6kbq",
+    "category": "Core",
+    "description": "When running new feature in skip automated testing once its got finished its moved to waiting approval for us to manual test it / follow up prompt. Once we are satisfied we can click commit button so ai agent can commit it work this is only hapening in this scenerio because if we have unchecked the skip automated testing its do it automaticly and commit already. But the issue is when its going to commit we move it to in progress state where we can use stop button and if user use that button its moved to backlog column and. that kinda break what we are doing becase we have no longer even abbility to move it back to waiting approval or to run commit button / follow up again so if user use manual one and stop the commit i want it to be again moved back to waiting approval state / column",
+    "steps": [],
+    "status": "verified",
+    "startedAt": "2025-12-09T22:31:41.946Z",
+    "imagePaths": [],
+    "skipTests": true
   }
 ]

app/electron/auto-mode-service.js

@@ -32,7 +32,7 @@ class AutoModeService {
       query: null,
       projectPath: null,
       sendToRenderer: null,
-      isActive: () => this.runningFeatures.has(featureId)
+      isActive: () => this.runningFeatures.has(featureId),
     };
     return context;
   }
@@ -126,7 +126,11 @@ class AutoModeService {
       console.log(`[AutoMode] Running feature: ${feature.description}`);
 
       // Update feature status to in_progress
-      await featureLoader.updateFeatureStatus(featureId, "in_progress", projectPath);
+      await featureLoader.updateFeatureStatus(
+        featureId,
+        "in_progress",
+        projectPath
+      );
 
       sendToRenderer({
         type: "auto_mode_feature_start",
@@ -135,13 +139,28 @@ class AutoModeService {
       });
 
       // Implement the feature
-      const result = await featureExecutor.implementFeature(feature, projectPath, sendToRenderer, execution);
+      const result = await featureExecutor.implementFeature(
+        feature,
+        projectPath,
+        sendToRenderer,
+        execution
+      );
 
       // Update feature status based on result
-      const newStatus = result.passes ? "verified" : "backlog";
-      await featureLoader.updateFeatureStatus(feature.id, newStatus, projectPath);
+      // For skipTests features, go to waiting_approval on success instead of verified
+      let newStatus;
+      if (result.passes) {
+        newStatus = feature.skipTests ? "waiting_approval" : "verified";
+      } else {
+        newStatus = "backlog";
+      }
+      await featureLoader.updateFeatureStatus(
+        feature.id,
+        newStatus,
+        projectPath
+      );
 
-      // Delete context file if verified
+      // Delete context file only if verified (not for waiting_approval)
       if (newStatus === "verified") {
         await contextManager.deleteContextFile(projectPath, feature.id);
       }
@@ -208,11 +227,20 @@ class AutoModeService {
       });
 
       // Verify the feature by running tests
-      const result = await featureVerifier.verifyFeatureTests(feature, projectPath, sendToRenderer, execution);
+      const result = await featureVerifier.verifyFeatureTests(
+        feature,
+        projectPath,
+        sendToRenderer,
+        execution
+      );
 
       // Update feature status based on result
       const newStatus = result.passes ? "verified" : "in_progress";
-      await featureLoader.updateFeatureStatus(featureId, newStatus, projectPath);
+      await featureLoader.updateFeatureStatus(
+        featureId,
+        newStatus,
+        projectPath
+      );
 
       // Delete context file if verified
       if (newStatus === "verified") {
@@ -281,10 +309,19 @@ class AutoModeService {
       });
 
       // Read existing context
-      const previousContext = await contextManager.readContextFile(projectPath, featureId);
+      const previousContext = await contextManager.readContextFile(
+        projectPath,
+        featureId
+      );
 
       // Resume implementation with context
-      const result = await featureExecutor.resumeFeatureWithContext(feature, projectPath, sendToRenderer, previousContext, execution);
+      const result = await featureExecutor.resumeFeatureWithContext(
+        feature,
+        projectPath,
+        sendToRenderer,
+        previousContext,
+        execution
+      );
 
       // If the agent ends early without finishing, automatically re-run
       let attempts = 0;
@@ -298,11 +335,16 @@ class AutoModeService {
 
         if (updatedFeature && updatedFeature.status === "in_progress") {
           attempts++;
-          console.log(`[AutoMode] Feature ended early, auto-retrying (attempt ${attempts}/${maxAttempts})...`);
+          console.log(
+            `[AutoMode] Feature ended early, auto-retrying (attempt ${attempts}/${maxAttempts})...`
+          );
 
           // Update context file with retry message
-          await contextManager.writeToContextFile(projectPath, featureId,
-            `\n\n🔄 Auto-retry #${attempts} - Continuing implementation...\n\n`);
+          await contextManager.writeToContextFile(
+            projectPath,
+            featureId,
+            `\n\n🔄 Auto-retry #${attempts} - Continuing implementation...\n\n`
+          );
 
           sendToRenderer({
             type: "auto_mode_progress",
@@ -311,20 +353,39 @@ class AutoModeService {
           });
 
           // Read updated context
-          const retryContext = await contextManager.readContextFile(projectPath, featureId);
+          const retryContext = await contextManager.readContextFile(
+            projectPath,
+            featureId
+          );
 
           // Resume again with full context
-          finalResult = await featureExecutor.resumeFeatureWithContext(feature, projectPath, sendToRenderer, retryContext, execution);
+          finalResult = await featureExecutor.resumeFeatureWithContext(
+            feature,
+            projectPath,
+            sendToRenderer,
+            retryContext,
+            execution
+          );
         } else {
           break;
         }
       }
 
       // Update feature status based on final result
-      const newStatus = finalResult.passes ? "verified" : "in_progress";
-      await featureLoader.updateFeatureStatus(featureId, newStatus, projectPath);
+      // For skipTests features, go to waiting_approval on success instead of verified
+      let newStatus;
+      if (finalResult.passes) {
+        newStatus = feature.skipTests ? "waiting_approval" : "verified";
+      } else {
+        newStatus = "in_progress";
+      }
+      await featureLoader.updateFeatureStatus(
+        featureId,
+        newStatus,
+        projectPath
+      );
 
-      // Delete context file if verified
+      // Delete context file only if verified (not for waiting_approval)
       if (newStatus === "verified") {
         await contextManager.deleteContextFile(projectPath, featureId);
       }
@@ -377,7 +438,9 @@ class AutoModeService {
 
         // Skip if this feature is already running (via manual trigger)
         if (this.runningFeatures.has(currentFeatureId)) {
-          console.log(`[AutoMode] Skipping ${currentFeatureId} - already running`);
+          console.log(
+            `[AutoMode] Skipping ${currentFeatureId} - already running`
+          );
           await this.sleep(3000);
           continue;
         }
@@ -397,13 +460,28 @@ class AutoModeService {
         this.runningFeatures.set(currentFeatureId, execution);
 
         // Implement the feature
-        const result = await featureExecutor.implementFeature(nextFeature, projectPath, sendToRenderer, execution);
+        const result = await featureExecutor.implementFeature(
+          nextFeature,
+          projectPath,
+          sendToRenderer,
+          execution
+        );
 
         // Update feature status based on result
-        const newStatus = result.passes ? "verified" : "backlog";
-        await featureLoader.updateFeatureStatus(nextFeature.id, newStatus, projectPath);
+        // For skipTests features, go to waiting_approval on success instead of verified
+        let newStatus;
+        if (result.passes) {
+          newStatus = nextFeature.skipTests ? "waiting_approval" : "verified";
+        } else {
+          newStatus = "backlog";
+        }
+        await featureLoader.updateFeatureStatus(
+          nextFeature.id,
+          newStatus,
+          projectPath
+        );
 
-        // Delete context file if verified
+        // Delete context file only if verified (not for waiting_approval)
         if (newStatus === "verified") {
           await contextManager.deleteContextFile(projectPath, nextFeature.id);
         }
@@ -477,7 +555,12 @@ class AutoModeService {
       });
 
       // Perform the analysis
-      const result = await projectAnalyzer.runProjectAnalysis(projectPath, analysisId, sendToRenderer, execution);
+      const result = await projectAnalyzer.runProjectAnalysis(
+        projectPath,
+        analysisId,
+        sendToRenderer,
+        execution
+      );
 
       sendToRenderer({
         type: "auto_mode_feature_complete",
@@ -500,6 +583,239 @@ class AutoModeService {
     }
   }
 
+  /**
+   * Stop a specific feature by ID
+   */
+  async stopFeature({ featureId }) {
+    if (!this.runningFeatures.has(featureId)) {
+      return { success: false, error: `Feature ${featureId} is not running` };
+    }
+
+    console.log(`[AutoMode] Stopping feature: ${featureId}`);
+
+    const execution = this.runningFeatures.get(featureId);
+    if (execution && execution.abortController) {
+      execution.abortController.abort();
+    }
+
+    // Clean up
+    this.runningFeatures.delete(featureId);
+
+    return { success: true };
+  }
+
+  /**
+   * Follow-up on a feature with additional prompt
+   * This continues work on a feature that's in waiting_approval status
+   */
+  async followUpFeature({
+    projectPath,
+    featureId,
+    prompt,
+    imagePaths,
+    sendToRenderer,
+  }) {
+    // Check if this feature is already running
+    if (this.runningFeatures.has(featureId)) {
+      throw new Error(`Feature ${featureId} is already running`);
+    }
+
+    console.log(
+      `[AutoMode] Follow-up on feature: ${featureId} with prompt: ${prompt}`
+    );
+
+    // Register this feature as running
+    const execution = this.createExecutionContext(featureId);
+    execution.projectPath = projectPath;
+    execution.sendToRenderer = sendToRenderer;
+    this.runningFeatures.set(featureId, execution);
+
+    // Start the async work in the background (don't await)
+    // This allows the API to return immediately so the modal can close
+    this.runFollowUpWork({
+      projectPath,
+      featureId,
+      prompt,
+      imagePaths,
+      sendToRenderer,
+      execution,
+    }).catch((error) => {
+      console.error("[AutoMode] Follow-up work error:", error);
+      this.runningFeatures.delete(featureId);
+    });
+
+    // Return immediately so the frontend can close the modal
+    return { success: true };
+  }
+
+  /**
+   * Internal method to run follow-up work asynchronously
+   */
+  async runFollowUpWork({
+    projectPath,
+    featureId,
+    prompt,
+    imagePaths,
+    sendToRenderer,
+    execution,
+  }) {
+    try {
+      // Load features
+      const features = await featureLoader.loadFeatures(projectPath);
+      const feature = features.find((f) => f.id === featureId);
+
+      if (!feature) {
+        throw new Error(`Feature ${featureId} not found`);
+      }
+
+      console.log(`[AutoMode] Following up on feature: ${feature.description}`);
+
+      // Update status to in_progress
+      await featureLoader.updateFeatureStatus(
+        featureId,
+        "in_progress",
+        projectPath
+      );
+
+      sendToRenderer({
+        type: "auto_mode_feature_start",
+        featureId: feature.id,
+        feature: feature,
+      });
+
+      // Read existing context and append follow-up prompt
+      const previousContext = await contextManager.readContextFile(
+        projectPath,
+        featureId
+      );
+
+      // Append follow-up prompt to context
+      const followUpContext = `${previousContext}\n\n## Follow-up Instructions\n\n${prompt}`;
+      await contextManager.writeToContextFile(
+        projectPath,
+        featureId,
+        `\n\n## Follow-up Instructions\n\n${prompt}`
+      );
+
+      // Resume implementation with follow-up context and optional images
+      const result = await featureExecutor.resumeFeatureWithContext(
+        { ...feature, followUpPrompt: prompt, followUpImages: imagePaths },
+        projectPath,
+        sendToRenderer,
+        followUpContext,
+        execution
+      );
+
+      // For skipTests features, go to waiting_approval on success instead of verified
+      const newStatus = result.passes
+        ? feature.skipTests
+          ? "waiting_approval"
+          : "verified"
+        : "in_progress";
+
+      await featureLoader.updateFeatureStatus(
+        feature.id,
+        newStatus,
+        projectPath
+      );
+
+      // Delete context file if verified (only for non-skipTests)
+      if (newStatus === "verified") {
+        await contextManager.deleteContextFile(projectPath, feature.id);
+      }
+
+      sendToRenderer({
+        type: "auto_mode_feature_complete",
+        featureId: feature.id,
+        passes: result.passes,
+        message: result.message,
+      });
+    } catch (error) {
+      console.error("[AutoMode] Error in follow-up:", error);
+      sendToRenderer({
+        type: "auto_mode_error",
+        error: error.message,
+        featureId: featureId,
+      });
+    } finally {
+      this.runningFeatures.delete(featureId);
+    }
+  }
+
+  /**
+   * Commit changes for a feature without doing additional work
+   * This marks the feature as verified and commits the changes
+   */
+  async commitFeature({ projectPath, featureId, sendToRenderer }) {
+    console.log(`[AutoMode] Committing feature: ${featureId}`);
+
+    // Register briefly as running for the commit operation
+    const execution = this.createExecutionContext(featureId);
+    execution.projectPath = projectPath;
+    execution.sendToRenderer = sendToRenderer;
+    this.runningFeatures.set(featureId, execution);
+
+    try {
+      // Load feature to get description for commit message
+      const features = await featureLoader.loadFeatures(projectPath);
+      const feature = features.find((f) => f.id === featureId);
+
+      if (!feature) {
+        throw new Error(`Feature ${featureId} not found`);
+      }
+
+      sendToRenderer({
+        type: "auto_mode_feature_start",
+        featureId: feature.id,
+        feature: { ...feature, description: "Committing changes..." },
+      });
+
+      sendToRenderer({
+        type: "auto_mode_phase",
+        featureId,
+        phase: "action",
+        message: "Committing changes to git...",
+      });
+
+      // Run git commit via the agent
+      const commitResult = await featureExecutor.commitChangesOnly(
+        feature,
+        projectPath,
+        sendToRenderer,
+        execution
+      );
+
+      // Update status to verified
+      await featureLoader.updateFeatureStatus(
+        featureId,
+        "verified",
+        projectPath
+      );
+
+      // Delete context file
+      await contextManager.deleteContextFile(projectPath, featureId);
+
+      sendToRenderer({
+        type: "auto_mode_feature_complete",
+        featureId: feature.id,
+        passes: true,
+        message: "Changes committed successfully",
+      });
+
+      return { success: true };
+    } catch (error) {
+      console.error("[AutoMode] Error committing feature:", error);
+      sendToRenderer({
+        type: "auto_mode_error",
+        error: error.message,
+        featureId: featureId,
+      });
+      throw error;
+    } finally {
+      this.runningFeatures.delete(featureId);
+    }
+  }
+
   /**
    * Sleep helper
    */

app/electron/main.js

@@ -500,3 +500,54 @@ ipcMain.handle("auto-mode:analyze-project", async (_, { projectPath }) => {
     return { success: false, error: error.message };
   }
 });
+
+/**
+ * Stop a specific feature
+ */
+ipcMain.handle("auto-mode:stop-feature", async (_, { featureId }) => {
+  console.log("[IPC] auto-mode:stop-feature called with:", { featureId });
+  try {
+    return await autoModeService.stopFeature({ featureId });
+  } catch (error) {
+    console.error("[IPC] auto-mode:stop-feature error:", error);
+    return { success: false, error: error.message };
+  }
+});
+
+/**
+ * Follow-up on a feature with additional prompt
+ */
+ipcMain.handle("auto-mode:follow-up-feature", async (_, { projectPath, featureId, prompt, imagePaths }) => {
+  console.log("[IPC] auto-mode:follow-up-feature called with:", { projectPath, featureId, prompt, imagePaths });
+  try {
+    const sendToRenderer = (data) => {
+      if (mainWindow && !mainWindow.isDestroyed()) {
+        mainWindow.webContents.send("auto-mode:event", data);
+      }
+    };
+
+    return await autoModeService.followUpFeature({ projectPath, featureId, prompt, imagePaths, sendToRenderer });
+  } catch (error) {
+    console.error("[IPC] auto-mode:follow-up-feature error:", error);
+    return { success: false, error: error.message };
+  }
+});
+
+/**
+ * Commit changes for a feature (no further work, just commit)
+ */
+ipcMain.handle("auto-mode:commit-feature", async (_, { projectPath, featureId }) => {
+  console.log("[IPC] auto-mode:commit-feature called with:", { projectPath, featureId });
+  try {
+    const sendToRenderer = (data) => {
+      if (mainWindow && !mainWindow.isDestroyed()) {
+        mainWindow.webContents.send("auto-mode:event", data);
+      }
+    };
+
+    return await autoModeService.commitFeature({ projectPath, featureId, sendToRenderer });
+  } catch (error) {
+    console.error("[IPC] auto-mode:commit-feature error:", error);
+    return { success: false, error: error.message };
+  }
+});

app/electron/preload.js

@@ -115,6 +115,18 @@ contextBridge.exposeInMainWorld("electronAPI", {
     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);

app/electron/services/feature-executor.js

@@ -182,10 +182,12 @@ class FeatureExecutor {
         content: checkingMsg,
       });
 
-      // Re-load features to check if it was marked as verified
+      // 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);
-      const passes = updatedFeature?.status === "verified";
+      // For skipTests features, waiting_approval is also considered a success
+      const passes = updatedFeature?.status === "verified" || 
+                     (updatedFeature?.skipTests && updatedFeature?.status === "waiting_approval");
 
       // Send verification result
       const resultMsg = passes
@@ -312,10 +314,12 @@ class FeatureExecutor {
       execution.query = null;
       execution.abortController = null;
 
-      // Check if feature was marked as verified
+      // Check if feature was marked as verified or waiting_approval (for skipTests)
       const updatedFeatures = await featureLoader.loadFeatures(projectPath);
       const updatedFeature = updatedFeatures.find((f) => f.id === feature.id);
-      const passes = updatedFeature?.status === "verified";
+      // For skipTests features, waiting_approval is also considered a success
+      const passes = updatedFeature?.status === "verified" || 
+                     (updatedFeature?.skipTests && updatedFeature?.status === "waiting_approval");
 
       const finalMsg = passes
         ? "✓ Feature successfully verified and completed\n"
@@ -354,6 +358,171 @@ class FeatureExecutor {
       throw error;
     }
   }
+
+  /**
+   * Commit changes for a feature without doing additional work
+   * Analyzes changes and creates a proper conventional commit message
+   */
+  async commitChangesOnly(feature, projectPath, sendToRenderer, execution) {
+    console.log(`[FeatureExecutor] Committing changes for: ${feature.description}`);
+
+    try {
+      const commitMessage = `\n📝 Committing changes for: ${feature.description}\n`;
+      await contextManager.writeToContextFile(projectPath, feature.id, commitMessage);
+
+      sendToRenderer({
+        type: "auto_mode_progress",
+        featureId: feature.id,
+        content: "Analyzing changes and creating commit...",
+      });
+
+      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-sonnet-4-20250514", // Use sonnet for commit task
+        systemPrompt: `You are a git commit assistant that creates professional conventional commit messages.
+
+IMPORTANT RULES:
+- DO NOT modify any code
+- DO NOT write tests
+- DO NOT do anything except analyzing changes and committing them
+- Use the git command line tools via Bash
+- Create proper conventional commit messages based on what was actually changed`,
+        maxTurns: 15, // Allow some turns to analyze and commit
+        cwd: projectPath,
+        mcpServers: {
+          "automaker-tools": featureToolsServer
+        },
+        allowedTools: ["Bash", "mcp__automaker-tools__UpdateFeatureStatus"],
+        permissionMode: "acceptEdits",
+        sandbox: {
+          enabled: false, // Need to run git commands
+        },
+        abortController: abortController,
+      };
+
+      // Prompt that guides the agent to create a proper conventional commit
+      const prompt = `Please commit the current changes with a proper conventional commit message.
+
+**Feature Context:**
+Category: ${feature.category}
+Description: ${feature.description}
+
+**Your Task:**
+
+1. First, run \`git status\` to see all untracked and modified files
+2. Run \`git diff\` to see the actual changes (both staged and unstaged)
+3. Run \`git log --oneline -5\` to see recent commit message styles in this repo
+4. Analyze all the changes and draft a proper conventional commit message:
+   - Use conventional commit format: \`type(scope): description\`
+   - Types: feat, fix, refactor, style, docs, test, chore
+   - The description should be concise (under 72 chars) and focus on "what" was done
+   - Summarize the nature of the changes (new feature, enhancement, bug fix, etc.)
+   - Make sure the commit message accurately reflects the actual code changes
+5. Run \`git add .\` to stage all changes
+6. Create the commit with a message ending with:
+   🤖 Generated with [Claude Code](https://claude.com/claude-code)
+
+   Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>
+
+Use a HEREDOC for the commit message to ensure proper formatting:
+\`\`\`bash
+git commit -m "$(cat <<'EOF'
+type(scope): Short description here
+
+Optional longer description if needed.
+
+🤖 Generated with [Claude Code](https://claude.com/claude-code)
+
+Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>
+EOF
+)"
+\`\`\`
+
+**IMPORTANT:**
+- DO NOT use the feature description verbatim as the commit message
+- Analyze the actual code changes to determine the appropriate commit message
+- The commit message should be professional and follow conventional commit standards
+- DO NOT modify any code or run tests - ONLY commit the existing changes`;
+
+      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;
+
+              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;
+
+      const finalMsg = "✓ Changes committed successfully\n";
+      await contextManager.writeToContextFile(projectPath, feature.id, finalMsg);
+
+      sendToRenderer({
+        type: "auto_mode_progress",
+        featureId: feature.id,
+        content: finalMsg,
+      });
+
+      return {
+        passes: true,
+        message: responseText.substring(0, 500),
+      };
+    } catch (error) {
+      if (error instanceof AbortError || error?.name === "AbortError") {
+        console.log("[FeatureExecutor] Commit aborted");
+        if (execution) {
+          execution.abortController = null;
+          execution.query = null;
+        }
+        return {
+          passes: false,
+          message: "Commit aborted",
+        };
+      }
+
+      console.error("[FeatureExecutor] Error committing feature:", error);
+      if (execution) {
+        execution.abortController = null;
+        execution.query = null;
+      }
+      throw error;
+    }
+  }
 }
 
 module.exports = new FeatureExecutor();

app/electron/services/feature-loader.js

@@ -32,8 +32,12 @@ class FeatureLoader {
 
   /**
    * 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
    */
-  async updateFeatureStatus(featureId, status, projectPath) {
+  async updateFeatureStatus(featureId, status, projectPath, summary) {
     const features = await this.loadFeatures(projectPath);
     const feature = features.find((f) => f.id === featureId);
 
@@ -45,31 +49,56 @@ class FeatureLoader {
     // Update the status field
     feature.status = status;
 
+    // Update the summary field if provided
+    if (summary) {
+      feature.summary = summary;
+    }
+
     // Save back to file
     const featuresPath = path.join(
       projectPath,
       ".automaker",
       "feature_list.json"
     );
-    const toSave = features.map((f) => ({
-      id: f.id,
-      category: f.category,
-      description: f.description,
-      steps: f.steps,
-      status: f.status,
-    }));
+    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;
+      }
+      return featureData;
+    });
 
     await fs.writeFile(featuresPath, JSON.stringify(toSave, null, 2), "utf-8");
-    console.log(`[FeatureLoader] Updated feature ${featureId}: status=${status}`);
+    console.log(`[FeatureLoader] Updated feature ${featureId}: status=${status}${summary ? `, summary="${summary}"` : ""}`);
   }
 
   /**
    * Select the next feature to implement
-   * Prioritizes: earlier features in the list that are not verified
+   * 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
-    return features.find((f) => f.status !== "verified");
+    // Skip verified and waiting_approval (which needs user input)
+    return features.find((f) => f.status !== "verified" && f.status !== "waiting_approval");
   }
 }
 

app/electron/services/feature-verifier.js

@@ -101,10 +101,12 @@ class FeatureVerifier {
       execution.query = null;
       execution.abortController = null;
 
-      // Re-load features to check if it was marked as verified
+      // 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);
-      const passes = updatedFeature?.status === "verified";
+      // 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"

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

@@ -1,5 +1,6 @@
 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
@@ -18,22 +19,42 @@ class McpServerFactory {
       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.",
+          "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")
+            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}`);
+              console.log(`[McpServerFactory] UpdateFeatureStatus tool called: featureId=${args.featureId}, status=${args.status}, summary=${args.summary || "(none)"}`);
 
-              // Call the provided callback to update feature status
-              await updateFeatureStatusCallback(args.featureId, args.status, projectPath);
+              // 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: `Successfully updated feature ${args.featureId} to status "${args.status}"`
+                  text: statusMessage
                 }]
               };
             } catch (error) {

app/electron/services/prompt-builder.js

@@ -6,6 +6,10 @@ class PromptBuilder {
    * Build the prompt for implementing a specific feature
    */
   buildFeaturePrompt(feature) {
+    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`
+      : "";
+
     return `You are working on a feature implementation task.
 
 **Current Feature to Implement:**
@@ -13,7 +17,7 @@ class PromptBuilder {
 ID: ${feature.id}
 Category: ${feature.category}
 Description: ${feature.description}
-
+${skipTestsNote}
 **Steps to Complete:**
 ${feature.steps.map((step, i) => `${i + 1}. ${step}`).join("\n")}
 
@@ -21,30 +25,64 @@ ${feature.steps.map((step, i) => `${i + 1}. ${step}`).join("\n")}
 
 1. Read the project files to understand the current codebase structure
 2. Implement the feature according to the description and steps
-3. Write Playwright tests to verify the feature works correctly
-4. Run the tests and ensure they pass
-5. **DELETE the test file(s) you created** - tests are only for immediate verification
-6. **CRITICAL: Use the UpdateFeatureStatus tool to mark this feature as verified** - DO NOT manually edit .automaker/feature_list.json
-7. Commit your changes with git
+${
+  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 and all tests pass, you MUST use the \`mcp__automaker-tools__UpdateFeatureStatus\` tool to update the 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
-- Write comprehensive Playwright tests
-- Ensure all existing tests still pass
-- Mark the feature as passing only when all tests are green
-- **CRITICAL: Delete test files after verification** - tests accumulate and become brittle
+${
+  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**
-- Make a git commit when complete
+- **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):**
 
@@ -75,6 +113,10 @@ Begin by reading the project structure and then implementing the feature.`;
    * Build the prompt for verifying a specific feature
    */
   buildVerificationPrompt(feature) {
+    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`
+      : "";
+
     return `You are implementing and verifying a feature until it is complete and working correctly.
 
 **Feature to Implement/Verify:**
@@ -83,7 +125,7 @@ ID: ${feature.id}
 Category: ${feature.category}
 Description: ${feature.description}
 Current Status: ${feature.status}
-
+${skipTestsNote}
 **Steps that should be implemented:**
 ${feature.steps.map((step, i) => `${i + 1}. ${step}`).join("\n")}
 
@@ -91,7 +133,10 @@ ${feature.steps.map((step, i) => `${i + 1}. ${step}`).join("\n")}
 
 1. Read the project files to understand the current implementation
 2. If the feature is not fully implemented, continue implementing it
-3. Write or update Playwright tests to verify the feature works correctly
+${
+  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:**
@@ -101,17 +146,43 @@ ${feature.steps.map((step, i) => `${i + 1}. ${step}`).join("\n")}
    - 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
-   - **CRITICAL: Use the UpdateFeatureStatus tool to mark this feature as verified** - DO NOT manually edit .automaker/feature_list.json
-   - Explain what was implemented/fixed and that all tests passed
-   - Commit your changes with git
+   - **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 all tests pass, you MUST use the \`mcp__automaker-tools__UpdateFeatureStatus\` tool to update the 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
@@ -126,13 +197,13 @@ rm tests/[feature-name].spec.ts
 \`\`\`
 
 **Important:**
-- **CONTINUE IMPLEMENTING until all tests pass** - don't stop at the first failure
-- Only mark as "verified" if Playwright tests pass
-- **CRITICAL: Delete test files after they pass** - tests should not accumulate
+${
+  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**
-- Update test utilities if functionality changed
-- Make a git commit when the feature is complete
-- Be thorough and persistent in fixing issues
+- **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.`;
   }
@@ -141,6 +212,10 @@ Begin by reading the project structure and understanding what needs to be implem
    * Build prompt for resuming feature with previous context
    */
   buildResumePrompt(feature, previousContext) {
+    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`
+      : "";
+
     return `You are resuming work on a feature implementation that was previously started.
 
 **Current Feature:**
@@ -148,7 +223,7 @@ Begin by reading the project structure and understanding what needs to be implem
 ID: ${feature.id}
 Category: ${feature.category}
 Description: ${feature.description}
-
+${skipTestsNote}
 **Steps to Complete:**
 ${feature.steps.map((step, i) => `${i + 1}. ${step}`).join("\n")}
 
@@ -162,29 +237,64 @@ 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
-3. Write Playwright tests to verify the feature works correctly (if not already done)
-4. Run the tests and ensure they pass
-5. **DELETE the test file(s) you created** - tests are only for immediate verification
-6. **CRITICAL: Use the UpdateFeatureStatus tool to mark this feature as verified** - DO NOT manually edit .automaker/feature_list.json
-7. Commit your changes with git
+${
+  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 all tests pass, you MUST use the \`mcp__automaker-tools__UpdateFeatureStatus\` tool to update the 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
-- Write comprehensive Playwright tests if not already done
-- Ensure all tests pass before marking as verified
-- **CRITICAL: Delete test files after verification**
+${
+  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**
-- Make a git commit when complete
+- **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.`;
   }
@@ -278,18 +388,38 @@ Begin by exploring the project structure.`;
 Your role is to:
 - Implement features exactly as specified
 - Write production-quality code
-- Create comprehensive Playwright tests using testing utilities
-- Ensure all tests pass before marking features complete
-- **DELETE test files after successful verification** - tests are only for immediate feature verification
+- 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
-- Commit working code to git
+- **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 all tests pass, use this tool to update the feature status:
-- Call with featureId and status="verified"
+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
@@ -327,21 +457,41 @@ Focus on one feature at a time and complete it fully before finishing. Always de
 
 Your role is to:
 - **Continue implementing features until they are complete** - don't stop at the first failure
-- Write or update code to fix failing tests
-- Run Playwright tests to verify feature implementations
-- If tests fail, analyze errors and fix the implementation
-- If other tests fail, verify if those tests are still accurate or should be updated or deleted
-- Continue rerunning tests and fixing issues until ALL tests pass
-- **DELETE test files after successful verification** - tests are only for immediate feature verification
+- 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
-- **Update test utilities (tests/utils.ts) if functionality changed** - keep helpers in sync with code
-- Commit working code to git
+- **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 all tests pass, use this tool to update the feature status:
-- Call with featureId and status="verified"
+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
@@ -365,7 +515,7 @@ You have access to:
 - Make git commits
 - **UpdateFeatureStatus tool** (mcp__automaker-tools__UpdateFeatureStatus) - Use this to update feature status
 
-**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, and commit your work.`;
+**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.`;
   }
 
   /**

app/package.json

@@ -34,6 +34,7 @@
     "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"

app/src/components/ui/markdown.tsx

@@ -0,0 +1,48 @@
+"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/views/agent-output-modal.tsx

@@ -205,7 +205,7 @@ export function AgentOutputModal({
         className="max-w-4xl max-h-[80vh] flex flex-col"
         data-testid="agent-output-modal"
       >
-        <DialogHeader>
+        <DialogHeader className="flex-shrink-0">
           <div className="flex items-center justify-between">
             <DialogTitle className="flex items-center gap-2">
               <Loader2 className="w-5 h-5 text-purple-500 animate-spin" />
@@ -238,7 +238,10 @@ export function AgentOutputModal({
               </button>
             </div>
           </div>
-          <DialogDescription className="mt-1">
+          <DialogDescription
+            className="mt-1 max-h-24 overflow-y-auto break-words"
+            data-testid="agent-output-description"
+          >
             {featureDescription}
           </DialogDescription>
         </DialogHeader>
@@ -266,7 +269,7 @@ export function AgentOutputModal({
           )}
         </div>
 
-        <div className="text-xs text-muted-foreground text-center">
+        <div className="text-xs text-muted-foreground text-center flex-shrink-0">
           {autoScrollRef.current
             ? "Auto-scrolling enabled"
             : "Scroll to bottom to enable auto-scroll"}

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

@@ -65,6 +65,8 @@ import {
   FastForward,
   FlaskConical,
   CheckCircle2,
+  MessageSquare,
+  GitCommit,
 } from "lucide-react";
 import { toast } from "sonner";
 import { Slider } from "@/components/ui/slider";
@@ -81,6 +83,7 @@ type ColumnId = Feature["status"];
 const COLUMNS: { id: ColumnId; title: string; color: string }[] = [
   { id: "backlog", title: "Backlog", color: "bg-zinc-500" },
   { id: "in_progress", title: "In Progress", color: "bg-yellow-500" },
+  { id: "waiting_approval", title: "Waiting Approval", color: "bg-orange-500" },
   { id: "verified", title: "Verified", color: "bg-green-500" },
 ];
 
@@ -119,6 +122,12 @@ export function BoardView() {
   const [showDeleteAllVerifiedDialog, setShowDeleteAllVerifiedDialog] =
     useState(false);
   const [persistedCategories, setPersistedCategories] = useState<string[]>([]);
+  const [showFollowUpDialog, setShowFollowUpDialog] = useState(false);
+  const [followUpFeature, setFollowUpFeature] = useState<Feature | null>(null);
+  const [followUpPrompt, setFollowUpPrompt] = useState("");
+  const [followUpImagePaths, setFollowUpImagePaths] = useState<
+    DescriptionImagePath[]
+  >([]);
 
   // Make current project available globally for modal
   useEffect(() => {
@@ -428,6 +437,7 @@ export function BoardView() {
         startedAt: f.startedAt,
         imagePaths: f.imagePaths,
         skipTests: f.skipTests,
+        summary: f.summary,
       }));
       await api.writeFile(
         `${currentProject.path}/.automaker/feature_list.json`,
@@ -776,6 +786,142 @@ export function BoardView() {
     });
   };
 
+  // Open follow-up dialog for waiting_approval features
+  const handleOpenFollowUp = (feature: Feature) => {
+    console.log("[Board] Opening follow-up dialog for feature:", {
+      id: feature.id,
+      description: feature.description,
+    });
+    setFollowUpFeature(feature);
+    setFollowUpPrompt("");
+    setFollowUpImagePaths([]);
+    setShowFollowUpDialog(true);
+  };
+
+  // Handle sending follow-up prompt
+  const handleSendFollowUp = async () => {
+    if (!currentProject || !followUpFeature || !followUpPrompt.trim()) return;
+
+    // Save values before clearing state
+    const featureId = followUpFeature.id;
+    const featureDescription = followUpFeature.description;
+    const prompt = followUpPrompt;
+    const imagePaths = followUpImagePaths.map((img) => img.path);
+
+    console.log("[Board] Sending follow-up prompt for feature:", {
+      id: featureId,
+      prompt: prompt,
+      imagePaths: imagePaths,
+    });
+
+    const api = getElectronAPI();
+    if (!api?.autoMode?.followUpFeature) {
+      console.error("Follow-up feature API not available");
+      toast.error("Follow-up not available", {
+        description: "This feature is not available in the current version.",
+      });
+      return;
+    }
+
+    // Move feature back to in_progress before sending follow-up
+    updateFeature(featureId, {
+      status: "in_progress",
+      startedAt: new Date().toISOString(),
+    });
+
+    // Reset follow-up state immediately (close dialog, clear form)
+    setShowFollowUpDialog(false);
+    setFollowUpFeature(null);
+    setFollowUpPrompt("");
+    setFollowUpImagePaths([]);
+
+    // Show success toast immediately
+    toast.success("Follow-up started", {
+      description: `Continuing work on: ${featureDescription.slice(0, 50)}${
+        featureDescription.length > 50 ? "..." : ""
+      }`,
+    });
+
+    // Call the API in the background (don't await - let it run async)
+    api.autoMode
+      .followUpFeature(currentProject.path, featureId, prompt, imagePaths)
+      .catch((error) => {
+        console.error("[Board] Error sending follow-up:", error);
+        toast.error("Failed to send follow-up", {
+          description:
+            error instanceof Error ? error.message : "An error occurred",
+        });
+        // Reload features to revert status if there was an error
+        loadFeatures();
+      });
+  };
+
+  // Handle commit-only for waiting_approval features (marks as verified and commits)
+  const handleCommitFeature = async (feature: Feature) => {
+    if (!currentProject) return;
+
+    console.log("[Board] Committing feature:", {
+      id: feature.id,
+      description: feature.description,
+    });
+
+    try {
+      const api = getElectronAPI();
+      if (!api?.autoMode?.commitFeature) {
+        console.error("Commit feature API not available");
+        toast.error("Commit not available", {
+          description: "This feature is not available in the current version.",
+        });
+        return;
+      }
+
+      // Call the API to commit this feature
+      const result = await api.autoMode.commitFeature(
+        currentProject.path,
+        feature.id
+      );
+
+      if (result.success) {
+        console.log("[Board] Feature committed successfully");
+        // Move to verified status
+        moveFeature(feature.id, "verified");
+        toast.success("Feature committed", {
+          description: `Committed and verified: ${feature.description.slice(
+            0,
+            50
+          )}${feature.description.length > 50 ? "..." : ""}`,
+        });
+      } else {
+        console.error("[Board] Failed to commit feature:", result.error);
+        toast.error("Failed to commit feature", {
+          description: result.error || "An error occurred",
+        });
+        await loadFeatures();
+      }
+    } catch (error) {
+      console.error("[Board] Error committing feature:", error);
+      toast.error("Failed to commit feature", {
+        description:
+          error instanceof Error ? error.message : "An error occurred",
+      });
+      await loadFeatures();
+    }
+  };
+
+  // Move feature to waiting_approval (for skipTests features when agent completes)
+  const handleMoveToWaitingApproval = (feature: Feature) => {
+    console.log("[Board] Moving feature to waiting_approval:", {
+      id: feature.id,
+      description: feature.description,
+    });
+    updateFeature(feature.id, { status: "waiting_approval" });
+    toast.info("Feature ready for review", {
+      description: `Ready for approval: ${feature.description.slice(0, 50)}${
+        feature.description.length > 50 ? "..." : ""
+      }`,
+    });
+  };
+
   const checkContextExists = async (featureId: string): Promise<boolean> => {
     if (!currentProject) return false;
 
@@ -844,12 +990,30 @@ export function BoardView() {
   const handleForceStopFeature = async (feature: Feature) => {
     try {
       await autoMode.stopFeature(feature.id);
-      // Move the feature back to backlog status after stopping
-      moveFeature(feature.id, "backlog");
+
+      // Determine where to move the feature after stopping:
+      // - If it's a skipTests feature that was in waiting_approval (i.e., during commit operation),
+      //   move it back to waiting_approval so user can try commit again or do follow-up
+      // - Otherwise, move to backlog
+      const targetStatus =
+        feature.skipTests && feature.status === "waiting_approval"
+          ? "waiting_approval"
+          : "backlog";
+
+      if (targetStatus !== feature.status) {
+        moveFeature(feature.id, targetStatus);
+      }
+
       toast.success("Agent stopped", {
-        description: `Stopped working on: ${feature.description.slice(0, 50)}${
-          feature.description.length > 50 ? "..." : ""
-        }`,
+        description:
+          targetStatus === "waiting_approval"
+            ? `Stopped commit - returned to waiting approval: ${feature.description.slice(
+                0,
+                50
+              )}${feature.description.length > 50 ? "..." : ""}`
+            : `Stopped working on: ${feature.description.slice(0, 50)}${
+                feature.description.length > 50 ? "..." : ""
+              }`,
       });
     } catch (error) {
       console.error("[Board] Error stopping feature:", error);
@@ -1114,6 +1278,8 @@ export function BoardView() {
                             onMoveBackToInProgress={() =>
                               handleMoveBackToInProgress(feature)
                             }
+                            onFollowUp={() => handleOpenFollowUp(feature)}
+                            onCommit={() => handleCommitFeature(feature)}
                             hasContext={featuresWithContext.has(feature.id)}
                             isCurrentAutoTask={runningAutoTasks.includes(
                               feature.id
@@ -1457,6 +1623,86 @@ export function BoardView() {
           </DialogFooter>
         </DialogContent>
       </Dialog>
+
+      {/* Follow-Up Prompt Dialog */}
+      <Dialog
+        open={showFollowUpDialog}
+        onOpenChange={(open) => {
+          if (!open) {
+            setShowFollowUpDialog(false);
+            setFollowUpFeature(null);
+            setFollowUpPrompt("");
+            setFollowUpImagePaths([]);
+          }
+        }}
+      >
+        <DialogContent
+          data-testid="follow-up-dialog"
+          onKeyDown={(e) => {
+            if (
+              (e.metaKey || e.ctrlKey) &&
+              e.key === "Enter" &&
+              followUpPrompt.trim()
+            ) {
+              e.preventDefault();
+              handleSendFollowUp();
+            }
+          }}
+        >
+          <DialogHeader>
+            <DialogTitle>Follow-Up Prompt</DialogTitle>
+            <DialogDescription>
+              Send additional instructions to continue working on this feature.
+              {followUpFeature && (
+                <span className="block mt-2 text-primary">
+                  Feature: {followUpFeature.description.slice(0, 100)}
+                  {followUpFeature.description.length > 100 ? "..." : ""}
+                </span>
+              )}
+            </DialogDescription>
+          </DialogHeader>
+          <div className="space-y-4 py-4">
+            <div className="space-y-2">
+              <Label htmlFor="follow-up-prompt">Instructions</Label>
+              <DescriptionImageDropZone
+                value={followUpPrompt}
+                onChange={setFollowUpPrompt}
+                images={followUpImagePaths}
+                onImagesChange={setFollowUpImagePaths}
+                placeholder="Describe what needs to be fixed or changed..."
+              />
+            </div>
+            <p className="text-xs text-muted-foreground">
+              The agent will continue from where it left off, using the existing
+              context. You can attach screenshots to help explain the issue.
+            </p>
+          </div>
+          <DialogFooter>
+            <Button
+              variant="ghost"
+              onClick={() => {
+                setShowFollowUpDialog(false);
+                setFollowUpFeature(null);
+                setFollowUpPrompt("");
+                setFollowUpImagePaths([]);
+              }}
+            >
+              Cancel
+            </Button>
+            <Button
+              onClick={handleSendFollowUp}
+              disabled={!followUpPrompt.trim()}
+              data-testid="confirm-follow-up"
+            >
+              <MessageSquare className="w-4 h-4 mr-2" />
+              Send Follow-Up
+              <span className="ml-2 px-1.5 py-0.5 text-[10px] font-mono rounded bg-white/10 border border-white/20">
+                ⌘↵
+              </span>
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
     </div>
   );
 }

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

@@ -0,0 +1,301 @@
+"use client";
+
+import { useEffect, useState, useCallback } from "react";
+import { useAppStore } from "@/store/app-store";
+import { getElectronAPI } from "@/lib/electron";
+import { Card, CardContent } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import {
+  File,
+  Folder,
+  FolderOpen,
+  ChevronRight,
+  ChevronDown,
+  RefreshCw,
+  Code,
+} from "lucide-react";
+import { cn } from "@/lib/utils";
+
+interface FileTreeNode {
+  name: string;
+  path: string;
+  isDirectory: boolean;
+  children?: FileTreeNode[];
+  isExpanded?: boolean;
+}
+
+const IGNORE_PATTERNS = [
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  ".DS_Store",
+  "*.log",
+];
+
+const shouldIgnore = (name: string) => {
+  return IGNORE_PATTERNS.some((pattern) => {
+    if (pattern.startsWith("*")) {
+      return name.endsWith(pattern.slice(1));
+    }
+    return name === pattern;
+  });
+};
+
+export function CodeView() {
+  const { currentProject } = useAppStore();
+  const [fileTree, setFileTree] = useState<FileTreeNode[]>([]);
+  const [selectedFile, setSelectedFile] = useState<string | null>(null);
+  const [fileContent, setFileContent] = useState<string>("");
+  const [isLoading, setIsLoading] = useState(true);
+  const [expandedFolders, setExpandedFolders] = useState<Set<string>>(
+    new Set()
+  );
+
+  // Load directory tree
+  const loadTree = useCallback(async () => {
+    if (!currentProject) return;
+
+    setIsLoading(true);
+    try {
+      const api = getElectronAPI();
+      const result = await api.readdir(currentProject.path);
+
+      if (result.success && result.entries) {
+        const entries = result.entries
+          .filter((e) => !shouldIgnore(e.name))
+          .sort((a, b) => {
+            // Directories first
+            if (a.isDirectory && !b.isDirectory) return -1;
+            if (!a.isDirectory && b.isDirectory) return 1;
+            return a.name.localeCompare(b.name);
+          })
+          .map((e) => ({
+            name: e.name,
+            path: `${currentProject.path}/${e.name}`,
+            isDirectory: e.isDirectory,
+          }));
+
+        setFileTree(entries);
+      }
+    } catch (error) {
+      console.error("Failed to load file tree:", error);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [currentProject]);
+
+  useEffect(() => {
+    loadTree();
+  }, [loadTree]);
+
+  // Load subdirectory
+  const loadSubdirectory = async (path: string): Promise<FileTreeNode[]> => {
+    try {
+      const api = getElectronAPI();
+      const result = await api.readdir(path);
+
+      if (result.success && result.entries) {
+        return result.entries
+          .filter((e) => !shouldIgnore(e.name))
+          .sort((a, b) => {
+            if (a.isDirectory && !b.isDirectory) return -1;
+            if (!a.isDirectory && b.isDirectory) return 1;
+            return a.name.localeCompare(b.name);
+          })
+          .map((e) => ({
+            name: e.name,
+            path: `${path}/${e.name}`,
+            isDirectory: e.isDirectory,
+          }));
+      }
+    } catch (error) {
+      console.error("Failed to load subdirectory:", error);
+    }
+    return [];
+  };
+
+  // Load file content
+  const loadFileContent = async (path: string) => {
+    try {
+      const api = getElectronAPI();
+      const result = await api.readFile(path);
+
+      if (result.success && result.content) {
+        setFileContent(result.content);
+        setSelectedFile(path);
+      }
+    } catch (error) {
+      console.error("Failed to load file:", error);
+    }
+  };
+
+  // Toggle folder expansion
+  const toggleFolder = async (node: FileTreeNode) => {
+    const newExpanded = new Set(expandedFolders);
+
+    if (expandedFolders.has(node.path)) {
+      newExpanded.delete(node.path);
+    } else {
+      newExpanded.add(node.path);
+
+      // Load children if not already loaded
+      if (!node.children) {
+        const children = await loadSubdirectory(node.path);
+        // Update the tree with children
+        const updateTree = (nodes: FileTreeNode[]): FileTreeNode[] => {
+          return nodes.map((n) => {
+            if (n.path === node.path) {
+              return { ...n, children };
+            }
+            if (n.children) {
+              return { ...n, children: updateTree(n.children) };
+            }
+            return n;
+          });
+        };
+        setFileTree(updateTree(fileTree));
+      }
+    }
+
+    setExpandedFolders(newExpanded);
+  };
+
+  // Render file tree node
+  const renderNode = (node: FileTreeNode, depth: number = 0) => {
+    const isExpanded = expandedFolders.has(node.path);
+    const isSelected = selectedFile === node.path;
+
+    return (
+      <div key={node.path}>
+        <div
+          className={cn(
+            "flex items-center gap-2 py-1 px-2 rounded cursor-pointer hover:bg-muted/50",
+            isSelected && "bg-muted"
+          )}
+          style={{ paddingLeft: `${depth * 16 + 8}px` }}
+          onClick={() => {
+            if (node.isDirectory) {
+              toggleFolder(node);
+            } else {
+              loadFileContent(node.path);
+            }
+          }}
+          data-testid={`file-tree-item-${node.name}`}
+        >
+          {node.isDirectory ? (
+            <>
+              {isExpanded ? (
+                <ChevronDown className="w-4 h-4 text-muted-foreground shrink-0" />
+              ) : (
+                <ChevronRight className="w-4 h-4 text-muted-foreground shrink-0" />
+              )}
+              {isExpanded ? (
+                <FolderOpen className="w-4 h-4 text-primary shrink-0" />
+              ) : (
+                <Folder className="w-4 h-4 text-primary shrink-0" />
+              )}
+            </>
+          ) : (
+            <>
+              <span className="w-4" />
+              <File className="w-4 h-4 text-muted-foreground shrink-0" />
+            </>
+          )}
+          <span className="text-sm truncate">{node.name}</span>
+        </div>
+        {node.isDirectory && isExpanded && node.children && (
+          <div>
+            {node.children.map((child) => renderNode(child, depth + 1))}
+          </div>
+        )}
+      </div>
+    );
+  };
+
+  if (!currentProject) {
+    return (
+      <div
+        className="flex-1 flex items-center justify-center"
+        data-testid="code-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="code-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="code-view"
+    >
+      {/* Header */}
+      <div className="flex items-center justify-between p-4 border-b border-white/10 bg-zinc-950/50 backdrop-blur-md">
+        <div className="flex items-center gap-3">
+          <Code className="w-5 h-5 text-muted-foreground" />
+          <div>
+            <h1 className="text-xl font-bold">Code Explorer</h1>
+            <p className="text-sm text-muted-foreground">
+              {currentProject.name}
+            </p>
+          </div>
+        </div>
+        <Button
+          variant="outline"
+          size="sm"
+          onClick={loadTree}
+          data-testid="refresh-tree"
+        >
+          <RefreshCw className="w-4 h-4 mr-2" />
+          Refresh
+        </Button>
+      </div>
+
+      {/* Split View */}
+      <div className="flex-1 flex overflow-hidden">
+        {/* File Tree */}
+        <div className="w-64 border-r overflow-y-auto" data-testid="file-tree">
+          <div className="p-2">{fileTree.map((node) => renderNode(node))}</div>
+        </div>
+
+        {/* Code Preview */}
+        <div className="flex-1 overflow-hidden">
+          {selectedFile ? (
+            <div className="h-full flex flex-col">
+              <div className="px-4 py-2 border-b bg-muted/30">
+                <p className="text-sm font-mono text-muted-foreground truncate">
+                  {selectedFile.replace(currentProject.path, "")}
+                </p>
+              </div>
+              <Card className="flex-1 m-4 overflow-hidden">
+                <CardContent className="p-0 h-full">
+                  <pre className="p-4 h-full overflow-auto text-sm font-mono whitespace-pre-wrap">
+                    <code data-testid="code-content">{fileContent}</code>
+                  </pre>
+                </CardContent>
+              </Card>
+            </div>
+          ) : (
+            <div className="flex-1 flex items-center justify-center">
+              <p className="text-muted-foreground">
+                Select a file to view its contents
+              </p>
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}

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

@@ -1,6 +1,6 @@
 "use client";
 
-import { useState } from "react";
+import { useState, useEffect } from "react";
 import { useSortable } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
 import { cn } from "@/lib/utils";
@@ -20,7 +20,7 @@ import {
   DialogHeader,
   DialogTitle,
 } from "@/components/ui/dialog";
-import { Feature } from "@/store/app-store";
+import { Feature, useAppStore } from "@/store/app-store";
 import {
   GripVertical,
   Edit,
@@ -34,8 +34,23 @@ import {
   StopCircle,
   FlaskConical,
   ArrowLeft,
+  MessageSquare,
+  GitCommit,
+  Cpu,
+  Wrench,
+  ListTodo,
+  Sparkles,
+  Expand,
 } 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";
 
 interface KanbanCardProps {
   feature: Feature;
@@ -47,9 +62,15 @@ interface KanbanCardProps {
   onForceStop?: () => void;
   onManualVerify?: () => void;
   onMoveBackToInProgress?: () => void;
+  onFollowUp?: () => void;
+  onCommit?: () => void;
   hasContext?: boolean;
   isCurrentAutoTask?: boolean;
   shortcutKey?: string;
+  /** Context content for extracting progress info */
+  contextContent?: string;
+  /** Feature summary from agent completion */
+  summary?: string;
 }
 
 export function KanbanCard({
@@ -62,11 +83,71 @@ export function KanbanCard({
   onForceStop,
   onManualVerify,
   onMoveBackToInProgress,
+  onFollowUp,
+  onCommit,
   hasContext,
   isCurrentAutoTask,
   shortcutKey,
+  contextContent,
+  summary,
 }: KanbanCardProps) {
   const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false);
+  const [isSummaryDialogOpen, setIsSummaryDialogOpen] = useState(false);
+  const [agentInfo, setAgentInfo] = useState<AgentTaskInfo | null>(null);
+  const { kanbanCardDetailLevel } = useAppStore();
+
+  // Helper functions to check what should be shown based on detail level
+  const showSteps =
+    kanbanCardDetailLevel === "standard" ||
+    kanbanCardDetailLevel === "detailed";
+  const showAgentInfo = kanbanCardDetailLevel === "detailed";
+  const showProgressBar =
+    kanbanCardDetailLevel === "standard" ||
+    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();
@@ -189,8 +270,8 @@ export function KanbanCard({
         </div>
       </CardHeader>
       <CardContent className="p-3 pt-0">
-        {/* Steps Preview */}
-        {feature.steps.length > 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
@@ -213,6 +294,195 @@ export function KanbanCard({
           </div>
         )}
 
+        {/* Agent Info Panel - shows for in_progress, waiting_approval, verified */}
+        {/* Standard mode: Only show progress bar */}
+        {showProgressBar &&
+          !showAgentInfo &&
+          feature.status !== "backlog" &&
+          agentInfo &&
+          (isCurrentAutoTask || feature.status === "in_progress") && (
+            <div className="mb-3 space-y-1">
+              <div className="w-full h-1.5 bg-zinc-800 rounded-full overflow-hidden">
+                <div
+                  className="w-full h-full bg-primary transition-transform duration-500 ease-out origin-left"
+                  style={{
+                    transform: `translateX(${
+                      agentInfo.progressPercentage - 100
+                    }%)`,
+                  }}
+                />
+              </div>
+              <div className="flex items-center justify-between text-[10px] text-muted-foreground">
+                <span>{Math.round(agentInfo.progressPercentage)}%</span>
+              </div>
+            </div>
+          )}
+
+        {/* Detailed mode: Show all agent info */}
+        {showAgentInfo && feature.status !== "backlog" && agentInfo && (
+          <div className="mb-3 space-y-2">
+            {/* Model & Phase */}
+            <div className="flex items-center gap-2 text-xs">
+              <div className="flex items-center gap-1 text-cyan-400">
+                <Cpu className="w-3 h-3" />
+                <span className="font-medium">
+                  {formatModelName(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>
+
+            {/* Progress Indicator */}
+            {(isCurrentAutoTask || feature.status === "in_progress") && (
+              <div className="space-y-1">
+                <div className="w-full h-1.5 bg-zinc-800 rounded-full overflow-hidden">
+                  <div
+                    className="w-full h-full bg-primary transition-transform duration-500 ease-out origin-left"
+                    style={{
+                      transform: `translateX(${
+                        agentInfo.progressPercentage - 100
+                      }%)`,
+                    }}
+                  />
+                </div>
+                <div className="flex items-center justify-between text-[10px] text-muted-foreground">
+                  <div className="flex items-center gap-2">
+                    <span className="flex items-center gap-1">
+                      <Wrench className="w-2.5 h-2.5" />
+                      {agentInfo.toolCallCount} tools
+                    </span>
+                    {agentInfo.lastToolUsed && (
+                      <span
+                        className="text-zinc-500 truncate max-w-[80px]"
+                        title={agentInfo.lastToolUsed}
+                      >
+                        {agentInfo.lastToolUsed}
+                      </span>
+                    )}
+                  </div>
+                  <span>{Math.round(agentInfo.progressPercentage)}%</span>
+                </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-zinc-500 shrink-0" />
+                      )}
+                      <span
+                        className={cn(
+                          "truncate",
+                          todo.status === "completed" &&
+                            "text-zinc-500 line-through",
+                          todo.status === "in_progress" && "text-amber-400",
+                          todo.status === "pending" && "text-zinc-400"
+                        )}
+                      >
+                        {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-white/5">
+                    <div className="flex items-center justify-between">
+                      <div className="flex items-center gap-1 text-[10px] text-green-400">
+                        <Sparkles className="w-3 h-3" />
+                        <span>Summary</span>
+                      </div>
+                      <button
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          setIsSummaryDialogOpen(true);
+                        }}
+                        className="p-0.5 rounded hover:bg-white/10 transition-colors text-zinc-500 hover:text-zinc-300"
+                        title="View full summary"
+                        data-testid={`expand-summary-${feature.id}`}
+                      >
+                        <Expand className="w-3 h-3" />
+                      </button>
+                    </div>
+                    <p className="text-[10px] text-zinc-400 line-clamp-3">
+                      {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-white/5">
+                      <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 && (
@@ -363,6 +633,51 @@ export function KanbanCard({
               </Button>
             </>
           )}
+          {!isCurrentAutoTask && feature.status === "waiting_approval" && (
+            <>
+              {/* Follow-up prompt button */}
+              {onFollowUp && (
+                <Button
+                  variant="default"
+                  size="sm"
+                  className="flex-1 h-7 text-xs bg-blue-600 hover:bg-blue-700"
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    onFollowUp();
+                  }}
+                  data-testid={`follow-up-${feature.id}`}
+                >
+                  <MessageSquare className="w-3 h-3 mr-1" />
+                  Follow-up
+                </Button>
+              )}
+              {/* Commit and verify button */}
+              {onCommit && (
+                <Button
+                  variant="default"
+                  size="sm"
+                  className="flex-1 h-7 text-xs bg-green-600 hover:bg-green-700"
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    onCommit();
+                  }}
+                  data-testid={`commit-${feature.id}`}
+                >
+                  <GitCommit className="w-3 h-3 mr-1" />
+                  Commit
+                </Button>
+              )}
+              <Button
+                variant="ghost"
+                size="sm"
+                className="h-7 text-xs text-destructive hover:text-destructive hover:bg-destructive/10"
+                onClick={handleDeleteClick}
+                data-testid={`delete-waiting-feature-${feature.id}`}
+              >
+                <Trash2 className="w-3 h-3" />
+              </Button>
+            </>
+          )}
           {!isCurrentAutoTask && feature.status === "backlog" && (
             <>
               <Button
@@ -420,6 +735,43 @@ export function KanbanCard({
           </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-zinc-900/50 rounded-lg border border-white/10">
+            <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>
     </Card>
   );
 }

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

@@ -5,13 +5,6 @@ import { useAppStore } from "@/store/app-store";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
-import {
-  Card,
-  CardContent,
-  CardDescription,
-  CardHeader,
-  CardTitle,
-} from "@/components/ui/card";
 import {
   Settings,
   Key,
@@ -34,11 +27,22 @@ import {
   Cat,
   Atom,
   Radio,
+  LayoutGrid,
+  Minimize2,
+  Square,
+  Maximize2,
 } from "lucide-react";
 
 export function SettingsView() {
-  const { apiKeys, setApiKeys, setCurrentView, theme, setTheme } =
-    useAppStore();
+  const {
+    apiKeys,
+    setApiKeys,
+    setCurrentView,
+    theme,
+    setTheme,
+    kanbanCardDetailLevel,
+    setKanbanCardDetailLevel,
+  } = useAppStore();
   const [anthropicKey, setAnthropicKey] = useState(apiKeys.anthropic);
   const [googleKey, setGoogleKey] = useState(apiKeys.google);
   const [showAnthropicKey, setShowAnthropicKey] = useState(false);
@@ -548,6 +552,81 @@ export function SettingsView() {
             </div>
           </div>
 
+          {/* Kanban Card Display Section */}
+          <div className="rounded-xl border border-white/10 bg-zinc-900/50 backdrop-blur-md overflow-hidden">
+            <div className="p-6 border-b border-white/10">
+              <div className="flex items-center gap-2 mb-2">
+                <LayoutGrid className="w-5 h-5 text-brand-500" />
+                <h2 className="text-lg font-semibold text-white">
+                  Kanban Card Display
+                </h2>
+              </div>
+              <p className="text-sm text-zinc-400">
+                Control how much information is displayed on Kanban cards.
+              </p>
+            </div>
+            <div className="p-6 space-y-4">
+              <div className="space-y-3">
+                <Label className="text-zinc-300">Detail Level</Label>
+                <div className="grid grid-cols-3 gap-3">
+                  <button
+                    onClick={() => setKanbanCardDetailLevel("minimal")}
+                    className={`flex flex-col items-center justify-center gap-2 px-4 py-4 rounded-lg border transition-all ${
+                      kanbanCardDetailLevel === "minimal"
+                        ? "bg-white/5 border-brand-500 text-white"
+                        : "bg-zinc-950/50 border-white/10 text-zinc-400 hover:text-white hover:bg-white/5"
+                    }`}
+                    data-testid="kanban-detail-minimal"
+                  >
+                    <Minimize2 className="w-5 h-5" />
+                    <span className="font-medium text-sm">Minimal</span>
+                    <span className="text-xs text-zinc-500 text-center">
+                      Title & category only
+                    </span>
+                  </button>
+                  <button
+                    onClick={() => setKanbanCardDetailLevel("standard")}
+                    className={`flex flex-col items-center justify-center gap-2 px-4 py-4 rounded-lg border transition-all ${
+                      kanbanCardDetailLevel === "standard"
+                        ? "bg-white/5 border-brand-500 text-white"
+                        : "bg-zinc-950/50 border-white/10 text-zinc-400 hover:text-white hover:bg-white/5"
+                    }`}
+                    data-testid="kanban-detail-standard"
+                  >
+                    <Square className="w-5 h-5" />
+                    <span className="font-medium text-sm">Standard</span>
+                    <span className="text-xs text-zinc-500 text-center">
+                      Steps & progress
+                    </span>
+                  </button>
+                  <button
+                    onClick={() => setKanbanCardDetailLevel("detailed")}
+                    className={`flex flex-col items-center justify-center gap-2 px-4 py-4 rounded-lg border transition-all ${
+                      kanbanCardDetailLevel === "detailed"
+                        ? "bg-white/5 border-brand-500 text-white"
+                        : "bg-zinc-950/50 border-white/10 text-zinc-400 hover:text-white hover:bg-white/5"
+                    }`}
+                    data-testid="kanban-detail-detailed"
+                  >
+                    <Maximize2 className="w-5 h-5" />
+                    <span className="font-medium text-sm">Detailed</span>
+                    <span className="text-xs text-zinc-500 text-center">
+                      Model, tools & tasks
+                    </span>
+                  </button>
+                </div>
+                <p className="text-xs text-zinc-500">
+                  <strong>Minimal:</strong> Shows only title and category
+                  <br />
+                  <strong>Standard:</strong> Adds steps preview and progress bar
+                  <br />
+                  <strong>Detailed:</strong> Shows all info including model,
+                  tool calls, task list, and summaries
+                </p>
+              </div>
+            </div>
+          </div>
+
           {/* Save Button */}
           <div className="flex items-center gap-4">
             <Button

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

@@ -113,7 +113,9 @@ export function useAutoMode() {
 
         case "auto_mode_phase":
           // Log phase transitions (Planning, Action, Verification)
-          console.log(`[AutoMode] Phase: ${event.phase} for ${event.featureId}`);
+          console.log(
+            `[AutoMode] Phase: ${event.phase} for ${event.featureId}`
+          );
           addAutoModeActivity({
             featureId: event.featureId,
             type: event.phase,
@@ -125,7 +127,13 @@ export function useAutoMode() {
     });
 
     return unsubscribe;
-  }, [addRunningTask, removeRunningTask, clearRunningTasks, setAutoModeRunning, addAutoModeActivity]);
+  }, [
+    addRunningTask,
+    removeRunningTask,
+    clearRunningTasks,
+    setAutoModeRunning,
+    addAutoModeActivity,
+  ]);
 
   // Start auto mode
   const start = useCallback(async () => {
@@ -181,33 +189,36 @@ export function useAutoMode() {
   }, [setAutoModeRunning, clearRunningTasks]);
 
   // Stop a specific feature
-  const stopFeature = useCallback(async (featureId: string) => {
-    try {
-      const api = getElectronAPI();
-      if (!api?.autoMode?.stopFeature) {
-        throw new Error("Stop feature API not available");
-      }
+  const stopFeature = useCallback(
+    async (featureId: string) => {
+      try {
+        const api = getElectronAPI();
+        if (!api?.autoMode?.stopFeature) {
+          throw new Error("Stop feature API not available");
+        }
 
-      const result = await api.autoMode.stopFeature(featureId);
+        const result = await api.autoMode.stopFeature(featureId);
 
-      if (result.success) {
-        removeRunningTask(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");
+        if (result.success) {
+          removeRunningTask(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;
       }
-    } catch (error) {
-      console.error("[AutoMode] Error stopping feature:", error);
-      throw error;
-    }
-  }, [removeRunningTask, addAutoModeActivity]);
+    },
+    [removeRunningTask, addAutoModeActivity]
+  );
 
   return {
     isRunning: isAutoModeRunning,

app/src/lib/agent-context-parser.ts

@@ -0,0 +1,247 @@
+/**
+ * Agent Context Parser
+ * Extracts useful information from agent context files for display in kanban cards
+ */
+
+export interface AgentTaskInfo {
+  // Task list extracted from TodoWrite tool calls
+  todos: {
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+  }[];
+
+  // Progress stats
+  toolCallCount: number;
+  lastToolUsed?: string;
+
+  // Phase info
+  currentPhase?: "planning" | "action" | "verification";
+
+  // Summary (if feature is completed)
+  summary?: string;
+
+  // Estimated progress percentage based on phase and tool calls
+  progressPercentage: number;
+}
+
+/**
+ * Default model used by the feature executor
+ */
+export const DEFAULT_MODEL = "claude-opus-4-5-20251101";
+
+/**
+ * Formats a model name for display
+ */
+export function formatModelName(model: string): string {
+  if (model.includes("opus")) return "Opus 4.5";
+  if (model.includes("sonnet")) return "Sonnet 4";
+  if (model.includes("haiku")) return "Haiku 3.5";
+  return model.split("-").slice(1, 3).join(" ");
+}
+
+/**
+ * Extracts todos from the context content
+ * Looks for TodoWrite tool calls in the format:
+ * TodoWrite: [{"content": "...", "status": "..."}]
+ */
+function extractTodos(content: string): AgentTaskInfo["todos"] {
+  const todos: AgentTaskInfo["todos"] = [];
+
+  // Look for TodoWrite tool inputs
+  const todoMatches = content.matchAll(/TodoWrite.*?(?:"todos"\s*:\s*)?(\[[\s\S]*?\](?=\s*(?:\}|$|🔧|📋|⚡|✅|❌)))/g);
+
+  for (const match of todoMatches) {
+    try {
+      // Try to find JSON array in the match
+      const jsonStr = match[1] || match[0];
+      const arrayMatch = jsonStr.match(/\[[\s\S]*?\]/);
+      if (arrayMatch) {
+        const parsed = JSON.parse(arrayMatch[0]);
+        if (Array.isArray(parsed)) {
+          for (const item of parsed) {
+            if (item.content && item.status) {
+              // Check if this todo already exists (avoid duplicates)
+              if (!todos.some(t => t.content === item.content)) {
+                todos.push({
+                  content: item.content,
+                  status: item.status,
+                });
+              }
+            }
+          }
+        }
+      }
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  // Also try to extract from markdown task lists
+  const markdownTodos = content.matchAll(/- \[([ xX])\] (.+)/g);
+  for (const match of markdownTodos) {
+    const isCompleted = match[1].toLowerCase() === "x";
+    const content = match[2].trim();
+    if (!todos.some(t => t.content === content)) {
+      todos.push({
+        content,
+        status: isCompleted ? "completed" : "pending",
+      });
+    }
+  }
+
+  return todos;
+}
+
+/**
+ * Counts tool calls in the content
+ */
+function countToolCalls(content: string): number {
+  const matches = content.match(/🔧\s*Tool:/g);
+  return matches?.length || 0;
+}
+
+/**
+ * Gets the last tool used
+ */
+function getLastToolUsed(content: string): string | undefined {
+  const matches = [...content.matchAll(/🔧\s*Tool:\s*(\S+)/g)];
+  if (matches.length > 0) {
+    return matches[matches.length - 1][1];
+  }
+  return undefined;
+}
+
+/**
+ * Determines the current phase from the content
+ */
+function getCurrentPhase(content: string): "planning" | "action" | "verification" | undefined {
+  // Find the last phase marker
+  const planningIndex = content.lastIndexOf("📋");
+  const actionIndex = content.lastIndexOf("⚡");
+  const verificationIndex = content.lastIndexOf("✅");
+
+  const maxIndex = Math.max(planningIndex, actionIndex, verificationIndex);
+
+  if (maxIndex === -1) return undefined;
+  if (maxIndex === verificationIndex) return "verification";
+  if (maxIndex === actionIndex) return "action";
+  return "planning";
+}
+
+/**
+ * Extracts a summary from completed feature context
+ */
+function extractSummary(content: string): string | undefined {
+  // Look for summary sections - capture everything including subsections (###)
+  // Stop at same-level ## sections (but not ###), or tool markers, or end
+  const summaryMatch = content.match(/## Summary[^\n]*\n([\s\S]*?)(?=\n## [^#]|\n🔧|$)/i);
+  if (summaryMatch) {
+    return summaryMatch[1].trim();
+  }
+
+  // Look for completion markers and extract surrounding text
+  const completionMatch = content.match(/✓ (?:Feature|Verification|Task) (?:successfully|completed|verified)[^\n]*(?:\n[^\n]{1,200})?/i);
+  if (completionMatch) {
+    return completionMatch[0].trim();
+  }
+
+  // Look for "What was done" type sections
+  const whatWasDoneMatch = content.match(/(?:What was done|Changes made|Implemented)[^\n]*\n([\s\S]*?)(?=\n## [^#]|\n🔧|$)/i);
+  if (whatWasDoneMatch) {
+    return whatWasDoneMatch[1].trim();
+  }
+
+  return undefined;
+}
+
+/**
+ * Calculates progress percentage based on phase and context
+ * Uses a more dynamic approach that better reflects actual progress
+ */
+function calculateProgress(phase: AgentTaskInfo["currentPhase"], toolCallCount: number, todos: AgentTaskInfo["todos"]): number {
+  // If we have todos, primarily use them for progress calculation
+  if (todos.length > 0) {
+    const completedCount = todos.filter(t => t.status === "completed").length;
+    const inProgressCount = todos.filter(t => t.status === "in_progress").length;
+
+    // Weight: completed = 1, in_progress = 0.5, pending = 0
+    const progress = ((completedCount + inProgressCount * 0.5) / todos.length) * 90;
+
+    // Add a small base amount and cap at 95%
+    return Math.min(5 + progress, 95);
+  }
+
+  // Fallback: use phase-based progress with tool call scaling
+  let phaseProgress = 0;
+  switch (phase) {
+    case "planning":
+      // Planning phase: 5-25%
+      phaseProgress = 5 + Math.min(toolCallCount * 1, 20);
+      break;
+    case "action":
+      // Action phase: 25-75% based on tool calls (logarithmic scaling)
+      phaseProgress = 25 + Math.min(Math.log2(toolCallCount + 1) * 10, 50);
+      break;
+    case "verification":
+      // Verification phase: 75-95%
+      phaseProgress = 75 + Math.min(toolCallCount * 0.5, 20);
+      break;
+    default:
+      // Starting: just use tool calls
+      phaseProgress = Math.min(toolCallCount * 0.5, 10);
+  }
+
+  return Math.min(Math.round(phaseProgress), 95);
+}
+
+/**
+ * Parses agent context content and extracts useful information
+ */
+export function parseAgentContext(content: string): AgentTaskInfo {
+  if (!content || !content.trim()) {
+    return {
+      todos: [],
+      toolCallCount: 0,
+      progressPercentage: 0,
+    };
+  }
+
+  const todos = extractTodos(content);
+  const toolCallCount = countToolCalls(content);
+  const lastToolUsed = getLastToolUsed(content);
+  const currentPhase = getCurrentPhase(content);
+  const summary = extractSummary(content);
+  const progressPercentage = calculateProgress(currentPhase, toolCallCount, todos);
+
+  return {
+    todos,
+    toolCallCount,
+    lastToolUsed,
+    currentPhase,
+    summary,
+    progressPercentage,
+  };
+}
+
+/**
+ * Quick stats for display in card badges
+ */
+export interface QuickStats {
+  toolCalls: number;
+  completedTasks: number;
+  totalTasks: number;
+  phase?: string;
+}
+
+/**
+ * Extracts quick stats from context for compact display
+ */
+export function getQuickStats(content: string): QuickStats {
+  const info = parseAgentContext(content);
+  return {
+    toolCalls: info.toolCallCount,
+    completedTasks: info.todos.filter(t => t.status === "completed").length,
+    totalTasks: info.todos.length,
+    phase: info.currentPhase,
+  };
+}

app/src/lib/electron.ts

@@ -67,6 +67,8 @@ export interface AutoModeAPI {
   resumeFeature: (projectPath: string, featureId: string) => Promise<{ success: boolean; passes?: boolean; error?: string }>;
   contextExists: (projectPath: string, featureId: string) => Promise<{ success: boolean; exists?: boolean; error?: string }>;
   analyzeProject: (projectPath: string) => Promise<{ success: boolean; message?: string; error?: string }>;
+  followUpFeature: (projectPath: string, featureId: string, prompt: string, imagePaths?: string[]) => Promise<{ success: boolean; passes?: boolean; error?: string }>;
+  commitFeature: (projectPath: string, featureId: string) => Promise<{ success: boolean; error?: string }>;
   onEvent: (callback: (event: AutoModeEvent) => void) => () => void;
 }
 
@@ -573,6 +575,58 @@ function createMockAutoModeAPI(): AutoModeAPI {
       return { success: true, message: "Project analyzed successfully" };
     },
 
+    followUpFeature: async (projectPath: string, featureId: string, prompt: string, imagePaths?: string[]) => {
+      if (mockRunningFeatures.has(featureId)) {
+        return { success: false, error: `Feature ${featureId} is already running` };
+      }
+
+      console.log("[Mock] Follow-up feature:", { featureId, prompt, imagePaths });
+
+      mockRunningFeatures.add(featureId);
+
+      // Simulate follow-up work (similar to run but with additional context)
+      // Note: We don't await this - it runs in the background like the real implementation
+      simulateAutoModeLoop(projectPath, featureId);
+
+      // Return immediately so the modal can close (matches real implementation)
+      return { success: true };
+    },
+
+    commitFeature: async (projectPath: string, featureId: string) => {
+      console.log("[Mock] Committing feature:", { projectPath, featureId });
+
+      // Simulate commit operation
+      emitAutoModeEvent({
+        type: "auto_mode_feature_start",
+        featureId,
+        feature: {
+          id: featureId,
+          category: "Commit",
+          description: "Committing changes",
+        },
+      });
+
+      await delay(300, featureId);
+
+      emitAutoModeEvent({
+        type: "auto_mode_phase",
+        featureId,
+        phase: "action",
+        message: "Committing changes to git...",
+      });
+
+      await delay(500, featureId);
+
+      emitAutoModeEvent({
+        type: "auto_mode_feature_complete",
+        featureId,
+        passes: true,
+        message: "Changes committed successfully",
+      });
+
+      return { success: true };
+    },
+
     onEvent: (callback: (event: AutoModeEvent) => void) => {
       mockAutoModeCallbacks.push(callback);
       return () => {

app/src/store/app-store.ts

@@ -11,6 +11,7 @@ export type ViewMode =
   | "tools"
   | "interview"
   | "context";
+
 export type ThemeMode =
   | "light"
   | "dark"
@@ -26,6 +27,8 @@ export type ThemeMode =
   | "onedark"
   | "synthwave";
 
+export type KanbanCardDetailLevel = "minimal" | "standard" | "detailed";
+
 export interface ApiKeys {
   anthropic: string;
   google: string;
@@ -77,11 +80,12 @@ export interface Feature {
   category: string;
   description: string;
   steps: string[];
-  status: "backlog" | "in_progress" | "verified";
+  status: "backlog" | "in_progress" | "waiting_approval" | "verified";
   images?: FeatureImage[];
   imagePaths?: FeatureImagePath[]; // Paths to temp files for agent context
   startedAt?: string; // ISO timestamp for when the card moved to in_progress
   skipTests?: boolean; // When true, skip TDD approach and require manual verification
+  summary?: string; // Summary of what was done/modified by the agent
 }
 
 export interface AppState {
@@ -118,6 +122,9 @@ export interface AppState {
   runningAutoTasks: string[]; // Feature IDs being worked on (supports concurrent tasks)
   autoModeActivityLog: AutoModeActivity[];
   maxConcurrency: number; // Maximum number of concurrent agent tasks
+
+  // Kanban Card Display Settings
+  kanbanCardDetailLevel: KanbanCardDetailLevel; // Level of detail shown on kanban cards
 }
 
 export interface AutoModeActivity {
@@ -192,6 +199,9 @@ export interface AppActions {
   clearAutoModeActivity: () => void;
   setMaxConcurrency: (max: number) => void;
 
+  // Kanban Card Settings actions
+  setKanbanCardDetailLevel: (level: KanbanCardDetailLevel) => void;
+
   // Reset
   reset: () => void;
 }
@@ -216,6 +226,7 @@ const initialState: AppState = {
   runningAutoTasks: [],
   autoModeActivityLog: [],
   maxConcurrency: 3, // Default to 3 concurrent agents
+  kanbanCardDetailLevel: "standard", // Default to standard detail level
 };
 
 export const useAppStore = create<AppState & AppActions>()(
@@ -454,6 +465,10 @@ export const useAppStore = create<AppState & AppActions>()(
 
       setMaxConcurrency: (max) => set({ maxConcurrency: max }),
 
+      // Kanban Card Settings actions
+      setKanbanCardDetailLevel: (level) =>
+        set({ kanbanCardDetailLevel: level }),
+
       // Reset
       reset: () => set(initialState),
     }),
@@ -469,6 +484,7 @@ export const useAppStore = create<AppState & AppActions>()(
         chatSessions: state.chatSessions,
         chatHistoryOpen: state.chatHistoryOpen,
         maxConcurrency: state.maxConcurrency,
+        kanbanCardDetailLevel: state.kanbanCardDetailLevel,
       }),
     }
   )

app/src/types/electron.d.ts

@@ -233,6 +233,17 @@ export interface AutoModeAPI {
     error?: string;
   }>;
 
+  followUpFeature: (projectPath: string, featureId: string, prompt: string, imagePaths?: string[]) => Promise<{
+    success: boolean;
+    passes?: boolean;
+    error?: string;
+  }>;
+
+  commitFeature: (projectPath: string, featureId: string) => Promise<{
+    success: boolean;
+    error?: string;
+  }>;
+
   onEvent: (callback: (event: AutoModeEvent) => void) => () => void;
 }
 

app/tests/utils.ts

@@ -2122,3 +2122,219 @@ export async function setupMockProjectWithAgentOutput(
     { featureId, outputContent }
   );
 }
+
+// ============ Waiting Approval Feature Utilities ============
+
+/**
+ * Get the follow-up button for a waiting_approval feature
+ */
+export async function getFollowUpButton(
+  page: Page,
+  featureId: string
+): Promise<Locator> {
+  return page.locator(`[data-testid="follow-up-${featureId}"]`);
+}
+
+/**
+ * Click the follow-up button for a waiting_approval feature
+ */
+export async function clickFollowUpButton(
+  page: Page,
+  featureId: string
+): Promise<void> {
+  const button = page.locator(`[data-testid="follow-up-${featureId}"]`);
+  await button.click();
+}
+
+/**
+ * Check if the follow-up button is visible for a feature
+ */
+export async function isFollowUpButtonVisible(
+  page: Page,
+  featureId: string
+): Promise<boolean> {
+  const button = page.locator(`[data-testid="follow-up-${featureId}"]`);
+  return await button.isVisible().catch(() => false);
+}
+
+/**
+ * Get the commit button for a waiting_approval feature
+ */
+export async function getCommitButton(
+  page: Page,
+  featureId: string
+): Promise<Locator> {
+  return page.locator(`[data-testid="commit-${featureId}"]`);
+}
+
+/**
+ * Click the commit button for a waiting_approval feature
+ */
+export async function clickCommitButton(
+  page: Page,
+  featureId: string
+): Promise<void> {
+  const button = page.locator(`[data-testid="commit-${featureId}"]`);
+  await button.click();
+}
+
+/**
+ * Check if the commit button is visible for a feature
+ */
+export async function isCommitButtonVisible(
+  page: Page,
+  featureId: string
+): Promise<boolean> {
+  const button = page.locator(`[data-testid="commit-${featureId}"]`);
+  return await button.isVisible().catch(() => false);
+}
+
+/**
+ * Check if the follow-up dialog is visible
+ */
+export async function isFollowUpDialogVisible(page: Page): Promise<boolean> {
+  const dialog = page.locator('[data-testid="follow-up-dialog"]');
+  return await dialog.isVisible().catch(() => false);
+}
+
+/**
+ * Wait for the follow-up dialog to be visible
+ */
+export async function waitForFollowUpDialog(
+  page: Page,
+  options?: { timeout?: number }
+): Promise<Locator> {
+  return await waitForElement(page, "follow-up-dialog", options);
+}
+
+/**
+ * Wait for the follow-up dialog to be hidden
+ */
+export async function waitForFollowUpDialogHidden(
+  page: Page,
+  options?: { timeout?: number }
+): Promise<void> {
+  await waitForElementHidden(page, "follow-up-dialog", options);
+}
+
+/**
+ * Click the confirm follow-up button in the follow-up dialog
+ */
+export async function clickConfirmFollowUp(page: Page): Promise<void> {
+  await clickElement(page, "confirm-follow-up");
+}
+
+/**
+ * Get the waiting_approval kanban column
+ */
+export async function getWaitingApprovalColumn(page: Page): Promise<Locator> {
+  return page.locator('[data-testid="kanban-column-waiting_approval"]');
+}
+
+/**
+ * Check if the waiting_approval column is visible
+ */
+export async function isWaitingApprovalColumnVisible(page: Page): Promise<boolean> {
+  const column = page.locator('[data-testid="kanban-column-waiting_approval"]');
+  return await column.isVisible().catch(() => false);
+}
+
+/**
+ * Get the agent output modal description element
+ */
+export async function getAgentOutputModalDescriptionElement(page: Page): Promise<Locator> {
+  return page.locator('[data-testid="agent-output-description"]');
+}
+
+/**
+ * Check if the agent output modal description is scrollable
+ */
+export async function isAgentOutputDescriptionScrollable(page: Page): Promise<boolean> {
+  const description = page.locator('[data-testid="agent-output-description"]');
+  const scrollInfo = await description.evaluate((el) => {
+    return {
+      scrollHeight: el.scrollHeight,
+      clientHeight: el.clientHeight,
+      isScrollable: el.scrollHeight > el.clientHeight,
+    };
+  });
+  return scrollInfo.isScrollable;
+}
+
+/**
+ * Get scroll dimensions of the agent output modal description
+ */
+export async function getAgentOutputDescriptionScrollDimensions(page: Page): Promise<{
+  scrollHeight: number;
+  clientHeight: number;
+  maxHeight: string;
+  overflowY: string;
+}> {
+  const description = page.locator('[data-testid="agent-output-description"]');
+  return await description.evaluate((el) => {
+    const style = window.getComputedStyle(el);
+    return {
+      scrollHeight: el.scrollHeight,
+      clientHeight: el.clientHeight,
+      maxHeight: style.maxHeight,
+      overflowY: style.overflowY,
+    };
+  });
+}
+
+/**
+ * Set up a mock project with features that include waiting_approval status
+ */
+export async function setupMockProjectWithWaitingApprovalFeatures(
+  page: Page,
+  options?: {
+    maxConcurrency?: number;
+    runningTasks?: string[];
+    features?: Array<{
+      id: string;
+      category: string;
+      description: string;
+      status: "backlog" | "in_progress" | "waiting_approval" | "verified";
+      steps?: string[];
+      startedAt?: string;
+      skipTests?: boolean;
+    }>;
+  }
+): Promise<void> {
+  await page.addInitScript(
+    (opts: typeof options) => {
+      const mockProject = {
+        id: "test-project-1",
+        name: "Test Project",
+        path: "/mock/test-project",
+        lastOpened: new Date().toISOString(),
+      };
+
+      const mockFeatures = opts?.features || [];
+
+      const mockState = {
+        state: {
+          projects: [mockProject],
+          currentProject: mockProject,
+          theme: "dark",
+          sidebarOpen: true,
+          apiKeys: { anthropic: "", google: "" },
+          chatSessions: [],
+          chatHistoryOpen: false,
+          maxConcurrency: opts?.maxConcurrency ?? 3,
+          isAutoModeRunning: false,
+          runningAutoTasks: opts?.runningTasks ?? [],
+          autoModeActivityLog: [],
+          features: mockFeatures,
+        },
+        version: 0,
+      };
+
+      localStorage.setItem("automaker-storage", JSON.stringify(mockState));
+
+      // Also store features in a global variable that the mock electron API can use
+      (window as any).__mockFeatures = mockFeatures;
+    },
+    options
+  );
+}