claudeboard 2.2.0 → 2.4.0

package/agents/claude-api.js

@@ -4,7 +4,7 @@
  */
 
 const MODEL = "claude-sonnet-4-20250514";
-const MAX_TOKENS = 16000; // Increased — large codegen responses need more tokens
+const MAX_TOKENS = 8096; // Max output tokens — input context window is 200k, no limits there
 
 function getHeaders() {
   const key = process.env.ANTHROPIC_API_KEY;

package/agents/developer.js

@@ -1,10 +1,7 @@
 /**
  * Developer Agent — powered by Claude Agent SDK
- *
- * Instead of calling the Claude API and manually writing files,
- * this agent spawns Claude Code directly in the project directory.
- * Claude Code can read the full codebase, run commands, install deps,
- * fix errors, and iterate — all autonomously.
+ * Replaces the old API-based developer with Claude Code running directly
+ * in the project directory — full codebase access, real shell commands.
  *
  * Requires: npm install -g @anthropic-ai/claude-code
  */
@@ -13,43 +10,27 @@ import { query } from "@anthropic-ai/claude-agent-sdk";
 import { startTask, completeTask, failTask, addLog } from "./board-client.js";
 import { execSync } from "child_process";
 
-// Resolve the global `claude` binary path at startup
+// ── Resolve the global `claude` binary path at startup ────────────────────────
 function resolveClaudePath() {
-  // 1. Explicit override via env var
   if (process.env.CLAUDE_CODE_PATH) return process.env.CLAUDE_CODE_PATH;
-
-  // 2. Ask the shell where `claude` lives (works after: npm install -g @anthropic-ai/claude-code)
-  try {
-    return execSync("which claude", { stdio: "pipe" }).toString().trim();
-  } catch {}
-
-  // 3. Common Homebrew / nvm / fnm paths
-  const candidates = [
+  try { return execSync("which claude", { stdio: "pipe" }).toString().trim(); } catch {}
+  for (const p of [
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude",
     `${process.env.HOME}/.nvm/versions/node/current/bin/claude`,
     `${process.env.HOME}/.npm-global/bin/claude`,
-  ];
-  for (const p of candidates) {
+  ]) {
     try { execSync(`test -f "${p}"`, { stdio: "pipe" }); return p; } catch {}
   }
-
-  return null; // will surface as CLINotFoundError
+  return null;
 }
 
-const CLAUDE_PATH = resolveClaudePath();
-
-// Build a full PATH for the Claude Code subprocess
-// Exit code 127 = "command not found" inside the subprocess — node/npm not in PATH
-function buildEnv() {// Exit code 127 = "command not found" inside the subprocess — node/npm not in PATH
+// ── Build a full PATH so node/npm/npx are found inside the subprocess ─────────
+// Exit code 127 = "command not found" — happens when PATH is stripped for global pkgs
 function buildEnv() {
-  // Get node/npm directory to ensure they're in PATH
   let nodeBinDir = "";
-  try {
-    nodeBinDir = execSync("dirname $(which node)", { stdio: "pipe" }).toString().trim();
-  } catch {}
+  try { nodeBinDir = execSync("dirname $(which node)", { stdio: "pipe" }).toString().trim(); } catch {}
 
-  // Merge: existing PATH + node bin dir + common locations
   const pathParts = [
     process.env.PATH || "",
     nodeBinDir,
@@ -63,57 +44,49 @@ function buildEnv() {
   ].filter(Boolean);
 
   const fullPath = [...new Set(pathParts.join(":").split(":"))].join(":");
-
-  return {
-    ...process.env,
-    PATH: fullPath,
-    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
-    HOME: process.env.HOME,
-  };
+  return { ...process.env, PATH: fullPath, HOME: process.env.HOME };
 }
 
-// Tools Claude Code can use — full developer access
+const CLAUDE_PATH = resolveClaudePath();
+
+// ── Tools Claude Code can use ─────────────────────────────────────────────────
 const DEVELOPER_TOOLS = [
-  "Read",        // Read any file in the project
-  "Write",       // Create new files
-  "Edit",        // Edit existing files (surgical, line-level)
-  "MultiEdit",   // Edit multiple files in one shot
-  "Bash",        // Run npm install, npx expo install, tsc, etc.
-  "Glob",        // Find files by pattern (e.g. "**/*.tsx")
-  "Grep",        // Search file contents
-  "TodoWrite",   // Let Claude track its own subtasks
-  "TodoRead",    // Read its own task list
+  "Read", "Write", "Edit", "MultiEdit",
+  "Bash", "Glob", "Grep",
+  "TodoWrite", "TodoRead",
 ];
 
 const DEV_RULES = `
-You are a senior React Native / Expo developer working as part of an autonomous engineering team.
+You are a senior React Native / Expo developer in an autonomous engineering team.
 
 RULES:
 - Write complete, production-ready code — no placeholders, no TODOs
 - Use TypeScript if the project uses it
-- Follow the existing code style and folder structure (read existing files first)
+- Read existing files first to follow the project's patterns
 - Install packages with: npx expo install <package>
-- After writing files, run: npx tsc --noEmit — fix any TypeScript errors
-- If you hit an error, read it and fix it — iterate until it works
-- Do NOT ask questions. Do NOT ask for confirmation. Make your best judgment.
+- After writing files run: npx tsc --noEmit — fix any errors you find
+- If you hit an error, read it carefully and fix it — iterate until it works
+- Do NOT ask questions or ask for confirmation. Make your best judgment.
 - When fully done, print EXACTLY this line: TASK_COMPLETE: <one sentence summary>
 `;
 
+// ── Main export ───────────────────────────────────────────────────────────────
 export async function runDeveloperAgent(task, projectPath, techStack, retryContext = null) {
   console.log(`  🤖  Claude Code working on: ${task.title}`);
-  if (CLAUDE_PATH) {
-    console.log(`     CLI: ${CLAUDE_PATH}`);
-  } else {
+
+  if (!CLAUDE_PATH) {
     const hint = "Claude Code CLI not found. Run: npm install -g @anthropic-ai/claude-code";
     await startTask(task.id, hint);
     await failTask(task.id, hint);
     console.error(`\n  ✗ ${hint}\n`);
     return { success: false, error: hint };
   }
+
+  console.log(`     CLI: ${CLAUDE_PATH}`);
   await startTask(task.id, `Claude Code starting: ${task.title}`);
 
   const retryNote = retryContext
-    ? `\n\n⚠️ RETRY — Previous attempt failed or QA flagged issues:\n${retryContext}\n\nFix these specific issues.`
+    ? `\n\n⚠️ RETRY — Previous attempt failed. Fix these issues:\n${retryContext}`
     : "";
 
   const techNote = techStack && Object.keys(techStack).length > 0
@@ -149,7 +122,7 @@ ${retryNote}
         permissionMode: "bypassPermissions",
         allowedTools: DEVELOPER_TOOLS,
         maxTurns: 80,
-        ...(CLAUDE_PATH ? { pathToClaudeCodeExecutable: CLAUDE_PATH } : {}),
+        pathToClaudeCodeExecutable: CLAUDE_PATH,
         systemPrompt: {
           type: "preset",
           preset: "claude_code",
@@ -159,27 +132,21 @@ ${retryNote}
       },
     })) {
 
-      // ── Assistant messages ─────────────────────────────────────────────────
+      // Assistant messages — log tools and text
       if (message.type === "assistant") {
         for (const block of message.message.content) {
-
           if (block.type === "text" && block.text?.trim()) {
             const text = block.text.trim();
-
-            // Detect completion signal
             if (text.includes("TASK_COMPLETE:")) {
               completed = true;
               summary = text.split("TASK_COMPLETE:")[1]?.trim().split("\n")[0] || task.title;
             }
-
-            // Log meaningful progress
             if (text.length > 20) {
               const preview = text.split("\n")[0].slice(0, 120);
               await addLog(task.id, preview, "progress");
               console.log(`     ${preview}`);
             }
           }
-
           if (block.type === "tool_use") {
             toolCallCount++;
             const log = formatToolLog(block);
@@ -191,14 +158,13 @@ ${retryNote}
         }
       }
 
-      // ── Result ─────────────────────────────────────────────────────────────
+      // Result — task finished or errored
       if (message.type === "result") {
         if (message.subtype === "success") {
           if (!completed && message.result?.includes("TASK_COMPLETE:")) {
             completed = true;
             summary = message.result.split("TASK_COMPLETE:")[1]?.trim().split("\n")[0] || task.title;
           }
-
           const finalSummary = summary || `Implemented: ${task.title}`;
           await completeTask(task.id, `✓ ${finalSummary} (${toolCallCount} tool calls)`);
           console.log(`  ✓ Done: ${task.title} — ${toolCallCount} tool calls`);
@@ -209,7 +175,7 @@ ${retryNote}
             await completeTask(task.id, `✓ ${summary} (hit turn limit)`);
             return { success: true, summary };
           }
-          const err = "Reached max turns without completing — increase maxTurns or break task into smaller pieces";
+          const err = "Reached max turns (80) — consider breaking this task into smaller pieces";
           await failTask(task.id, err);
           return { success: false, error: err };
 
@@ -220,11 +186,11 @@ ${retryNote}
         }
       }
 
-      // ── System init ────────────────────────────────────────────────────────
+      // System init — log session info
       if (message.type === "system" && message.subtype === "init") {
-        const sessionShort = message.session_id?.slice(0, 8) || "?";
-        console.log(`     📡 Session ${sessionShort} | ${message.tools?.length || 0} tools | ${message.model}`);
-        await addLog(task.id, `Claude Code session ${sessionShort} in ${projectPath}`, "start");
+        const s = message.session_id?.slice(0, 8) || "?";
+        console.log(`     📡 Session ${s} | ${message.tools?.length || 0} tools | ${message.model}`);
+        await addLog(task.id, `Session ${s} started`, "start");
       }
     }
 
@@ -233,7 +199,6 @@ ${retryNote}
       await completeTask(task.id, `✓ ${summary}`);
       return { success: true, summary };
     }
-
     const err = "Session ended without result";
     await failTask(task.id, err);
     return { success: false, error: err };
@@ -241,15 +206,11 @@ ${retryNote}
   } catch (err) {
     const msg = err.message || String(err);
     console.error(`  ✗ Error:`, msg.slice(0, 200));
-
-    // Missing CLI — helpful message
-    if (msg.includes("CLINotFoundError") || msg.includes("ENOENT") || msg.includes("claude-code")) {
+    if (msg.includes("CLINotFoundError") || msg.includes("ENOENT")) {
       const hint = "Claude Code CLI not installed. Run: npm install -g @anthropic-ai/claude-code";
       await failTask(task.id, hint);
-      console.error(`\n  ⚠️  ${hint}\n`);
       return { success: false, error: hint };
     }
-
     await failTask(task.id, msg.slice(0, 500));
     return { success: false, error: msg };
   }
@@ -257,15 +218,16 @@ ${retryNote}
 
 function formatToolLog(block) {
   const { name, input = {} } = block;
+  const p = input.file_path || input.path || "";
   switch (name) {
-    case "Read":       return `Read: ${input.file_path || input.path || ""}`;
-    case "Write":      return `Write: ${input.file_path || input.path || ""}`;
+    case "Read":      return `Read: ${p}`;
+    case "Write":     return `Write: ${p}`;
     case "Edit":
-    case "MultiEdit":  return `Edit: ${input.file_path || input.path || ""}`;
-    case "Bash":       return `Run: ${(input.command || "").slice(0, 80)}`;
-    case "Glob":       return `Glob: ${input.pattern || ""}`;
-    case "Grep":       return `Grep: "${(input.pattern || "").slice(0, 40)}"`;
-    case "TodoWrite":  return `Planning subtasks...`;
-    default:           return null;
+    case "MultiEdit": return `Edit: ${p}`;
+    case "Bash":      return `Run: ${(input.command || "").slice(0, 80)}`;
+    case "Glob":      return `Glob: ${input.pattern || ""}`;
+    case "Grep":      return `Grep: "${(input.pattern || "").slice(0, 40)}"`;
+    case "TodoWrite": return `Planning...`;
+    default:          return null;
   }
 }

package/agents/qa.js

@@ -1,133 +1,103 @@
 import { callClaude, callClaudeJSON, callClaudeWithImage } from "./claude-api.js";
-import { addLog, createTask, startTask, completeTask, failTask } from "./board-client.js";
-import { readFile, listFiles, projectTree } from "../tools/filesystem.js";
-import { runCommand, waitForPort } from "../tools/terminal.js";
+import { addLog } from "./board-client.js";
+import { readFile, listFiles } from "../tools/filesystem.js";
+import { runCommand } from "../tools/terminal.js";
 import { screenshotExpoWeb } from "../tools/screenshot.js";
-import { readRecentLogs, readErrorLogs } from "../tools/supabase-reader.js";
+import { readErrorLogs } from "../tools/supabase-reader.js";
 import path from "path";
 import fs from "fs";
 
-const SYSTEM_QA = `You are a senior QA engineer for mobile apps built with React Native / Expo.
-Your job is to verify that implemented features work correctly and look good.
-
-You receive:
-- The original PRD description of a feature
-- Console logs from the app
-- A screenshot of the current state
-- TypeScript/build errors if any
-
-You must determine:
-1. Does the feature work as described in the PRD?
-2. Does the UI look polished and correct?
-3. Are there any errors in the logs?
-4. What bugs or issues need to be fixed?
-
-Be specific about what's wrong and what needs to change.`;
+const SYSTEM_QA = `You are a senior QA engineer for React Native / Expo apps.
+Verify that implemented features work correctly. Be specific about actual issues.
+If Expo is not running, evaluate purely on code quality and completeness.`;
 
 export async function runQAAgent(task, devResult, projectPath, prdContent, expoPort = 8081) {
   console.log(`  🔍  QA checking: ${task.title}`);
-  await addLog(task.id, "QA agent starting verification", "progress");
-
-  const qaReport = {
-    passed: false,
-    issues: [],
-    screenshotPath: null,
-    fixInstructions: null,
-  };
-
-  // 1. Check for TypeScript errors
-  const tsResult = await runCommand("npx tsc --noEmit 2>&1 | head -30", projectPath, 30000);
-  if (tsResult.stdout.includes("error TS")) {
-    qaReport.issues.push(`TypeScript errors found:\n${tsResult.stdout}`);
-    await addLog(task.id, `QA: TypeScript errors detected`, "error");
+  await addLog(task.id, "QA starting", "progress");
+
+  // ── 1. TypeScript check ────────────────────────────────────────────────────
+  const tsResult = await runCommand("npx tsc --noEmit 2>&1", projectPath, 60000);
+  const tsErrors = tsResult.stdout.includes("error TS") ? tsResult.stdout : null;
+  if (tsErrors) await addLog(task.id, `TypeScript errors detected`, "error");
+
+  // ── 2. Check for truncated/incomplete files ────────────────────────────────
+  const truncationIssues = await checkForTruncatedFiles(task, projectPath);
+  if (truncationIssues.length > 0) {
+    const msg = `Incomplete files: ${truncationIssues.join(", ")}`;
+    await addLog(task.id, msg, "error");
+    return {
+      passed: false,
+      issues: truncationIssues,
+      fixInstructions: `These files are truncated/incomplete:\n${truncationIssues.join("\n")}\n\nRe-implement them completely from scratch.`,
+      screenshotPath: null,
+    };
   }
 
-  // 2. Read console/app logs
-  let appLogs = "";
-  try {
-    // Read from Expo CLI output (saved to temp file by runner)
-    const logFile = path.join(projectPath, ".claudeboard-logs.txt");
-    if (fs.existsSync(logFile)) {
-      appLogs = fs.readFileSync(logFile, "utf8").slice(-3000);
+  // ── 3. Screenshot (only if Expo is running) ────────────────────────────────
+  let visualVerdict = null;
+  const expoRunning = await isPortOpen(expoPort);
+
+  if (expoRunning) {
+    await addLog(task.id, "Taking screenshot...", "progress");
+    const screenshotDir = path.join(projectPath, ".claudeboard-screenshots");
+    const screenshot = await screenshotExpoWeb(expoPort, screenshotDir);
+    if (screenshot.success && screenshot.base64) {
+      const visionResult = await callClaudeWithImage(
+        SYSTEM_QA,
+        `Task: ${task.title}\nExpected: ${task.description}\n\nDoes the UI look correct? Any visual bugs?`,
+        screenshot.base64
+      );
+      visualVerdict = visionResult.text;
+      await addLog(task.id, `Visual: ${visualVerdict}`, "progress");
+    } else {
+      await addLog(task.id, `Screenshot failed: ${screenshot.error}`, "progress");
     }
-  } catch {}
-
-  // 3. Read Supabase error logs if project uses Supabase
-  let supabaseLogs = [];
-  try {
-    supabaseLogs = await readErrorLogs("logs", 10);
-  } catch {}
-
-  // 4. Take screenshot
-  await addLog(task.id, "Taking screenshot of Expo Web...", "progress");
-  const screenshotDir = path.join(projectPath, ".claudeboard-screenshots");
-  const screenshot = await screenshotExpoWeb(expoPort, screenshotDir);
-
-  if (screenshot.success) {
-    qaReport.screenshotPath = screenshot.imagePath;
-    await addLog(task.id, `Screenshot captured: ${path.basename(screenshot.imagePath)}`, "progress");
   } else {
-    await addLog(task.id, `Screenshot failed: ${screenshot.error}`, "progress");
-  }
-
-  // 5. Visual QA via Claude Vision
-  let visualVerdict = null;
-  if (screenshot.success && screenshot.base64) {
-    const visualPrompt = `
-This is a screenshot of a React Native / Expo app screen.
-
-Task that was just implemented: ${task.title}
-Expected behavior from PRD: ${task.description}
-
-Evaluate:
-1. Does the screen look implemented? (not blank, not error screen)
-2. Does the UI look polished? (proper layout, readable text, no obvious visual bugs)
-3. Does it appear to match what was described in the task?
-4. Any visual issues? (overlapping elements, cut off text, missing components)
-
-Be concise and specific.`;
-
-    const visionResult = await callClaudeWithImage(SYSTEM_QA, visualPrompt, screenshot.base64);
-    visualVerdict = visionResult.text;
-    await addLog(task.id, `Visual QA: ${visualVerdict.slice(0, 200)}`, "progress");
+    await addLog(task.id, "Expo not running — code-only QA", "progress");
   }
 
-  // 6. Functional QA — read code and verify logic
-  const relevantFiles = listFiles(projectPath, [".ts", ".tsx"])
-    .filter((f) => {
-      const rel = path.relative(projectPath, f).toLowerCase();
-      return task.title.toLowerCase().split(" ").some((w) => w.length > 4 && rel.includes(w));
-    })
-    .slice(0, 5);
-
+  // ── 4. Read ALL relevant code — no artificial limits ──────────────────────
+  // Claude Code already wrote these files — we read them fully for QA review
+  const relevantFiles = getRelevantFiles(task, projectPath);
   let codeContext = "";
   for (const f of relevantFiles) {
     const content = readFile(f);
     if (content) {
-      codeContext += `\n### ${path.relative(projectPath, f)}\n${content.slice(0, 1500)}\n`;
+      // No slice — read the complete file
+      codeContext += `\n### ${path.relative(projectPath, f)}\n${content}\n`;
     }
   }
 
-  const functionalVerdict = await callClaudeJSON(
+  // ── 5. App logs (full) ─────────────────────────────────────────────────────
+  let appLogs = "";
+  try {
+    const logFile = path.join(projectPath, ".claudeboard-logs.txt");
+    if (fs.existsSync(logFile)) appLogs = fs.readFileSync(logFile, "utf8");
+  } catch {}
+
+  // ── 6. Supabase errors ─────────────────────────────────────────────────────
+  let supabaseLogs = [];
+  try { supabaseLogs = await readErrorLogs("logs", 20); } catch {}
+
+  // ── 7. Functional verdict ─────────────────────────────────────────────────
+  const verdict = await callClaudeJSON(
     SYSTEM_QA,
-    `
-Task: ${task.title}
+    `Task: ${task.title}
 Description: ${task.description}
 
-Code implemented:
+Implemented code (complete files):
 ${codeContext || "Could not read relevant files"}
 
-Console logs:
-${appLogs || "No logs captured"}
-
-Supabase errors:
-${supabaseLogs.length > 0 ? JSON.stringify(supabaseLogs) : "None"}
+TypeScript: ${tsErrors ? `ERRORS:\n${tsErrors}` : "Clean — no errors"}
+App logs: ${appLogs || "None"}
+Supabase errors: ${supabaseLogs.length > 0 ? JSON.stringify(supabaseLogs, null, 2) : "None"}
+Visual QA: ${visualVerdict || "No screenshot (Expo not running — evaluate code only)"}
 
-TypeScript status:
-${tsResult.stdout.includes("error TS") ? tsResult.stdout : "No TypeScript errors"}
-
-Visual QA notes:
-${visualVerdict || "No screenshot available"}
+EVALUATION RULES:
+- PASS if: code is complete, TypeScript is clean, implementation matches description
+- FAIL only if: code is incomplete/truncated, has TS errors, or implementation is clearly wrong
+- Do NOT fail just because Expo isn't running
+- Do NOT fail for minor style preferences
 
 Respond with JSON:
 {
@@ -135,74 +105,125 @@ Respond with JSON:
   "confidence": 0-100,
   "issues": ["specific issue 1", "specific issue 2"],
   "summary": "One sentence verdict",
-  "fixInstructions": "If failed: specific instructions for the developer to fix. If passed: null"
-}`,
-    { maxTokens: 2000 }
+  "fixInstructions": "Specific fix instructions if failed, null if passed"
+}`
   );
 
-  qaReport.passed = functionalVerdict.passed;
-  qaReport.issues = functionalVerdict.issues || [];
-  qaReport.fixInstructions = functionalVerdict.fixInstructions;
+  const qaReport = {
+    passed: verdict.passed,
+    issues: verdict.issues || [],
+    fixInstructions: verdict.fixInstructions,
+    screenshotPath: null,
+  };
 
   if (qaReport.passed) {
-    await addLog(task.id, `✓ QA passed (${functionalVerdict.confidence}%): ${functionalVerdict.summary}`, "complete");
+    await addLog(task.id, `✓ QA passed (${verdict.confidence}%): ${verdict.summary}`, "complete");
     console.log(`  ✓ QA passed: ${task.title}`);
   } else {
-    await addLog(
-      task.id,
-      `✗ QA failed: ${functionalVerdict.summary}. Issues: ${qaReport.issues.slice(0, 2).join("; ")}`,
-      "error"
-    );
-    console.log(`  ✗ QA failed: ${task.title}`);
-    console.log(`    Issues: ${qaReport.issues.join(", ")}`);
+    await addLog(task.id, `✗ QA failed: ${verdict.summary}`, "error");
+    console.log(`  ✗ QA failed: ${task.title} — ${verdict.issues?.slice(0,2).join(", ")}`);
   }
 
   return qaReport;
 }
 
-/**
- * Full app QA — run at end of development phase
- * Goes through every major screen and validates against PRD
- */
+// ── Detect truncated/incomplete files ──────────────────────────────────────────
+async function checkForTruncatedFiles(task, projectPath) {
+  const issues = [];
+  const keywords = task.title.toLowerCase().split(" ").filter(w => w.length > 4);
+
+  const files = listFiles(projectPath, [".ts", ".tsx"])
+    .filter(f => {
+      const rel = path.relative(projectPath, f).toLowerCase();
+      if (rel.includes("node_modules") || rel.includes(".claudeboard")) return false;
+      return keywords.some(kw => rel.includes(kw));
+    });
+
+  for (const f of files) {
+    const content = readFile(f);
+    if (!content) continue;
+    const rel = path.relative(projectPath, f);
+    const lastLines = content.split("\n").slice(-5).join("\n").trim();
+    const openBraces  = (content.match(/\{/g) || []).length;
+    const closeBraces = (content.match(/\}/g) || []).length;
+
+    const truncated =
+      lastLines.endsWith("{") || lastLines.endsWith("(") || lastLines.endsWith(",") ||
+      lastLines.match(/^(import|\/\/) *$/) ||
+      openBraces > closeBraces + 3 ||
+      (content.length < 80 && (rel.includes("store") || rel.includes("hook") || rel.includes("screen")));
+
+    if (truncated) {
+      issues.push(`${rel} (ends: "${lastLines.slice(-80)}")`);
+    }
+  }
+  return issues;
+}
+
+// ── Full app QA ────────────────────────────────────────────────────────────────
 export async function runFullAppQA(projectPath, prdContent, expoPort = 8081) {
   console.log("\n  🔍  Running full app QA...");
 
-  // Detect routes from expo-router structure
-  const routeFiles = listFiles(path.join(projectPath, "app"), [".tsx", ".ts"])
-    .filter((f) => !f.includes("_layout") && !f.includes("_error"))
-    .map((f) => {
-      const rel = path.relative(path.join(projectPath, "app"), f);
-      return "/" + rel.replace(/\.(tsx|ts)$/, "").replace(/index$/, "");
-    });
+  if (!await isPortOpen(expoPort)) {
+    console.log("  ⚠️  Expo not running — skipping visual QA");
+    return { passed: true, routes: [], screenshotsCaptures: 0, issues: [] };
+  }
+
+  const appDir = path.join(projectPath, "app");
+  if (!fs.existsSync(appDir)) return { passed: true, routes: [], screenshotsCaptures: 0, issues: [] };
+
+  const routeFiles = listFiles(appDir, [".tsx", ".ts"])
+    .filter(f => !f.includes("_layout") && !f.includes("_error"))
+    .map(f => "/" + path.relative(appDir, f).replace(/\.(tsx|ts)$/, "").replace(/index$/, ""));
 
   const screenshotDir = path.join(projectPath, ".claudeboard-screenshots", "full-qa");
   const screenshots = [];
 
-  for (const route of routeFiles.slice(0, 10)) {
+  for (const route of routeFiles) {
     const shot = await screenshotExpoWeb(expoPort, screenshotDir, route);
     if (shot.success) screenshots.push({ route, ...shot });
-    await new Promise((r) => setTimeout(r, 1000));
+    await new Promise(r => setTimeout(r, 800));
   }
 
-  // Send all screenshots + PRD to Claude for final verdict
-  const report = {
-    passed: screenshots.length > 0,
-    routes: routeFiles,
-    screenshotsCaptures: screenshots.length,
-    issues: [],
-  };
+  const report = { passed: true, routes: routeFiles, screenshotsCaptures: screenshots.length, issues: [] };
 
   for (const shot of screenshots) {
     if (!shot.base64) continue;
     const verdict = await callClaudeWithImage(
       SYSTEM_QA,
-      `Route: ${shot.route}\n\nPRD for reference:\n${prdContent.slice(0, 2000)}\n\nDoes this screen look complete and working? Any issues?`,
+      `Route: ${shot.route}\n\nFull PRD:\n${prdContent}\n\nAny obvious issues?`,
       shot.base64
     );
     if (verdict.text.toLowerCase().includes("issue") || verdict.text.toLowerCase().includes("problem")) {
-      report.issues.push({ route: shot.route, note: verdict.text.slice(0, 200) });
+      report.issues.push({ route: shot.route, note: verdict.text });
     }
   }
 
   return report;
 }
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function getRelevantFiles(task, projectPath) {
+  const keywords = task.title.toLowerCase().split(" ").filter(w => w.length > 4);
+  return listFiles(projectPath, [".ts", ".tsx"])
+    .filter(f => {
+      const rel = path.relative(projectPath, f).toLowerCase();
+      if (rel.includes("node_modules") || rel.includes(".claudeboard")) return false;
+      return keywords.some(kw => rel.includes(kw));
+    });
+  // No .slice() — return all matching files
+}
+
+async function isPortOpen(port) {
+  try {
+    const { default: net } = await import("net");
+    return new Promise(resolve => {
+      const sock = new net.Socket();
+      sock.setTimeout(800);
+      sock.once("connect", () => { sock.destroy(); resolve(true); });
+      sock.once("error", () => resolve(false));
+      sock.once("timeout", () => resolve(false));
+      sock.connect(port, "127.0.0.1");
+    });
+  } catch { return false; }
+}

package/bin/cli.js

@@ -166,11 +166,21 @@ program
       process.exit(1);
     }
 
+    const resolvedProject = path.resolve(opts.project);
+
+    // Persist the project path so `claudeboard start` uses the right directory for Expo
+    const configPath = path.join(process.cwd(), ".claudeboard.json");
+    try {
+      const saved = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      saved.projectDir = resolvedProject;
+      fs.writeFileSync(configPath, JSON.stringify(saved, null, 2));
+    } catch {}
+
     const { runOrchestrator } = await import("../agents/orchestrator.js");
 
     await runOrchestrator({
       prdPath: path.resolve(opts.prd),
-      projectPath: path.resolve(opts.project),
+      projectPath: resolvedProject,
       supabaseUrl: config.supabaseUrl,
       supabaseKey: config.supabaseKey,
       projectName: config.projectName,

package/dashboard/index.html

@@ -929,7 +929,14 @@
       <button class="stab" id="tab-detail" onclick="switchTab('detail')">Detail</button>
     </div>
     <div class="sidebar-body" id="sidebarBody">
-      <div class="detail-empty">Waiting for activity...<br><br>Agents will log<br>their work here.</div>
+      <!-- Activity pane — always in DOM, shown/hidden -->
+      <div id="activityPane">
+        <div class="detail-empty">Waiting for activity...<br><br>Agents will log<br>their work here.</div>
+      </div>
+      <!-- Detail pane — always in DOM, shown/hidden -->
+      <div id="detailPane" style="display:none">
+        <div class="detail-empty">Click any task card<br>to see its details.</div>
+      </div>
     </div>
   </div>
 
@@ -1102,6 +1109,7 @@ function connectWS() {
     if (event === 'log') {
       board.logs.unshift(data);
       if (activeTab === 'activity') renderLogs();
+      // If on detail tab, don't touch activityPane — it'll refresh next time they switch
     }
     if (event === 'expo_status') {
       setExpoStatus(data.status, data.url);
@@ -1265,10 +1273,6 @@ async function onDrop(e, status) {
 
 // ── CARD SELECT ───────────────────────────────────────────────────────────────
 async function selectCard(id) {
-  activeTab = 'detail';
-  document.getElementById('tab-activity').className = 'stab';
-  document.getElementById('tab-detail').className = 'stab active';
-
   const task = allTasks().find(t => t.id === id);
   if (!task) return;
   selectedTask = task;
@@ -1276,8 +1280,8 @@ async function selectCard(id) {
   const res = await fetch(`/api/tasks/${id}/logs`);
   const { logs } = await res.json();
 
-  const el = document.getElementById('sidebarBody');
-  el.innerHTML = `
+  // Write into the dedicated detail pane (never touches activityPane)
+  document.getElementById('detailPane').innerHTML = `
     <div>
       <div class="detail-title">${esc(task.title)}</div>
       <div class="detail-tags">
@@ -1295,16 +1299,23 @@ async function selectCard(id) {
           }).join('')
       }
     </div>`;
+
+  // Switch to detail tab
+  activeTab = 'detail';
+  document.getElementById('tab-activity').className = 'stab';
+  document.getElementById('tab-detail').className = 'stab active';
+  document.getElementById('activityPane').style.display = 'none';
+  document.getElementById('detailPane').style.display = 'block';
 }
 
 // ── LOGS ──────────────────────────────────────────────────────────────────────
 function renderLogs() {
-  const el = document.getElementById('sidebarBody');
+  // Only update the activity pane — never overwrites detail pane
+  const el = document.getElementById('activityPane');
   if (!board.logs?.length) {
     el.innerHTML = `<div class="detail-empty">Waiting for activity...<br><br>Agents will log<br>their work here.</div>`;
     return;
   }
-
   const icons = { start: '▶', complete: '✓', error: '✕', progress: '·', info: '·' };
   el.innerHTML = board.logs.map(l => {
     const t = new Date(l.created_at).toLocaleTimeString('en',{hour12:false,hour:'2-digit',minute:'2-digit',second:'2-digit'});
@@ -1325,6 +1336,9 @@ function switchTab(tab) {
   activeTab = tab;
   document.getElementById('tab-activity').className = 'stab' + (tab === 'activity' ? ' active' : '');
   document.getElementById('tab-detail').className   = 'stab' + (tab === 'detail'   ? ' active' : '');
+  // Show/hide panes — never overwrite the other pane's content
+  document.getElementById('activityPane').style.display = tab === 'activity' ? 'block' : 'none';
+  document.getElementById('detailPane').style.display   = tab === 'detail'   ? 'block' : 'none';
   if (tab === 'activity') renderLogs();
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeboard",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "AI engineering team — from PRD to working mobile app, autonomously",
   "type": "module",
   "bin": {