@dunnewold-labs/mr-manager 0.4.28 → 0.4.29

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 existsSync17 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join12 } from "path";
@@ -185,7 +185,7 @@ import { fileURLToPath } from "url";
 // cli/package.json
 var package_default = {
   name: "@dunnewold-labs/mr-manager",
-  version: "0.4.28",
+  version: "0.4.29",
   description: "Mr. Manager - Task and project management CLI",
   bin: {
     mr: "./dist/index.mjs"
@@ -1162,6 +1162,19 @@ function taskLikelyDoesNotNeedCodeChanges(task) {
   return NON_CODE_TASK_KEYWORDS.some((keyword) => haystack.includes(keyword)) || NON_CODE_TASK_PATTERNS.some((pattern) => pattern.test(haystack));
 }
 
+// lib/task-branch.ts
+function isPrOrMrUrl(input) {
+  try {
+    const url = new URL(input.trim());
+    const path = url.pathname;
+    if (url.hostname.includes("github") && /\/pull\/\d+/.test(path)) return true;
+    if (url.hostname.includes("gitlab") && /\/merge_requests\/\d+/.test(path)) return true;
+  } catch {
+    return false;
+  }
+  return false;
+}
+
 // cli/browse-runner.ts
 import { execSync as execSync3, spawn as spawn3 } from "child_process";
 import { existsSync as existsSync6 } from "fs";
@@ -1482,6 +1495,15 @@ function taskBranchName(task) {
   }
   return `${ownerPrefix(task)}/${slugify(task.title)}`;
 }
+function resolveBranchFromPrUrl(prUrl, repoDir, vcs) {
+  const cmd = vcs === "gitlab" ? `glab mr view "${prUrl}" --output json 2>/dev/null | jq -r '.source_branch // empty'` : `gh pr view "${prUrl}" --json headRefName -q .headRefName 2>/dev/null`;
+  return new Promise((resolve9) => {
+    exec(cmd, { cwd: repoDir }, (err, stdout) => {
+      const branch = stdout?.trim();
+      resolve9(branch || null);
+    });
+  });
+}
 function formatElapsed(ms) {
   const totalMinutes = Math.max(1, Math.floor(ms / 6e4));
   const hours = Math.floor(totalMinutes / 60);
@@ -2119,9 +2141,6 @@ function protoTag(sid) {
 function repoTag(sid) {
   return paint("cyan", `[repo:${sid}]`);
 }
-function ideaTag(sid) {
-  return paint("magenta", `[idea:${sid}]`);
-}
 function buildRepoCreationPrompt(project, rootDir, vcs = "github") {
   const apiBase = process.env.MR_API_BASE ?? "http://localhost:3000";
   const apiKey = process.env.MR_API_KEY ?? "";
@@ -2400,83 +2419,6 @@ function buildRefinementPrompt(proto, parentFiles, repoDir) {
     `- Do NOT exit until ALL ${proto.variantCount} files have been written and verified.`
   ].join("\n");
 }
-function buildIdeaPrompt(idea, repoDir) {
-  const feedbackSection = idea.feedback ? [
-    `## Previous Feedback`,
-    ``,
-    `The user provided this feedback on a previous generation:`,
-    `${idea.feedback}`,
-    ``,
-    `Please incorporate this feedback into your new generation.`,
-    ``
-  ] : [];
-  const existingPlanSection = idea.plan && idea.feedback ? [
-    `## Previous Plan`,
-    ``,
-    `Here is the plan from the previous iteration:`,
-    `\`\`\`markdown`,
-    idea.plan,
-    `\`\`\``,
-    ``
-  ] : [];
-  return [
-    `You are a product strategist and UI designer. Your job is to take a rough idea and generate two outputs:`,
-    `1. An implementation plan (saved as \`idea-plan.md\`)`,
-    `2. A visual prototype (saved as \`idea-prototype.html\`)`,
-    ``,
-    `Working directory: ${repoDir}`,
-    ``,
-    `## Idea`,
-    `Title: ${idea.title}`,
-    `ID: ${idea.id}`,
-    ...idea.description ? [``, `Description: ${idea.description}`] : [],
-    ``,
-    ...feedbackSection,
-    ...existingPlanSection,
-    `## Instructions`,
-    ``,
-    `### Step 1: Generate the Plan`,
-    ``,
-    `Write a comprehensive implementation plan to \`${repoDir}/idea-plan.md\` covering:`,
-    `- **Problem statement**: What problem does this idea solve?`,
-    `- **Proposed solution**: High-level approach`,
-    `- **Key features**: Bulleted list of features/capabilities`,
-    `- **Technical approach**: How it could be built (components, data model, integrations)`,
-    `- **Implementation phases**: Phased rollout plan with milestones`,
-    `- **Open questions**: Things that need clarification`,
-    ``,
-    `### Step 2: Generate Follow-up Tasks`,
-    ``,
-    `Write a JSON file to \`${repoDir}/idea-tasks.json\` containing an array of follow-up tasks that will need to be done after the project repo is created. These are setup and implementation tasks the user will need to complete. Examples: "Add environment variables (.env)", "Set up CI/CD pipeline", "Configure database", "Add authentication", etc.`,
-    ``,
-    `Format: a JSON array of objects with "title" (short task name) and optional "notes" (additional context):`,
-    `\`\`\`json`,
-    `[`,
-    `  { "title": "Add environment variables (.env)", "notes": "Create .env file with required API keys and database URL" },`,
-    `  { "title": "Set up CI/CD pipeline" }`,
-    `]`,
-    `\`\`\``,
-    ``,
-    `Generate 3-8 tasks that are specific to this idea. Focus on actionable setup and implementation steps.`,
-    ``,
-    `### Step 3: Generate the Prototype`,
-    ``,
-    `Write a self-contained HTML prototype to \`${repoDir}/idea-prototype.html\` that visually demonstrates the idea.`,
-    `- Must be completely self-contained (inline CSS/JS, Tailwind CDN is acceptable)`,
-    `- Should be interactive where possible (click handlers, animations, sample data)`,
-    `- Should look polished and professional \u2014 this will be shown to stakeholders`,
-    `- Include realistic sample data that demonstrates the feature`,
-    ``,
-    `### Step 4: Verify`,
-    ``,
-    `List the files in ${repoDir} and confirm \`idea-plan.md\`, \`idea-tasks.json\`, and \`idea-prototype.html\` all exist.`,
-    ``,
-    `IMPORTANT RULES:`,
-    `- Write EXACTLY three files: idea-plan.md, idea-tasks.json, and idea-prototype.html`,
-    `- Do NOT upload or POST the files anywhere \u2014 the watch handler will upload them automatically`,
-    `- Do NOT exit until both files have been written and verified`
-  ].join("\n");
-}
 function buildAgentArgs(agent, prompt2, mode, sessionId, name, resumeSession = false, systemPrompt, maxTurns, claudeModel) {
   if (agent === "codex") {
     const args = [];
@@ -2619,14 +2561,13 @@ function spawnAgent(agent, repoDir, prompt2, prefix, onActivity, sessionId, name
 }
 var watchCommand = new Command8("watch").description(
   "Watch for in-progress tasks and autonomously dispatch an AI coding agent to work on them"
-).option("--interval <seconds>", "Polling interval in seconds", "15").option("--dry-run", "Show what would be dispatched without spawning the agent", false).option("--plan-approval", "Show the agent's plan and ask for approval before executing", false).option("--root <dir>", "Root directory filter for linked repos (default: cwd)").option("--agent <agent>", "AI agent to use: claude, codex, or gemini", "claude").option("--scan-at <HH:MM>", "Run a product scan daily at this time (e.g., 02:00)").option("--quiet", "Run all tasks in quiet mode (agent outputs only status updates, no conversation)", false).action(async (opts) => {
+).option("--interval <seconds>", "Polling interval in seconds", "15").option("--dry-run", "Show what would be dispatched without spawning the agent", false).option("--plan-approval", "Show the agent's plan and ask for approval before executing", false).option("--root <dir>", "Root directory filter for linked repos (default: cwd)").option("--agent <agent>", "AI agent to use: claude, codex, or gemini", "claude").option("--scan-at <HH:MM>", "Run a product scan daily at this time (e.g., 02:00)").action(async (opts) => {
   const intervalMs = parseInt(opts.interval, 10) * 1e3;
   const dryRun = opts.dryRun;
   const planApproval = opts.planApproval;
   const rootDir = opts.root ? resolve2(opts.root) : process.cwd();
   const agent = opts.agent === "codex" ? "codex" : opts.agent === "gemini" ? "gemini" : "claude";
   const scanAt = opts.scanAt;
-  const globalQuietMode = opts.quiet;
   const taskStallTimeoutMs = getTaskStallTimeoutMs();
   const hungTaskTimeoutMinutes = Math.max(5, parseInt(process.env.MR_WATCH_HUNG_TASK_TIMEOUT_MINUTES ?? "60", 10) || 60);
   const hungTaskTimeoutMs = hungTaskTimeoutMinutes * 6e4;
@@ -2647,7 +2588,6 @@ var watchCommand = new Command8("watch").description(
     `stall-timeout=${paint("cyan", formatTimeoutMinutes(taskStallTimeoutMs))}`,
     ...planApproval ? [paint("yellow", "plan-approval")] : [],
     ...dryRun ? [paint("yellow", "dry-run")] : [],
-    ...globalQuietMode ? [paint("yellow", "quiet")] : [],
     ...scanAt ? [`scan-at=${paint("cyan", scanAt)}`] : [],
     `hung-timeout=${paint("cyan", `${hungTaskTimeoutMinutes}m`)}`
   ].join("  ");
@@ -2721,7 +2661,7 @@ var watchCommand = new Command8("watch").description(
       logWarn(watchTag(), `Network unavailable \u2014 pausing active tasks until connectivity returns (${reason})`);
     }
     for (const taskId of active.keys()) {
-      const nonTaskPrefixes = ["proto-", "repo-", "scan-", "idea-", "test-"];
+      const nonTaskPrefixes = ["proto-", "repo-", "scan-", "test-"];
       if (nonTaskPrefixes.some((prefix) => taskId.startsWith(prefix))) continue;
       pauseTaskForNetwork(taskId, reason);
     }
@@ -2768,13 +2708,19 @@ var watchCommand = new Command8("watch").description(
     const sid = shortId(task.id);
     const slug = slugify(task.title);
     const owner = ownerPrefix(task);
-    const branchName = taskBranchName(task);
+    let branchName = taskBranchName(task);
     const legacyBranchName = `mr/${sid}/${slug}`;
     const prefix = taskTag(sid);
     const vcs = detectVcs(repoDir)?.provider ?? "github";
-    const taskIsQuiet = task.quietMode || globalQuietMode;
-    logDispatch(prefix, `"${paint("bold", task.title)}"  ${paint("gray", repoDir)}  ${paint("dim", `[${vcs}]`)}${taskIsQuiet ? `  ${paint("yellow", "[quiet]")}` : ""}`);
-    await postTaskUpdate(task.id, `Agent dispatched${taskIsQuiet ? " (quiet mode)" : ""} \u2014 starting work on "${task.title}"`, "system");
+    if (!task.attachedBranch?.trim() && task.attachedBranchLink && isPrOrMrUrl(task.attachedBranchLink)) {
+      const resolved = await resolveBranchFromPrUrl(task.attachedBranchLink, repoDir, vcs);
+      if (resolved) {
+        branchName = resolved;
+        logInfo(prefix, `Resolved branch ${paint("cyan", resolved)} from attached ${vcs === "gitlab" ? "MR" : "PR"}`);
+      }
+    }
+    logDispatch(prefix, `"${paint("bold", task.title)}"  ${paint("gray", repoDir)}  ${paint("dim", `[${vcs}]`)}`);
+    await postTaskUpdate(task.id, `Agent dispatched \u2014 starting work on "${task.title}"`, "system");
     let subtasks = [];
     try {
       subtasks = await api.get(`/api/tasks/${task.id}/subtasks`);
@@ -2840,7 +2786,6 @@ var watchCommand = new Command8("watch").description(
       );
     }
     const prompt2 = buildExecutionPrompt(task, repoDir, subtasks, vcs, protoRefs, feedbackUpdates, existingResources, skillRefs, executionDir, startWithoutWorktree, !startWithoutWorktree && isGitRepo(repoDir) ? branchName : void 0);
-    const taskIsQuietForEntry = task.quietMode || globalQuietMode;
     const activeEntry = {
       process: void 0,
       title: task.title,
@@ -2849,8 +2794,7 @@ var watchCommand = new Command8("watch").description(
       cleanupWorktreePath,
       startedAt: Date.now(),
       lastActivityAt: Date.now(),
-      outputBytes: 0,
-      quietMode: taskIsQuietForEntry
+      outputBytes: 0
     };
     const touchActivity = () => {
       activeEntry.lastActivityAt = Date.now();
@@ -2879,12 +2823,8 @@ var watchCommand = new Command8("watch").description(
       const shouldResumeClaudeSession = attemptAgent === "claude" && !!task.claudeSessionId && !resumeAlreadyRetried && (hasFeedback || pausedForNetwork?.resumeSession === true);
       const sessionId = attemptAgent === "claude" ? shouldResumeClaudeSession ? task.claudeSessionId : randomUUID() : void 0;
       const effectiveClaudeModel = attemptAgent === "claude" ? taskClaudeModel : void 0;
-      const isQuiet = task.quietMode || globalQuietMode;
-      const systemSections = isQuiet ? ["quiet-mode", ...EXECUTION_SYSTEM_SECTIONS] : [...EXECUTION_SYSTEM_SECTIONS];
+      const systemSections = ["quiet-mode", ...EXECUTION_SYSTEM_SECTIONS];
       const executionSystemPrompt = composeSystemPrompt(systemSections);
-      if (isQuiet) {
-        logInfo(prefix, `${paint("yellow", "quiet mode")} \u2014 agent will suppress conversational output`);
-      }
       const child = spawnAgent(
         attemptAgent,
         executionDir,
@@ -2932,36 +2872,47 @@ var watchCommand = new Command8("watch").description(
             logWarn(prefix, `${attemptAgent} paused after network loss (${failureDetail})`);
             return;
           }
-          if (shouldResumeClaudeSession && !resumeAlreadyRetried) {
-            resumeAlreadyRetried = true;
-            logWarn(prefix, `Claude session resume failed (${failureDetail}) \u2014 retrying with fresh session`);
-            await postTaskUpdate(
-              task.id,
-              `Claude session resume failed \u2014 retrying with fresh session`,
-              "system"
-            );
-            await launchAttempt("claude");
-            return;
+          try {
+            const currentTask = await api.get(`/api/tasks/${task.id}`);
+            if (currentTask.status === "completed" || currentTask.status === "review" || currentTask.status === "error") {
+              logWarn(prefix, `Task already in "${currentTask.status}" state after agent exit \u2014 skipping retry`);
+              activeEntry.terminatedForError = true;
+            }
+          } catch {
+            logWarn(prefix, `Could not verify task status \u2014 skipping retry to avoid stale re-dispatch`);
+            activeEntry.terminatedForError = true;
           }
-          const nextAgent = attemptOrder[attemptIndex + 1];
-          if (nextAgent) {
-            logWarn(prefix, `${attemptAgent} failed (${failureDetail}) \u2014 retrying with ${nextAgent}`);
-            await postTaskUpdate(
-              task.id,
-              `${attemptAgent} failed (${failureDetail}) \u2014 retrying with ${nextAgent}`,
-              "system"
-            );
-            attemptIndex += 1;
-            await launchAttempt(nextAgent);
-            return;
+          if (!activeEntry.terminatedForError) {
+            if (shouldResumeClaudeSession && !resumeAlreadyRetried) {
+              resumeAlreadyRetried = true;
+              logWarn(prefix, `Claude session resume failed (${failureDetail}) \u2014 retrying with fresh session`);
+              await postTaskUpdate(
+                task.id,
+                `Claude session resume failed \u2014 retrying with fresh session`,
+                "system"
+              );
+              await launchAttempt("claude");
+              return;
+            }
+            const nextAgent = attemptOrder[attemptIndex + 1];
+            if (nextAgent) {
+              logWarn(prefix, `${attemptAgent} failed (${failureDetail}) \u2014 retrying with ${nextAgent}`);
+              await postTaskUpdate(
+                task.id,
+                `${attemptAgent} failed (${failureDetail}) \u2014 retrying with ${nextAgent}`,
+                "system"
+              );
+              attemptIndex += 1;
+              await launchAttempt(nextAgent);
+              return;
+            }
           }
         }
         finishing.add(task.id);
         const elapsedMs = Date.now() - activeEntry.startedAt;
-        const modeLabel = activeEntry.quietMode ? "quiet" : "standard";
         const outputTokenEstimate = Math.ceil(activeEntry.outputBytes / 4);
         console.log(
-          `${timestamp()} ${prefix} ${paint("dim", `[output] mode=${modeLabel} output=~${formatTokenCount(outputTokenEstimate)} elapsed=${Math.round(elapsedMs / 1e3)}s exit=${code}`)}`
+          `${timestamp()} ${prefix} ${paint("dim", `[output] output=~${formatTokenCount(outputTokenEstimate)} elapsed=${Math.round(elapsedMs / 1e3)}s exit=${code}`)}`
         );
         try {
           if (code === 0) {
@@ -3301,7 +3252,7 @@ var watchCommand = new Command8("watch").description(
           active.delete(key);
         }
         const failedAttempt = code !== 0 || spawnFailureReason !== null;
-        if (failedAttempt) {
+        if (failedAttempt && !activeEntry.terminatedForError) {
           const nextAgent = attemptOrder[attemptIndex + 1];
           if (nextAgent) {
             const failureDetail = spawnFailureReason ?? `exit code ${code}`;
@@ -3411,7 +3362,7 @@ var watchCommand = new Command8("watch").description(
           active.delete(key);
         }
         const failedAttempt = code !== 0 || spawnFailureReason !== null;
-        if (failedAttempt) {
+        if (failedAttempt && !activeEntry.terminatedForError) {
           const nextAgent = attemptOrder[attemptIndex + 1];
           if (nextAgent) {
             const failureDetail = spawnFailureReason ?? `exit code ${code}`;
@@ -3448,158 +3399,6 @@ var watchCommand = new Command8("watch").description(
     };
     await launchAttempt(attemptOrder[attemptIndex]);
   }
-  async function dispatchIdeaJob(idea, repoDir) {
-    const sid = shortId(idea.id);
-    const prefix = ideaTag(sid);
-    logDispatch(prefix, `"${paint("bold", idea.title)}"${idea.feedback ? paint("cyan", " (iteration)") : ""}  ${paint("gray", repoDir)}`);
-    for (const f of ["idea-plan.md", "idea-tasks.json", "idea-prototype.html"]) {
-      try {
-        unlinkSync(resolve2(repoDir, f));
-      } catch {
-      }
-    }
-    const prompt2 = buildIdeaPrompt(idea, repoDir);
-    const key = `idea-${idea.id}`;
-    const attemptOrder = await resolveAgentChain(agent);
-    if (attemptOrder.length === 0) {
-      logError(prefix, `No available agents found for fallback chain starting at ${agent}`);
-      queued.delete(key);
-      try {
-        await api.patch(`/api/ideas/${idea.id}`, { status: "draft" });
-      } catch {
-      }
-      return;
-    }
-    const activeEntry = {
-      process: void 0,
-      title: idea.title,
-      repoDir,
-      startedAt: Date.now(),
-      lastActivityAt: Date.now()
-    };
-    let attemptIndex = 0;
-    const launchAttempt = async (attemptAgent) => {
-      let spawnFailureReason = null;
-      const child = spawnAgent(
-        attemptAgent,
-        repoDir,
-        prompt2,
-        prefix,
-        void 0,
-        void 0,
-        idea.title,
-        false,
-        (err) => {
-          spawnFailureReason = err.message;
-        }
-      );
-      activeEntry.process = child;
-      activeEntry.currentAgent = attemptAgent;
-      active.set(key, activeEntry);
-      child.on("exit", async (code) => {
-        if (active.get(key)?.process === child) {
-          active.delete(key);
-        }
-        const failedAttempt = code !== 0 || spawnFailureReason !== null;
-        if (failedAttempt) {
-          const nextAgent = attemptOrder[attemptIndex + 1];
-          if (nextAgent) {
-            const failureDetail = spawnFailureReason ?? `exit code ${code}`;
-            logWarn(prefix, `${attemptAgent} failed (${failureDetail}) \u2014 retrying idea generation with ${nextAgent}`);
-            attemptIndex += 1;
-            await launchAttempt(nextAgent);
-            return;
-          }
-        }
-        finishing.add(key);
-        try {
-          if (code === 0) {
-            try {
-              let plan;
-              let protoHtml;
-              let followUpTasks;
-              const planPath = resolve2(repoDir, "idea-plan.md");
-              const tasksPath = resolve2(repoDir, "idea-tasks.json");
-              const protoPath = resolve2(repoDir, "idea-prototype.html");
-              try {
-                plan = readFileSync5(planPath, "utf-8");
-              } catch {
-              }
-              try {
-                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 {
-              }
-            }
-          } else {
-            const failureDetail = spawnFailureReason ?? `exit code ${code}`;
-            logError(prefix, `"${paint("bold", idea.title)}" generation failed via ${attemptAgent} (${failureDetail})`);
-            try {
-              await api.patch(`/api/ideas/${idea.id}`, { status: "draft" });
-            } catch {
-            }
-          }
-        } finally {
-          queued.delete(key);
-          finishing.delete(key);
-        }
-      });
-    };
-    await launchAttempt(attemptOrder[attemptIndex]);
-  }
   function dispatchScan(scan, prefix, key) {
     logDispatch(prefix, `Running scan for project ${paint("cyan", scan.projectId.slice(0, 8))}`);
     const scanProc = spawn4(process.execPath, [process.argv[1], "scan", "--project", scan.projectId, "--report", scan.id], {
@@ -3736,6 +3535,7 @@ ${divider}`);
         const running = active.get(task.id);
         if (running) {
           logWarn(prefix, `Task exceeded hang timeout after ${formatElapsed(Date.now() - running.startedAt)}, terminating agent\u2026`);
+          running.terminatedForError = true;
           running.process.kill("SIGTERM");
           active.delete(task.id);
         }
@@ -3792,7 +3592,7 @@ ${divider}`);
           queued.delete(taskId);
         }
       }
-      const nonTaskPrefixes = ["proto-", "repo-", "scan-", "idea-", "test-"];
+      const nonTaskPrefixes = ["proto-", "repo-", "scan-", "test-"];
       for (const taskId of failed.keys()) {
         if (nonTaskPrefixes.some((p) => taskId.startsWith(p))) continue;
         if (!activeTaskIds.has(taskId)) failed.delete(taskId);
@@ -3861,6 +3661,7 @@ ${divider}`);
       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.terminatedForError = true;
           entry.process.kill("SIGTERM");
           active.delete(key);
           queued.delete(key);
@@ -4074,59 +3875,6 @@ ${divider}`);
         }
         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 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;
-        }
-        dispatchIdeaJob(idea, repoDir);
-      }
       let pendingScans = [];
       try {
         pendingScans = await api.get("/api/scans?status=pending&limit=5");
@@ -4751,7 +4499,7 @@ 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;
@@ -4765,10 +4513,10 @@ function printResults(checks) {
 }
 async function autoFix(checks, agent) {
   const { spawn: spawn8 } = 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 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(paint5("cyan", "  Installing Claude Code..."));
     console.log(paint5("dim", "  Running: curl -fsSL https://claude.ai/install.sh | bash"));
@@ -4831,7 +4579,7 @@ var setupCommand = new Command14("setup").description("Check that all dependenci
     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(paint5("yellow", "  To fix:"));
     for (const fix of fixes) {
@@ -6024,10 +5772,10 @@ ${codebaseAnalysis.routes.map((r) => `- ${r}`).join("\n")}
 ${codebaseAnalysis.prismaModels.map((m) => `- ${m}`).join("\n")}
 
 **Components:**
-${codebaseAnalysis.components.slice(0, 15).map((c12) => `- ${c12}`).join("\n")}
+${codebaseAnalysis.components.slice(0, 15).map((c11) => `- ${c11}`).join("\n")}
 
 **Recent Git Commits:**
-${codebaseAnalysis.recentCommits.slice(0, 8).map((c12) => `- ${c12}`).join("\n")}
+${codebaseAnalysis.recentCommits.slice(0, 8).map((c11) => `- ${c11}`).join("\n")}
 
 **Completed Tasks:**
 ${context.completedTasks.slice(0, 10).map((t) => `- ${t.title}`).join("\n") || "None"}
@@ -6474,128 +6222,8 @@ var scanCommand = new Command23("scan").description("Run a product scan on the c
   }
 });
 
-// cli/commands/idea.ts
-import { Command as Command24 } from "commander";
-var c9 = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  cyan: "\x1B[36m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  red: "\x1B[31m",
-  blue: "\x1B[34m",
-  gray: "\x1B[90m",
-  magenta: "\x1B[35m"
-};
-function paint9(color, text) {
-  return `${c9[color]}${text}${c9.reset}`;
-}
-function statusBadge2(status) {
-  switch (status) {
-    case "draft":
-      return paint9("gray", "\u25CB draft");
-    case "generating":
-      return paint9("cyan", "\u27F3 generating");
-    case "generated":
-      return paint9("green", "\u2713 generated");
-    case "promoted":
-      return paint9("magenta", "\u2191 promoted");
-    case "archived":
-      return paint9("dim", "\u2298 archived");
-    default:
-      return paint9("gray", status);
-  }
-}
-var ideaCommand = new Command24("idea").description("Manage ideas \u2014 brainstorm, generate prototypes & plans").addCommand(
-  new Command24("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();
-      if (projectId) {
-        params.set("projectId", projectId);
-      }
-    }
-    if (opts.status) params.set("status", opts.status);
-    const ideas = await api.get(`/api/ideas?${params.toString()}`);
-    if (ideas.length === 0) {
-      console.log(paint9("gray", "No ideas found."));
-      return;
-    }
-    console.log();
-    for (const idea of ideas) {
-      const date = new Date(idea.createdAt).toLocaleDateString();
-      console.log(
-        `  ${paint9("bold", idea.title)}  ${statusBadge2(idea.status)}  ${paint9("gray", idea.id.slice(0, 8))}  ${paint9("dim", date)}`
-      );
-      if (idea.description) {
-        console.log(`  ${paint9("dim", idea.description.slice(0, 80) + (idea.description.length > 80 ? "\u2026" : ""))}`);
-      }
-      console.log();
-    }
-  })
-).addCommand(
-  new Command24("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,
-      description: opts.description,
-      projectId
-    });
-    console.log();
-    console.log(`  ${paint9("green", "\u2713")} Created idea: ${paint9("bold", idea.title)}`);
-    console.log(`  ${paint9("gray", "ID:")} ${idea.id}`);
-    if (opts.generate) {
-      await api.post(`/api/ideas/${idea.id}/generate`);
-      console.log(`  ${paint9("cyan", "\u27F3")} Generation will begin automatically via the watch agent.`);
-    }
-    console.log();
-  })
-).addCommand(
-  new Command24("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(`  ${paint9("cyan", "\u27F3")} Generating: ${paint9("bold", idea.title)}`);
-    console.log(`  ${paint9("gray", "The watch agent will pick this up shortly.")}`);
-    console.log();
-  })
-).addCommand(
-  new Command24("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(`  ${paint9("cyan", "\u27F3")} Feedback sent for: ${paint9("bold", idea.title)}`);
-    console.log(`  ${paint9("gray", "The watch agent will re-generate with your feedback.")}`);
-    console.log();
-  })
-).addCommand(
-  new Command24("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(`  ${paint9("green", "\u2713")} Promoted idea to task: ${paint9("bold", result.task.title)}`);
-    console.log(`  ${paint9("gray", "Task ID:")} ${result.task.id}`);
-    console.log();
-  })
-).addCommand(
-  new Command24("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(`  ${paint9("green", "\u2713")} Spinning up project: ${paint9("bold", result.project.name)}`);
-    console.log(`  ${paint9("gray", "Project ID:")} ${result.project.id}`);
-    if (result.tasks && result.tasks.length > 0) {
-      console.log(`  ${paint9("green", "\u2713")} Created ${result.tasks.length} follow-up task(s):`);
-      for (const task of result.tasks) {
-        console.log(`    ${paint9("gray", "\u2022")} ${task.title}`);
-      }
-    }
-    console.log(`  ${paint9("cyan", "\u27F3")} Repo creation is queued \u2014 the watch daemon will pick it up.`);
-    console.log();
-  })
-);
-
 // cli/commands/doctor.ts
-import { Command as Command25 } from "commander";
+import { Command as Command24 } from "commander";
 import { existsSync as existsSync15 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join11 } from "path";
@@ -6643,7 +6271,7 @@ async function checkProjectLink() {
     optional: true
   };
 }
-var doctorCommand = new Command25("doctor").description("Diagnose Mr. Manager CLI installation and environment").action(async () => {
+var doctorCommand = new Command24("doctor").description("Diagnose Mr. Manager CLI installation and environment").action(async () => {
   const banner = [
     ``,
     paint5("cyan", `  MR DOCTOR`),
@@ -6674,7 +6302,7 @@ var doctorCommand = new Command25("doctor").description("Diagnose Mr. Manager CL
     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(paint5("yellow", "  To fix:"));
     for (const fix of fixes) {
@@ -6686,14 +6314,14 @@ var doctorCommand = new Command25("doctor").description("Diagnose Mr. Manager CL
 });
 
 // cli/commands/prompt-audit.ts
-import { Command as Command26 } from "commander";
+import { Command as Command25 } from "commander";
 import { resolve as resolve8 } from "path";
 import { existsSync as existsSync16, readFileSync as readFileSync12 } from "fs";
 function auditLine(label, tokens) {
   const bar = "\u2588".repeat(Math.min(60, Math.round(tokens / 200)));
   return `  ${label.padEnd(30)} ${formatTokenCount(tokens).padStart(8)}  ${bar}`;
 }
-var promptAuditCommand = new Command26("prompt-audit").description("Dry-run prompt construction and report estimated token counts by job type").option("--task <id>", "Audit prompts for a specific task ID").option("--all", "Audit all supported job types with representative data", false).option("--json", "Output as JSON instead of plain text", false).action(async (opts) => {
+var promptAuditCommand = new Command25("prompt-audit").description("Dry-run prompt construction and report estimated token counts by job type").option("--task <id>", "Audit prompts for a specific task ID").option("--all", "Audit all supported job types with representative data", false).option("--json", "Output as JSON instead of plain text", false).action(async (opts) => {
   const results = [];
   if (opts.task) {
     try {
@@ -6853,14 +6481,6 @@ ${task.notes}` : "";
           { name: "instructions", tokens: 500 }
         ]
       },
-      {
-        jobType: "idea",
-        description: "Idea generation prompt",
-        sections: [
-          { name: "core-prompt", tokens: 500 },
-          { name: "idea-desc", tokens: 200 }
-        ]
-      },
       {
         jobType: "repo-creation",
         description: "Repository creation prompt",
@@ -6906,8 +6526,8 @@ ${r.jobType} [${r.identifier}]`);
 });
 
 // cli/commands/skill.ts
-import { Command as Command27 } from "commander";
-var c10 = {
+import { Command as Command26 } from "commander";
+var c9 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -6915,7 +6535,7 @@ var c10 = {
   green: "\x1B[32m",
   yellow: "\x1B[33m"
 };
-var skillCommand = new Command27("skill").description("Manage skills \u2014 reusable playbooks for AI agents");
+var skillCommand = new Command26("skill").description("Manage skills \u2014 reusable playbooks for AI agents");
 skillCommand.command("list").alias("ls").description("List all skills").option("--category <category>", "Filter by category").action(async (opts) => {
   const params = new URLSearchParams();
   if (opts.category) params.set("category", opts.category);
@@ -6923,17 +6543,17 @@ skillCommand.command("list").alias("ls").description("List all skills").option("
     `/api/skills${params.toString() ? `?${params}` : ""}`
   );
   if (skills.length === 0) {
-    console.log(`${c10.dim}No skills found.${c10.reset}`);
+    console.log(`${c9.dim}No skills found.${c9.reset}`);
     return;
   }
   for (const skill of skills) {
-    const cat = skill.category ? ` ${c10.dim}[${skill.category}]${c10.reset}` : "";
-    const scope = skill.projectId ? ` ${c10.dim}(project)${c10.reset}` : ` ${c10.dim}(global)${c10.reset}`;
-    console.log(`  ${c10.cyan}${skill.name}${c10.reset}${cat}${scope}`);
+    const cat = skill.category ? ` ${c9.dim}[${skill.category}]${c9.reset}` : "";
+    const scope = skill.projectId ? ` ${c9.dim}(project)${c9.reset}` : ` ${c9.dim}(global)${c9.reset}`;
+    console.log(`  ${c9.cyan}${skill.name}${c9.reset}${cat}${scope}`);
     if (skill.description) {
-      console.log(`    ${c10.dim}${skill.description}${c10.reset}`);
+      console.log(`    ${c9.dim}${skill.description}${c9.reset}`);
     }
-    console.log(`    ${c10.dim}id: ${skill.id}${c10.reset}`);
+    console.log(`    ${c9.dim}id: ${skill.id}${c9.reset}`);
   }
 });
 skillCommand.command("create").description("Create a new skill from a markdown file or inline content").argument("<name>", "Skill name").option("-d, --description <desc>", "Short description").option("-c, --category <cat>", "Category (e.g. Deployment, Testing)").option("-f, --file <path>", "Read content from a markdown file").option("--content <text>", "Inline markdown content").option("-p, --project", "Scope to the linked project").action(async (name, opts) => {
@@ -6969,7 +6589,7 @@ skillCommand.command("create").description("Create a new skill from a markdown f
     projectId
   });
   console.log(
-    `${c10.green}Created skill:${c10.reset} ${c10.bold}${skill.name}${c10.reset} ${c10.dim}(${skill.id})${c10.reset}`
+    `${c9.green}Created skill:${c9.reset} ${c9.bold}${skill.name}${c9.reset} ${c9.dim}(${skill.id})${c9.reset}`
   );
 });
 skillCommand.command("generate").alias("gen").description("Generate a new skill using AI from a text prompt").argument("<prompt>", "Describe the skill to generate").option("-p, --project", "Scope to the linked project").action(async (prompt2, opts) => {
@@ -6983,22 +6603,22 @@ skillCommand.command("generate").alias("gen").description("Generate a new skill
       process.exit(1);
     }
   }
-  console.log(`${c10.dim}Generating skill...${c10.reset}`);
+  console.log(`${c9.dim}Generating skill...${c9.reset}`);
   try {
     const skill = await api.post("/api/skills/generate", {
       prompt: prompt2,
       projectId
     });
     console.log(
-      `${c10.green}Generated skill:${c10.reset} ${c10.bold}${skill.name}${c10.reset}`
+      `${c9.green}Generated skill:${c9.reset} ${c9.bold}${skill.name}${c9.reset}`
     );
     if (skill.description) {
-      console.log(`  ${c10.dim}${skill.description}${c10.reset}`);
+      console.log(`  ${c9.dim}${skill.description}${c9.reset}`);
     }
     if (skill.category) {
-      console.log(`  ${c10.dim}Category: ${skill.category}${c10.reset}`);
+      console.log(`  ${c9.dim}Category: ${skill.category}${c9.reset}`);
     }
-    console.log(`  ${c10.dim}id: ${skill.id}${c10.reset}`);
+    console.log(`  ${c9.dim}id: ${skill.id}${c9.reset}`);
   } catch (err) {
     console.error(`Failed to generate skill: ${err.message}`);
     process.exit(1);
@@ -7006,17 +6626,17 @@ skillCommand.command("generate").alias("gen").description("Generate a new skill
 });
 
 // cli/commands/tests.ts
-import { Command as Command28 } from "commander";
-var c11 = {
+import { Command as Command27 } from "commander";
+var c10 = {
   reset: "\x1B[0m",
   dim: "\x1B[2m",
   yellow: "\x1B[33m"
 };
-var testsCommand = new Command28("tests").description("List MR Test scenarios for the linked project").action(async () => {
+var testsCommand = new Command27("tests").description("List MR Test scenarios for the linked project").action(async () => {
   const projectId = getLinkedProjectId();
   if (!projectId) {
     console.error(
-      `${c11.yellow}No project linked to this directory.${c11.reset} Run "mr link <project-id>" first.`
+      `${c10.yellow}No project linked to this directory.${c10.reset} Run "mr link <project-id>" first.`
     );
     process.exit(1);
   }
@@ -7029,13 +6649,13 @@ var testsCommand = new Command28("tests").description("List MR Test scenarios fo
     process.exit(1);
   }
   if (scenarios.length === 0) {
-    console.log(`${c11.dim}No test scenarios found for this project.${c11.reset}`);
+    console.log(`${c10.dim}No test scenarios found for this project.${c10.reset}`);
     return;
   }
   for (const scenario of scenarios) {
     console.log(`### ${scenario.name}`);
     if (scenario.description) {
-      console.log(`${c11.dim}${scenario.description}${c11.reset}`);
+      console.log(`${c10.dim}${scenario.description}${c10.reset}`);
       console.log();
     }
     console.log(scenario.content);
@@ -7050,7 +6670,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",
@@ -7060,28 +6680,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(CLI_VERSION);
 program.addCommand(initCommand);
 program.addCommand(authCommand);
@@ -7109,7 +6729,6 @@ program.addCommand(testCommand);
 program.addCommand(featuresCommand);
 program.addCommand(noMrCommand);
 program.addCommand(scanCommand);
-program.addCommand(ideaCommand);
 program.addCommand(doctorCommand);
 program.addCommand(promptAuditCommand);
 program.addCommand(skillCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunnewold-labs/mr-manager",
-  "version": "0.4.28",
+  "version": "0.4.29",
   "description": "Mr. Manager - Task and project management CLI",
   "bin": {
     "mr": "./dist/index.mjs"