@dunnewold-labs/mr-manager 0.3.0 → 0.4.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // cli/index.ts
-import { Command as Command29 } from "commander";
+import { Command as Command28 } from "commander";
 import { existsSync as existsSync15 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join13 } from "path";
@@ -696,7 +696,7 @@ async function runTest(options) {
     postUpdate,
     onProgress
   } = options;
-  const log4 = onProgress || (() => {
+  const log3 = onProgress || (() => {
   });
   const result = {
     status: "passed",
@@ -709,37 +709,37 @@ async function runTest(options) {
   let wtPath = null;
   const worktreeName = `mr-test-${taskId.slice(0, 8)}`;
   const timeoutHandle = setTimeout(() => {
-    log4("Test timed out after 5 minutes");
+    log3("Test timed out after 5 minutes");
     if (devProc) devProc.kill("SIGTERM");
   }, 5 * 60 * 1e3);
   try {
-    log4("Extracting branch from MR/PR link...");
+    log3("Extracting branch from MR/PR link...");
     const branch = extractBranchFromLink(taskLink, localPath);
     if (!branch) {
       throw new Error(`Could not extract branch from link: ${taskLink}`);
     }
-    log4(`Branch: ${branch}`);
-    log4("Creating git worktree...");
+    log3(`Branch: ${branch}`);
+    log3("Creating git worktree...");
     wtPath = createWorktree(localPath, branch, worktreeName);
-    log4(`Worktree created at ${wtPath}`);
-    log4("Installing dependencies...");
+    log3(`Worktree created at ${wtPath}`);
+    log3("Installing dependencies...");
     try {
       installDependencies(wtPath);
     } catch (err) {
-      log4(`Warning: dependency install failed: ${err.message}`);
+      log3(`Warning: dependency install failed: ${err.message}`);
     }
-    log4("Starting dev server...");
+    log3("Starting dev server...");
     const port = await findAvailablePort(4e3);
     devProc = await startDevServer(wtPath, port);
     const baseUrl = `http://127.0.0.1:${port}`;
-    log4(`Dev server running on ${baseUrl}`);
+    log3(`Dev server running on ${baseUrl}`);
     await browseRunner(["goto", baseUrl]);
     const plan = customPlan || buildDefaultTestPlan(baseUrl);
-    log4(`Executing ${plan.length}-step test plan...`);
+    log3(`Executing ${plan.length}-step test plan...`);
     for (let i = 0; i < plan.length; i++) {
       const step = plan[i];
       const stepDesc = step.description || `${step.command} ${(step.args || []).join(" ")}`;
-      log4(`Step ${i + 1}/${plan.length}: ${stepDesc}`);
+      log3(`Step ${i + 1}/${plan.length}: ${stepDesc}`);
       try {
         if (step.command.startsWith("assert")) {
           const assertResult = await evaluateAssertion(step, i, browseRunner);
@@ -789,7 +789,7 @@ async function runTest(options) {
         }
       } catch (err) {
         result.errors.push(`Step ${i + 1} (${step.command}): ${err.message}`);
-        log4(`Step ${i + 1} error: ${err.message}`);
+        log3(`Step ${i + 1} error: ${err.message}`);
       }
     }
     const totalAssertions = result.assertions.length;
@@ -1906,6 +1906,8 @@ var watchCommand = new Command8("watch").description(
   const active = /* @__PURE__ */ new Map();
   const failed = /* @__PURE__ */ new Map();
   const queued = /* @__PURE__ */ new Set();
+  const finishing = /* @__PURE__ */ new Set();
+  let pollRunning = false;
   const approvalQueue = [];
   let approvalRunning = false;
   const flags = [
@@ -1990,32 +1992,94 @@ var watchCommand = new Command8("watch").description(
     active.set(task.id, { process: child, title: task.title, repoDir });
     child.on("exit", async (code) => {
       active.delete(task.id);
-      queued.delete(task.id);
-      if (code === 0) {
-        try {
-          const researchPath = resolve(repoDir, "research.md");
-          if (existsSync6(researchPath)) {
-            try {
-              const researchContent = readFileSync5(researchPath, "utf-8");
-              const existingResearch = existingResources.find((r) => r.type === "research");
-              if (existingResearch) {
-                await api.patch(`/api/tasks/${task.id}/resources/${existingResearch.id}`, {
-                  content: researchContent
-                });
-                logSuccess(prefix, `Updated existing research resource`);
+      finishing.add(task.id);
+      try {
+        if (code === 0) {
+          try {
+            const researchPath = resolve(repoDir, "research.md");
+            if (existsSync6(researchPath)) {
+              try {
+                const researchContent = readFileSync5(researchPath, "utf-8");
+                const existingResearch = existingResources.find((r) => r.type === "research");
+                if (existingResearch) {
+                  await api.patch(`/api/tasks/${task.id}/resources/${existingResearch.id}`, {
+                    content: researchContent
+                  });
+                  logSuccess(prefix, `Updated existing research resource`);
+                } else {
+                  await api.post(`/api/tasks/${task.id}/resources`, {
+                    type: "research",
+                    title: `Research \u2014 ${task.title}`,
+                    content: researchContent
+                  });
+                  logSuccess(prefix, `Uploaded research.md as task resource`);
+                }
+                unlinkSync(researchPath);
+              } catch (err) {
+                logWarn(prefix, `Failed to upload research resource: ${err.message}`);
+              }
+            }
+            if (sessionId) {
+              try {
+                const sessionEntries = readAndParseSessionLog(sessionId, repoDir);
+                if (sessionEntries && sessionEntries.length > 0) {
+                  const sessionContent = JSON.stringify(sessionEntries);
+                  const existingSessionLog = existingResources.find((r) => r.type === "session-log");
+                  if (existingSessionLog) {
+                    await api.patch(`/api/tasks/${task.id}/resources/${existingSessionLog.id}`, {
+                      content: sessionContent
+                    });
+                    logSuccess(prefix, `Updated session log resource (${sessionEntries.length} messages)`);
+                  } else {
+                    await api.post(`/api/tasks/${task.id}/resources`, {
+                      type: "session-log",
+                      title: `Session Log \u2014 ${task.title}`,
+                      content: sessionContent
+                    });
+                    logSuccess(prefix, `Uploaded session log (${sessionEntries.length} messages)`);
+                  }
+                }
+              } catch (err) {
+                logWarn(prefix, `Failed to upload session log: ${err.message}`);
+              }
+            }
+            const noMrPath = resolve(repoDir, ".mr-no-mr");
+            const noMrRequested = existsSync6(noMrPath);
+            let noMrDescription;
+            if (noMrRequested) {
+              noMrDescription = readFileSync5(noMrPath, "utf-8").trim();
+              unlinkSync(noMrPath);
+              logSuccess(prefix, `No ${vcs === "gitlab" ? "MR" : "PR"} needed \u2014 ${noMrDescription}`);
+            }
+            const prLabel = vcs === "gitlab" ? "MR" : "PR";
+            let prUrl = null;
+            if (!noMrRequested) {
+              prUrl = await findPrUrlAcrossRepos(branchName, repoDir, vcs);
+              if (!prUrl) {
+                prUrl = await extractPrUrlFromUpdates(task.id);
+                if (prUrl) {
+                  logInfo(prefix, `Found ${prLabel} URL from agent updates: ${paint("cyan", prUrl)}`);
+                }
+              }
+              if (prUrl) {
+                logSuccess(prefix, `${prLabel} ready: ${paint("cyan", prUrl)}`);
               } else {
-                await api.post(`/api/tasks/${task.id}/resources`, {
-                  type: "research",
-                  title: `Research \u2014 ${task.title}`,
-                  content: researchContent
-                });
-                logSuccess(prefix, `Uploaded research.md as task resource`);
+                logWarn(prefix, `No ${prLabel} found for branch ${paint("cyan", branchName)}`);
+                await postTaskUpdate(task.id, `Agent finished \u2014 no ${prLabel} found for branch ${branchName}`, "system");
               }
-              unlinkSync(researchPath);
-            } catch (err) {
-              logWarn(prefix, `Failed to upload research resource: ${err.message}`);
             }
+            await api.patch(`/api/tasks/${task.id}`, {
+              status: "review",
+              ...prUrl ? { link: prUrl } : {}
+            });
+            logSuccess(prefix, `"${paint("bold", task.title)}" marked ready for review`);
+            await postTaskUpdate(task.id, noMrRequested ? `Task marked ready for review \u2014 no ${prLabel} needed: ${noMrDescription}` : "Task marked ready for review", "system");
+          } catch (err) {
+            logError(prefix, `Failed to update task: ${err.message}`);
           }
+        } else {
+          logError(prefix, `"${paint("bold", task.title)}" failed (exit ${code}), leaving status unchanged`);
+          await postTaskUpdate(task.id, `Agent failed with exit code ${code}`, "system");
           if (sessionId) {
             try {
               const sessionEntries = readAndParseSessionLog(sessionId, repoDir);
@@ -2026,79 +2090,22 @@ var watchCommand = new Command8("watch").description(
                   await api.patch(`/api/tasks/${task.id}/resources/${existingSessionLog.id}`, {
                     content: sessionContent
                   });
-                  logSuccess(prefix, `Updated session log resource (${sessionEntries.length} messages)`);
                 } else {
                   await api.post(`/api/tasks/${task.id}/resources`, {
                     type: "session-log",
                     title: `Session Log \u2014 ${task.title}`,
                     content: sessionContent
                   });
-                  logSuccess(prefix, `Uploaded session log (${sessionEntries.length} messages)`);
                 }
+                logInfo(prefix, `Uploaded session log for failed task (${sessionEntries.length} messages)`);
               }
-            } catch (err) {
-              logWarn(prefix, `Failed to upload session log: ${err.message}`);
-            }
-          }
-          const noMrPath = resolve(repoDir, ".mr-no-mr");
-          const noMrRequested = existsSync6(noMrPath);
-          let noMrDescription;
-          if (noMrRequested) {
-            noMrDescription = readFileSync5(noMrPath, "utf-8").trim();
-            unlinkSync(noMrPath);
-            logSuccess(prefix, `No ${vcs === "gitlab" ? "MR" : "PR"} needed \u2014 ${noMrDescription}`);
-          }
-          const prLabel = vcs === "gitlab" ? "MR" : "PR";
-          let prUrl = null;
-          if (!noMrRequested) {
-            prUrl = await findPrUrlAcrossRepos(branchName, repoDir, vcs);
-            if (!prUrl) {
-              prUrl = await extractPrUrlFromUpdates(task.id);
-              if (prUrl) {
-                logInfo(prefix, `Found ${prLabel} URL from agent updates: ${paint("cyan", prUrl)}`);
-              }
-            }
-            if (prUrl) {
-              logSuccess(prefix, `${prLabel} ready: ${paint("cyan", prUrl)}`);
-            } else {
-              logWarn(prefix, `No ${prLabel} found for branch ${paint("cyan", branchName)}`);
-              await postTaskUpdate(task.id, `Agent finished \u2014 no ${prLabel} found for branch ${branchName}`, "system");
+            } catch {
             }
           }
-          await api.patch(`/api/tasks/${task.id}`, {
-            status: "review",
-            ...prUrl ? { link: prUrl } : {}
-          });
-          logSuccess(prefix, `"${paint("bold", task.title)}" marked ready for review`);
-          await postTaskUpdate(task.id, noMrRequested ? `Task marked ready for review \u2014 no ${prLabel} needed: ${noMrDescription}` : "Task marked ready for review", "system");
-        } catch (err) {
-          logError(prefix, `Failed to update task: ${err.message}`);
-        }
-      } else {
-        logError(prefix, `"${paint("bold", task.title)}" failed (exit ${code}), leaving status unchanged`);
-        await postTaskUpdate(task.id, `Agent failed with exit code ${code}`, "system");
-        if (sessionId) {
-          try {
-            const sessionEntries = readAndParseSessionLog(sessionId, repoDir);
-            if (sessionEntries && sessionEntries.length > 0) {
-              const sessionContent = JSON.stringify(sessionEntries);
-              const existingSessionLog = existingResources.find((r) => r.type === "session-log");
-              if (existingSessionLog) {
-                await api.patch(`/api/tasks/${task.id}/resources/${existingSessionLog.id}`, {
-                  content: sessionContent
-                });
-              } else {
-                await api.post(`/api/tasks/${task.id}/resources`, {
-                  type: "session-log",
-                  title: `Session Log \u2014 ${task.title}`,
-                  content: sessionContent
-                });
-              }
-              logInfo(prefix, `Uploaded session log for failed task (${sessionEntries.length} messages)`);
-            }
-          } catch {
-          }
         }
+      } finally {
+        queued.delete(task.id);
+        finishing.delete(task.id);
       }
     });
   }
@@ -2135,49 +2142,54 @@ var watchCommand = new Command8("watch").description(
     active.set(task.id, { process: child, title: task.title, repoDir });
     child.on("exit", async (code) => {
       active.delete(task.id);
-      queued.delete(task.id);
-      if (code === 0) {
-        try {
-          const prdPath = resolve(repoDir, "prd.md");
-          let prdContent;
+      finishing.add(task.id);
+      try {
+        if (code === 0) {
           try {
-            prdContent = readFileSync5(prdPath, "utf-8");
-            logInfo(prefix, `Read PRD from ${paint("cyan", "prd.md")} (${prdContent.length} chars)`);
-            unlinkSync(prdPath);
-          } catch {
-            logWarn(prefix, `No prd.md file found in ${repoDir} \u2014 PRD may have been posted inline`);
-          }
-          if (prdContent) {
+            const prdPath = resolve(repoDir, "prd.md");
+            let prdContent;
             try {
-              if (existingPlanResource) {
-                await api.patch(`/api/tasks/${task.id}/resources/${existingPlanResource.id}`, {
-                  content: prdContent
-                });
-                logSuccess(prefix, `Updated existing PRD resource`);
-              } else {
-                await api.post(`/api/tasks/${task.id}/resources`, {
-                  type: "plan",
-                  title: `PRD \u2014 ${task.title}`,
-                  content: prdContent
-                });
-                logSuccess(prefix, `Uploaded PRD as task resource`);
+              prdContent = readFileSync5(prdPath, "utf-8");
+              logInfo(prefix, `Read PRD from ${paint("cyan", "prd.md")} (${prdContent.length} chars)`);
+              unlinkSync(prdPath);
+            } catch {
+              logWarn(prefix, `No prd.md file found in ${repoDir} \u2014 PRD may have been posted inline`);
+            }
+            if (prdContent) {
+              try {
+                if (existingPlanResource) {
+                  await api.patch(`/api/tasks/${task.id}/resources/${existingPlanResource.id}`, {
+                    content: prdContent
+                  });
+                  logSuccess(prefix, `Updated existing PRD resource`);
+                } else {
+                  await api.post(`/api/tasks/${task.id}/resources`, {
+                    type: "plan",
+                    title: `PRD \u2014 ${task.title}`,
+                    content: prdContent
+                  });
+                  logSuccess(prefix, `Uploaded PRD as task resource`);
+                }
+              } catch (err) {
+                logWarn(prefix, `Failed to upload PRD resource: ${err.message}`);
               }
-            } catch (err) {
-              logWarn(prefix, `Failed to upload PRD resource: ${err.message}`);
             }
+            await api.patch(`/api/tasks/${task.id}`, {
+              status: "review",
+              ...prdContent ? { prdContent } : {}
+            });
+            logSuccess(prefix, `"${paint("bold", task.title)}" PRD generated and marked ready for review`);
+            await postTaskUpdate(task.id, "PRD generated \u2014 ready for review", "system");
+          } catch (err) {
+            logError(prefix, `Failed to update task: ${err.message}`);
           }
-          await api.patch(`/api/tasks/${task.id}`, {
-            status: "review",
-            ...prdContent ? { prdContent } : {}
-          });
-          logSuccess(prefix, `"${paint("bold", task.title)}" PRD generated and marked ready for review`);
-          await postTaskUpdate(task.id, "PRD generated \u2014 ready for review", "system");
-        } catch (err) {
-          logError(prefix, `Failed to update task: ${err.message}`);
+        } else {
+          logError(prefix, `"${paint("bold", task.title)}" PRD generation failed (exit ${code}), leaving status unchanged`);
+          await postTaskUpdate(task.id, `PRD generation failed with exit code ${code}`, "system");
         }
-      } else {
-        logError(prefix, `"${paint("bold", task.title)}" PRD generation failed (exit ${code}), leaving status unchanged`);
-        await postTaskUpdate(task.id, `PRD generation failed with exit code ${code}`, "system");
+      } finally {
+        queued.delete(task.id);
+        finishing.delete(task.id);
       }
     });
   }
@@ -2208,42 +2220,48 @@ var watchCommand = new Command8("watch").description(
     const child = spawnAgent(agent, repoDir, prompt2, prefix, void 0, proto.title);
     active.set(`proto-${proto.id}`, { process: child, title: proto.title, repoDir });
     child.on("exit", async (code) => {
-      active.delete(`proto-${proto.id}`);
-      queued.delete(`proto-${proto.id}`);
-      if (code === 0) {
-        try {
-          const protoPattern = /^prototype-\d+\.html$/;
-          const found = readdirSync(repoDir).filter((f) => protoPattern.test(f)).sort();
-          const files = found.map((f) => ({
-            name: f,
-            content: readFileSync5(resolve(repoDir, f), "utf-8")
-          }));
-          if (files.length === 0) {
-            logError(prefix, `No prototype HTML files found in ${repoDir}`);
-            await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" });
-            return;
-          }
-          await api.patch(`/api/prototypes/${proto.id}`, { status: "completed", files });
-          logSuccess(prefix, `"${paint("bold", proto.title)}" uploaded ${files.length} file(s)`);
-          for (const file of files) {
+      const key = `proto-${proto.id}`;
+      active.delete(key);
+      finishing.add(key);
+      try {
+        if (code === 0) {
+          try {
+            const protoPattern = /^prototype-\d+\.html$/;
+            const found = readdirSync(repoDir).filter((f) => protoPattern.test(f)).sort();
+            const files = found.map((f) => ({
+              name: f,
+              content: readFileSync5(resolve(repoDir, f), "utf-8")
+            }));
+            if (files.length === 0) {
+              logError(prefix, `No prototype HTML files found in ${repoDir}`);
+              await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" });
+              return;
+            }
+            await api.patch(`/api/prototypes/${proto.id}`, { status: "completed", files });
+            logSuccess(prefix, `"${paint("bold", proto.title)}" uploaded ${files.length} file(s)`);
+            for (const file of files) {
+              try {
+                unlinkSync(resolve(repoDir, file.name));
+              } catch {
+              }
+            }
+          } catch (err) {
+            logError(prefix, `Failed to upload prototype: ${err.message}`);
             try {
-              unlinkSync(resolve(repoDir, file.name));
+              await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" });
             } catch {
             }
           }
-        } catch (err) {
-          logError(prefix, `Failed to upload prototype: ${err.message}`);
+        } else {
+          logError(prefix, `"${paint("bold", proto.title)}" prototype failed (exit ${code})`);
           try {
             await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" });
           } catch {
           }
         }
-      } else {
-        logError(prefix, `"${paint("bold", proto.title)}" prototype failed (exit ${code})`);
-        try {
-          await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" });
-        } catch {
-        }
+      } finally {
+        queued.delete(key);
+        finishing.delete(key);
       }
     });
   }
@@ -2259,16 +2277,22 @@ var watchCommand = new Command8("watch").description(
     const child = spawnAgent(agent, workDir, prompt2, prefix, void 0, project.name);
     active.set(`repo-${project.id}`, { process: child, title: project.name, repoDir: workDir });
     child.on("exit", async (code) => {
-      active.delete(`repo-${project.id}`);
-      queued.delete(`repo-${project.id}`);
-      if (code === 0) {
-        logSuccess(prefix, `"${paint("bold", project.name)}" repo creation complete`);
-      } else {
-        logError(prefix, `"${paint("bold", project.name)}" repo creation failed (exit ${code})`);
-        try {
-          await api.patch(`/api/projects/${project.id}`, { repoCreationStatus: "failed" });
-        } catch {
+      const key = `repo-${project.id}`;
+      active.delete(key);
+      finishing.add(key);
+      try {
+        if (code === 0) {
+          logSuccess(prefix, `"${paint("bold", project.name)}" repo creation complete`);
+        } else {
+          logError(prefix, `"${paint("bold", project.name)}" repo creation failed (exit ${code})`);
+          try {
+            await api.patch(`/api/projects/${project.id}`, { repoCreationStatus: "failed" });
+          } catch {
+          }
         }
+      } finally {
+        queued.delete(key);
+        finishing.delete(key);
       }
     });
   }
@@ -2286,85 +2310,91 @@ var watchCommand = new Command8("watch").description(
     const child = spawnAgent(agent, repoDir, prompt2, prefix, void 0, idea.title);
     active.set(`idea-${idea.id}`, { process: child, title: idea.title, repoDir });
     child.on("exit", async (code) => {
-      active.delete(`idea-${idea.id}`);
-      queued.delete(`idea-${idea.id}`);
-      if (code === 0) {
-        try {
-          let plan;
-          let protoHtml;
-          let followUpTasks;
-          const planPath = resolve(repoDir, "idea-plan.md");
-          const tasksPath = resolve(repoDir, "idea-tasks.json");
-          const protoPath = resolve(repoDir, "idea-prototype.html");
-          try {
-            plan = readFileSync5(planPath, "utf-8");
-          } catch {
-          }
-          try {
-            protoHtml = readFileSync5(protoPath, "utf-8");
-          } catch {
-          }
+      const key = `idea-${idea.id}`;
+      active.delete(key);
+      finishing.add(key);
+      try {
+        if (code === 0) {
           try {
-            const tasksRaw = readFileSync5(tasksPath, "utf-8");
-            const parsed = JSON.parse(tasksRaw);
-            if (Array.isArray(parsed)) {
-              followUpTasks = parsed.filter((t) => t && typeof t === "object" && "title" in t);
+            let plan;
+            let protoHtml;
+            let followUpTasks;
+            const planPath = resolve(repoDir, "idea-plan.md");
+            const tasksPath = resolve(repoDir, "idea-tasks.json");
+            const protoPath = resolve(repoDir, "idea-prototype.html");
+            try {
+              plan = readFileSync5(planPath, "utf-8");
+            } catch {
             }
-          } catch {
-          }
-          if (!plan && !protoHtml) {
-            logError(prefix, `No output files found in ${repoDir}`);
-            await api.patch(`/api/ideas/${idea.id}`, { status: "draft" });
-            return;
-          }
-          const updateData = { status: "generated" };
-          if (plan) updateData.plan = plan;
-          if (followUpTasks) updateData.followUpTasks = followUpTasks;
-          if (protoHtml) {
             try {
-              const proto = await api.post("/api/prototypes", {
-                title: `${idea.title} \u2014 Idea Prototype`,
-                prompt: idea.description || idea.title,
-                variantCount: 1,
-                projectId: idea.projectId ?? null
-              });
-              await api.patch(`/api/prototypes/${proto.id}`, {
-                status: "completed",
-                files: [{ name: "idea-prototype.html", content: protoHtml }]
-              });
-              updateData.generatedPrototypeId = proto.id;
-              logSuccess(prefix, `Prototype created: ${paint("gray", proto.id.slice(0, 8))}`);
-            } catch (err) {
-              logError(prefix, `Failed to create prototype: ${err.message}`);
+              protoHtml = readFileSync5(protoPath, "utf-8");
+            } catch {
+            }
+            try {
+              const tasksRaw = readFileSync5(tasksPath, "utf-8");
+              const parsed = JSON.parse(tasksRaw);
+              if (Array.isArray(parsed)) {
+                followUpTasks = parsed.filter((t) => t && typeof t === "object" && "title" in t);
+              }
+            } catch {
+            }
+            if (!plan && !protoHtml) {
+              logError(prefix, `No output files found in ${repoDir}`);
+              await api.patch(`/api/ideas/${idea.id}`, { status: "draft" });
+              return;
+            }
+            const updateData = { status: "generated" };
+            if (plan) updateData.plan = plan;
+            if (followUpTasks) updateData.followUpTasks = followUpTasks;
+            if (protoHtml) {
+              try {
+                const proto = await api.post("/api/prototypes", {
+                  title: `${idea.title} \u2014 Idea Prototype`,
+                  prompt: idea.description || idea.title,
+                  variantCount: 1,
+                  projectId: idea.projectId ?? null
+                });
+                await api.patch(`/api/prototypes/${proto.id}`, {
+                  status: "completed",
+                  files: [{ name: "idea-prototype.html", content: protoHtml }]
+                });
+                updateData.generatedPrototypeId = proto.id;
+                logSuccess(prefix, `Prototype created: ${paint("gray", proto.id.slice(0, 8))}`);
+              } catch (err) {
+                logError(prefix, `Failed to create prototype: ${err.message}`);
+              }
+            }
+            await api.patch(`/api/ideas/${idea.id}`, updateData);
+            logSuccess(prefix, `"${paint("bold", idea.title)}" generation complete`);
+            try {
+              unlinkSync(planPath);
+            } catch {
+            }
+            try {
+              unlinkSync(tasksPath);
+            } catch {
+            }
+            try {
+              unlinkSync(protoPath);
+            } catch {
+            }
+          } catch (err) {
+            logError(prefix, `Failed to upload idea output: ${err.message}`);
+            try {
+              await api.patch(`/api/ideas/${idea.id}`, { status: "draft" });
+            } catch {
             }
           }
-          await api.patch(`/api/ideas/${idea.id}`, updateData);
-          logSuccess(prefix, `"${paint("bold", idea.title)}" generation complete`);
-          try {
-            unlinkSync(planPath);
-          } catch {
-          }
-          try {
-            unlinkSync(tasksPath);
-          } catch {
-          }
-          try {
-            unlinkSync(protoPath);
-          } catch {
-          }
-        } catch (err) {
-          logError(prefix, `Failed to upload idea output: ${err.message}`);
+        } else {
+          logError(prefix, `"${paint("bold", idea.title)}" generation failed (exit ${code})`);
           try {
             await api.patch(`/api/ideas/${idea.id}`, { status: "draft" });
           } catch {
           }
         }
-      } else {
-        logError(prefix, `"${paint("bold", idea.title)}" generation failed (exit ${code})`);
-        try {
-          await api.patch(`/api/ideas/${idea.id}`, { status: "draft" });
-        } catch {
-        }
+      } finally {
+        queued.delete(key);
+        finishing.delete(key);
       }
     });
   }
@@ -2443,329 +2473,342 @@ ${divider}`);
     }
   }
   async function poll() {
-    let queuedTasks;
-    let delegatedTasks;
+    if (pollRunning) return;
+    pollRunning = true;
     try {
-      queuedTasks = await api.get("/api/tasks?status=queued");
-      delegatedTasks = await api.get("/api/tasks?status=delegated");
-    } catch (err) {
-      logError(watchTag(), `Failed to fetch tasks: ${err.message}`);
-      return;
-    }
-    const nonTestQueued = queuedTasks.filter((t) => t.mode !== "testing");
-    const nonTestDelegated = delegatedTasks.filter((t) => t.mode !== "testing");
-    const tasks = [...nonTestQueued, ...nonTestDelegated];
-    const config = loadConfig();
-    const activeTaskIds = new Set(tasks.map((t) => t.id));
-    for (const [taskId, entry] of active) {
-      if (taskId.startsWith("proto-") || taskId.startsWith("repo-") || taskId.startsWith("scan-")) continue;
-      if (!activeTaskIds.has(taskId)) {
-        logWarn(watchTag(), `Task ${paint("yellow", taskId.slice(0, 8))} no longer active, terminating\u2026`);
-        entry.process.kill("SIGTERM");
-        active.delete(taskId);
-        queued.delete(taskId);
-      }
-    }
-    const nonTaskPrefixes = ["proto-", "repo-", "scan-", "idea-", "test-"];
-    for (const taskId of failed.keys()) {
-      if (nonTaskPrefixes.some((p) => taskId.startsWith(p))) continue;
-      if (!activeTaskIds.has(taskId)) failed.delete(taskId);
-    }
-    for (const taskId of queued) {
-      if (nonTaskPrefixes.some((p) => taskId.startsWith(p))) continue;
-      if (!activeTaskIds.has(taskId)) queued.delete(taskId);
-    }
-    for (const task of tasks) {
-      if (queued.has(task.id)) continue;
-      if (failed.has(task.id)) continue;
-      const sid = shortId(task.id);
-      const prefix = taskTag(sid);
-      const repoDir = findDirectoryForProject(config, task.projectId, rootDir);
-      if (!repoDir) {
-        const reason = `no linked directory found under ${rootDir}`;
-        logError(prefix, `"${task.title}": ${reason} \u2014 will not retry`);
-        failed.set(task.id, reason);
-        continue;
-      }
-      if (!existsSync6(repoDir)) {
-        const reason = `linked directory "${repoDir}" does not exist`;
-        logError(prefix, `"${task.title}": ${reason} \u2014 will not retry`);
-        failed.set(task.id, reason);
-        continue;
+      let queuedTasks;
+      let delegatedTasks;
+      try {
+        queuedTasks = await api.get("/api/tasks?status=queued");
+        delegatedTasks = await api.get("/api/tasks?status=delegated");
+      } catch (err) {
+        logError(watchTag(), `Failed to fetch tasks: ${err.message}`);
+        return;
       }
-      if (task.status === "queued") {
-        try {
-          await api.patch(`/api/tasks/${task.id}`, { status: "delegated" });
-        } catch (err) {
-          logError(prefix, `Failed to mark task as delegated: ${err.message}`);
-          continue;
+      const nonTestQueued = queuedTasks.filter((t) => t.mode !== "testing");
+      const nonTestDelegated = delegatedTasks.filter((t) => t.mode !== "testing");
+      const tasks = [...nonTestQueued, ...nonTestDelegated];
+      const config = loadConfig();
+      const activeTaskIds = new Set(tasks.map((t) => t.id));
+      for (const [taskId, entry] of active) {
+        if (taskId.startsWith("proto-") || taskId.startsWith("repo-") || taskId.startsWith("scan-")) continue;
+        if (!activeTaskIds.has(taskId)) {
+          logWarn(watchTag(), `Task ${paint("yellow", taskId.slice(0, 8))} no longer active, terminating\u2026`);
+          entry.process.kill("SIGTERM");
+          active.delete(taskId);
+          queued.delete(taskId);
         }
       }
-      queued.add(task.id);
-      if (dryRun) {
-        logInfo(
-          watchTag(),
-          `${paint("yellow", "[dry-run]")} would dispatch "${paint("bold", task.title)}" (${paint("gray", task.id)}) in ${paint("cyan", repoDir)}`
-        );
-        continue;
+      const nonTaskPrefixes = ["proto-", "repo-", "scan-", "idea-", "test-"];
+      for (const taskId of failed.keys()) {
+        if (nonTaskPrefixes.some((p) => taskId.startsWith(p))) continue;
+        if (!activeTaskIds.has(taskId)) failed.delete(taskId);
       }
-      if (task.mode === "planning") {
-        dispatchPlanModeTask(task, repoDir);
-      } else if (planApproval) {
-        approvalQueue.push({ task, repoDir });
-        processApprovalQueue();
-      } else {
-        dispatchTask(task, repoDir);
+      for (const taskId of queued) {
+        if (nonTaskPrefixes.some((p) => taskId.startsWith(p))) continue;
+        if (finishing.has(taskId)) continue;
+        if (!activeTaskIds.has(taskId)) queued.delete(taskId);
       }
-    }
-    let prototypes = [];
-    try {
-      prototypes = await api.get("/api/prototypes?status=in_progress");
-    } catch (err) {
-      logError(watchTag(), `Failed to fetch prototypes: ${err.message}`);
-    }
-    const inProgressProtoKeys = new Set(prototypes.map((p) => `proto-${p.id}`));
-    for (const [key, entry] of active) {
-      if (key.startsWith("proto-") && !inProgressProtoKeys.has(key)) {
-        logWarn(watchTag(), `Prototype ${paint("yellow", key)} no longer in_progress, terminating\u2026`);
-        entry.process.kill("SIGTERM");
-        active.delete(key);
-        queued.delete(key);
-      }
-    }
-    for (const key of failed.keys()) {
-      if (key.startsWith("proto-") && !inProgressProtoKeys.has(key)) failed.delete(key);
-    }
-    for (const key of queued) {
-      if (key.startsWith("proto-") && !inProgressProtoKeys.has(key)) queued.delete(key);
-    }
-    const activeProtoCount = [...active.keys()].filter((k) => k.startsWith("proto-")).length;
-    let protoSlots = Math.max(0, 2 - activeProtoCount);
-    for (const proto of prototypes) {
-      if (protoSlots <= 0) break;
-      const key = `proto-${proto.id}`;
-      if (queued.has(key)) continue;
-      if (failed.has(key)) continue;
-      const sid = shortId(proto.id);
-      const prefix = protoTag(sid);
-      if (!proto.projectId) {
-        logWarn(prefix, `"${proto.title}": no projectId \u2014 skipping`);
-        continue;
+      for (const task of tasks) {
+        if (queued.has(task.id)) continue;
+        if (finishing.has(task.id)) continue;
+        if (failed.has(task.id)) continue;
+        const sid = shortId(task.id);
+        const prefix = taskTag(sid);
+        const repoDir = findDirectoryForProject(config, task.projectId, rootDir);
+        if (!repoDir) {
+          const reason = `no linked directory found under ${rootDir}`;
+          logError(prefix, `"${task.title}": ${reason} \u2014 will not retry`);
+          failed.set(task.id, reason);
+          continue;
+        }
+        if (!existsSync6(repoDir)) {
+          const reason = `linked directory "${repoDir}" does not exist`;
+          logError(prefix, `"${task.title}": ${reason} \u2014 will not retry`);
+          failed.set(task.id, reason);
+          continue;
+        }
+        if (task.status === "queued") {
+          try {
+            await api.patch(`/api/tasks/${task.id}`, { status: "delegated" });
+          } catch (err) {
+            logError(prefix, `Failed to mark task as delegated: ${err.message}`);
+            continue;
+          }
+        }
+        queued.add(task.id);
+        if (dryRun) {
+          logInfo(
+            watchTag(),
+            `${paint("yellow", "[dry-run]")} would dispatch "${paint("bold", task.title)}" (${paint("gray", task.id)}) in ${paint("cyan", repoDir)}`
+          );
+          continue;
+        }
+        if (task.mode === "planning") {
+          dispatchPlanModeTask(task, repoDir);
+        } else if (planApproval) {
+          approvalQueue.push({ task, repoDir });
+          processApprovalQueue();
+        } else {
+          dispatchTask(task, repoDir);
+        }
       }
-      const repoDir = findDirectoryForProject(config, proto.projectId, rootDir);
-      if (!repoDir) {
-        logWarn(prefix, `"${proto.title}": no linked directory found \u2014 skipping`);
-        continue;
+      let prototypes = [];
+      try {
+        prototypes = await api.get("/api/prototypes?status=in_progress");
+      } catch (err) {
+        logError(watchTag(), `Failed to fetch prototypes: ${err.message}`);
       }
-      if (!existsSync6(repoDir)) {
-        logError(prefix, `"${proto.title}": linked directory "${repoDir}" does not exist \u2014 skipping`);
-        failed.set(key, `directory does not exist: ${repoDir}`);
-        continue;
+      const inProgressProtoKeys = new Set(prototypes.map((p) => `proto-${p.id}`));
+      for (const [key, entry] of active) {
+        if (key.startsWith("proto-") && !inProgressProtoKeys.has(key)) {
+          logWarn(watchTag(), `Prototype ${paint("yellow", key)} no longer in_progress, terminating\u2026`);
+          entry.process.kill("SIGTERM");
+          active.delete(key);
+          queued.delete(key);
+        }
       }
-      queued.add(key);
-      protoSlots--;
-      if (dryRun) {
-        logInfo(
-          watchTag(),
-          `${paint("yellow", "[dry-run]")} would dispatch prototype "${paint("bold", proto.title)}" in ${paint("cyan", repoDir)}`
-        );
-        continue;
+      for (const key of failed.keys()) {
+        if (key.startsWith("proto-") && !inProgressProtoKeys.has(key)) failed.delete(key);
       }
-      dispatchPrototypeJob(proto, repoDir);
-    }
-    const testTasks = queuedTasks.filter((t) => t.mode === "testing");
-    for (const task of testTasks) {
-      const key = `test-${task.id}`;
-      if (queued.has(key)) continue;
-      if (failed.has(key)) continue;
-      const sid = shortId(task.id);
-      const prefix = testTag(sid);
-      if (!task.link) {
-        logWarn(prefix, `"${task.title}": no MR/PR link \u2014 skipping`);
-        continue;
+      for (const key of queued) {
+        if (key.startsWith("proto-") && !inProgressProtoKeys.has(key) && !finishing.has(key)) queued.delete(key);
       }
-      queued.add(key);
-      if (dryRun) {
-        logInfo(
-          watchTag(),
-          `${paint("yellow", "[dry-run]")} would run test for "${paint("bold", task.title)}"`
-        );
-        continue;
+      const activeProtoCount = [...active.keys()].filter((k) => k.startsWith("proto-")).length;
+      let protoSlots = Math.max(0, 2 - activeProtoCount);
+      for (const proto of prototypes) {
+        if (protoSlots <= 0) break;
+        const key = `proto-${proto.id}`;
+        if (queued.has(key)) continue;
+        if (finishing.has(key)) continue;
+        if (failed.has(key)) continue;
+        const sid = shortId(proto.id);
+        const prefix = protoTag(sid);
+        if (!proto.projectId) {
+          logWarn(prefix, `"${proto.title}": no projectId \u2014 skipping`);
+          continue;
+        }
+        const repoDir = findDirectoryForProject(config, proto.projectId, rootDir);
+        if (!repoDir) {
+          logWarn(prefix, `"${proto.title}": no linked directory found \u2014 skipping`);
+          continue;
+        }
+        if (!existsSync6(repoDir)) {
+          logError(prefix, `"${proto.title}": linked directory "${repoDir}" does not exist \u2014 skipping`);
+          failed.set(key, `directory does not exist: ${repoDir}`);
+          continue;
+        }
+        queued.add(key);
+        protoSlots--;
+        if (dryRun) {
+          logInfo(
+            watchTag(),
+            `${paint("yellow", "[dry-run]")} would dispatch prototype "${paint("bold", proto.title)}" in ${paint("cyan", repoDir)}`
+          );
+          continue;
+        }
+        dispatchPrototypeJob(proto, repoDir);
       }
-      (async () => {
-        logDispatch(prefix, `Running test for "${paint("bold", task.title)}"\u2026`);
-        try {
-          await api.patch(`/api/tasks/${task.id}`, { status: "delegated" });
-          await postTaskUpdate(task.id, "Test started \u2014 setting up environment\u2026");
-          let localPath;
-          try {
-            const project = await api.get(`/api/projects/${task.projectId}`);
-            localPath = project.localPath ?? void 0;
-          } catch {
-          }
-          if (!localPath) {
-            const cfg = loadConfig();
-            localPath = findDirectoryForProject(cfg, task.projectId, rootDir) ?? void 0;
-          }
-          if (!localPath) {
-            throw new Error("Local repo path not configured. Run `mr link` in the project directory.");
-          }
-          let testPlan;
+      const testTasks = queuedTasks.filter((t) => t.mode === "testing");
+      for (const task of testTasks) {
+        const key = `test-${task.id}`;
+        if (queued.has(key)) continue;
+        if (finishing.has(key)) continue;
+        if (failed.has(key)) continue;
+        const sid = shortId(task.id);
+        const prefix = testTag(sid);
+        if (!task.link) {
+          logWarn(prefix, `"${task.title}": no MR/PR link \u2014 skipping`);
+          continue;
+        }
+        queued.add(key);
+        if (dryRun) {
+          logInfo(
+            watchTag(),
+            `${paint("yellow", "[dry-run]")} would run test for "${paint("bold", task.title)}"`
+          );
+          continue;
+        }
+        (async () => {
+          logDispatch(prefix, `Running test for "${paint("bold", task.title)}"\u2026`);
           try {
-            const resources = await api.get(`/api/tasks/${task.id}/resources`);
-            const planResource = resources.find((r) => r.type === "test-plan");
-            if (planResource) {
-              testPlan = JSON.parse(planResource.content);
-              logInfo(prefix, `Using agent-authored test plan (${testPlan.length} steps)`);
+            await api.patch(`/api/tasks/${task.id}`, { status: "delegated" });
+            await postTaskUpdate(task.id, "Test started \u2014 setting up environment\u2026");
+            let localPath;
+            try {
+              const project = await api.get(`/api/projects/${task.projectId}`);
+              localPath = project.localPath ?? void 0;
+            } catch {
             }
-          } catch {
-          }
-          const result = await runTest({
-            taskId: task.id,
-            taskLink: task.link,
-            localPath,
-            testPlan,
-            browseRunner: runBrowseCommand2,
-            uploadScreenshot: async (screenshotPath, message) => {
-              try {
-                const { readFileSync: readFileSync12 } = await import("fs");
-                const cfg = loadConfig();
-                const imageBuffer = readFileSync12(screenshotPath);
-                const fileName = screenshotPath.split("/").pop() || "test-screenshot.png";
-                const formData = new FormData();
-                const blob = new Blob([imageBuffer], { type: "image/png" });
-                formData.append("file", blob, fileName);
-                formData.append("prefix", "test-screenshots");
-                const uploadRes = await fetch(`${cfg.apiUrl}/api/upload`, {
-                  method: "POST",
-                  headers: { Authorization: `Bearer ${cfg.apiKey}` },
-                  body: formData
-                });
-                if (!uploadRes.ok) return null;
-                const uploadData = await uploadRes.json();
-                await api.post(`/api/tasks/${task.id}/updates`, {
-                  message,
-                  imageUrl: uploadData.url,
-                  source: "system"
-                });
-                return uploadData.url;
-              } catch {
-                return null;
+            if (!localPath) {
+              const cfg = loadConfig();
+              localPath = findDirectoryForProject(cfg, task.projectId, rootDir) ?? void 0;
+            }
+            if (!localPath) {
+              throw new Error("Local repo path not configured. Run `mr link` in the project directory.");
+            }
+            let testPlan;
+            try {
+              const resources = await api.get(`/api/tasks/${task.id}/resources`);
+              const planResource = resources.find((r) => r.type === "test-plan");
+              if (planResource) {
+                testPlan = JSON.parse(planResource.content);
+                logInfo(prefix, `Using agent-authored test plan (${testPlan.length} steps)`);
               }
-            },
-            postUpdate: async (message, imageUrl) => {
-              await postTaskUpdate(task.id, message);
-            },
-            onProgress: (msg) => logInfo(prefix, msg)
-          });
-          await api.patch(`/api/tasks/${task.id}`, { status: "completed", testResult: result.status });
-          logSuccess(prefix, result.summary);
-        } catch (err) {
-          logError(prefix, `Test failed: ${err.message}`);
-          try {
-            await api.patch(`/api/tasks/${task.id}`, { status: "completed", testResult: "failed" });
-            await postTaskUpdate(task.id, `Test failed: ${err.message}`);
-          } catch {
+            } catch {
+            }
+            const result = await runTest({
+              taskId: task.id,
+              taskLink: task.link,
+              localPath,
+              testPlan,
+              browseRunner: runBrowseCommand2,
+              uploadScreenshot: async (screenshotPath, message) => {
+                try {
+                  const { readFileSync: readFileSync12 } = await import("fs");
+                  const cfg = loadConfig();
+                  const imageBuffer = readFileSync12(screenshotPath);
+                  const fileName = screenshotPath.split("/").pop() || "test-screenshot.png";
+                  const formData = new FormData();
+                  const blob = new Blob([imageBuffer], { type: "image/png" });
+                  formData.append("file", blob, fileName);
+                  formData.append("prefix", "test-screenshots");
+                  const uploadRes = await fetch(`${cfg.apiUrl}/api/upload`, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${cfg.apiKey}` },
+                    body: formData
+                  });
+                  if (!uploadRes.ok) return null;
+                  const uploadData = await uploadRes.json();
+                  await api.post(`/api/tasks/${task.id}/updates`, {
+                    message,
+                    imageUrl: uploadData.url,
+                    source: "system"
+                  });
+                  return uploadData.url;
+                } catch {
+                  return null;
+                }
+              },
+              postUpdate: async (message, imageUrl) => {
+                await postTaskUpdate(task.id, message);
+              },
+              onProgress: (msg) => logInfo(prefix, msg)
+            });
+            await api.patch(`/api/tasks/${task.id}`, { status: "completed", testResult: result.status });
+            logSuccess(prefix, result.summary);
+          } catch (err) {
+            logError(prefix, `Test failed: ${err.message}`);
+            try {
+              await api.patch(`/api/tasks/${task.id}`, { status: "completed", testResult: "failed" });
+              await postTaskUpdate(task.id, `Test failed: ${err.message}`);
+            } catch {
+            }
+            failed.set(key, err.message);
+          } finally {
+            queued.delete(key);
           }
-          failed.set(key, err.message);
-        } finally {
+        })();
+      }
+      let pendingProjects = [];
+      try {
+        pendingProjects = await api.get("/api/projects?repoCreationStatus=pending");
+      } catch (err) {
+        logError(watchTag(), `Failed to fetch pending projects: ${err.message}`);
+      }
+      for (const project of pendingProjects) {
+        const key = `repo-${project.id}`;
+        if (queued.has(key)) continue;
+        if (finishing.has(key)) continue;
+        if (failed.has(key)) continue;
+        queued.add(key);
+        if (dryRun) {
+          logInfo(
+            watchTag(),
+            `${paint("yellow", "[dry-run]")} would create repo for "${paint("bold", project.name)}" in ${paint("cyan", rootDir)}`
+          );
+          continue;
+        }
+        dispatchRepoCreation(project, rootDir);
+      }
+      let generatingIdeas = [];
+      try {
+        generatingIdeas = await api.get("/api/ideas?status=generating");
+      } catch (err) {
+        logError(watchTag(), `Failed to fetch generating ideas: ${err.message}`);
+      }
+      const inProgressIdeaKeys = new Set(generatingIdeas.map((i) => `idea-${i.id}`));
+      for (const [key, entry] of active) {
+        if (key.startsWith("idea-") && !inProgressIdeaKeys.has(key)) {
+          logWarn(watchTag(), `Idea ${paint("yellow", key)} no longer generating, terminating\u2026`);
+          entry.process.kill("SIGTERM");
+          active.delete(key);
           queued.delete(key);
         }
-      })();
-    }
-    let pendingProjects = [];
-    try {
-      pendingProjects = await api.get("/api/projects?repoCreationStatus=pending");
-    } catch (err) {
-      logError(watchTag(), `Failed to fetch pending projects: ${err.message}`);
-    }
-    for (const project of pendingProjects) {
-      const key = `repo-${project.id}`;
-      if (queued.has(key)) continue;
-      if (failed.has(key)) continue;
-      queued.add(key);
-      if (dryRun) {
-        logInfo(
-          watchTag(),
-          `${paint("yellow", "[dry-run]")} would create repo for "${paint("bold", project.name)}" in ${paint("cyan", rootDir)}`
-        );
-        continue;
       }
-      dispatchRepoCreation(project, rootDir);
-    }
-    let generatingIdeas = [];
-    try {
-      generatingIdeas = await api.get("/api/ideas?status=generating");
-    } catch (err) {
-      logError(watchTag(), `Failed to fetch generating ideas: ${err.message}`);
-    }
-    const inProgressIdeaKeys = new Set(generatingIdeas.map((i) => `idea-${i.id}`));
-    for (const [key, entry] of active) {
-      if (key.startsWith("idea-") && !inProgressIdeaKeys.has(key)) {
-        logWarn(watchTag(), `Idea ${paint("yellow", key)} no longer generating, terminating\u2026`);
-        entry.process.kill("SIGTERM");
-        active.delete(key);
-        queued.delete(key);
+      for (const key of failed.keys()) {
+        if (key.startsWith("idea-") && !inProgressIdeaKeys.has(key)) failed.delete(key);
       }
-    }
-    for (const key of failed.keys()) {
-      if (key.startsWith("idea-") && !inProgressIdeaKeys.has(key)) failed.delete(key);
-    }
-    for (const key of queued) {
-      if (key.startsWith("idea-") && !inProgressIdeaKeys.has(key)) queued.delete(key);
-    }
-    const activeIdeaCount = [...active.keys()].filter((k) => k.startsWith("idea-")).length;
-    let ideaSlots = Math.max(0, 1 - activeIdeaCount);
-    for (const idea of generatingIdeas) {
-      if (ideaSlots <= 0) break;
-      const key = `idea-${idea.id}`;
-      if (queued.has(key)) continue;
-      if (failed.has(key)) continue;
-      const sid = shortId(idea.id);
-      const prefix = ideaTag(sid);
-      let repoDir;
-      if (idea.projectId) {
-        const dir = findDirectoryForProject(config, idea.projectId, rootDir);
-        if (!dir) {
-          logWarn(prefix, `"${idea.title}": no linked directory found \u2014 skipping`);
+      for (const key of queued) {
+        if (key.startsWith("idea-") && !inProgressIdeaKeys.has(key) && !finishing.has(key)) queued.delete(key);
+      }
+      const activeIdeaCount = [...active.keys()].filter((k) => k.startsWith("idea-")).length;
+      let ideaSlots = Math.max(0, 1 - activeIdeaCount);
+      for (const idea of generatingIdeas) {
+        if (ideaSlots <= 0) break;
+        const key = `idea-${idea.id}`;
+        if (queued.has(key)) continue;
+        if (finishing.has(key)) continue;
+        if (failed.has(key)) continue;
+        const sid = shortId(idea.id);
+        const prefix = ideaTag(sid);
+        let repoDir;
+        if (idea.projectId) {
+          const dir = findDirectoryForProject(config, idea.projectId, rootDir);
+          if (!dir) {
+            logWarn(prefix, `"${idea.title}": no linked directory found \u2014 skipping`);
+            continue;
+          }
+          repoDir = dir;
+        } else {
+          repoDir = rootDir;
+        }
+        queued.add(key);
+        ideaSlots--;
+        if (dryRun) {
+          logInfo(
+            watchTag(),
+            `${paint("yellow", "[dry-run]")} would dispatch idea "${paint("bold", idea.title)}" in ${paint("cyan", repoDir)}`
+          );
           continue;
         }
-        repoDir = dir;
-      } else {
-        repoDir = rootDir;
+        dispatchIdeaJob(idea, repoDir);
       }
-      queued.add(key);
-      ideaSlots--;
-      if (dryRun) {
-        logInfo(
-          watchTag(),
-          `${paint("yellow", "[dry-run]")} would dispatch idea "${paint("bold", idea.title)}" in ${paint("cyan", repoDir)}`
-        );
-        continue;
+      let pendingScans = [];
+      try {
+        pendingScans = await api.get("/api/scans?status=pending&limit=5");
+      } catch (err) {
+        logError(watchTag(), `Failed to fetch pending scans: ${err.message}`);
       }
-      dispatchIdeaJob(idea, repoDir);
-    }
-    let pendingScans = [];
-    try {
-      pendingScans = await api.get("/api/scans?status=pending&limit=5");
-    } catch (err) {
-      logError(watchTag(), `Failed to fetch pending scans: ${err.message}`);
-    }
-    for (const scan of pendingScans) {
-      const key = `scan-${scan.id}`;
-      if (queued.has(key)) continue;
-      if (failed.has(key)) continue;
-      const sid = shortId(scan.id);
-      const prefix = `${paint("magenta", `[scan:${sid}]`)}`;
-      queued.add(key);
-      if (dryRun) {
-        logInfo(
-          watchTag(),
-          `${paint("yellow", "[dry-run]")} would run scan ${paint("yellow", sid)} for project ${paint("cyan", scan.projectId)}`
-        );
-        continue;
+      for (const scan of pendingScans) {
+        const key = `scan-${scan.id}`;
+        if (queued.has(key)) continue;
+        if (finishing.has(key)) continue;
+        if (failed.has(key)) continue;
+        const sid = shortId(scan.id);
+        const prefix = `${paint("magenta", `[scan:${sid}]`)}`;
+        queued.add(key);
+        if (dryRun) {
+          logInfo(
+            watchTag(),
+            `${paint("yellow", "[dry-run]")} would run scan ${paint("yellow", sid)} for project ${paint("cyan", scan.projectId)}`
+          );
+          continue;
+        }
+        dispatchScan(scan, prefix, key);
       }
-      dispatchScan(scan, prefix, key);
+    } finally {
+      pollRunning = false;
     }
   }
   async function shutdown() {
@@ -2944,9 +2987,11 @@ var subtaskCompleteCommand = new Command12("subtask-complete").description("Mark
   console.log(`\u2713 Subtask completed: ${subtask.title}`);
 });
 
-// cli/commands/digest.ts
+// cli/commands/up.ts
 import { Command as Command13 } from "commander";
 import { spawn as spawn5 } from "child_process";
+import { resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var c4 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -2964,270 +3009,23 @@ function paint4(color, text) {
 function timestamp2() {
   return paint4("gray", (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false }));
 }
-function digestTag() {
-  return paint4("magenta", "[digest]");
-}
-function shortId2(id) {
-  return id.slice(0, 8);
+function upTag() {
+  return paint4("cyan", "[up]");
 }
 function log(msg) {
-  console.log(`${timestamp2()} ${digestTag()} ${msg}`);
-}
-function logOk(msg) {
-  console.log(`${timestamp2()} ${digestTag()} ${paint4("green", "\u2713")} ${msg}`);
+  console.log(`${timestamp2()} ${upTag()} ${msg}`);
 }
 function logErr(msg) {
-  console.error(`${timestamp2()} ${digestTag()} ${paint4("red", "\u2717")} ${msg}`);
-}
-function buildPrompt(messages) {
-  const emailsText = messages.map(
-    (msg, i) => `Email ${i + 1}:
-ID: ${msg.id}
-Subject: ${msg.subject}
-From: ${msg.sender} <${msg.senderEmail}>
-Date: ${msg.date}
-Snippet: ${msg.snippet}
-Body preview: ${msg.body.slice(0, 500)}`
-  ).join("\n\n---\n\n");
-  return `You are an email triage assistant. Analyze the following unread emails and produce a structured digest.
-
-For each email, determine:
-1. Is it relevant/actionable (requires attention, is personal, work-related, or important)?
-2. Or is it not relevant (newsletters, marketing, automated notifications, promotions)?
-3. Assign a category that groups it with similar emails (e.g. "Finance & Trading", "Real Estate", "Work", "Personal", "Promotions & Newsletters", "Travel", "Health", etc.).
-4. Write a 2-3 sentence summary of the email's content and what action (if any) is needed.
-
-Also write a 2-3 sentence executive summary of the overall inbox state.
-
-Here are the unread emails:
-
-${emailsText}
-
-Respond with a JSON object in this exact format:
-{
-  "summary": "2-3 sentence overview of the inbox",
-  "items": [
-    {
-      "emailId": "the email ID",
-      "summary": "2-3 sentence summary of this email's content and any action needed",
-      "isRelevant": true or false,
-      "relevanceReason": "brief explanation of why relevant or not",
-      "category": "short category label (2-4 words)"
-    }
-  ]
-}
-
-Be conservative with "isRelevant: false" \u2014 only mark as not relevant if clearly promotional, newsletter, or automated. Personal emails, work emails, and anything requiring a response should be relevant. Group similar emails under the same category label.`;
-}
-function runAgent(prompt2, agent) {
-  return new Promise((resolve7, reject) => {
-    let bin;
-    let args;
-    if (agent === "codex") {
-      bin = "codex";
-      args = ["exec", "--full-auto", prompt2];
-    } else {
-      bin = "claude";
-      args = ["-p", "--dangerously-skip-permissions", prompt2];
-    }
-    const child = spawn5(bin, args, {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let output = "";
-    let errOutput = "";
-    child.stdout?.on("data", (d) => {
-      output += d.toString();
-    });
-    child.stderr?.on("data", (d) => {
-      errOutput += d.toString();
-    });
-    child.on("exit", (code) => {
-      if (code === 0) resolve7(output.trim());
-      else reject(new Error(`${bin} exited with code ${code}
-${errOutput.trim()}`));
-    });
-  });
-}
-async function processDigest(digest, agent) {
-  const sid = shortId2(digest.id);
-  if (digest.rawMessages.length === 0) {
-    await api.post(`/api/email-digest/${digest.id}/complete`, {
-      summary: "No unread emails found in your inbox.",
-      items: []
-    });
-    logOk(`${paint4("yellow", sid)} completed (no emails)`);
-    return;
-  }
-  log(`${paint4("yellow", sid)} analyzing ${paint4("cyan", String(digest.rawMessages.length))} emails\u2026`);
-  const prompt2 = buildPrompt(digest.rawMessages);
-  const output = await runAgent(prompt2, agent);
-  const jsonMatch = output.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) {
-    throw new Error("Could not extract JSON from Claude output");
-  }
-  const parsed = JSON.parse(jsonMatch[0]);
-  const msgMap = new Map(digest.rawMessages.map((m) => [m.id, m]));
-  const items = parsed.items.map((item) => {
-    const msg = msgMap.get(item.emailId);
-    if (!msg) return null;
-    return {
-      emailId: msg.id,
-      threadId: msg.threadId,
-      subject: msg.subject,
-      sender: msg.sender,
-      senderEmail: msg.senderEmail,
-      date: msg.date,
-      snippet: msg.snippet,
-      summary: item.summary || msg.snippet,
-      isRelevant: item.isRelevant,
-      relevanceReason: item.relevanceReason,
-      category: item.category || (item.isRelevant ? "General" : "Promotions & Newsletters"),
-      archived: false
-    };
-  }).filter((item) => item !== null);
-  await api.post(`/api/email-digest/${digest.id}/complete`, {
-    summary: parsed.summary,
-    items
-  });
-  const relevantItems = items.filter((i) => i.isRelevant);
-  const noiseItems = items.filter((i) => !i.isRelevant);
-  logOk(
-    `${paint4("yellow", sid)} done \u2014 ${paint4("green", String(relevantItems.length))} relevant, ${paint4("gray", String(noiseItems.length))} not relevant`
-  );
-  console.log("");
-  console.log(`  ${paint4("bold", "Summary:")} ${parsed.summary}`);
-  console.log("");
-  if (relevantItems.length > 0) {
-    console.log(`  ${paint4("bold", paint4("green", "Important"))}`);
-    for (const item of relevantItems) {
-      console.log(`    ${paint4("cyan", "\u2022")} ${item.subject} ${paint4("dim", `\u2014 ${item.sender}`)}`);
-    }
-    console.log("");
-  }
-  if (noiseItems.length > 0) {
-    console.log(`  ${paint4("dim", "Not important")}`);
-    for (const item of noiseItems) {
-      console.log(`    ${paint4("dim", `\u2022 ${item.subject} \u2014 ${item.sender}`)}`);
-    }
-    console.log("");
-  }
-}
-async function generateDigest() {
-  let result;
-  try {
-    result = await api.post("/api/email-digest/generate");
-  } catch (err) {
-    logErr(`Auto-generate failed: ${err.message}`);
-    return;
-  }
-  if (result.needsReauth) {
-    logErr("Auto-generate skipped: Gmail re-authentication required");
-    return;
-  }
-  if (result.status === "completed") {
-    log(`Auto-generated digest ${paint4("yellow", shortId2(result.id))} \u2014 no new emails`);
-  } else {
-    log(`Auto-generated digest ${paint4("yellow", shortId2(result.id))} \u2014 queued for processing`);
-  }
-}
-var digestCommand = new Command13("digest").description("Process pending email digests using an AI coding agent (run alongside mr watch)").option("--interval <seconds>", "Polling interval in seconds", "15").option("--generate-interval <seconds>", "How often to auto-generate new digests", "3600").option("--once", "Process pending digests once and exit", false).option("--agent <agent>", "AI agent to use: claude or codex", "claude").action(async (opts) => {
-  const intervalMs = parseInt(opts.interval, 10) * 1e3;
-  const generateIntervalMs = parseInt(opts.generateInterval, 10) * 1e3;
-  const once = opts.once;
-  const agent = opts.agent === "codex" ? "codex" : "claude";
-  const processing = /* @__PURE__ */ new Set();
-  const banner = [
-    ``,
-    paint4("magenta", `  \u2554\u2566\u2557\u2566\u2550\u2557  \u2554\u2566\u2557\u2566\u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2566\u2557`),
-    paint4("magenta", `  \u2551\u2551\u2551\u2560\u2566\u255D   \u2551\u2551\u2551\u2551 \u2566\u2551\u2563 \u255A\u2550\u2557 \u2551`),
-    paint4("magenta", `  \u2569 \u2569\u2569\u255A\u2550  \u2550\u2569\u255D\u2569\u255A\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u255D \u2569`),
-    paint4("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
-    paint4("dim", `  email digest processor \xB7 powered by ${agent}`),
-    ``
-  ].join("\n");
-  console.log(banner);
-  console.log(
-    `  interval=${paint4("cyan", opts.interval + "s")}  generate-interval=${paint4("cyan", opts.generateInterval + "s")}${once ? `  ${paint4("yellow", "once")}` : ""}
-`
-  );
-  async function poll() {
-    let pending;
-    try {
-      pending = await api.get("/api/email-digest/pending");
-    } catch (err) {
-      logErr(`Failed to fetch pending digests: ${err.message}`);
-      return;
-    }
-    if (pending.length === 0) return;
-    const digest = pending[pending.length - 1];
-    if (processing.has(digest.id)) return;
-    log(`Processing digest ${paint4("yellow", shortId2(digest.id))} (${paint4("cyan", String(digest.rawMessages.length))} emails)`);
-    processing.add(digest.id);
-    processDigest(digest, agent).catch((err) => logErr(`${shortId2(digest.id)} failed: ${err.message}`)).finally(() => processing.delete(digest.id));
-  }
-  process.on("SIGINT", () => {
-    console.log(`
-${timestamp2()} ${digestTag()} Shutting down\u2026`);
-    process.exit(0);
-  });
-  await generateDigest();
-  await poll();
-  if (once) {
-    const wait = () => new Promise((resolve7) => {
-      if (processing.size === 0) return resolve7();
-      const check = setInterval(() => {
-        if (processing.size === 0) {
-          clearInterval(check);
-          resolve7();
-        }
-      }, 500);
-    });
-    await wait();
-  } else {
-    setInterval(poll, intervalMs);
-    setInterval(generateDigest, generateIntervalMs);
-  }
-});
-
-// cli/commands/up.ts
-import { Command as Command14 } from "commander";
-import { spawn as spawn6 } from "child_process";
-import { resolve as resolve2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var c5 = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  cyan: "\x1B[36m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  red: "\x1B[31m",
-  magenta: "\x1B[35m",
-  gray: "\x1B[90m"
-};
-function paint5(color, text) {
-  return `${c5[color]}${text}${c5.reset}`;
-}
-function timestamp3() {
-  return paint5("gray", (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false }));
-}
-function upTag() {
-  return paint5("cyan", "[up]");
-}
-function log2(msg) {
-  console.log(`${timestamp3()} ${upTag()} ${msg}`);
-}
-function logErr2(msg) {
-  console.error(`${timestamp3()} ${upTag()} ${paint5("red", "\u2717")} ${msg}`);
+  console.error(`${timestamp2()} ${upTag()} ${paint4("red", "\u2717")} ${msg}`);
 }
 function spawnMr(args) {
   const entry = process.argv[1];
-  const child = spawn6(process.execPath, [entry, ...args], {
+  const child = spawn5(process.execPath, [entry, ...args], {
     stdio: ["ignore", "pipe", "pipe"]
   });
   return child;
 }
-var upCommand = new Command14("up").description("Run mr watch and mr digest together with a single command").option("--interval <seconds>", "Polling interval for both watch and digest", "15").option("--watch-interval <seconds>", "Override polling interval for mr watch").option("--digest-interval <seconds>", "Override polling interval for mr digest").option("--dry-run", "Pass --dry-run to mr watch", false).option("--plan-approval", "Pass --plan-approval to mr watch", false).option("--root <dir>", "Pass --root to mr watch (default: cwd)").option("--agent <agent>", "AI agent to use: claude or codex", "claude").action((opts) => {
+var upCommand = new Command13("up").description("Run mr watch and mr digest together with a single command").option("--interval <seconds>", "Polling interval for both watch and digest", "15").option("--watch-interval <seconds>", "Override polling interval for mr watch").option("--digest-interval <seconds>", "Override polling interval for mr digest").option("--dry-run", "Pass --dry-run to mr watch", false).option("--plan-approval", "Pass --plan-approval to mr watch", false).option("--root <dir>", "Pass --root to mr watch (default: cwd)").option("--agent <agent>", "AI agent to use: claude or codex", "claude").action((opts) => {
   const watchInterval = opts.watchInterval ?? opts.interval;
   const digestInterval = opts.digestInterval ?? opts.interval;
   const agent = opts.agent === "codex" ? "codex" : "claude";
@@ -3238,21 +3036,21 @@ var upCommand = new Command14("up").description("Run mr watch and mr digest toge
   const digestArgs = ["digest", "--interval", digestInterval, "--agent", agent];
   const banner = [
     ``,
-    paint5("cyan", `  \u2554\u2566\u2557\u2566\u2550\u2557  \u2566 \u2566\u2554\u2550\u2557`),
-    paint5("magenta", `  \u2551\u2551\u2551\u2560\u2566\u255D  \u2551 \u2551\u2560\u2550\u255D`),
-    paint5("cyan", `  \u2569 \u2569\u2569\u255A\u2550  \u255A\u2550\u255D\u2569  `),
-    paint5("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
-    paint5("dim", `  mr watch + mr digest \xB7 powered by ${agent}`),
+    paint4("cyan", `  \u2554\u2566\u2557\u2566\u2550\u2557  \u2566 \u2566\u2554\u2550\u2557`),
+    paint4("magenta", `  \u2551\u2551\u2551\u2560\u2566\u255D  \u2551 \u2551\u2560\u2550\u255D`),
+    paint4("cyan", `  \u2569 \u2569\u2569\u255A\u2550  \u255A\u2550\u255D\u2569  `),
+    paint4("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
+    paint4("dim", `  mr watch + mr digest \xB7 powered by ${agent}`),
     ``
   ].join("\n");
   console.log(banner);
   const flags = [
-    `watch-interval=${paint5("cyan", watchInterval + "s")}`,
-    `digest-interval=${paint5("cyan", digestInterval + "s")}`,
-    `agent=${paint5("cyan", agent)}`,
-    ...opts.dryRun ? [paint5("yellow", "dry-run")] : [],
-    ...opts.planApproval ? [paint5("yellow", "plan-approval")] : [],
-    ...opts.root ? [`root=${paint5("cyan", resolve2(opts.root))}`] : []
+    `watch-interval=${paint4("cyan", watchInterval + "s")}`,
+    `digest-interval=${paint4("cyan", digestInterval + "s")}`,
+    `agent=${paint4("cyan", agent)}`,
+    ...opts.dryRun ? [paint4("yellow", "dry-run")] : [],
+    ...opts.planApproval ? [paint4("yellow", "plan-approval")] : [],
+    ...opts.root ? [`root=${paint4("cyan", resolve2(opts.root))}`] : []
   ].join("  ");
   console.log(`  ${flags}
 `);
@@ -3263,12 +3061,12 @@ var upCommand = new Command14("up").description("Run mr watch and mr digest toge
     proc.stderr?.on("data", (d) => process.stderr.write(d));
     proc.on("exit", (code, signal) => {
       if (signal !== "SIGTERM" && signal !== "SIGINT") {
-        logErr2(`mr ${label} exited unexpectedly (code=${code ?? "?"}, signal=${signal ?? "none"})`);
+        logErr(`mr ${label} exited unexpectedly (code=${code ?? "?"}, signal=${signal ?? "none"})`);
       }
     });
   }
   function shutdown() {
-    log2("Shutting down\u2026");
+    log("Shutting down\u2026");
     watchProc.kill("SIGTERM");
     digestProc.kill("SIGTERM");
     setTimeout(() => process.exit(0), 500);
@@ -3278,8 +3076,8 @@ var upCommand = new Command14("up").description("Run mr watch and mr digest toge
 });
 
 // cli/commands/prototype.ts
-import { Command as Command15 } from "commander";
-var c6 = {
+import { Command as Command14 } from "commander";
+var c5 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -3290,25 +3088,25 @@ var c6 = {
   blue: "\x1B[34m",
   gray: "\x1B[90m"
 };
-function paint6(color, text) {
-  return `${c6[color]}${text}${c6.reset}`;
+function paint5(color, text) {
+  return `${c5[color]}${text}${c5.reset}`;
 }
 function statusBadge(status) {
   switch (status) {
     case "pending":
-      return paint6("gray", "\u25CB pending");
+      return paint5("gray", "\u25CB pending");
     case "in_progress":
-      return paint6("cyan", "\u27F3 in_progress");
+      return paint5("cyan", "\u27F3 in_progress");
     case "completed":
-      return paint6("green", "\u2713 completed");
+      return paint5("green", "\u2713 completed");
     case "failed":
-      return paint6("red", "\u2717 failed");
+      return paint5("red", "\u2717 failed");
     default:
-      return paint6("gray", status);
+      return paint5("gray", status);
   }
 }
-var prototypeCommand = new Command15("prototype").description("Manage prototypes").addCommand(
-  new Command15("list").description("List prototypes for the linked project").option("--all", "Show prototypes for all projects").action(async (opts) => {
+var prototypeCommand = new Command14("prototype").description("Manage prototypes").addCommand(
+  new Command14("list").description("List prototypes for the linked project").option("--all", "Show prototypes for all projects").action(async (opts) => {
     const params = new URLSearchParams();
     if (!opts.all) {
       const projectId = getLinkedProjectId();
@@ -3320,21 +3118,21 @@ var prototypeCommand = new Command15("prototype").description("Manage prototypes
     }
     const prototypes = await api.get(`/api/prototypes?${params.toString()}`);
     if (prototypes.length === 0) {
-      console.log(paint6("gray", "No prototypes found."));
+      console.log(paint5("gray", "No prototypes found."));
       return;
     }
     console.log();
     for (const p of prototypes) {
       const date = new Date(p.createdAt).toLocaleDateString();
       console.log(
-        `  ${paint6("bold", p.title)}  ${statusBadge(p.status)}  ${paint6("gray", p.id.slice(0, 8))}  ${paint6("dim", date)}`
+        `  ${paint5("bold", p.title)}  ${statusBadge(p.status)}  ${paint5("gray", p.id.slice(0, 8))}  ${paint5("dim", date)}`
       );
-      console.log(`  ${paint6("dim", p.prompt.slice(0, 80) + (p.prompt.length > 80 ? "\u2026" : ""))}`);
+      console.log(`  ${paint5("dim", p.prompt.slice(0, 80) + (p.prompt.length > 80 ? "\u2026" : ""))}`);
       console.log();
     }
   })
 ).addCommand(
-  new Command15("create").description("Create a new prototype").argument("<title>", "Title of the prototype").requiredOption("--prompt <prompt>", "Design description / prompt").option("--project <projectId>", "Project ID (defaults to linked project)").option("--variants <count>", "Number of variants to generate (1-50)", "5").action(async (title, opts) => {
+  new Command14("create").description("Create a new prototype").argument("<title>", "Title of the prototype").requiredOption("--prompt <prompt>", "Design description / prompt").option("--project <projectId>", "Project ID (defaults to linked project)").option("--variants <count>", "Number of variants to generate (1-50)", "5").action(async (title, opts) => {
     const projectId = opts.project ?? getLinkedProjectId();
     if (!projectId) {
       console.error('No project linked. Run "mr link <project-id>" or use --project.');
@@ -3348,37 +3146,37 @@ var prototypeCommand = new Command15("prototype").description("Manage prototypes
       projectId
     });
     console.log();
-    console.log(`  ${paint6("green", "\u2713")} Created prototype: ${paint6("bold", prototype.title)}`);
-    console.log(`  ${paint6("gray", "ID:")} ${prototype.id}`);
-    console.log(`  ${paint6("cyan", "\u27F3")} Generation will begin automatically via the watch agent.`);
+    console.log(`  ${paint5("green", "\u2713")} Created prototype: ${paint5("bold", prototype.title)}`);
+    console.log(`  ${paint5("gray", "ID:")} ${prototype.id}`);
+    console.log(`  ${paint5("cyan", "\u27F3")} Generation will begin automatically via the watch agent.`);
     console.log();
   })
 ).addCommand(
-  new Command15("start").description("Start prototype generation (sets status to in_progress)").argument("<id>", "Prototype ID").action(async (id) => {
+  new Command14("start").description("Start prototype generation (sets status to in_progress)").argument("<id>", "Prototype ID").action(async (id) => {
     const prototype = await api.patch(`/api/prototypes/${id}`, {
       status: "in_progress"
     });
     console.log();
-    console.log(`  ${paint6("cyan", "\u27F3")} Started: ${paint6("bold", prototype.title)}`);
-    console.log(`  ${paint6("gray", "The watch agent will pick this up shortly.")}`);
+    console.log(`  ${paint5("cyan", "\u27F3")} Started: ${paint5("bold", prototype.title)}`);
+    console.log(`  ${paint5("gray", "The watch agent will pick this up shortly.")}`);
     console.log();
   })
 ).addCommand(
-  new Command15("retry").description("Retry a failed prototype").argument("<id>", "Prototype ID").action(async (id) => {
+  new Command14("retry").description("Retry a failed prototype").argument("<id>", "Prototype ID").action(async (id) => {
     const prototype = await api.patch(`/api/prototypes/${id}`, {
       status: "in_progress",
       files: null
     });
     console.log();
-    console.log(`  ${paint6("cyan", "\u27F3")} Retrying: ${paint6("bold", prototype.title)}`);
+    console.log(`  ${paint5("cyan", "\u27F3")} Retrying: ${paint5("bold", prototype.title)}`);
     console.log();
   })
 );
 
 // cli/commands/setup.ts
-import { Command as Command16 } from "commander";
+import { Command as Command15 } from "commander";
 import { exec as exec2 } from "child_process";
-var c7 = {
+var c6 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -3389,8 +3187,8 @@ var c7 = {
   magenta: "\x1B[35m",
   gray: "\x1B[90m"
 };
-function paint7(color, text) {
-  return `${c7[color]}${text}${c7.reset}`;
+function paint6(color, text) {
+  return `${c6[color]}${text}${c6.reset}`;
 }
 function commandExists(cmd) {
   return new Promise((resolve7) => {
@@ -3634,60 +3432,60 @@ async function checkApiConnectivity() {
   }
 }
 function printResults(checks) {
-  const maxNameLen = Math.max(...checks.map((c12) => c12.name.length));
+  const maxNameLen = Math.max(...checks.map((c11) => c11.name.length));
   let allOk = true;
   for (const check of checks) {
     const isOptional = check.optional ?? false;
-    const icon = check.ok ? paint7("green", "\u2713") : isOptional ? paint7("yellow", "\u25CB") : paint7("red", "\u2717");
+    const icon = check.ok ? paint6("green", "\u2713") : isOptional ? paint6("yellow", "\u25CB") : paint6("red", "\u2717");
     const name = check.name.padEnd(maxNameLen);
-    const msg = check.ok ? paint7("green", check.message) : isOptional ? paint7("yellow", check.message) : paint7("red", check.message);
+    const msg = check.ok ? paint6("green", check.message) : isOptional ? paint6("yellow", check.message) : paint6("red", check.message);
     console.log(`  ${icon}  ${name}  ${msg}`);
     if (!check.ok && !isOptional) allOk = false;
   }
   return allOk;
 }
 async function autoFix(checks, agent) {
-  const { spawn: spawn10 } = await import("child_process");
-  const ghInstalled = checks.find((c12) => c12.name === "GitHub CLI (gh)").ok;
-  const ghAuthed = checks.find((c12) => c12.name === "GitHub CLI auth").ok;
-  const mrAuthed = checks.find((c12) => c12.name === "Mr. Manager CLI auth").ok;
-  const claudeCheck = checks.find((c12) => c12.name === "Claude Code (claude)");
+  const { spawn: spawn9 } = await import("child_process");
+  const ghInstalled = checks.find((c11) => c11.name === "GitHub CLI (gh)").ok;
+  const ghAuthed = checks.find((c11) => c11.name === "GitHub CLI auth").ok;
+  const mrAuthed = checks.find((c11) => c11.name === "Mr. Manager CLI auth").ok;
+  const claudeCheck = checks.find((c11) => c11.name === "Claude Code (claude)");
   if (claudeCheck && !claudeCheck.ok && agent === "claude") {
-    console.log(paint7("cyan", "  Installing Claude Code..."));
-    console.log(paint7("dim", "  Running: curl -fsSL https://claude.ai/install.sh | bash"));
+    console.log(paint6("cyan", "  Installing Claude Code..."));
+    console.log(paint6("dim", "  Running: curl -fsSL https://claude.ai/install.sh | bash"));
     await new Promise((resolve7) => {
-      const child = spawn10("bash", ["-c", "curl -fsSL https://claude.ai/install.sh | bash"], { stdio: "inherit" });
+      const child = spawn9("bash", ["-c", "curl -fsSL https://claude.ai/install.sh | bash"], { stdio: "inherit" });
       child.on("exit", () => resolve7());
     });
     console.log("");
   }
   if (ghInstalled && !ghAuthed) {
-    console.log(paint7("cyan", "  Running gh auth login..."));
+    console.log(paint6("cyan", "  Running gh auth login..."));
     await new Promise((resolve7) => {
-      const child = spawn10("gh", ["auth", "login"], { stdio: "inherit" });
+      const child = spawn9("gh", ["auth", "login"], { stdio: "inherit" });
       child.on("exit", () => resolve7());
     });
     console.log("");
   }
   if (!mrAuthed) {
-    console.log(paint7("cyan", "  Running mr login..."));
+    console.log(paint6("cyan", "  Running mr login..."));
     const entry = process.argv[1];
     await new Promise((resolve7) => {
-      const child = spawn10(process.execPath, [entry, "login"], { stdio: "inherit" });
+      const child = spawn9(process.execPath, [entry, "login"], { stdio: "inherit" });
       child.on("exit", () => resolve7());
     });
     console.log("");
   }
 }
-var setupCommand = new Command16("setup").description("Check that all dependencies for mr watch are installed and configured").option("--fix", "Attempt to auto-fix issues where possible", false).option("--agent <agent>", "AI agent to check: claude, codex, or gemini (default: claude)", "claude").action(async (opts) => {
+var setupCommand = new Command15("setup").description("Check that all dependencies for mr watch are installed and configured").option("--fix", "Attempt to auto-fix issues where possible", false).option("--agent <agent>", "AI agent to check: claude, codex, or gemini (default: claude)", "claude").action(async (opts) => {
   const agent = opts.agent === "codex" ? "codex" : opts.agent === "gemini" ? "gemini" : "claude";
   const banner = [
     ``,
-    paint7("cyan", `  \u2554\u2566\u2557\u2551\u2550\u2557  \u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2566\u2557\u2551 \u2551\u2554\u2550\u2557`),
-    paint7("magenta", `  \u2551\u2551\u2551\u2560\u2566\u2563  \u255A\u2550\u2557\u2551\u2563  \u2551 \u2551 \u2551\u2560\u2550\u2563`),
-    paint7("cyan", `  \u2569 \u2569\u2569\u255A\u2550  \u255A\u2550\u255D\u255A\u2550\u255D \u2569 \u255A\u2550\u255D\u2569  `),
-    paint7("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
-    paint7("dim", `  environment check for mr watch (agent: ${agent})`),
+    paint6("cyan", `  \u2554\u2566\u2557\u2551\u2550\u2557  \u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2566\u2557\u2551 \u2551\u2554\u2550\u2557`),
+    paint6("magenta", `  \u2551\u2551\u2551\u2560\u2566\u2563  \u255A\u2550\u2557\u2551\u2563  \u2551 \u2551 \u2551\u2560\u2550\u2563`),
+    paint6("cyan", `  \u2569 \u2569\u2569\u255A\u2550  \u255A\u2550\u255D\u255A\u2550\u255D \u2569 \u255A\u2550\u255D\u2569  `),
+    paint6("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
+    paint6("dim", `  environment check for mr watch (agent: ${agent})`),
     ``
   ].join("\n");
   console.log(banner);
@@ -3707,18 +3505,18 @@ var setupCommand = new Command16("setup").description("Check that all dependenci
   const allOk = printResults(checks);
   console.log("");
   if (allOk) {
-    console.log(paint7("green", "  All checks passed! You're ready to run mr watch."));
+    console.log(paint6("green", "  All checks passed! You're ready to run mr watch."));
     if (agent === "claude") {
-      console.log(paint7("dim", "  Tip: check other agents with --agent codex or --agent gemini"));
+      console.log(paint6("dim", "  Tip: check other agents with --agent codex or --agent gemini"));
     }
     console.log("");
     return;
   }
-  const fixes = checks.filter((c12) => !c12.ok && c12.fix && !c12.optional);
+  const fixes = checks.filter((c11) => !c11.ok && c11.fix && !c11.optional);
   if (fixes.length > 0) {
-    console.log(paint7("yellow", "  To fix:"));
+    console.log(paint6("yellow", "  To fix:"));
     for (const fix of fixes) {
-      console.log(`  ${paint7("dim", "\u2192")} ${paint7("bold", fix.name)}: ${fix.fix}`);
+      console.log(`  ${paint6("dim", "\u2192")} ${paint6("bold", fix.name)}: ${fix.fix}`);
     }
     console.log("");
   }
@@ -3729,8 +3527,8 @@ var setupCommand = new Command16("setup").description("Check that all dependenci
 });
 
 // cli/commands/update.ts
-import { Command as Command17 } from "commander";
-var updateCommand = new Command17("update").description("Post a status update to a task (used by agents to report progress)").argument("<task-id>", "Task ID").argument("<message>", "Status update message").option("--source <source>", "Update source: agent, system, or user", "agent").action(async (taskId, message, opts) => {
+import { Command as Command16 } from "commander";
+var updateCommand = new Command16("update").description("Post a status update to a task (used by agents to report progress)").argument("<task-id>", "Task ID").argument("<message>", "Status update message").option("--source <source>", "Update source: agent, system, or user", "agent").action(async (taskId, message, opts) => {
   await api.post(`/api/tasks/${taskId}/updates`, {
     message,
     source: opts.source
@@ -3739,11 +3537,11 @@ var updateCommand = new Command17("update").description("Post a status update to
 });
 
 // cli/commands/screenshot.ts
-import { Command as Command18 } from "commander";
+import { Command as Command17 } from "commander";
 import { readFileSync as readFileSync6, existsSync as existsSync7, unlinkSync as unlinkSync2 } from "fs";
 import { join as join8 } from "path";
 import { tmpdir } from "os";
-var screenshotCommand = new Command18("screenshot").description(
+var screenshotCommand = new Command17("screenshot").description(
   "Take or attach a screenshot to a task update (agents use this to show their work)"
 ).argument("<task-id>", "Task ID").argument("[file]", "Path to an image file (if omitted, uses headless browser to screenshot the app)").option("-m, --message <message>", "Optional message to include with the screenshot").option("-u, --url <url>", "Custom URL to screenshot (defaults to the task's project page)").action(async (taskId, file, opts) => {
   let filePath = file;
@@ -3834,10 +3632,10 @@ var screenshotCommand = new Command18("screenshot").description(
 });
 
 // cli/commands/resume.ts
-import { Command as Command19 } from "commander";
-import { spawn as spawn7 } from "child_process";
+import { Command as Command18 } from "commander";
+import { spawn as spawn6 } from "child_process";
 import { resolve as resolve3 } from "path";
-var c8 = {
+var c7 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -3848,15 +3646,15 @@ var c8 = {
   magenta: "\x1B[35m",
   gray: "\x1B[90m"
 };
-function paint8(color, text) {
-  return `${c8[color]}${text}${c8.reset}`;
+function paint7(color, text) {
+  return `${c7[color]}${text}${c7.reset}`;
 }
-var resumeCommand = new Command19("resume").description("Resume an interactive Claude session for a task (non-headless)").argument("<task-id>", "Task ID whose Claude session to resume").option("--dir <directory>", "Override the working directory for the session").action(async (taskId, opts) => {
+var resumeCommand = new Command18("resume").description("Resume an interactive Claude session for a task (non-headless)").argument("<task-id>", "Task ID whose Claude session to resume").option("--dir <directory>", "Override the working directory for the session").action(async (taskId, opts) => {
   const task = await api.get(`/api/tasks/${taskId}`);
   if (!task.claudeSessionId) {
     console.error(
       `
-  ${paint8("red", "\u2717")} No Claude session found for task ${paint8("dim", taskId.slice(0, 8))}`
+  ${paint7("red", "\u2717")} No Claude session found for task ${paint7("dim", taskId.slice(0, 8))}`
     );
     console.error(
       `    The task may not have been dispatched yet.
@@ -3867,16 +3665,16 @@ var resumeCommand = new Command19("resume").description("Resume an interactive C
   if (task.status === "completed" || task.status === "todo") {
     console.error(
       `
-  ${paint8("yellow", "\u26A0")} Task ${paint8("dim", taskId.slice(0, 8))} has already completed.`
+  ${paint7("yellow", "\u26A0")} Task ${paint7("dim", taskId.slice(0, 8))} has already completed.`
     );
     console.error(
-      `    Session ID: ${paint8("cyan", task.claudeSessionId)}`
+      `    Session ID: ${paint7("cyan", task.claudeSessionId)}`
     );
     console.error(
       `    View the session log in the Mr. Manager web UI, or run:`
     );
     console.error(
-      `    ${paint8("dim", `claude --resume ${task.claudeSessionId}`)}
+      `    ${paint7("dim", `claude --resume ${task.claudeSessionId}`)}
 `
     );
     process.exit(0);
@@ -3895,16 +3693,16 @@ var resumeCommand = new Command19("resume").description("Resume an interactive C
   const sid = taskId.slice(0, 8);
   console.log([
     ``,
-    paint8("magenta", `  \u2554\u2566\u2557\u2566\u2550\u2557  `) + paint8("bold", "resume"),
-    paint8("magenta", `  \u2551\u2551\u2551\u2560\u2566\u255D  `) + paint8("dim", "\u2500".repeat(44)),
-    paint8("magenta", `  \u2569 \u2569\u2569\u255A\u2550  `) + task.title,
-    `           ${paint8("gray", sid)}`,
+    paint7("magenta", `  \u2554\u2566\u2557\u2566\u2550\u2557  `) + paint7("bold", "resume"),
+    paint7("magenta", `  \u2551\u2551\u2551\u2560\u2566\u255D  `) + paint7("dim", "\u2500".repeat(44)),
+    paint7("magenta", `  \u2569 \u2569\u2569\u255A\u2550  `) + task.title,
+    `           ${paint7("gray", sid)}`,
     ``,
-    `  ${paint8("dim", "session")}  ${paint8("cyan", task.claudeSessionId)}`,
-    `  ${paint8("dim", "cwd")}      ${paint8("cyan", cwd)}`,
+    `  ${paint7("dim", "session")}  ${paint7("cyan", task.claudeSessionId)}`,
+    `  ${paint7("dim", "cwd")}      ${paint7("cyan", cwd)}`,
     ``
   ].join("\n"));
-  const child = spawn7("claude", ["--resume", task.claudeSessionId], {
+  const child = spawn6("claude", ["--resume", task.claudeSessionId], {
     cwd,
     stdio: "inherit"
   });
@@ -3913,15 +3711,15 @@ var resumeCommand = new Command19("resume").description("Resume an interactive C
   });
   child.on("error", (err) => {
     console.error(`
-  ${paint8("red", "\u2717")} Failed to launch Claude: ${err.message}
+  ${paint7("red", "\u2717")} Failed to launch Claude: ${err.message}
 `);
     process.exit(1);
   });
 });
 
 // cli/commands/browse.ts
-import { Command as Command20 } from "commander";
-import { execSync as execSync5, spawn as spawn8 } from "child_process";
+import { Command as Command19 } from "commander";
+import { execSync as execSync5, spawn as spawn7 } from "child_process";
 import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import { join as join9 } from "path";
 var BROWSE_DIR2 = join9(import.meta.dirname, "..", "..", "browse");
@@ -3962,7 +3760,7 @@ async function ensureDevServer() {
   }
   const port = await findAvailablePort2(3e3);
   console.log(`[browse] Starting dev server on port ${port}...`);
-  const devProc = spawn8("npm", ["run", "dev", "--", "--port", String(port)], {
+  const devProc = spawn7("npm", ["run", "dev", "--", "--port", String(port)], {
     stdio: ["ignore", "pipe", "pipe"],
     detached: true,
     cwd: join9(import.meta.dirname, "..", ".."),
@@ -3984,7 +3782,7 @@ async function ensureDevServer() {
   }
   throw new Error("Dev server failed to start within 30s");
 }
-var browseCommand = new Command20("browse").description("Control a headless browser for QA and testing").argument("[command]", "Browse command (goto, click, fill, screenshot, etc.)").argument("[args...]", "Command arguments").option(
+var browseCommand = new Command19("browse").description("Control a headless browser for QA and testing").argument("[command]", "Browse command (goto, click, fill, screenshot, etc.)").argument("[args...]", "Command arguments").option(
   "--task-id <id>",
   "Attach screenshot to a task update (only for screenshot command)"
 ).option("--dev", "Auto-start local dev server before browsing").allowUnknownOption(true).action(
@@ -4067,10 +3865,10 @@ var browseCommand = new Command20("browse").description("Control a headless brow
 );
 
 // cli/commands/set-path.ts
-import { Command as Command21 } from "commander";
+import { Command as Command20 } from "commander";
 import { resolve as resolve4 } from "path";
 import { existsSync as existsSync9 } from "fs";
-var setPathCommand = new Command21("set-path").description("Set or update the local repo path for a project").argument("<project-id>", "Project ID").argument("<path>", "Absolute or relative path to the local repo").action(async (projectId, pathArg) => {
+var setPathCommand = new Command20("set-path").description("Set or update the local repo path for a project").argument("<project-id>", "Project ID").argument("<path>", "Absolute or relative path to the local repo").action(async (projectId, pathArg) => {
   const absolutePath = resolve4(pathArg);
   if (!existsSync9(absolutePath)) {
     console.error(`Error: Path does not exist: ${absolutePath}`);
@@ -4088,9 +3886,9 @@ var setPathCommand = new Command21("set-path").description("Set or update the lo
 });
 
 // cli/commands/test.ts
-import { Command as Command22 } from "commander";
+import { Command as Command21 } from "commander";
 import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
-var testCommand = new Command22("test").description("Run automated browser test for a task's MR/PR").argument("<task-id>", "Task ID to test").option("--plan <file>", "Path to a custom test plan JSON file").action(async (taskId, opts) => {
+var testCommand = new Command21("test").description("Run automated browser test for a task's MR/PR").argument("<task-id>", "Task ID to test").option("--plan <file>", "Path to a custom test plan JSON file").action(async (taskId, opts) => {
   const config = loadConfig();
   console.log("[test] Fetching task...");
   let task;
@@ -4210,11 +4008,11 @@ var testCommand = new Command22("test").description("Run automated browser test
 });
 
 // cli/commands/features.ts
-import { Command as Command23 } from "commander";
+import { Command as Command22 } from "commander";
 import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync11 } from "fs";
 import { resolve as resolve5, sep as sep2 } from "path";
 var FEATURES_FILE3 = ".mr-features.md";
-var c9 = {
+var c8 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -4224,8 +4022,8 @@ var c9 = {
   magenta: "\x1B[35m",
   gray: "\x1B[90m"
 };
-function paint9(color, text) {
-  return `${c9[color]}${text}${c9.reset}`;
+function paint8(color, text) {
+  return `${c8[color]}${text}${c8.reset}`;
 }
 function resolveProjectRoot2() {
   const cwd = process.cwd();
@@ -4244,7 +4042,7 @@ function readFeatures2() {
   if (!existsSync11(path)) return null;
   return readFileSync9(path, "utf-8");
 }
-var featuresCommand = new Command23("features").description("View or update the project features & goals document (.mr-features.md)").option("--update <content>", "Replace the features document with the given content").option("--file <path>", "Read content from a file and use it to update the features document").option("--path", "Print the path to the features file").action(async (opts) => {
+var featuresCommand = new Command22("features").description("View or update the project features & goals document (.mr-features.md)").option("--update <content>", "Replace the features document with the given content").option("--file <path>", "Read content from a file and use it to update the features document").option("--path", "Print the path to the features file").action(async (opts) => {
   if (opts.path) {
     console.log(getFeaturesPath());
     return;
@@ -4253,30 +4051,30 @@ var featuresCommand = new Command23("features").description("View or update the
     const content2 = readFileSync9(resolve5(opts.file), "utf-8");
     const featuresPath = getFeaturesPath();
     writeFileSync5(featuresPath, content2);
-    console.log(`${paint9("green", "\u2713")} Updated ${paint9("cyan", featuresPath)} from ${paint9("cyan", opts.file)}`);
+    console.log(`${paint8("green", "\u2713")} Updated ${paint8("cyan", featuresPath)} from ${paint8("cyan", opts.file)}`);
     return;
   }
   if (opts.update) {
     const featuresPath = getFeaturesPath();
     writeFileSync5(featuresPath, opts.update);
-    console.log(`${paint9("green", "\u2713")} Updated ${paint9("cyan", featuresPath)}`);
+    console.log(`${paint8("green", "\u2713")} Updated ${paint8("cyan", featuresPath)}`);
     return;
   }
   const content = readFeatures2();
   if (!content) {
-    console.log(paint9("dim", `No features document found. One will be created when an agent completes a task.`));
-    console.log(paint9("dim", `Path: ${getFeaturesPath()}`));
+    console.log(paint8("dim", `No features document found. One will be created when an agent completes a task.`));
+    console.log(paint8("dim", `Path: ${getFeaturesPath()}`));
     return;
   }
   console.log(content);
 });
 
 // cli/commands/no-mr.ts
-import { Command as Command24 } from "commander";
+import { Command as Command23 } from "commander";
 import { writeFileSync as writeFileSync6 } from "fs";
 import { resolve as resolve6 } from "path";
 var NO_MR_FILE = ".mr-no-mr";
-var noMrCommand = new Command24("no-mr").description("Signal that a task does not require a merge/pull request and describe what was done instead").argument("<task-id>", "Task ID").argument("<description>", "Description of what was done instead of creating an MR/PR").action(async (taskId, description) => {
+var noMrCommand = new Command23("no-mr").description("Signal that a task does not require a merge/pull request and describe what was done instead").argument("<task-id>", "Task ID").argument("<description>", "Description of what was done instead of creating an MR/PR").action(async (taskId, description) => {
   const filePath = resolve6(process.cwd(), NO_MR_FILE);
   writeFileSync6(filePath, description, "utf-8");
   await api.post(`/api/tasks/${taskId}/updates`, {
@@ -4288,8 +4086,8 @@ var noMrCommand = new Command24("no-mr").description("Signal that a task does no
 });
 
 // cli/commands/mobile.ts
-import { Command as Command25 } from "commander";
-function paint10(color, text) {
+import { Command as Command24 } from "commander";
+function paint9(color, text) {
   const colors = {
     cyan: "\x1B[36m",
     green: "\x1B[32m",
@@ -4300,7 +4098,7 @@ function paint10(color, text) {
   };
   return `${colors[color] ?? ""}${text}${colors.reset}`;
 }
-var mobileCommand = new Command25("mobile").description(
+var mobileCommand = new Command24("mobile").description(
   "Start the Web-to-Mobile Conversion Wizard for the linked project"
 ).argument("[project-id]", "Project ID (defaults to linked project)").option("--framework <framework>", "Framework: react-native or native").option("--url <url>", "Web app URL for analysis").action(
   async (projectIdArg, opts) => {
@@ -4312,7 +4110,7 @@ var mobileCommand = new Command25("mobile").description(
       process.exit(1);
     }
     console.log(
-      paint10("cyan", "mobile") + paint10("dim", " \u2014 starting conversion wizard")
+      paint9("cyan", "mobile") + paint9("dim", " \u2014 starting conversion wizard")
     );
     const task = await api.post("/api/tasks", {
       title: "Convert to Mobile App",
@@ -4343,13 +4141,13 @@ var mobileCommand = new Command25("mobile").description(
     }
     console.log(
       `
-  ${paint10("green", "\u2713")} Wizard initialized. Open the web UI to continue:
+  ${paint9("green", "\u2713")} Wizard initialized. Open the web UI to continue:
     \u2192 Task ID: ${task.id}
     \u2192 Use the "Convert to Mobile" button on the project page`
     );
   }
 );
-var statusSubcommand = new Command25("status").description("Show mobile conversion status for a task").argument("<task-id>", "Parent conversion task ID").action(async (taskId) => {
+var statusSubcommand = new Command24("status").description("Show mobile conversion status for a task").argument("<task-id>", "Parent conversion task ID").action(async (taskId) => {
   const resources = await api.get(
     `/api/tasks/${taskId}/resources`
   );
@@ -4362,7 +4160,7 @@ var statusSubcommand = new Command25("status").description("Show mobile conversi
   }
   try {
     const state = JSON.parse(wizardState.content);
-    console.log(paint10("cyan", "Mobile Conversion Status"));
+    console.log(paint9("cyan", "Mobile Conversion Status"));
     console.log(`  Phase: ${state.phase}`);
     if (state.framework) {
       console.log(`  Framework: ${state.framework}`);
@@ -4385,10 +4183,10 @@ var statusSubcommand = new Command25("status").description("Show mobile conversi
 mobileCommand.addCommand(statusSubcommand);
 
 // cli/commands/scan.ts
-import { Command as Command26 } from "commander";
+import { Command as Command25 } from "commander";
 
 // lib/scanner/index.ts
-import { spawn as spawn9 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 
 // lib/scanner/config.ts
 import { readFileSync as readFileSync10, existsSync as existsSync12 } from "fs";
@@ -4854,10 +4652,10 @@ ${codebaseAnalysis.routes.map((r) => `- ${r}`).join("\n")}
 ${codebaseAnalysis.prismaModels.map((m) => `- ${m}`).join("\n")}
 
 **Components:**
-${codebaseAnalysis.components.slice(0, 30).map((c12) => `- ${c12}`).join("\n")}
+${codebaseAnalysis.components.slice(0, 30).map((c11) => `- ${c11}`).join("\n")}
 
 **Recent Git Commits:**
-${codebaseAnalysis.recentCommits.slice(0, 15).map((c12) => `- ${c12}`).join("\n")}
+${codebaseAnalysis.recentCommits.slice(0, 15).map((c11) => `- ${c11}`).join("\n")}
 
 **Completed Tasks:**
 ${context.completedTasks.slice(0, 20).map((t) => `- ${t.title}`).join("\n") || "None"}
@@ -5067,7 +4865,7 @@ async function fetchScanContext(opts) {
 }
 function runClaude(prompt2) {
   return new Promise((resolve7, reject) => {
-    const child = spawn9("claude", ["-p", "--dangerously-skip-permissions", prompt2], {
+    const child = spawn8("claude", ["-p", "--dangerously-skip-permissions", prompt2], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let output = "";
@@ -5123,7 +4921,7 @@ function parseSynthesisOutput(output) {
 }
 
 // cli/commands/scan.ts
-var c10 = {
+var c9 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -5134,53 +4932,53 @@ var c10 = {
   magenta: "\x1B[35m",
   gray: "\x1B[90m"
 };
-function paint11(color, text) {
-  return `${c10[color]}${text}${c10.reset}`;
+function paint10(color, text) {
+  return `${c9[color]}${text}${c9.reset}`;
 }
-function timestamp4() {
-  return paint11("gray", (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false }));
+function timestamp3() {
+  return paint10("gray", (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false }));
 }
 function scanTag() {
-  return paint11("magenta", "[scan]");
+  return paint10("magenta", "[scan]");
 }
-function log3(msg) {
-  console.log(`${timestamp4()} ${scanTag()} ${msg}`);
+function log2(msg) {
+  console.log(`${timestamp3()} ${scanTag()} ${msg}`);
 }
-function logOk2(msg) {
-  console.log(`${timestamp4()} ${scanTag()} ${paint11("green", "\u2713")} ${msg}`);
+function logOk(msg) {
+  console.log(`${timestamp3()} ${scanTag()} ${paint10("green", "\u2713")} ${msg}`);
 }
-function logErr3(msg) {
-  console.error(`${timestamp4()} ${scanTag()} ${paint11("red", "\u2717")} ${msg}`);
+function logErr2(msg) {
+  console.error(`${timestamp3()} ${scanTag()} ${paint10("red", "\u2717")} ${msg}`);
 }
-var scanCommand = new Command26("scan").description("Run a product scan on the current project \u2014 analyzes codebase, crawls the app, and surfaces findings").option("--project <id>", "Project ID (defaults to linked project)").option("--report <id>", "Use an existing scan report ID (created by UI trigger)").option("--no-crawl", "Skip live crawl (codebase analysis only)").action(async (opts) => {
+var scanCommand = new Command25("scan").description("Run a product scan on the current project \u2014 analyzes codebase, crawls the app, and surfaces findings").option("--project <id>", "Project ID (defaults to linked project)").option("--report <id>", "Use an existing scan report ID (created by UI trigger)").option("--no-crawl", "Skip live crawl (codebase analysis only)").action(async (opts) => {
   const config = loadConfig();
   if (!config.apiKey) {
-    logErr3('Not authenticated. Run "mr login" first.');
+    logErr2('Not authenticated. Run "mr login" first.');
     process.exit(1);
   }
   const banner = [
     ``,
-    paint11("magenta", `  \u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2557\u2554`),
-    paint11("magenta", `  \u255A\u2550\u2557\u2551  \u2560\u2550\u2563\u2551\u2551\u2551`),
-    paint11("magenta", `  \u255A\u2550\u255D\u255A\u2550\u255D\u2569 \u2569\u255D\u255A\u255D`),
-    paint11("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
-    paint11("dim", `  autonomous product scanner`),
+    paint10("magenta", `  \u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2557\u2554`),
+    paint10("magenta", `  \u255A\u2550\u2557\u2551  \u2560\u2550\u2563\u2551\u2551\u2551`),
+    paint10("magenta", `  \u255A\u2550\u255D\u255A\u2550\u255D\u2569 \u2569\u255D\u255A\u255D`),
+    paint10("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
+    paint10("dim", `  autonomous product scanner`),
     ``
   ].join("\n");
   console.log(banner);
   const projectId = opts.project || getLinkedProjectId();
   if (!projectId) {
-    logErr3('No project linked. Run "mr link" or pass --project <id>.');
+    logErr2('No project linked. Run "mr link" or pass --project <id>.');
     process.exit(1);
   }
   let project;
   try {
     project = await api.get(`/api/projects/${projectId}`);
   } catch {
-    logErr3(`Failed to fetch project ${projectId}`);
+    logErr2(`Failed to fetch project ${projectId}`);
     process.exit(1);
   }
-  log3(`Scanning project: ${paint11("cyan", project.name)}`);
+  log2(`Scanning project: ${paint10("cyan", project.name)}`);
   let projectPath = project.localPath;
   if (!projectPath) {
     for (const [dir, pid] of Object.entries(config.directories)) {
@@ -5196,12 +4994,12 @@ var scanCommand = new Command26("scan").description("Run a product scan on the c
   let reportId;
   if (opts.report) {
     reportId = opts.report;
-    log3(`Using existing scan report ${paint11("yellow", reportId.slice(0, 8))}`);
+    log2(`Using existing scan report ${paint10("yellow", reportId.slice(0, 8))}`);
   } else {
     try {
       const scans = await api.get(`/api/scans?projectId=${projectId}&status=processing`);
       if (scans.length > 0) {
-        logErr3("A scan is already in progress for this project. Wait for it to complete.");
+        logErr2("A scan is already in progress for this project. Wait for it to complete.");
         process.exit(1);
       }
     } catch {
@@ -5212,9 +5010,9 @@ var scanCommand = new Command26("scan").description("Run a product scan on the c
         status: "pending"
       });
       reportId = report.id;
-      log3(`Created scan report ${paint11("yellow", reportId.slice(0, 8))}`);
+      log2(`Created scan report ${paint10("yellow", reportId.slice(0, 8))}`);
     } catch (err) {
-      logErr3(`Failed to create scan report: ${err.message}`);
+      logErr2(`Failed to create scan report: ${err.message}`);
       process.exit(1);
     }
   }
@@ -5225,7 +5023,7 @@ var scanCommand = new Command26("scan").description("Run a product scan on the c
   try {
     const current = await api.get(`/api/scans/${reportId}`);
     if (current.status === "cancelled") {
-      log3(paint11("yellow", "Scan was cancelled \u2014 aborting."));
+      log2(paint10("yellow", "Scan was cancelled \u2014 aborting."));
       process.exit(0);
     }
   } catch {
@@ -5239,9 +5037,9 @@ var scanCommand = new Command26("scan").description("Run a product scan on the c
       apiUrl: config.apiUrl,
       apiKey: config.apiKey,
       runBrowse: runBrowseCommand2,
-      onLog: log3,
+      onLog: log2,
       onProgress: (phase, detail) => {
-        log3(`${paint11("dim", `[${phase}]`)} ${detail}`);
+        log2(`${paint10("dim", `[${phase}]`)} ${detail}`);
       }
     });
     let wasCancelled = false;
@@ -5253,7 +5051,7 @@ var scanCommand = new Command26("scan").description("Run a product scan on the c
     } catch {
     }
     if (wasCancelled) {
-      log3(paint11("yellow", "Scan was cancelled by user \u2014 discarding results."));
+      log2(paint10("yellow", "Scan was cancelled by user \u2014 discarding results."));
       process.exit(0);
     }
     await api.patch(`/api/scans/${reportId}`, {
@@ -5264,37 +5062,37 @@ var scanCommand = new Command26("scan").description("Run a product scan on the c
       scanDurationMs: result.scanDurationMs,
       routesCrawled: result.routesCrawled
     });
-    logOk2(`Scan complete \u2014 ${paint11("cyan", String(result.findings.length))} findings`);
+    logOk(`Scan complete \u2014 ${paint10("cyan", String(result.findings.length))} findings`);
     console.log("");
-    console.log(`  ${paint11("bold", "Summary:")} ${result.summary}`);
+    console.log(`  ${paint10("bold", "Summary:")} ${result.summary}`);
     console.log("");
     const high = result.findings.filter((f) => f.priority === "high");
     const medium = result.findings.filter((f) => f.priority === "medium");
     const low = result.findings.filter((f) => f.priority === "low");
     if (high.length > 0) {
-      console.log(`  ${paint11("bold", paint11("red", `High Priority (${high.length})`))}`);
+      console.log(`  ${paint10("bold", paint10("red", `High Priority (${high.length})`))}`);
       for (const f of high) {
-        console.log(`    ${paint11("red", "\u25CF")} [${f.type}] ${f.title}`);
-        console.log(`      ${paint11("dim", f.description.slice(0, 120))}`);
+        console.log(`    ${paint10("red", "\u25CF")} [${f.type}] ${f.title}`);
+        console.log(`      ${paint10("dim", f.description.slice(0, 120))}`);
       }
       console.log("");
     }
     if (medium.length > 0) {
-      console.log(`  ${paint11("bold", paint11("yellow", `Medium Priority (${medium.length})`))}`);
+      console.log(`  ${paint10("bold", paint10("yellow", `Medium Priority (${medium.length})`))}`);
       for (const f of medium) {
-        console.log(`    ${paint11("yellow", "\u25CF")} [${f.type}] ${f.title}`);
+        console.log(`    ${paint10("yellow", "\u25CF")} [${f.type}] ${f.title}`);
       }
       console.log("");
     }
     if (low.length > 0) {
-      console.log(`  ${paint11("dim", `Low Priority (${low.length})`)} `);
+      console.log(`  ${paint10("dim", `Low Priority (${low.length})`)} `);
       for (const f of low) {
-        console.log(`    ${paint11("dim", `\u25CB [${f.type}] ${f.title}`)}`);
+        console.log(`    ${paint10("dim", `\u25CB [${f.type}] ${f.title}`)}`);
       }
       console.log("");
     }
   } catch (err) {
-    logErr3(`Scan failed: ${err.message}`);
+    logErr2(`Scan failed: ${err.message}`);
     try {
       await api.patch(`/api/scans/${reportId}`, {
         status: "failed",
@@ -5307,8 +5105,8 @@ var scanCommand = new Command26("scan").description("Run a product scan on the c
 });
 
 // cli/commands/idea.ts
-import { Command as Command27 } from "commander";
-var c11 = {
+import { Command as Command26 } from "commander";
+var c10 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -5320,27 +5118,27 @@ var c11 = {
   gray: "\x1B[90m",
   magenta: "\x1B[35m"
 };
-function paint12(color, text) {
-  return `${c11[color]}${text}${c11.reset}`;
+function paint11(color, text) {
+  return `${c10[color]}${text}${c10.reset}`;
 }
 function statusBadge2(status) {
   switch (status) {
     case "draft":
-      return paint12("gray", "\u25CB draft");
+      return paint11("gray", "\u25CB draft");
     case "generating":
-      return paint12("cyan", "\u27F3 generating");
+      return paint11("cyan", "\u27F3 generating");
     case "generated":
-      return paint12("green", "\u2713 generated");
+      return paint11("green", "\u2713 generated");
     case "promoted":
-      return paint12("magenta", "\u2191 promoted");
+      return paint11("magenta", "\u2191 promoted");
     case "archived":
-      return paint12("dim", "\u2298 archived");
+      return paint11("dim", "\u2298 archived");
     default:
-      return paint12("gray", status);
+      return paint11("gray", status);
   }
 }
-var ideaCommand = new Command27("idea").description("Manage ideas \u2014 brainstorm, generate prototypes & plans").addCommand(
-  new Command27("list").description("List ideas for the linked project").option("--all", "Show ideas for all projects").option("--status <status>", "Filter by status").action(async (opts) => {
+var ideaCommand = new Command26("idea").description("Manage ideas \u2014 brainstorm, generate prototypes & plans").addCommand(
+  new Command26("list").description("List ideas for the linked project").option("--all", "Show ideas for all projects").option("--status <status>", "Filter by status").action(async (opts) => {
     const params = new URLSearchParams();
     if (!opts.all) {
       const projectId = getLinkedProjectId();
@@ -5351,23 +5149,23 @@ var ideaCommand = new Command27("idea").description("Manage ideas \u2014 brainst
     if (opts.status) params.set("status", opts.status);
     const ideas = await api.get(`/api/ideas?${params.toString()}`);
     if (ideas.length === 0) {
-      console.log(paint12("gray", "No ideas found."));
+      console.log(paint11("gray", "No ideas found."));
       return;
     }
     console.log();
     for (const idea of ideas) {
       const date = new Date(idea.createdAt).toLocaleDateString();
       console.log(
-        `  ${paint12("bold", idea.title)}  ${statusBadge2(idea.status)}  ${paint12("gray", idea.id.slice(0, 8))}  ${paint12("dim", date)}`
+        `  ${paint11("bold", idea.title)}  ${statusBadge2(idea.status)}  ${paint11("gray", idea.id.slice(0, 8))}  ${paint11("dim", date)}`
       );
       if (idea.description) {
-        console.log(`  ${paint12("dim", idea.description.slice(0, 80) + (idea.description.length > 80 ? "\u2026" : ""))}`);
+        console.log(`  ${paint11("dim", idea.description.slice(0, 80) + (idea.description.length > 80 ? "\u2026" : ""))}`);
       }
       console.log();
     }
   })
 ).addCommand(
-  new Command27("create").description("Create a new idea").argument("<title>", "Title of the idea").option("--description <desc>", "Description of the idea").option("--project <projectId>", "Project ID (defaults to linked project)").option("--generate", "Immediately start generating plan & prototype").action(async (title, opts) => {
+  new Command26("create").description("Create a new idea").argument("<title>", "Title of the idea").option("--description <desc>", "Description of the idea").option("--project <projectId>", "Project ID (defaults to linked project)").option("--generate", "Immediately start generating plan & prototype").action(async (title, opts) => {
     const projectId = opts.project ?? getLinkedProjectId() ?? null;
     const idea = await api.post("/api/ideas", {
       title,
@@ -5375,59 +5173,59 @@ var ideaCommand = new Command27("idea").description("Manage ideas \u2014 brainst
       projectId
     });
     console.log();
-    console.log(`  ${paint12("green", "\u2713")} Created idea: ${paint12("bold", idea.title)}`);
-    console.log(`  ${paint12("gray", "ID:")} ${idea.id}`);
+    console.log(`  ${paint11("green", "\u2713")} Created idea: ${paint11("bold", idea.title)}`);
+    console.log(`  ${paint11("gray", "ID:")} ${idea.id}`);
     if (opts.generate) {
       await api.post(`/api/ideas/${idea.id}/generate`);
-      console.log(`  ${paint12("cyan", "\u27F3")} Generation will begin automatically via the watch agent.`);
+      console.log(`  ${paint11("cyan", "\u27F3")} Generation will begin automatically via the watch agent.`);
     }
     console.log();
   })
 ).addCommand(
-  new Command27("generate").description("Start generating plan & prototype for an idea").argument("<id>", "Idea ID").action(async (id) => {
+  new Command26("generate").description("Start generating plan & prototype for an idea").argument("<id>", "Idea ID").action(async (id) => {
     const idea = await api.post(`/api/ideas/${id}/generate`);
     console.log();
-    console.log(`  ${paint12("cyan", "\u27F3")} Generating: ${paint12("bold", idea.title)}`);
-    console.log(`  ${paint12("gray", "The watch agent will pick this up shortly.")}`);
+    console.log(`  ${paint11("cyan", "\u27F3")} Generating: ${paint11("bold", idea.title)}`);
+    console.log(`  ${paint11("gray", "The watch agent will pick this up shortly.")}`);
     console.log();
   })
 ).addCommand(
-  new Command27("feedback").description("Send feedback to iterate on an idea's generated content").argument("<id>", "Idea ID").argument("<feedback>", "Feedback text").action(async (id, feedback) => {
+  new Command26("feedback").description("Send feedback to iterate on an idea's generated content").argument("<id>", "Idea ID").argument("<feedback>", "Feedback text").action(async (id, feedback) => {
     const idea = await api.post(`/api/ideas/${id}/feedback`, { feedback });
     console.log();
-    console.log(`  ${paint12("cyan", "\u27F3")} Feedback sent for: ${paint12("bold", idea.title)}`);
-    console.log(`  ${paint12("gray", "The watch agent will re-generate with your feedback.")}`);
+    console.log(`  ${paint11("cyan", "\u27F3")} Feedback sent for: ${paint11("bold", idea.title)}`);
+    console.log(`  ${paint11("gray", "The watch agent will re-generate with your feedback.")}`);
     console.log();
   })
 ).addCommand(
-  new Command27("promote").description("Promote an idea to a task").argument("<id>", "Idea ID").action(async (id) => {
+  new Command26("promote").description("Promote an idea to a task").argument("<id>", "Idea ID").action(async (id) => {
     const result = await api.post(`/api/ideas/${id}/promote`);
     console.log();
-    console.log(`  ${paint12("green", "\u2713")} Promoted idea to task: ${paint12("bold", result.task.title)}`);
-    console.log(`  ${paint12("gray", "Task ID:")} ${result.task.id}`);
+    console.log(`  ${paint11("green", "\u2713")} Promoted idea to task: ${paint11("bold", result.task.title)}`);
+    console.log(`  ${paint11("gray", "Task ID:")} ${result.task.id}`);
     console.log();
   })
 ).addCommand(
-  new Command27("spin-up").description("Spin up a new project with a GitHub repo from an idea").argument("<id>", "Idea ID").option("--name <name>", "Custom project name (defaults to idea title)").action(async (id, opts) => {
+  new Command26("spin-up").description("Spin up a new project with a GitHub repo from an idea").argument("<id>", "Idea ID").option("--name <name>", "Custom project name (defaults to idea title)").action(async (id, opts) => {
     const body = {};
     if (opts.name) body.name = opts.name;
     const result = await api.post(`/api/ideas/${id}/spin-up`, body);
     console.log();
-    console.log(`  ${paint12("green", "\u2713")} Spinning up project: ${paint12("bold", result.project.name)}`);
-    console.log(`  ${paint12("gray", "Project ID:")} ${result.project.id}`);
+    console.log(`  ${paint11("green", "\u2713")} Spinning up project: ${paint11("bold", result.project.name)}`);
+    console.log(`  ${paint11("gray", "Project ID:")} ${result.project.id}`);
     if (result.tasks && result.tasks.length > 0) {
-      console.log(`  ${paint12("green", "\u2713")} Created ${result.tasks.length} follow-up task(s):`);
+      console.log(`  ${paint11("green", "\u2713")} Created ${result.tasks.length} follow-up task(s):`);
       for (const task of result.tasks) {
-        console.log(`    ${paint12("gray", "\u2022")} ${task.title}`);
+        console.log(`    ${paint11("gray", "\u2022")} ${task.title}`);
       }
     }
-    console.log(`  ${paint12("cyan", "\u27F3")} Repo creation is queued \u2014 the watch daemon will pick it up.`);
+    console.log(`  ${paint11("cyan", "\u27F3")} Repo creation is queued \u2014 the watch daemon will pick it up.`);
     console.log();
   })
 );
 
 // cli/commands/doctor.ts
-import { Command as Command28 } from "commander";
+import { Command as Command27 } from "commander";
 import { existsSync as existsSync14 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join12 } from "path";
@@ -5475,12 +5273,12 @@ async function checkProjectLink() {
     optional: true
   };
 }
-var doctorCommand = new Command28("doctor").description("Diagnose Mr. Manager CLI installation and environment").action(async () => {
+var doctorCommand = new Command27("doctor").description("Diagnose Mr. Manager CLI installation and environment").action(async () => {
   const banner = [
     ``,
-    paint7("cyan", `  MR DOCTOR`),
-    paint7("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
-    paint7("dim", `  diagnosing your mr environment`),
+    paint6("cyan", `  MR DOCTOR`),
+    paint6("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
+    paint6("dim", `  diagnosing your mr environment`),
     ``
   ].join("\n");
   console.log(banner);
@@ -5502,15 +5300,15 @@ var doctorCommand = new Command28("doctor").description("Diagnose Mr. Manager CL
   const allOk = printResults(checks);
   console.log("");
   if (allOk) {
-    console.log(paint7("green", "  Everything looks good!"));
+    console.log(paint6("green", "  Everything looks good!"));
     console.log("");
     return;
   }
-  const fixes = checks.filter((c12) => !c12.ok && c12.fix && !c12.optional);
+  const fixes = checks.filter((c11) => !c11.ok && c11.fix && !c11.optional);
   if (fixes.length > 0) {
-    console.log(paint7("yellow", "  To fix:"));
+    console.log(paint6("yellow", "  To fix:"));
     for (const fix of fixes) {
-      console.log(`  ${paint7("dim", "\u2192")} ${paint7("bold", fix.name)}: ${fix.fix}`);
+      console.log(`  ${paint6("dim", "\u2192")} ${paint6("bold", fix.name)}: ${fix.fix}`);
     }
     console.log("");
   }
@@ -5524,7 +5322,7 @@ var userArgs = process.argv.slice(2);
 var bypassCommands = /* @__PURE__ */ new Set(["login", "init", "auth", "help", "--help", "-h", "--version", "-V", "doctor", "setup"]);
 var shouldBypass = userArgs.length > 0 && bypassCommands.has(userArgs[0]);
 if (isFirstRun && !shouldBypass) {
-  const c12 = {
+  const c11 = {
     reset: "\x1B[0m",
     bold: "\x1B[1m",
     dim: "\x1B[2m",
@@ -5534,28 +5332,28 @@ if (isFirstRun && !shouldBypass) {
     magenta: "\x1B[35m"
   };
   console.log("");
-  console.log(`${c12.cyan}  \u2554\u2566\u2557\u2566\u2550\u2557  \u2554\u2566\u2557\u2554\u2550\u2557\u2554\u2557\u2554\u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2550\u2557\u2566\u2550\u2557${c12.reset}`);
-  console.log(`${c12.magenta}  \u2551\u2551\u2551\u2560\u2566\u255D  \u2551\u2551\u2551\u2560\u2550\u2563\u2551\u2551\u2551\u2560\u2550\u2563\u2551 \u2566\u2551\u2563 \u2560\u2566\u255D${c12.reset}`);
-  console.log(`${c12.cyan}  \u2569 \u2569\u2569\u255A\u2550  \u2569 \u2569\u2569 \u2569\u255D\u255A\u255D\u2569 \u2569\u255A\u2550\u255D\u255A\u2550\u255D\u2569\u255A\u2550${c12.reset}`);
-  console.log(`${c12.dim}  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${c12.reset}`);
+  console.log(`${c11.cyan}  \u2554\u2566\u2557\u2566\u2550\u2557  \u2554\u2566\u2557\u2554\u2550\u2557\u2554\u2557\u2554\u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2550\u2557\u2566\u2550\u2557${c11.reset}`);
+  console.log(`${c11.magenta}  \u2551\u2551\u2551\u2560\u2566\u255D  \u2551\u2551\u2551\u2560\u2550\u2563\u2551\u2551\u2551\u2560\u2550\u2563\u2551 \u2566\u2551\u2563 \u2560\u2566\u255D${c11.reset}`);
+  console.log(`${c11.cyan}  \u2569 \u2569\u2569\u255A\u2550  \u2569 \u2569\u2569 \u2569\u255D\u255A\u255D\u2569 \u2569\u255A\u2550\u255D\u255A\u2550\u255D\u2569\u255A\u2550${c11.reset}`);
+  console.log(`${c11.dim}  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${c11.reset}`);
   console.log("");
-  console.log(`${c12.bold}  Welcome to Mr. Manager!${c12.reset}`);
-  console.log(`${c12.dim}  Let's get you set up in a few quick steps.${c12.reset}`);
+  console.log(`${c11.bold}  Welcome to Mr. Manager!${c11.reset}`);
+  console.log(`${c11.dim}  Let's get you set up in a few quick steps.${c11.reset}`);
   console.log("");
-  console.log(`  ${c12.yellow}Step 1:${c12.reset} Authenticate via Google OAuth`);
-  console.log(`  ${c12.dim}Run:${c12.reset} ${c12.cyan}mr login${c12.reset}`);
+  console.log(`  ${c11.yellow}Step 1:${c11.reset} Authenticate via Google OAuth`);
+  console.log(`  ${c11.dim}Run:${c11.reset} ${c11.cyan}mr login${c11.reset}`);
   console.log("");
-  console.log(`  ${c12.yellow}Step 2:${c12.reset} Verify your environment`);
-  console.log(`  ${c12.dim}Run:${c12.reset} ${c12.cyan}mr setup${c12.reset}`);
+  console.log(`  ${c11.yellow}Step 2:${c11.reset} Verify your environment`);
+  console.log(`  ${c11.dim}Run:${c11.reset} ${c11.cyan}mr setup${c11.reset}`);
   console.log("");
-  console.log(`  ${c12.yellow}Step 3:${c12.reset} Link a repo and start watching`);
-  console.log(`  ${c12.dim}Run:${c12.reset} ${c12.cyan}mr link${c12.reset} ${c12.dim}&&${c12.reset} ${c12.cyan}mr watch${c12.reset}`);
+  console.log(`  ${c11.yellow}Step 3:${c11.reset} Link a repo and start watching`);
+  console.log(`  ${c11.dim}Run:${c11.reset} ${c11.cyan}mr link${c11.reset} ${c11.dim}&&${c11.reset} ${c11.cyan}mr watch${c11.reset}`);
   console.log("");
-  console.log(`${c12.dim}  Or run ${c12.reset}${c12.cyan}mr login${c12.reset}${c12.dim} to get started now.${c12.reset}`);
+  console.log(`${c11.dim}  Or run ${c11.reset}${c11.cyan}mr login${c11.reset}${c11.dim} to get started now.${c11.reset}`);
   console.log("");
   process.exit(0);
 }
-var program = new Command29();
+var program = new Command28();
 program.name("mr").description("Mr. Manager - Task and project management CLI").version("0.2.0");
 program.addCommand(initCommand);
 program.addCommand(authCommand);
@@ -5572,7 +5370,6 @@ program.addCommand(undelegateCommand);
 program.addCommand(createCommand);
 program.addCommand(completeCommand);
 program.addCommand(subtaskCompleteCommand);
-program.addCommand(digestCommand);
 program.addCommand(upCommand);
 program.addCommand(prototypeCommand);
 program.addCommand(setupCommand);