@dunnewold-labs/mr-manager 0.3.0 → 0.4.2

package/dist/index.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // cli/index.ts
-import { Command as Command29 } from "commander";
-import { existsSync as existsSync15 } from "fs";
-import { homedir as homedir4 } from "os";
+import { Command as Command27 } from "commander";
+import { existsSync as existsSync16 } from "fs";
+import { homedir as homedir3 } from "os";
 import { join as join13 } from "path";
 
 // cli/commands/init.ts
@@ -177,19 +177,70 @@ var loginCommand = new Command3("login").description("Authenticate the CLI via b
 // cli/commands/projects.ts
 import { Command as Command4 } from "commander";
 
-// cli/api.ts
-import { readFileSync as readFileSync2 } from "fs";
+// cli/package.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join2, resolve } from "path";
 import { fileURLToPath } from "url";
-import { dirname, join as join2 } from "path";
-var cliVersion = "unknown";
-try {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = dirname(__filename);
-  const pkg = JSON.parse(readFileSync2(join2(__dirname, "..", "package.json"), "utf-8"));
-  cliVersion = pkg.version;
-} catch {
-  cliVersion = "0.2.0";
+
+// cli/package.json
+var package_default = {
+  name: "@dunnewold-labs/mr-manager",
+  version: "0.4.2",
+  description: "Mr. Manager - Task and project management CLI",
+  bin: {
+    mr: "./dist/index.mjs"
+  },
+  files: [
+    "dist"
+  ],
+  type: "module",
+  engines: {
+    node: ">=20"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    postinstall: `echo '\\n  Run "mr login" to authenticate with Mr. Manager.\\n'`
+  },
+  dependencies: {
+    commander: "^13.1.0"
+  }
+};
+
+// cli/package.ts
+var FALLBACK_CLI_VERSION = "0.2.0";
+var CLI_PACKAGE_NAME = "@dunnewold-labs/mr-manager";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function isCliPackageDir(dir) {
+  const pkgPath = join2(dir, "package.json");
+  if (!existsSync2(pkgPath)) {
+    return false;
+  }
+  try {
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    return pkg.name === CLI_PACKAGE_NAME;
+  } catch {
+    return false;
+  }
+}
+function resolveCliDir() {
+  const candidates = [resolve(__dirname), resolve(__dirname, "..")];
+  for (const candidate of candidates) {
+    if (isCliPackageDir(candidate)) {
+      return candidate;
+    }
+  }
+  return resolve(__dirname, "..");
 }
+var CLI_DIR = resolveCliDir();
+var REPO_ROOT = resolve(CLI_DIR, "..");
+var CLI_PACKAGE_PATH = join2(CLI_DIR, "package.json");
+var CLI_VERSION = package_default.version ?? FALLBACK_CLI_VERSION;
+
+// cli/api.ts
+var cliVersion = CLI_VERSION;
 var ApiError = class extends Error {
   constructor(status, statusText, body) {
     super(`API error ${status} ${statusText}: ${body}`);
@@ -365,7 +416,7 @@ var unlinkCommand = new Command6("unlink").description("Remove current directory
 
 // cli/commands/context.ts
 import { Command as Command7 } from "commander";
-import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
 import { join as join3, sep } from "path";
 var FEATURES_FILE = ".mr-features.md";
 function resolveProjectRoot() {
@@ -379,13 +430,13 @@ function resolveProjectRoot() {
 }
 function readFeatures() {
   const path = join3(resolveProjectRoot(), FEATURES_FILE);
-  if (!existsSync2(path)) return null;
+  if (!existsSync3(path)) return null;
   return readFileSync3(path, "utf-8");
 }
 var contextCommand = new Command7("context").description("Output project context JSON for Claude Code").option("--install", "Install Claude Code command to .claude/commands/").action(async (opts) => {
   if (opts.install) {
     const dir = join3(process.cwd(), ".claude", "commands");
-    if (!existsSync2(dir)) {
+    if (!existsSync3(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
     const filePath = join3(dir, "mr-tasks.md");
@@ -408,11 +459,13 @@ var contextCommand = new Command7("context").description("Output project context
     `/api/projects/${projectId}/tasks`
   );
   const inProgress = allTasks.filter((t) => t.status === "in_progress" || t.status === "queued" || t.status === "delegated" || t.status === "review");
+  const needsAttention = allTasks.filter((t) => t.status === "error");
   const todo = allTasks.filter((t) => t.status === "todo");
   const recentlyCompleted = allTasks.filter((t) => t.status === "completed").slice(0, 10);
   const summaryLines = [
     `Project: ${project.name} (${project.status})`,
     ...inProgress.map((t) => `In Progress: ${t.title}`),
+    ...needsAttention.map((t) => `Needs Attention: ${t.title}`),
     `Todo: ${todo.length} tasks`,
     `Recently Completed: ${recentlyCompleted.length} tasks`
   ];
@@ -438,23 +491,22 @@ var contextCommand = new Command7("context").description("Output project context
 import { Command as Command8 } from "commander";
 import { spawn as spawn4, exec } from "child_process";
 import { randomUUID } from "crypto";
-import { resolve, join as join7 } from "path";
-import { readFileSync as readFileSync5, readdirSync, unlinkSync, existsSync as existsSync6, statSync } from "fs";
-import { homedir as homedir2 } from "os";
+import { resolve as resolve2 } from "path";
+import { readFileSync as readFileSync5, readdirSync, unlinkSync, existsSync as existsSync7, statSync } from "fs";
 import * as readline from "readline";
 
 // lib/test-runner.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 import { join as join5 } from "path";
 
 // lib/git-worktree.ts
 import { execSync as execSync2 } from "child_process";
-import { copyFileSync, existsSync as existsSync3 } from "fs";
+import { copyFileSync, existsSync as existsSync4 } from "fs";
 import { join as join4 } from "path";
 function createWorktree(repoDir, branch, worktreeName) {
   const wtPath = join4(repoDir, ".mr-worktrees", worktreeName);
-  if (existsSync3(wtPath)) {
+  if (existsSync4(wtPath)) {
     execSync2(`git checkout ${branch}`, { cwd: wtPath, stdio: "pipe" });
     return wtPath;
   }
@@ -482,7 +534,7 @@ function createWorktree(repoDir, branch, worktreeName) {
   }
   for (const envFile of [".env", ".env.local"]) {
     const src = join4(repoDir, envFile);
-    if (existsSync3(src)) {
+    if (existsSync4(src)) {
       copyFileSync(src, join4(wtPath, envFile));
     }
   }
@@ -525,13 +577,13 @@ function extractBranchFromLink(link, cwd) {
   return null;
 }
 function installDependencies(wtPath) {
-  if (existsSync3(join4(wtPath, "bun.lock")) || existsSync3(join4(wtPath, "bun.lockb"))) {
+  if (existsSync4(join4(wtPath, "bun.lock")) || existsSync4(join4(wtPath, "bun.lockb"))) {
     execSync2("bun install", { cwd: wtPath, stdio: "pipe" });
-  } else if (existsSync3(join4(wtPath, "pnpm-lock.yaml"))) {
+  } else if (existsSync4(join4(wtPath, "pnpm-lock.yaml"))) {
     execSync2("pnpm install --frozen-lockfile", { cwd: wtPath, stdio: "pipe" });
-  } else if (existsSync3(join4(wtPath, "package-lock.json"))) {
+  } else if (existsSync4(join4(wtPath, "package-lock.json"))) {
     execSync2("npm ci", { cwd: wtPath, stdio: "pipe" });
-  } else if (existsSync3(join4(wtPath, "yarn.lock"))) {
+  } else if (existsSync4(join4(wtPath, "yarn.lock"))) {
     execSync2("yarn install --frozen-lockfile", { cwd: wtPath, stdio: "pipe" });
   }
 }
@@ -539,7 +591,7 @@ function installDependencies(wtPath) {
 // lib/test-runner.ts
 function detectDevCommand(wtPath) {
   const configPath2 = join5(wtPath, ".mr-test.json");
-  if (existsSync4(configPath2)) {
+  if (existsSync5(configPath2)) {
     try {
       const config = JSON.parse(readFileSync4(configPath2, "utf-8"));
       if (config.devCommand) {
@@ -549,16 +601,16 @@ function detectDevCommand(wtPath) {
     } catch {
     }
   }
-  if (existsSync4(join5(wtPath, "bun.lock")) || existsSync4(join5(wtPath, "bun.lockb"))) {
+  if (existsSync5(join5(wtPath, "bun.lock")) || existsSync5(join5(wtPath, "bun.lockb"))) {
     return { cmd: "bun", args: ["dev"] };
   }
-  if (existsSync4(join5(wtPath, "pnpm-lock.yaml"))) {
+  if (existsSync5(join5(wtPath, "pnpm-lock.yaml"))) {
     return { cmd: "pnpm", args: ["dev"] };
   }
-  if (existsSync4(join5(wtPath, "package-lock.json"))) {
+  if (existsSync5(join5(wtPath, "package-lock.json"))) {
     return { cmd: "npm", args: ["run", "dev"] };
   }
-  if (existsSync4(join5(wtPath, "yarn.lock"))) {
+  if (existsSync5(join5(wtPath, "yarn.lock"))) {
     return { cmd: "yarn", args: ["dev"] };
   }
   return { cmd: "npm", args: ["run", "dev"] };
@@ -696,7 +748,7 @@ async function runTest(options) {
     postUpdate,
     onProgress
   } = options;
-  const log4 = onProgress || (() => {
+  const log2 = onProgress || (() => {
   });
   const result = {
     status: "passed",
@@ -709,37 +761,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");
+    log2("Test timed out after 5 minutes");
     if (devProc) devProc.kill("SIGTERM");
   }, 5 * 60 * 1e3);
   try {
-    log4("Extracting branch from MR/PR link...");
+    log2("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...");
+    log2(`Branch: ${branch}`);
+    log2("Creating git worktree...");
     wtPath = createWorktree(localPath, branch, worktreeName);
-    log4(`Worktree created at ${wtPath}`);
-    log4("Installing dependencies...");
+    log2(`Worktree created at ${wtPath}`);
+    log2("Installing dependencies...");
     try {
       installDependencies(wtPath);
     } catch (err) {
-      log4(`Warning: dependency install failed: ${err.message}`);
+      log2(`Warning: dependency install failed: ${err.message}`);
     }
-    log4("Starting dev server...");
+    log2("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}`);
+    log2(`Dev server running on ${baseUrl}`);
     await browseRunner(["goto", baseUrl]);
     const plan = customPlan || buildDefaultTestPlan(baseUrl);
-    log4(`Executing ${plan.length}-step test plan...`);
+    log2(`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}`);
+      log2(`Step ${i + 1}/${plan.length}: ${stepDesc}`);
       try {
         if (step.command.startsWith("assert")) {
           const assertResult = await evaluateAssertion(step, i, browseRunner);
@@ -789,7 +841,7 @@ async function runTest(options) {
         }
       } catch (err) {
         result.errors.push(`Step ${i + 1} (${step.command}): ${err.message}`);
-        log4(`Step ${i + 1} error: ${err.message}`);
+        log2(`Step ${i + 1} error: ${err.message}`);
       }
     }
     const totalAssertions = result.assertions.length;
@@ -835,18 +887,18 @@ async function runTest(options) {
 
 // cli/browse-runner.ts
 import { execSync as execSync4, spawn as spawn3 } from "child_process";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { join as join6 } from "path";
 var BROWSE_DIR = join6(import.meta.dirname, "..", "..", "browse");
 var BROWSE_BINARY = join6(BROWSE_DIR, "dist", "browse");
 var BROWSE_DEV_CMD = join6(BROWSE_DIR, "src", "cli.ts");
 function getBrowseRunner() {
-  if (existsSync5(BROWSE_BINARY)) {
+  if (existsSync6(BROWSE_BINARY)) {
     return { cmd: BROWSE_BINARY, args: [] };
   }
   try {
     execSync4("which bun", { stdio: "pipe" });
-    if (existsSync5(BROWSE_DEV_CMD)) {
+    if (existsSync6(BROWSE_DEV_CMD)) {
       return { cmd: "bun", args: ["run", BROWSE_DEV_CMD] };
     }
   } catch {
@@ -886,95 +938,11 @@ async function runBrowseCommand2(browseArgs) {
 
 // cli/commands/watch.ts
 var FEATURES_FILE2 = ".mr-features.md";
-var CLAUDE_PROJECTS_DIR = join7(homedir2(), ".claude", "projects");
 function readFeaturesDoc(repoDir) {
-  const path = resolve(repoDir, FEATURES_FILE2);
-  if (!existsSync6(path)) return null;
+  const path = resolve2(repoDir, FEATURES_FILE2);
+  if (!existsSync7(path)) return null;
   return readFileSync5(path, "utf-8");
 }
-function toClaudePath(dir) {
-  return dir.replace(/\//g, "-");
-}
-function findSessionFile(sessionId, repoDir) {
-  const mainPath = join7(CLAUDE_PROJECTS_DIR, toClaudePath(repoDir));
-  const mainFile = join7(mainPath, `${sessionId}.jsonl`);
-  if (existsSync6(mainFile)) return mainFile;
-  const worktreePrefix = toClaudePath(repoDir) + "-.mr-worktrees-";
-  try {
-    const entries = readdirSync(CLAUDE_PROJECTS_DIR);
-    for (const entry of entries) {
-      if (entry.startsWith(worktreePrefix)) {
-        const worktreeFile = join7(CLAUDE_PROJECTS_DIR, entry, `${sessionId}.jsonl`);
-        if (existsSync6(worktreeFile)) return worktreeFile;
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-function parseSessionJsonl(raw) {
-  const lines = raw.split("\n").filter((l) => l.trim());
-  const entries = [];
-  for (const line of lines) {
-    try {
-      const parsed = JSON.parse(line);
-      if (parsed.type !== "user" && parsed.type !== "assistant") continue;
-      if (!parsed.message) continue;
-      const content = [];
-      const msgContent = parsed.message.content;
-      if (typeof msgContent === "string") {
-        content.push({ type: "text", text: msgContent });
-      } else if (Array.isArray(msgContent)) {
-        for (const block of msgContent) {
-          if (block.type === "thinking" && block.thinking) {
-            content.push({ type: "thinking", thinking: block.thinking });
-          } else if (block.type === "text" && block.text) {
-            content.push({ type: "text", text: block.text });
-          } else if (block.type === "tool_use") {
-            content.push({
-              type: "tool_use",
-              id: block.id,
-              name: block.name,
-              input: block.input ?? {}
-            });
-          } else if (block.type === "tool_result") {
-            let resultContent = block.content;
-            if (typeof resultContent === "string") {
-            } else if (Array.isArray(resultContent)) {
-              resultContent = resultContent.filter((r) => r.type === "text").map((r) => r.text).join("\n");
-            } else {
-              resultContent = "";
-            }
-            content.push({
-              type: "tool_result",
-              tool_use_id: block.tool_use_id,
-              content: resultContent
-            });
-          }
-        }
-      }
-      if (content.length === 0) continue;
-      entries.push({
-        type: parsed.type,
-        timestamp: parsed.timestamp,
-        uuid: parsed.uuid,
-        content
-      });
-    } catch {
-    }
-  }
-  return entries;
-}
-function readAndParseSessionLog(sessionId, repoDir) {
-  const filePath = findSessionFile(sessionId, repoDir);
-  if (!filePath) return null;
-  try {
-    const raw = readFileSync5(filePath, "utf-8");
-    return parseSessionJsonl(raw);
-  } catch {
-    return null;
-  }
-}
 var c = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -1028,9 +996,20 @@ async function postTaskUpdate(taskId, message, source = "system") {
     logError(taskTag(shortId(taskId)), `Failed to post update: ${err.message}`);
   }
 }
+var DEFAULT_TASK_STALL_TIMEOUT_MS = 45 * 60 * 1e3;
+function getTaskStallTimeoutMs() {
+  const raw = process.env.MR_TASK_STALL_TIMEOUT_MS;
+  if (!raw) return DEFAULT_TASK_STALL_TIMEOUT_MS;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_TASK_STALL_TIMEOUT_MS;
+}
+function formatTimeoutMinutes(ms) {
+  const minutes = Math.round(ms / 6e4);
+  return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+}
 function findDirectoryForProject(config, projectId, rootDir) {
   for (const [dir, pid] of Object.entries(config.directories)) {
-    if (pid === projectId && resolve(dir).startsWith(resolve(rootDir))) {
+    if (pid === projectId && resolve2(dir).startsWith(resolve2(rootDir))) {
       return dir;
     }
   }
@@ -1102,14 +1081,14 @@ function findPrUrl(branchName, repoDir, vcs = "github") {
 }
 function isGitRepo(dir) {
   try {
-    return existsSync6(resolve(dir, ".git"));
+    return existsSync7(resolve2(dir, ".git"));
   } catch {
     return false;
   }
 }
 function findChildGitRepos(parentDir) {
   try {
-    return readdirSync(parentDir).filter((name) => !name.startsWith(".")).map((name) => resolve(parentDir, name)).filter((path) => {
+    return readdirSync(parentDir).filter((name) => !name.startsWith(".")).map((name) => resolve2(parentDir, name)).filter((path) => {
       try {
         return statSync(path).isDirectory() && isGitRepo(path);
       } catch {
@@ -1808,7 +1787,7 @@ function buildAgentArgs(agent, prompt2, mode, sessionId, name) {
   if (agent === "codex") {
     const args = ["exec"];
     if (mode === "execute") {
-      args.push("--full-auto");
+      args.push("-a", "never", "-s", "danger-full-access");
     }
     args.push(prompt2);
     return { bin: "codex", args };
@@ -1847,7 +1826,7 @@ function runPlanningPhase(task, repoDir, agent) {
 ${output.trim()}`));
         return;
       }
-      const planPath = resolve(repoDir, "plan.md");
+      const planPath = resolve2(repoDir, "plan.md");
       try {
         const planContent = readFileSync5(planPath, "utf-8");
         try {
@@ -1873,7 +1852,7 @@ function askYesNo(question) {
     });
   });
 }
-function spawnAgent(agent, repoDir, prompt2, prefix, sessionId, name) {
+function spawnAgent(agent, repoDir, prompt2, prefix, onActivity, sessionId, name) {
   const { bin, args } = buildAgentArgs(agent, prompt2, "execute", sessionId, name);
   const child = spawn4(bin, args, { cwd: repoDir, stdio: ["ignore", "pipe", "pipe"] });
   child.on("error", (err) => {
@@ -1882,12 +1861,19 @@ function spawnAgent(agent, repoDir, prompt2, prefix, sessionId, name) {
       logError(prefix, `Check that "${bin}" is on PATH and "${repoDir}" exists`);
     }
   });
+  if (agent === "codex") {
+    child.stdout?.on("data", () => onActivity?.());
+    child.stderr?.on("data", () => onActivity?.());
+    return child;
+  }
   child.stdout?.on("data", (data) => {
+    onActivity?.();
     for (const line of data.toString().split("\n")) {
       if (line) console.log(`${timestamp()} ${prefix} ${paint("dim", line)}`);
     }
   });
   child.stderr?.on("data", (data) => {
+    onActivity?.();
     for (const line of data.toString().split("\n")) {
       if (line) logError(prefix, paint("dim", line));
     }
@@ -1900,18 +1886,22 @@ var watchCommand = new Command8("watch").description(
   const intervalMs = parseInt(opts.interval, 10) * 1e3;
   const dryRun = opts.dryRun;
   const planApproval = opts.planApproval;
-  const rootDir = opts.root ? resolve(opts.root) : process.cwd();
+  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 taskStallTimeoutMs = getTaskStallTimeoutMs();
   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 = [
     `interval=${paint("cyan", opts.interval + "s")}`,
     `root=${paint("cyan", rootDir)}`,
     `agent=${paint("cyan", agent)}`,
+    `stall-timeout=${paint("cyan", formatTimeoutMinutes(taskStallTimeoutMs))}`,
     ...planApproval ? [paint("yellow", "plan-approval")] : [],
     ...dryRun ? [paint("yellow", "dry-run")] : [],
     ...scanAt ? [`scan-at=${paint("cyan", scanAt)}`] : []
@@ -1981,124 +1971,94 @@ var watchCommand = new Command8("watch").description(
     }
     const prompt2 = buildExecutionPrompt(task, repoDir, subtasks, vcs, protoRefs, feedbackUpdates, existingResources, skillRefs);
     const sessionId = agent === "claude" ? randomUUID() : void 0;
-    const child = spawnAgent(agent, repoDir, prompt2, prefix, sessionId, task.title);
+    const activeEntry = {
+      process: void 0,
+      title: task.title,
+      repoDir,
+      startedAt: Date.now(),
+      lastActivityAt: Date.now()
+    };
+    const touchActivity = () => {
+      activeEntry.lastActivityAt = Date.now();
+    };
+    const child = spawnAgent(agent, repoDir, prompt2, prefix, touchActivity, sessionId, task.title);
+    activeEntry.process = child;
     if (sessionId) {
       api.patch(`/api/tasks/${task.id}`, { claudeSessionId: sessionId }).catch(() => {
       });
       logInfo(prefix, `Claude session: ${paint("dim", sessionId)}`);
     }
-    active.set(task.id, { process: child, title: task.title, repoDir });
+    active.set(task.id, activeEntry);
     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`);
-              } 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
+      finishing.add(task.id);
+      try {
+        if (code === 0) {
+          try {
+            const researchPath = resolve2(repoDir, "research.md");
+            if (existsSync7(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 session log resource (${sessionEntries.length} messages)`);
+                  logSuccess(prefix, `Updated existing research resource`);
                 } else {
                   await api.post(`/api/tasks/${task.id}/resources`, {
-                    type: "session-log",
-                    title: `Session Log \u2014 ${task.title}`,
-                    content: sessionContent
+                    type: "research",
+                    title: `Research \u2014 ${task.title}`,
+                    content: researchContent
                   });
-                  logSuccess(prefix, `Uploaded session log (${sessionEntries.length} messages)`);
+                  logSuccess(prefix, `Uploaded research.md as task resource`);
                 }
-              }
-            } 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)}`);
+                unlinkSync(researchPath);
+              } catch (err) {
+                logWarn(prefix, `Failed to upload research resource: ${err.message}`);
               }
             }
-            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");
+            const noMrPath = resolve2(repoDir, ".mr-no-mr");
+            const noMrRequested = existsSync7(noMrPath);
+            let noMrDescription;
+            if (noMrRequested) {
+              noMrDescription = readFileSync5(noMrPath, "utf-8").trim();
+              unlinkSync(noMrPath);
+              logSuccess(prefix, `No ${vcs === "gitlab" ? "MR" : "PR"} needed \u2014 ${noMrDescription}`);
             }
-          }
-          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
-                });
+            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: "session-log",
-                  title: `Session Log \u2014 ${task.title}`,
-                  content: sessionContent
-                });
+                logWarn(prefix, `No ${prLabel} found for branch ${paint("cyan", branchName)}`);
+                await postTaskUpdate(task.id, `Agent finished \u2014 no ${prLabel} found for branch ${branchName}`, "system");
               }
-              logInfo(prefix, `Uploaded session log for failed task (${sessionEntries.length} messages)`);
             }
-          } 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 if (!activeEntry.terminatedForError) {
+          logError(prefix, `"${paint("bold", task.title)}" failed (exit ${code}), leaving status unchanged`);
+          await postTaskUpdate(task.id, `Agent failed with exit code ${code}`, "system");
         }
+      } finally {
+        queued.delete(task.id);
+        finishing.delete(task.id);
       }
     });
   }
@@ -2135,49 +2095,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 = resolve2(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);
       }
     });
   }
@@ -2188,7 +2153,7 @@ var watchCommand = new Command8("watch").description(
     const stalePattern = /^prototype-\d+\.html$/;
     for (const f of readdirSync(repoDir).filter((f2) => stalePattern.test(f2))) {
       try {
-        unlinkSync(resolve(repoDir, f));
+        unlinkSync(resolve2(repoDir, f));
       } catch {
       }
     }
@@ -2208,42 +2173,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(resolve2(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(resolve2(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 +2230,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);
       }
     });
   }
@@ -2278,7 +2255,7 @@ var watchCommand = new Command8("watch").description(
     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(resolve(repoDir, f));
+        unlinkSync(resolve2(repoDir, f));
       } catch {
       }
     }
@@ -2286,85 +2263,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 = 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 {
             }
-          } 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 +2426,371 @@ ${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") {
+      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 task of tasks) {
+        if (task.status !== "delegated") continue;
+        const sid = shortId(task.id);
+        const prefix = taskTag(sid);
+        const activeEntry = active.get(task.id);
+        const idleMs = activeEntry ? Date.now() - activeEntry.lastActivityAt : null;
+        const delegatedAtMs = task.inProgressSince ? Date.now() - new Date(task.inProgressSince).getTime() : null;
+        const exceededIdleTimeout = idleMs !== null && idleMs >= taskStallTimeoutMs;
+        const exceededOrphanTimeout = !activeEntry && delegatedAtMs !== null && delegatedAtMs >= taskStallTimeoutMs;
+        if (!exceededIdleTimeout && !exceededOrphanTimeout) continue;
+        const timeoutLabel = formatTimeoutMinutes(taskStallTimeoutMs);
+        const reason = activeEntry ? `Agent process became idle for more than ${timeoutLabel}` : `Task remained delegated without an active watch process for more than ${timeoutLabel}`;
+        logError(prefix, `"${task.title}" marked as error: ${reason}`);
+        if (activeEntry) {
+          activeEntry.terminatedForError = true;
+        }
         try {
-          await api.patch(`/api/tasks/${task.id}`, { status: "delegated" });
+          await api.patch(`/api/tasks/${task.id}`, { status: "error" });
+          await postTaskUpdate(task.id, `Task moved to error \u2014 ${reason}`, "system");
         } catch (err) {
-          logError(prefix, `Failed to mark task as delegated: ${err.message}`);
+          logError(prefix, `Failed to mark task as error: ${err.message}`);
           continue;
         }
+        failed.set(task.id, reason);
+        queued.delete(task.id);
+        if (activeEntry) {
+          activeEntry.process.kill("SIGTERM");
+        }
       }
-      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;
+      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);
+        }
       }
-      if (task.mode === "planning") {
-        dispatchPlanModeTask(task, repoDir);
-      } else if (planApproval) {
-        approvalQueue.push({ task, repoDir });
-        processApprovalQueue();
-      } else {
-        dispatchTask(task, repoDir);
+      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);
       }
-    }
-    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 taskId of queued) {
+        if (nonTaskPrefixes.some((p) => taskId.startsWith(p))) continue;
+        if (finishing.has(taskId)) continue;
+        if (!activeTaskIds.has(taskId)) queued.delete(taskId);
       }
-    }
-    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 (!existsSync7(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 (!existsSync7(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 +2969,8 @@ var subtaskCompleteCommand = new Command12("subtask-complete").description("Mark
   console.log(`\u2713 Subtask completed: ${subtask.title}`);
 });
 
-// cli/commands/digest.ts
+// cli/commands/prototype.ts
 import { Command as Command13 } from "commander";
-import { spawn as spawn5 } from "child_process";
 var c4 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -2955,360 +2979,28 @@ var c4 = {
   green: "\x1B[32m",
   yellow: "\x1B[33m",
   red: "\x1B[31m",
-  magenta: "\x1B[35m",
+  blue: "\x1B[34m",
   gray: "\x1B[90m"
 };
 function paint4(color, text) {
   return `${c4[color]}${text}${c4.reset}`;
 }
-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 log(msg) {
-  console.log(`${timestamp2()} ${digestTag()} ${msg}`);
-}
-function logOk(msg) {
-  console.log(`${timestamp2()} ${digestTag()} ${paint4("green", "\u2713")} ${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}`);
-}
-function spawnMr(args) {
-  const entry = process.argv[1];
-  const child = spawn6(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) => {
-  const watchInterval = opts.watchInterval ?? opts.interval;
-  const digestInterval = opts.digestInterval ?? opts.interval;
-  const agent = opts.agent === "codex" ? "codex" : "claude";
-  const watchArgs = ["watch", "--interval", watchInterval, "--agent", agent];
-  if (opts.dryRun) watchArgs.push("--dry-run");
-  if (opts.planApproval) watchArgs.push("--plan-approval");
-  if (opts.root) watchArgs.push("--root", opts.root);
-  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}`),
-    ``
-  ].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))}`] : []
-  ].join("  ");
-  console.log(`  ${flags}
-`);
-  const watchProc = spawnMr(watchArgs);
-  const digestProc = spawnMr(digestArgs);
-  for (const [proc, label] of [[watchProc, "watch"], [digestProc, "digest"]]) {
-    proc.stdout?.on("data", (d) => process.stdout.write(d));
-    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"})`);
-      }
-    });
-  }
-  function shutdown() {
-    log2("Shutting down\u2026");
-    watchProc.kill("SIGTERM");
-    digestProc.kill("SIGTERM");
-    setTimeout(() => process.exit(0), 500);
-  }
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-});
-
-// cli/commands/prototype.ts
-import { Command as Command15 } from "commander";
-var c6 = {
-  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"
-};
-function paint6(color, text) {
-  return `${c6[color]}${text}${c6.reset}`;
-}
 function statusBadge(status) {
   switch (status) {
     case "pending":
-      return paint6("gray", "\u25CB pending");
+      return paint4("gray", "\u25CB pending");
     case "in_progress":
-      return paint6("cyan", "\u27F3 in_progress");
+      return paint4("cyan", "\u27F3 in_progress");
     case "completed":
-      return paint6("green", "\u2713 completed");
+      return paint4("green", "\u2713 completed");
     case "failed":
-      return paint6("red", "\u2717 failed");
+      return paint4("red", "\u2717 failed");
     default:
-      return paint6("gray", status);
+      return paint4("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 Command13("prototype").description("Manage prototypes").addCommand(
+  new Command13("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 +3012,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(paint4("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)}`
+        `  ${paint4("bold", p.title)}  ${statusBadge(p.status)}  ${paint4("gray", p.id.slice(0, 8))}  ${paint4("dim", date)}`
       );
-      console.log(`  ${paint6("dim", p.prompt.slice(0, 80) + (p.prompt.length > 80 ? "\u2026" : ""))}`);
+      console.log(`  ${paint4("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 Command13("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 +3040,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(`  ${paint4("green", "\u2713")} Created prototype: ${paint4("bold", prototype.title)}`);
+    console.log(`  ${paint4("gray", "ID:")} ${prototype.id}`);
+    console.log(`  ${paint4("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 Command13("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(`  ${paint4("cyan", "\u27F3")} Started: ${paint4("bold", prototype.title)}`);
+    console.log(`  ${paint4("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 Command13("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(`  ${paint4("cyan", "\u27F3")} Retrying: ${paint4("bold", prototype.title)}`);
     console.log();
   })
 );
 
 // cli/commands/setup.ts
-import { Command as Command16 } from "commander";
+import { Command as Command14 } from "commander";
 import { exec as exec2 } from "child_process";
-var c7 = {
+var c5 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -3389,8 +3081,8 @@ var c7 = {
   magenta: "\x1B[35m",
   gray: "\x1B[90m"
 };
-function paint7(color, text) {
-  return `${c7[color]}${text}${c7.reset}`;
+function paint5(color, text) {
+  return `${c5[color]}${text}${c5.reset}`;
 }
 function commandExists(cmd) {
   return new Promise((resolve7) => {
@@ -3634,60 +3326,60 @@ async function checkApiConnectivity() {
   }
 }
 function printResults(checks) {
-  const maxNameLen = Math.max(...checks.map((c12) => c12.name.length));
+  const maxNameLen = Math.max(...checks.map((c10) => c10.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 ? paint5("green", "\u2713") : isOptional ? paint5("yellow", "\u25CB") : paint5("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 ? paint5("green", check.message) : isOptional ? paint5("yellow", check.message) : paint5("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: spawn8 } = await import("child_process");
+  const ghInstalled = checks.find((c10) => c10.name === "GitHub CLI (gh)").ok;
+  const ghAuthed = checks.find((c10) => c10.name === "GitHub CLI auth").ok;
+  const mrAuthed = checks.find((c10) => c10.name === "Mr. Manager CLI auth").ok;
+  const claudeCheck = checks.find((c10) => c10.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(paint5("cyan", "  Installing Claude Code..."));
+    console.log(paint5("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 = spawn8("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(paint5("cyan", "  Running gh auth login..."));
     await new Promise((resolve7) => {
-      const child = spawn10("gh", ["auth", "login"], { stdio: "inherit" });
+      const child = spawn8("gh", ["auth", "login"], { stdio: "inherit" });
       child.on("exit", () => resolve7());
     });
     console.log("");
   }
   if (!mrAuthed) {
-    console.log(paint7("cyan", "  Running mr login..."));
+    console.log(paint5("cyan", "  Running mr login..."));
     const entry = process.argv[1];
     await new Promise((resolve7) => {
-      const child = spawn10(process.execPath, [entry, "login"], { stdio: "inherit" });
+      const child = spawn8(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 Command14("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})`),
+    paint5("cyan", `  \u2554\u2566\u2557\u2551\u2550\u2557  \u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2566\u2557\u2551 \u2551\u2554\u2550\u2557`),
+    paint5("magenta", `  \u2551\u2551\u2551\u2560\u2566\u2563  \u255A\u2550\u2557\u2551\u2563  \u2551 \u2551 \u2551\u2560\u2550\u2563`),
+    paint5("cyan", `  \u2569 \u2569\u2569\u255A\u2550  \u255A\u2550\u255D\u255A\u2550\u255D \u2569 \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`),
+    paint5("dim", `  environment check for mr watch (agent: ${agent})`),
     ``
   ].join("\n");
   console.log(banner);
@@ -3707,18 +3399,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(paint5("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(paint5("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((c10) => !c10.ok && c10.fix && !c10.optional);
   if (fixes.length > 0) {
-    console.log(paint7("yellow", "  To fix:"));
+    console.log(paint5("yellow", "  To fix:"));
     for (const fix of fixes) {
-      console.log(`  ${paint7("dim", "\u2192")} ${paint7("bold", fix.name)}: ${fix.fix}`);
+      console.log(`  ${paint5("dim", "\u2192")} ${paint5("bold", fix.name)}: ${fix.fix}`);
     }
     console.log("");
   }
@@ -3729,8 +3421,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 Command15 } from "commander";
+var updateCommand = new Command15("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 +3431,11 @@ var updateCommand = new Command17("update").description("Post a status update to
 });
 
 // cli/commands/screenshot.ts
-import { Command as Command18 } from "commander";
-import { readFileSync as readFileSync6, existsSync as existsSync7, unlinkSync as unlinkSync2 } from "fs";
+import { Command as Command16 } from "commander";
+import { readFileSync as readFileSync6, existsSync as existsSync8, unlinkSync as unlinkSync2 } from "fs";
 import { join as join8 } from "path";
 import { tmpdir } from "os";
-var screenshotCommand = new Command18("screenshot").description(
+var screenshotCommand = new Command16("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;
@@ -3780,13 +3472,13 @@ var screenshotCommand = new Command18("screenshot").description(
       console.error("[screenshot] Make sure the browse daemon is set up: mr browse setup");
       process.exit(1);
     }
-    if (!existsSync7(tempFile)) {
+    if (!existsSync8(tempFile)) {
       console.error("[screenshot] Screenshot file was not created");
       process.exit(1);
     }
     filePath = tempFile;
   }
-  if (!existsSync7(filePath)) {
+  if (!existsSync8(filePath)) {
     console.error(`File not found: ${filePath}`);
     process.exit(1);
   }
@@ -3828,16 +3520,16 @@ var screenshotCommand = new Command18("screenshot").description(
     source: "agent"
   });
   console.log(`\u2713 Screenshot uploaded and attached to task`);
-  if (tempFile && existsSync7(tempFile)) {
+  if (tempFile && existsSync8(tempFile)) {
     unlinkSync2(tempFile);
   }
 });
 
 // cli/commands/resume.ts
-import { Command as Command19 } from "commander";
-import { spawn as spawn7 } from "child_process";
+import { Command as Command17 } from "commander";
+import { spawn as spawn5 } from "child_process";
 import { resolve as resolve3 } from "path";
-var c8 = {
+var c6 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -3848,15 +3540,15 @@ var c8 = {
   magenta: "\x1B[35m",
   gray: "\x1B[90m"
 };
-function paint8(color, text) {
-  return `${c8[color]}${text}${c8.reset}`;
+function paint6(color, text) {
+  return `${c6[color]}${text}${c6.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 Command17("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))}`
+  ${paint6("red", "\u2717")} No Claude session found for task ${paint6("dim", taskId.slice(0, 8))}`
     );
     console.error(
       `    The task may not have been dispatched yet.
@@ -3867,16 +3559,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.`
+  ${paint6("yellow", "\u26A0")} Task ${paint6("dim", taskId.slice(0, 8))} has already completed.`
     );
     console.error(
-      `    Session ID: ${paint8("cyan", task.claudeSessionId)}`
+      `    Session ID: ${paint6("cyan", task.claudeSessionId)}`
     );
     console.error(
-      `    View the session log in the Mr. Manager web UI, or run:`
+      `    To resume the session, run:`
     );
     console.error(
-      `    ${paint8("dim", `claude --resume ${task.claudeSessionId}`)}
+      `    ${paint6("dim", `claude --resume ${task.claudeSessionId}`)}
 `
     );
     process.exit(0);
@@ -3895,16 +3587,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)}`,
+    paint6("magenta", `  \u2554\u2566\u2557\u2566\u2550\u2557  `) + paint6("bold", "resume"),
+    paint6("magenta", `  \u2551\u2551\u2551\u2560\u2566\u255D  `) + paint6("dim", "\u2500".repeat(44)),
+    paint6("magenta", `  \u2569 \u2569\u2569\u255A\u2550  `) + task.title,
+    `           ${paint6("gray", sid)}`,
     ``,
-    `  ${paint8("dim", "session")}  ${paint8("cyan", task.claudeSessionId)}`,
-    `  ${paint8("dim", "cwd")}      ${paint8("cyan", cwd)}`,
+    `  ${paint6("dim", "session")}  ${paint6("cyan", task.claudeSessionId)}`,
+    `  ${paint6("dim", "cwd")}      ${paint6("cyan", cwd)}`,
     ``
   ].join("\n"));
-  const child = spawn7("claude", ["--resume", task.claudeSessionId], {
+  const child = spawn5("claude", ["--resume", task.claudeSessionId], {
     cwd,
     stdio: "inherit"
   });
@@ -3913,16 +3605,16 @@ 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}
+  ${paint6("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 { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { Command as Command18 } from "commander";
+import { execSync as execSync5, spawn as spawn6 } from "child_process";
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import { join as join9 } from "path";
 var BROWSE_DIR2 = join9(import.meta.dirname, "..", "..", "browse");
 function isProcessAlive(pid) {
@@ -3962,7 +3654,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 = spawn6("npm", ["run", "dev", "--", "--port", String(port)], {
     stdio: ["ignore", "pipe", "pipe"],
     detached: true,
     cwd: join9(import.meta.dirname, "..", ".."),
@@ -3984,7 +3676,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 Command18("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(
@@ -4027,7 +3719,7 @@ var browseCommand = new Command20("browse").description("Control a headless brow
     }
     if (command === "screenshot" && opts.taskId) {
       const screenshotPath = stdout.match(/Screenshot saved: (.+)/)?.[1];
-      if (!screenshotPath || !existsSync8(screenshotPath)) {
+      if (!screenshotPath || !existsSync9(screenshotPath)) {
         console.error("[browse] Could not find screenshot file");
         process.exit(1);
       }
@@ -4067,12 +3759,12 @@ var browseCommand = new Command20("browse").description("Control a headless brow
 );
 
 // cli/commands/set-path.ts
-import { Command as Command21 } from "commander";
+import { Command as Command19 } 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) => {
+import { existsSync as existsSync10 } from "fs";
+var setPathCommand = new Command19("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)) {
+  if (!existsSync10(absolutePath)) {
     console.error(`Error: Path does not exist: ${absolutePath}`);
     process.exit(1);
   }
@@ -4088,9 +3780,9 @@ var setPathCommand = new Command21("set-path").description("Set or update the lo
 });
 
 // cli/commands/test.ts
-import { Command as Command22 } 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) => {
+import { Command as Command20 } from "commander";
+import { readFileSync as readFileSync8, existsSync as existsSync11 } from "fs";
+var testCommand = new Command20("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;
@@ -4111,7 +3803,7 @@ var testCommand = new Command22("test").description("Run automated browser test
     );
     process.exit(1);
   }
-  if (!existsSync10(localPath)) {
+  if (!existsSync11(localPath)) {
     console.error(
       `[test] Local repo path not found at ${localPath}. Run \`mr set-path\` to update.`
     );
@@ -4210,11 +3902,11 @@ var testCommand = new Command22("test").description("Run automated browser test
 });
 
 // cli/commands/features.ts
-import { Command as Command23 } from "commander";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync11 } from "fs";
+import { Command as Command21 } from "commander";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync12 } from "fs";
 import { resolve as resolve5, sep as sep2 } from "path";
 var FEATURES_FILE3 = ".mr-features.md";
-var c9 = {
+var c7 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -4224,8 +3916,8 @@ var c9 = {
   magenta: "\x1B[35m",
   gray: "\x1B[90m"
 };
-function paint9(color, text) {
-  return `${c9[color]}${text}${c9.reset}`;
+function paint7(color, text) {
+  return `${c7[color]}${text}${c7.reset}`;
 }
 function resolveProjectRoot2() {
   const cwd = process.cwd();
@@ -4241,10 +3933,10 @@ function getFeaturesPath() {
 }
 function readFeatures2() {
   const path = getFeaturesPath();
-  if (!existsSync11(path)) return null;
+  if (!existsSync12(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 Command21("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 +3945,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(`${paint7("green", "\u2713")} Updated ${paint7("cyan", featuresPath)} from ${paint7("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(`${paint7("green", "\u2713")} Updated ${paint7("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(paint7("dim", `No features document found. One will be created when an agent completes a task.`));
+    console.log(paint7("dim", `Path: ${getFeaturesPath()}`));
     return;
   }
   console.log(content);
 });
 
 // cli/commands/no-mr.ts
-import { Command as Command24 } from "commander";
+import { Command as Command22 } 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 Command22("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 +3980,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 Command23 } from "commander";
+function paint8(color, text) {
   const colors = {
     cyan: "\x1B[36m",
     green: "\x1B[32m",
@@ -4300,7 +3992,7 @@ function paint10(color, text) {
   };
   return `${colors[color] ?? ""}${text}${colors.reset}`;
 }
-var mobileCommand = new Command25("mobile").description(
+var mobileCommand = new Command23("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 +4004,7 @@ var mobileCommand = new Command25("mobile").description(
       process.exit(1);
     }
     console.log(
-      paint10("cyan", "mobile") + paint10("dim", " \u2014 starting conversion wizard")
+      paint8("cyan", "mobile") + paint8("dim", " \u2014 starting conversion wizard")
     );
     const task = await api.post("/api/tasks", {
       title: "Convert to Mobile App",
@@ -4343,13 +4035,13 @@ var mobileCommand = new Command25("mobile").description(
     }
     console.log(
       `
-  ${paint10("green", "\u2713")} Wizard initialized. Open the web UI to continue:
+  ${paint8("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 Command23("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 +4054,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(paint8("cyan", "Mobile Conversion Status"));
     console.log(`  Phase: ${state.phase}`);
     if (state.framework) {
       console.log(`  Framework: ${state.framework}`);
@@ -4385,13 +4077,13 @@ 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 Command24 } from "commander";
 
 // lib/scanner/index.ts
-import { spawn as spawn9 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 
 // lib/scanner/config.ts
-import { readFileSync as readFileSync10, existsSync as existsSync12 } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync13 } from "fs";
 import { join as join10 } from "path";
 var ALL_FINDING_TYPES = [
   "idea",
@@ -4409,7 +4101,7 @@ var DEFAULTS = {
 };
 function loadScanConfig(projectPath) {
   const configPath2 = join10(projectPath, ".mr-scan.json");
-  if (!existsSync12(configPath2)) {
+  if (!existsSync13(configPath2)) {
     return { ...DEFAULTS };
   }
   try {
@@ -4455,13 +4147,13 @@ async function authenticateBrowseSession(magicUrl, runBrowse) {
 }
 
 // lib/scanner/codebase-analysis.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync11, existsSync as existsSync13 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync11, existsSync as existsSync14 } from "fs";
 import { join as join11, relative } from "path";
 import { execSync as execSync6 } from "child_process";
 function resolveDir(projectPath, candidates) {
   for (const candidate of candidates) {
     const dir = join11(projectPath, candidate);
-    if (existsSync13(dir)) return dir;
+    if (existsSync14(dir)) return dir;
   }
   return null;
 }
@@ -4495,7 +4187,7 @@ function discoverRoutes(projectPath) {
 }
 function extractModels(projectPath) {
   const schemaPath = join11(projectPath, "prisma", "schema.prisma");
-  if (existsSync13(schemaPath)) {
+  if (existsSync14(schemaPath)) {
     const content = readFileSync11(schemaPath, "utf-8");
     const models2 = [];
     const modelRegex = /^model\s+(\w+)\s*\{/gm;
@@ -4509,7 +4201,7 @@ function extractModels(projectPath) {
   const drizzleDirs = ["src/db", "src/schema", "db", "drizzle"];
   for (const dir of drizzleDirs) {
     const fullDir = join11(projectPath, dir);
-    if (!existsSync13(fullDir)) continue;
+    if (!existsSync14(fullDir)) continue;
     try {
       const entries = readdirSync2(fullDir, { withFileTypes: true });
       for (const entry of entries) {
@@ -4550,7 +4242,7 @@ function discoverComponents(projectPath) {
 function extractInternalLinks(projectPath) {
   const links = /* @__PURE__ */ new Set();
   function searchDir(dir) {
-    if (!existsSync13(dir)) return;
+    if (!existsSync14(dir)) return;
     const entries = readdirSync2(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
@@ -4854,10 +4546,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((c10) => `- ${c10}`).join("\n")}
 
 **Recent Git Commits:**
-${codebaseAnalysis.recentCommits.slice(0, 15).map((c12) => `- ${c12}`).join("\n")}
+${codebaseAnalysis.recentCommits.slice(0, 15).map((c10) => `- ${c10}`).join("\n")}
 
 **Completed Tasks:**
 ${context.completedTasks.slice(0, 20).map((t) => `- ${t.title}`).join("\n") || "None"}
@@ -5067,7 +4759,7 @@ async function fetchScanContext(opts) {
 }
 function runClaude(prompt2) {
   return new Promise((resolve7, reject) => {
-    const child = spawn9("claude", ["-p", "--dangerously-skip-permissions", prompt2], {
+    const child = spawn7("claude", ["-p", "--dangerously-skip-permissions", prompt2], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let output = "";
@@ -5123,7 +4815,7 @@ function parseSynthesisOutput(output) {
 }
 
 // cli/commands/scan.ts
-var c10 = {
+var c8 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -5134,53 +4826,53 @@ var c10 = {
   magenta: "\x1B[35m",
   gray: "\x1B[90m"
 };
-function paint11(color, text) {
-  return `${c10[color]}${text}${c10.reset}`;
+function paint9(color, text) {
+  return `${c8[color]}${text}${c8.reset}`;
 }
-function timestamp4() {
-  return paint11("gray", (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false }));
+function timestamp2() {
+  return paint9("gray", (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false }));
 }
 function scanTag() {
-  return paint11("magenta", "[scan]");
+  return paint9("magenta", "[scan]");
 }
-function log3(msg) {
-  console.log(`${timestamp4()} ${scanTag()} ${msg}`);
+function log(msg) {
+  console.log(`${timestamp2()} ${scanTag()} ${msg}`);
 }
-function logOk2(msg) {
-  console.log(`${timestamp4()} ${scanTag()} ${paint11("green", "\u2713")} ${msg}`);
+function logOk(msg) {
+  console.log(`${timestamp2()} ${scanTag()} ${paint9("green", "\u2713")} ${msg}`);
 }
-function logErr3(msg) {
-  console.error(`${timestamp4()} ${scanTag()} ${paint11("red", "\u2717")} ${msg}`);
+function logErr(msg) {
+  console.error(`${timestamp2()} ${scanTag()} ${paint9("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 Command24("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.');
+    logErr('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`),
+    paint9("magenta", `  \u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2557\u2554`),
+    paint9("magenta", `  \u255A\u2550\u2557\u2551  \u2560\u2550\u2563\u2551\u2551\u2551`),
+    paint9("magenta", `  \u255A\u2550\u255D\u255A\u2550\u255D\u2569 \u2569\u255D\u255A\u255D`),
+    paint9("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
+    paint9("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>.');
+    logErr('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}`);
+    logErr(`Failed to fetch project ${projectId}`);
     process.exit(1);
   }
-  log3(`Scanning project: ${paint11("cyan", project.name)}`);
+  log(`Scanning project: ${paint9("cyan", project.name)}`);
   let projectPath = project.localPath;
   if (!projectPath) {
     for (const [dir, pid] of Object.entries(config.directories)) {
@@ -5196,12 +4888,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))}`);
+    log(`Using existing scan report ${paint9("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.");
+        logErr("A scan is already in progress for this project. Wait for it to complete.");
         process.exit(1);
       }
     } catch {
@@ -5212,9 +4904,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))}`);
+      log(`Created scan report ${paint9("yellow", reportId.slice(0, 8))}`);
     } catch (err) {
-      logErr3(`Failed to create scan report: ${err.message}`);
+      logErr(`Failed to create scan report: ${err.message}`);
       process.exit(1);
     }
   }
@@ -5225,7 +4917,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."));
+      log(paint9("yellow", "Scan was cancelled \u2014 aborting."));
       process.exit(0);
     }
   } catch {
@@ -5239,9 +4931,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: log,
       onProgress: (phase, detail) => {
-        log3(`${paint11("dim", `[${phase}]`)} ${detail}`);
+        log(`${paint9("dim", `[${phase}]`)} ${detail}`);
       }
     });
     let wasCancelled = false;
@@ -5253,7 +4945,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."));
+      log(paint9("yellow", "Scan was cancelled by user \u2014 discarding results."));
       process.exit(0);
     }
     await api.patch(`/api/scans/${reportId}`, {
@@ -5264,37 +4956,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 ${paint9("cyan", String(result.findings.length))} findings`);
     console.log("");
-    console.log(`  ${paint11("bold", "Summary:")} ${result.summary}`);
+    console.log(`  ${paint9("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(`  ${paint9("bold", paint9("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(`    ${paint9("red", "\u25CF")} [${f.type}] ${f.title}`);
+        console.log(`      ${paint9("dim", f.description.slice(0, 120))}`);
       }
       console.log("");
     }
     if (medium.length > 0) {
-      console.log(`  ${paint11("bold", paint11("yellow", `Medium Priority (${medium.length})`))}`);
+      console.log(`  ${paint9("bold", paint9("yellow", `Medium Priority (${medium.length})`))}`);
       for (const f of medium) {
-        console.log(`    ${paint11("yellow", "\u25CF")} [${f.type}] ${f.title}`);
+        console.log(`    ${paint9("yellow", "\u25CF")} [${f.type}] ${f.title}`);
       }
       console.log("");
     }
     if (low.length > 0) {
-      console.log(`  ${paint11("dim", `Low Priority (${low.length})`)} `);
+      console.log(`  ${paint9("dim", `Low Priority (${low.length})`)} `);
       for (const f of low) {
-        console.log(`    ${paint11("dim", `\u25CB [${f.type}] ${f.title}`)}`);
+        console.log(`    ${paint9("dim", `\u25CB [${f.type}] ${f.title}`)}`);
       }
       console.log("");
     }
   } catch (err) {
-    logErr3(`Scan failed: ${err.message}`);
+    logErr(`Scan failed: ${err.message}`);
     try {
       await api.patch(`/api/scans/${reportId}`, {
         status: "failed",
@@ -5307,8 +4999,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 Command25 } from "commander";
+var c9 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -5320,27 +5012,27 @@ var c11 = {
   gray: "\x1B[90m",
   magenta: "\x1B[35m"
 };
-function paint12(color, text) {
-  return `${c11[color]}${text}${c11.reset}`;
+function paint10(color, text) {
+  return `${c9[color]}${text}${c9.reset}`;
 }
 function statusBadge2(status) {
   switch (status) {
     case "draft":
-      return paint12("gray", "\u25CB draft");
+      return paint10("gray", "\u25CB draft");
     case "generating":
-      return paint12("cyan", "\u27F3 generating");
+      return paint10("cyan", "\u27F3 generating");
     case "generated":
-      return paint12("green", "\u2713 generated");
+      return paint10("green", "\u2713 generated");
     case "promoted":
-      return paint12("magenta", "\u2191 promoted");
+      return paint10("magenta", "\u2191 promoted");
     case "archived":
-      return paint12("dim", "\u2298 archived");
+      return paint10("dim", "\u2298 archived");
     default:
-      return paint12("gray", status);
+      return paint10("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 Command25("idea").description("Manage ideas \u2014 brainstorm, generate prototypes & plans").addCommand(
+  new Command25("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 +5043,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(paint10("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)}`
+        `  ${paint10("bold", idea.title)}  ${statusBadge2(idea.status)}  ${paint10("gray", idea.id.slice(0, 8))}  ${paint10("dim", date)}`
       );
       if (idea.description) {
-        console.log(`  ${paint12("dim", idea.description.slice(0, 80) + (idea.description.length > 80 ? "\u2026" : ""))}`);
+        console.log(`  ${paint10("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 Command25("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,65 +5067,65 @@ 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(`  ${paint10("green", "\u2713")} Created idea: ${paint10("bold", idea.title)}`);
+    console.log(`  ${paint10("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(`  ${paint10("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 Command25("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(`  ${paint10("cyan", "\u27F3")} Generating: ${paint10("bold", idea.title)}`);
+    console.log(`  ${paint10("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 Command25("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(`  ${paint10("cyan", "\u27F3")} Feedback sent for: ${paint10("bold", idea.title)}`);
+    console.log(`  ${paint10("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 Command25("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(`  ${paint10("green", "\u2713")} Promoted idea to task: ${paint10("bold", result.task.title)}`);
+    console.log(`  ${paint10("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 Command25("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(`  ${paint10("green", "\u2713")} Spinning up project: ${paint10("bold", result.project.name)}`);
+    console.log(`  ${paint10("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(`  ${paint10("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(`    ${paint10("gray", "\u2022")} ${task.title}`);
       }
     }
-    console.log(`  ${paint12("cyan", "\u27F3")} Repo creation is queued \u2014 the watch daemon will pick it up.`);
+    console.log(`  ${paint10("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 { existsSync as existsSync14 } from "fs";
-import { homedir as homedir3 } from "os";
+import { Command as Command26 } from "commander";
+import { existsSync as existsSync15 } from "fs";
+import { homedir as homedir2 } from "os";
 import { join as join12 } from "path";
 async function checkConfigExists() {
-  const configPath2 = join12(homedir3(), ".mr-manager", "config.json");
-  const exists = existsSync14(configPath2);
+  const configPath2 = join12(homedir2(), ".mr-manager", "config.json");
+  const exists = existsSync15(configPath2);
   if (!exists) {
     return {
       name: "Config file",
@@ -5475,12 +5167,12 @@ async function checkProjectLink() {
     optional: true
   };
 }
-var doctorCommand = new Command28("doctor").description("Diagnose Mr. Manager CLI installation and environment").action(async () => {
+var doctorCommand = new Command26("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`),
+    paint5("cyan", `  MR DOCTOR`),
+    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`),
+    paint5("dim", `  diagnosing your mr environment`),
     ``
   ].join("\n");
   console.log(banner);
@@ -5502,15 +5194,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(paint5("green", "  Everything looks good!"));
     console.log("");
     return;
   }
-  const fixes = checks.filter((c12) => !c12.ok && c12.fix && !c12.optional);
+  const fixes = checks.filter((c10) => !c10.ok && c10.fix && !c10.optional);
   if (fixes.length > 0) {
-    console.log(paint7("yellow", "  To fix:"));
+    console.log(paint5("yellow", "  To fix:"));
     for (const fix of fixes) {
-      console.log(`  ${paint7("dim", "\u2192")} ${paint7("bold", fix.name)}: ${fix.fix}`);
+      console.log(`  ${paint5("dim", "\u2192")} ${paint5("bold", fix.name)}: ${fix.fix}`);
     }
     console.log("");
   }
@@ -5518,13 +5210,13 @@ var doctorCommand = new Command28("doctor").description("Diagnose Mr. Manager CL
 });
 
 // cli/index.ts
-var configPath = join13(homedir4(), ".mr-manager", "config.json");
-var isFirstRun = !existsSync15(configPath);
+var configPath = join13(homedir3(), ".mr-manager", "config.json");
+var isFirstRun = !existsSync16(configPath);
 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 c10 = {
     reset: "\x1B[0m",
     bold: "\x1B[1m",
     dim: "\x1B[2m",
@@ -5534,29 +5226,29 @@ 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(`${c10.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${c10.reset}`);
+  console.log(`${c10.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${c10.reset}`);
+  console.log(`${c10.cyan}  \u2569 \u2569\u2569\u255A\u2550  \u2569 \u2569\u2569 \u2569\u255D\u255A\u255D\u2569 \u2569\u255A\u2550\u255D\u255A\u2550\u255D\u2569\u255A\u2550${c10.reset}`);
+  console.log(`${c10.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${c10.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(`${c10.bold}  Welcome to Mr. Manager!${c10.reset}`);
+  console.log(`${c10.dim}  Let's get you set up in a few quick steps.${c10.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(`  ${c10.yellow}Step 1:${c10.reset} Authenticate via Google OAuth`);
+  console.log(`  ${c10.dim}Run:${c10.reset} ${c10.cyan}mr login${c10.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(`  ${c10.yellow}Step 2:${c10.reset} Verify your environment`);
+  console.log(`  ${c10.dim}Run:${c10.reset} ${c10.cyan}mr setup${c10.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(`  ${c10.yellow}Step 3:${c10.reset} Link a repo and start watching`);
+  console.log(`  ${c10.dim}Run:${c10.reset} ${c10.cyan}mr link${c10.reset} ${c10.dim}&&${c10.reset} ${c10.cyan}mr watch${c10.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(`${c10.dim}  Or run ${c10.reset}${c10.cyan}mr login${c10.reset}${c10.dim} to get started now.${c10.reset}`);
   console.log("");
   process.exit(0);
 }
-var program = new Command29();
-program.name("mr").description("Mr. Manager - Task and project management CLI").version("0.2.0");
+var program = new Command27();
+program.name("mr").description("Mr. Manager - Task and project management CLI").version(CLI_VERSION);
 program.addCommand(initCommand);
 program.addCommand(authCommand);
 program.addCommand(loginCommand);
@@ -5572,8 +5264,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);
 program.addCommand(updateCommand);