@dunnewold-labs/mr-manager 0.4.4 → 0.4.6

package/dist/index.mjs

@@ -2,7 +2,7 @@
 
 // cli/index.ts
 import { Command as Command27 } from "commander";
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join12 } from "path";
 
@@ -132,7 +132,7 @@ Remote login \u2014 visit this URL in any browser:
 }
 async function loginWithLocalServer(apiUrl) {
   const port = getRandomPort();
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const server = createServer((req, res) => {
       const url = new URL(req.url ?? "/", `http://localhost:${port}`);
       const key = url.searchParams.get("key");
@@ -144,7 +144,7 @@ async function loginWithLocalServer(apiUrl) {
         </body></html>
       `);
       server.close();
-      if (key) resolve7(key);
+      if (key) resolve8(key);
       else reject(new Error("No key received from server"));
     });
     server.listen(port, () => {
@@ -185,7 +185,7 @@ import { fileURLToPath } from "url";
 // cli/package.json
 var package_default = {
   name: "@dunnewold-labs/mr-manager",
-  version: "0.4.4",
+  version: "0.4.6",
   description: "Mr. Manager - Task and project management CLI",
   bin: {
     mr: "./dist/index.mjs"
@@ -356,10 +356,10 @@ function detectVcs(cwd) {
 // cli/commands/link.ts
 function prompt(question) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve7(answer.trim());
+      resolve8(answer.trim());
     });
   });
 }
@@ -492,7 +492,7 @@ import { Command as Command8 } from "commander";
 import { spawn as spawn4, exec } from "child_process";
 import { randomUUID } from "crypto";
 import { resolve as resolve2 } from "path";
-import { readFileSync as readFileSync5, readdirSync, unlinkSync, existsSync as existsSync7, statSync } from "fs";
+import { readFileSync as readFileSync5, readdirSync, unlinkSync, existsSync as existsSync7, statSync, writeFileSync as writeFileSync4 } from "fs";
 import * as readline from "readline";
 
 // lib/test-runner.ts
@@ -512,25 +512,89 @@ function tryExec(command, cwd) {
     return false;
   }
 }
+function resolveWorktreeStartPoint(hasRemoteBranch, hasLocalBranch, hasOriginMain) {
+  if (hasRemoteBranch && !hasLocalBranch) {
+    return "origin-branch";
+  }
+  if (hasLocalBranch) {
+    return "local-branch";
+  }
+  if (hasOriginMain) {
+    return "origin-main";
+  }
+  return null;
+}
+function parseGitWorktreePorcelain(output) {
+  const entries = [];
+  const blocks = output.trim().split(/\n(?=worktree )/);
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+    let path = null;
+    let branch = null;
+    for (const line of block.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        path = line.slice("worktree ".length).trim();
+      } else if (line.startsWith("branch ")) {
+        const ref = line.slice("branch ".length).trim();
+        branch = ref.replace(/^refs\/heads\//, "");
+      }
+    }
+    if (path) {
+      entries.push({ path, branch });
+    }
+  }
+  return entries;
+}
+function findExistingWorktreeForBranch(repoDir, branch) {
+  try {
+    const output = execSync2("git worktree list --porcelain", {
+      cwd: repoDir,
+      stdio: "pipe"
+    }).toString();
+    const match = parseGitWorktreePorcelain(output).find((entry) => entry.branch === branch);
+    return match?.path ?? null;
+  } catch {
+    return null;
+  }
+}
 function createWorktree(repoDir, branch, worktreeName) {
   const wtPath = join4(repoDir, ".mr-worktrees", worktreeName);
   if (existsSync4(wtPath)) {
     execSync2(`git checkout ${branch}`, { cwd: wtPath, stdio: "pipe" });
-    return wtPath;
+    return {
+      path: wtPath,
+      created: false,
+      reusedBranchWorktree: false
+    };
+  }
+  const existingBranchWorktree = findExistingWorktreeForBranch(repoDir, branch);
+  if (existingBranchWorktree) {
+    return {
+      path: existingBranchWorktree,
+      created: false,
+      reusedBranchWorktree: true
+    };
   }
   tryExec(`git fetch origin ${branch}`, repoDir);
+  const hasOriginMain = tryExec(`git fetch origin main`, repoDir) && tryExec(`git rev-parse --verify "origin/main"`, repoDir);
   const hasRemoteBranch = tryExec(`git rev-parse --verify "origin/${branch}"`, repoDir);
   const hasLocalBranch = tryExec(`git rev-parse --verify "${branch}"`, repoDir);
-  if (hasRemoteBranch && !hasLocalBranch) {
+  const startPoint = resolveWorktreeStartPoint(hasRemoteBranch, hasLocalBranch, hasOriginMain);
+  if (startPoint === "origin-branch") {
     execSync2(`git worktree add -b "${branch}" "${wtPath}" "origin/${branch}"`, {
       cwd: repoDir,
       stdio: "pipe"
     });
-  } else if (hasLocalBranch) {
+  } else if (startPoint === "local-branch") {
     execSync2(`git worktree add "${wtPath}" "${branch}"`, {
       cwd: repoDir,
       stdio: "pipe"
     });
+  } else if (startPoint === "origin-main") {
+    execSync2(`git worktree add -b "${branch}" "${wtPath}" "origin/main"`, {
+      cwd: repoDir,
+      stdio: "pipe"
+    });
   } else {
     execSync2(`git worktree add -b "${branch}" "${wtPath}"`, {
       cwd: repoDir,
@@ -543,7 +607,11 @@ function createWorktree(repoDir, branch, worktreeName) {
       copyFileSync(src, join4(wtPath, envFile));
     }
   }
-  return wtPath;
+  return {
+    path: wtPath,
+    created: true,
+    reusedBranchWorktree: false
+  };
 }
 function removeWorktree(repoDir, wtPath) {
   try {
@@ -777,7 +845,7 @@ async function runTest(options) {
     }
     log2(`Branch: ${branch}`);
     log2("Creating git worktree...");
-    wtPath = createWorktree(localPath, branch, worktreeName);
+    wtPath = createWorktree(localPath, branch, worktreeName).path;
     log2(`Worktree created at ${wtPath}`);
     log2("Installing dependencies...");
     try {
@@ -890,6 +958,55 @@ async function runTest(options) {
   return result;
 }
 
+// lib/agent-fallback.ts
+var AGENT_FALLBACK_ORDER = ["claude", "codex", "gemini"];
+function getAgentFallbackChain(agent) {
+  const startIndex = AGENT_FALLBACK_ORDER.indexOf(agent);
+  if (startIndex === -1) {
+    return [];
+  }
+  return AGENT_FALLBACK_ORDER.slice(startIndex);
+}
+function getAvailableAgentFallbackChain(agent, availability) {
+  return getAgentFallbackChain(agent).filter((candidate) => availability[candidate] !== false);
+}
+
+// lib/task-workflow.ts
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+var NON_CODE_TASK_KEYWORDS = [
+  "no code",
+  "no-code",
+  "without code",
+  "research",
+  "document",
+  "documentation",
+  "docs",
+  "prd",
+  "test plan",
+  "resource",
+  "write up",
+  "writeup",
+  "config via the ui",
+  "configuration via the ui",
+  "ui configuration",
+  "upload"
+];
+var NON_CODE_TASK_PATTERNS = [
+  /\b(?:doesn'?t|does not|don't|do not)\s+(?:involve|require|need)\s+(?:writing\s+)?(?:any\s+)?code\b/,
+  /\b(?:without|avoids?)\s+(?:writing\s+)?(?:any\s+)?code\b/,
+  /\b(?:no need|skip)\s+to\s+(?:spin up|create|prepare)\s+(?:an?\s+)?worktree\b/
+];
+function taskLikelyDoesNotNeedCodeChanges(task) {
+  if (task.mode && task.mode !== "development") return true;
+  const haystack = normalizeWhitespace(
+    [task.title, task.notes, task.prdContent].filter(Boolean).join(" ").toLowerCase()
+  );
+  if (!haystack) return false;
+  return NON_CODE_TASK_KEYWORDS.some((keyword) => haystack.includes(keyword)) || NON_CODE_TASK_PATTERNS.some((pattern) => pattern.test(haystack));
+}
+
 // cli/browse-runner.ts
 import { execSync as execSync4, spawn as spawn3 } from "child_process";
 import { existsSync as existsSync6 } from "fs";
@@ -916,7 +1033,7 @@ Run the setup script: cd browse && ./setup`
 async function runBrowseCommand2(browseArgs) {
   const runner = getBrowseRunner();
   const fullArgs = [...runner.args, ...browseArgs];
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const proc = spawn3(runner.cmd, fullArgs, {
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env }
@@ -933,21 +1050,156 @@ async function runBrowseCommand2(browseArgs) {
       if (stderr && code !== 0) {
         process.stderr.write(stderr);
       }
-      resolve7({ stdout: stdout.trim(), exitCode: code || 0 });
+      resolve8({ stdout: stdout.trim(), exitCode: code || 0 });
     });
     proc.on("error", () => {
-      resolve7({ stdout: "", exitCode: 1 });
+      resolve8({ stdout: "", exitCode: 1 });
     });
   });
 }
 
+// cli/utils/token-estimate.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function formatTokenCount(tokens) {
+  if (tokens < 1e3) return String(tokens);
+  if (tokens < 1e4) return `~${(tokens / 1e3).toFixed(1)}k`;
+  return `~${Math.round(tokens / 1e3)}k`;
+}
+function tokenLogLine(jobType, identifier, prompt2, systemPrompt) {
+  const promptTokens = estimateTokens(prompt2);
+  const systemTokens = systemPrompt ? estimateTokens(systemPrompt) : 0;
+  const total = promptTokens + systemTokens;
+  const parts = [`[tokens] ${jobType}:${identifier} prompt=${formatTokenCount(promptTokens)}`];
+  if (systemTokens > 0) {
+    parts[0] += ` system=${formatTokenCount(systemTokens)}`;
+  }
+  parts[0] += ` total=${formatTokenCount(total)}`;
+  return parts[0];
+}
+
 // cli/commands/watch.ts
 var FEATURES_FILE2 = ".mr-features.md";
-function readFeaturesDoc(repoDir) {
-  const path = resolve2(repoDir, FEATURES_FILE2);
-  if (!existsSync7(path)) return null;
-  return readFileSync5(path, "utf-8");
+var SYSTEM_SECTION_STATUS_UPDATES = `## Status Updates
+
+As you work, post brief status updates so progress is visible in the UI.
+Use: mr update <task-id> "your status message here"
+
+The system automatically posts updates for: agent dispatch and task completion. Do NOT duplicate these \u2014 focus your updates on what you're actually doing:
+- What you found while exploring (e.g. "Found the auth logic in src/auth.ts, needs refactoring")
+- What specific changes you're making (e.g. "Adding validation to the signup form component")
+- Problems you hit and how you solved them (e.g. "Fixed circular dependency between User and Order models")
+- What files/components you modified (e.g. "Updated api/routes.ts and middleware/auth.ts")
+
+Be specific about your changes \u2014 don't post vague messages like "working on the task" or "exploring the codebase". Each update should tell the user something concrete about what changed or what you learned.
+
+Keep messages short (1 sentence). Post 3-5 updates total.`;
+var SYSTEM_SECTION_SCREENSHOTS = `## Screenshots
+
+Before you finish, take a screenshot of your work to attach to the task. This helps the reviewer see what changed visually.
+Use: mr screenshot <task-id> <path-to-image> -m "Description of what the screenshot shows"
+
+You can take a screenshot on macOS (no file arg needed) or provide a path to an existing image file.
+When no file is provided, the command uses the browse daemon (headless Chromium) to screenshot the app's project page automatically.
+You can also specify a custom URL: mr screenshot <task-id> --url "http://localhost:3000/some-page" -m "description"
+If your changes are visual (UI changes), try to capture the result. If they are purely backend/logic changes, you can skip this step.`;
+var SYSTEM_SECTION_TEST_PLAN = `## Test Plan
+
+After pushing your MR/PR, create a structured test plan so the reviewer can run automated browser tests against your changes.
+Save the test plan as a TaskResource by calling:
+mr update <task-id> --resource test-plan "Test plan for <task-title>" '<json>'
+
+Or write it to a file and upload it. The test plan is a JSON array of browse commands:
+
+\`\`\`json
+[
+  { "command": "goto", "args": ["/login"], "description": "Navigate to login page" },
+  { "command": "fill", "args": ["input[type=email]", "test@example.com"], "description": "Enter email" },
+  { "command": "fill", "args": ["input[type=password]", "test-password"], "description": "Enter password" },
+  { "command": "click", "args": ["button[type=submit]"], "description": "Submit login" },
+  { "command": "wait", "args": ["2000"], "description": "Wait for redirect" },
+  { "command": "goto", "args": ["/dashboard"], "description": "Navigate to changed page" },
+  { "command": "screenshot", "description": "Capture dashboard" },
+  { "command": "assertVisible", "args": [".dashboard-widget"], "description": "Verify widget renders" },
+  { "command": "assertText", "args": ["h1", "Dashboard"], "description": "Verify page title" }
+]
+\`\`\`
+
+Supported commands: goto, click, fill, wait, screenshot, assertVisible, assertText, assertUrl.
+Include auth steps (login/signup URLs) if the feature requires authentication.
+If your changes don't have a testable UI flow, you can skip this step.`;
+var SYSTEM_SECTION_NO_MR = `## Tasks That Don't Need an MR/PR
+
+If the task does not require code changes (e.g. research, documentation uploaded as a resource, configuration via the UI, etc.), you can signal this instead of creating a pull request:
+mr no-mr <task-id> "Brief description of what was done instead"
+
+This tells the watch system to skip looking for a PR and records what action was taken. You should still clean up any worktrees and exit normally.`;
+var SYSTEM_SECTION_FEATURES_WORKFLOW = `## Features & Goals Document Workflow
+
+After completing your work, check if the project has a .mr-features.md file. If changes are relevant, update it.
+Write the updated content to a temp file and run: mr features --file /tmp/mr-features-update.md
+Only update the sections relevant to your changes. Preserve existing content that is still accurate.
+If the project does not yet have .mr-features.md, create one capturing the current state of features grouped by area.`;
+var SYSTEM_SECTION_PRD_FORMAT = `### PRD Format Conventions
+
+Follow these conventions so PRDs are scannable by humans and parseable by agents.
+All sections are optional \u2014 include only what's relevant for this task type (greenfield, feature, bug fix, refactor). Omit sections that would be boilerplate.
+
+**TL;DR Block** \u2014 Start the PRD with a \`> \` blockquote summary (2-3 sentences) immediately after the \`# PRD: Title\` heading.
+
+**Requirement IDs** \u2014 Every requirement gets a unique ID prefix and a single-sentence summary on the first line:
+\`**F1: Name** \u2014 One-sentence summary.\` followed by optional \`- Detail bullet\` lines.
+Use \`F\` prefix for functional requirements, \`NF\` for non-functional. Number sequentially within each category.
+
+**Success Metrics as JSON** \u2014 Use a fenced \`json\` code block containing an array of objects with \`Metric\`, \`Target\`, and \`Type\` fields.
+
+**Affected Components as JSON** \u2014 Use the same JSON table format for the technical approach section.
+
+**Implementation Steps as Phased Checklists** \u2014 Use \`### Phase N: Name\` headers with markdown checklists (\`- [ ]\`).
+
+**Edge Cases as Tagged List** \u2014 Each edge case leads with a bold tag: \`- **Tag** \u2014 Description.\`
+
+**No Frontmatter** \u2014 Do not include YAML frontmatter. Metadata lives in the database.`;
+var SYSTEM_SECTION_PRD_OPEN_QUESTIONS = `### Open Questions Format
+
+The "Open Questions" section of the PRD MUST end with a fenced JSON code block tagged \`open-questions\`.
+
+Format:
+\`\`\`open-questions
+[
+  {
+    "id": "q1",
+    "question": "Which approach should we use for X?",
+    "context": "One sentence explaining why this decision matters.",
+    "options": [
+      "Option A \u2014 brief description",
+      "Option B \u2014 brief description"
+    ]
+  }
+]
+\`\`\`
+
+Rules:
+- Each question MUST have 2-4 concrete options.
+- Options should be actionable choices.
+- The "context" field should be a single sentence.
+- Use sequential IDs: q1, q2, q3, etc.
+- Place the JSON block at the very end of the "Open Questions" section.`;
+var SYSTEM_SECTIONS = {
+  "status-updates": SYSTEM_SECTION_STATUS_UPDATES,
+  "screenshots": SYSTEM_SECTION_SCREENSHOTS,
+  "test-plan": SYSTEM_SECTION_TEST_PLAN,
+  "no-mr": SYSTEM_SECTION_NO_MR,
+  "features-workflow": SYSTEM_SECTION_FEATURES_WORKFLOW,
+  "prd-format": SYSTEM_SECTION_PRD_FORMAT,
+  "prd-open-questions": SYSTEM_SECTION_PRD_OPEN_QUESTIONS
+};
+function composeSystemPrompt(sections) {
+  return sections.map((s) => SYSTEM_SECTIONS[s]).join("\n\n");
 }
+var EXECUTION_SYSTEM_SECTIONS = ["status-updates", "screenshots", "test-plan", "no-mr", "features-workflow"];
+var PRD_SYSTEM_SECTIONS = ["prd-format", "prd-open-questions"];
 var c = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -1026,6 +1278,12 @@ function slugify(title) {
 function shortId(id) {
   return id.slice(0, 8);
 }
+function ownerPrefix(task) {
+  const name = task.user?.name;
+  if (!name) return "mr";
+  const first = name.split(/\s+/)[0].toLowerCase().replace(/[^a-z0-9]/g, "");
+  return first || "mr";
+}
 function formatElapsed(ms) {
   const totalMinutes = Math.max(1, Math.floor(ms / 6e4));
   const hours = Math.floor(totalMinutes / 60);
@@ -1035,13 +1293,13 @@ function formatElapsed(ms) {
   }
   return `${totalMinutes}m`;
 }
-function worktreePath(sid) {
-  return `.mr-worktrees/mr-${sid}`;
+function worktreePath(name) {
+  return `.mr-worktrees/${name}`;
 }
 function worktreeNameFromPath(wtPath) {
   return wtPath.replace(/^\.mr-worktrees\//, "");
 }
-function normalizeWhitespace(value) {
+function normalizeWhitespace2(value) {
   return value.replace(/\s+/g, " ").trim();
 }
 function extractFirstMeaningfulParagraph(markdown) {
@@ -1066,7 +1324,7 @@ function extractFirstMeaningfulParagraph(markdown) {
     if (quoteLines.length > 0) break;
   }
   if (quoteLines.length > 0) {
-    const text2 = normalizeWhitespace(quoteLines.join(" "));
+    const text2 = normalizeWhitespace2(quoteLines.join(" "));
     return text2 || null;
   }
   const paragraphLines = [];
@@ -1089,7 +1347,7 @@ function extractFirstMeaningfulParagraph(markdown) {
     paragraphLines.push(line);
   }
   if (paragraphLines.length === 0) return null;
-  const text = normalizeWhitespace(paragraphLines.join(" "));
+  const text = normalizeWhitespace2(paragraphLines.join(" "));
   return text || null;
 }
 function truncateText(value, maxLength) {
@@ -1127,25 +1385,6 @@ function buildPrBodyTemplate(task, subtasks, protoRefs = [], feedbackUpdates = [
     "_Replace every placeholder above before creating the PR. Remove bullets or sections that do not apply._"
   ].join("\n");
 }
-function pullLatestMain(repoDir, prefix) {
-  return new Promise((resolve7) => {
-    exec(
-      "git pull origin main --ff-only",
-      { cwd: repoDir },
-      (err, stdout, stderr) => {
-        if (err) {
-          logWarn(prefix, `git pull failed (proceeding anyway): ${stderr.trim() || err.message}`);
-        } else {
-          const msg = stdout.trim();
-          if (msg && msg !== "Already up to date.") {
-            logInfo(prefix, `pulled latest main: ${paint("gray", msg.split("\n")[0])}`);
-          }
-        }
-        resolve7();
-      }
-    );
-  });
-}
 function buildPlanningPrompt(task, repoDir) {
   const notes = task.notes ? `
 
@@ -1171,17 +1410,109 @@ ${task.notes}` : "";
 }
 function findPrUrl(branchName, repoDir, vcs = "github") {
   const cmd = vcs === "gitlab" ? `glab mr view "${branchName}" --output json 2>/dev/null | jq -r '.web_url // empty'` : `gh pr view "${branchName}" --json url -q .url`;
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     exec(
       cmd,
       { cwd: repoDir },
       (err, stdout) => {
-        if (err) resolve7(null);
-        else resolve7(stdout.trim() || null);
+        if (err) resolve8(null);
+        else resolve8(stdout.trim() || null);
       }
     );
   });
 }
+function buildAutomaticPrBody(task, branchName, vcs, subtasks, protoRefs = [], feedbackUpdates = [], existingResources = [], skillRefs = []) {
+  const contextSource = task.prdContent ?? task.notes ?? "";
+  const taskContext = extractFirstMeaningfulParagraph(contextSource);
+  const contextBullets = [
+    `- Resolves MR Manager task ${task.id}.`,
+    `- Task: ${task.title}.`,
+    ...taskContext ? [`- Goal/context: ${truncateText(taskContext, 220)}.`] : [],
+    ...subtasks.map((subtask) => `- Completed subtask: ${subtask.title}.`),
+    ...protoRefs.map((ref) => `- Related prototype: ${ref.prototype.title}${ref.selectedVariants?.length ? ` (variants ${ref.selectedVariants.join(", ")})` : ""}.`),
+    ...feedbackUpdates.slice(0, 3).map((update) => `- Addresses feedback from ${new Date(update.createdAt).toLocaleDateString("en-US")}.`),
+    ...existingResources.slice(0, 3).map((resource) => `- Referenced resource: ${resource.name}.${resource.kind === "link" && resource.url ? ` (${resource.url})` : ""}`),
+    ...skillRefs.slice(0, 3).map((ref) => `- Applied skill guidance: ${ref.skill.name}.`)
+  ];
+  return [
+    "## Summary",
+    `- Auto-created by \`mr watch\` because no existing ${detectPrLabelFromVcs(vcs)} was found for branch \`${branchName}\` after the agent finished.`,
+    `- Captures the implementation for MR Manager task \`${task.id}\` while preserving the task title as the review title.`,
+    "",
+    "## Context",
+    ...contextBullets,
+    "",
+    "## Testing",
+    "- [ ] Automated tests: Not run by `mr watch`; see task updates or follow-up commits for validation details.",
+    "- [ ] Manual verification completed by reviewer."
+  ].join("\n");
+}
+function detectPrLabelFromVcs(vcs) {
+  return vcs === "gitlab" ? "MR" : "PR";
+}
+function extractPrUrlFromText(value) {
+  const match = value.match(/https?:\/\/(?:github\.com\/[^\s]+\/pull\/\d+|gitlab\.[^\s]+\/merge_requests\/\d+)/);
+  return match ? match[0] : null;
+}
+function commandSucceeds(command, cwd) {
+  return new Promise((resolve8) => {
+    exec(command, { cwd }, (err) => resolve8(!err));
+  });
+}
+async function createPrInRepo(task, branchName, repoDir, vcs, subtasks, protoRefs = [], feedbackUpdates = [], existingResources = [], skillRefs = []) {
+  const hasLocalBranch = await commandSucceeds(`git show-ref --verify --quiet refs/heads/${JSON.stringify(branchName)}`, repoDir);
+  const hasRemoteBranch = await commandSucceeds(`git ls-remote --exit-code --heads origin ${JSON.stringify(branchName)}`, repoDir);
+  if (!hasLocalBranch && !hasRemoteBranch) {
+    return null;
+  }
+  const bodyPath = resolve2("/tmp", `mr-auto-pr-${randomUUID()}.md`);
+  const body = buildAutomaticPrBody(task, branchName, vcs, subtasks, protoRefs, feedbackUpdates, existingResources, skillRefs);
+  writeFileSync4(bodyPath, `${body}
+`, "utf-8");
+  const createCommand2 = vcs === "gitlab" ? `glab mr create --source-branch ${JSON.stringify(branchName)} --title ${JSON.stringify(task.title)} --description-file ${JSON.stringify(bodyPath)} --yes` : `gh pr create --head ${JSON.stringify(branchName)} --title ${JSON.stringify(task.title)} --body-file ${JSON.stringify(bodyPath)}`;
+  try {
+    const output = await new Promise((resolve8, reject) => {
+      exec(createCommand2, { cwd: repoDir }, (err, stdout, stderr) => {
+        if (err) {
+          reject(new Error(stderr.trim() || stdout.trim() || err.message));
+          return;
+        }
+        resolve8(`${stdout}
+${stderr}`.trim());
+      });
+    });
+    const createdUrl = extractPrUrlFromText(output);
+    return createdUrl ?? await findPrUrl(branchName, repoDir, vcs);
+  } catch {
+    return null;
+  } finally {
+    if (existsSync7(bodyPath)) {
+      unlinkSync(bodyPath);
+    }
+  }
+}
+async function createPrAcrossRepos(task, branchName, repoDir, vcs, subtasks, protoRefs = [], feedbackUpdates = [], existingResources = [], skillRefs = []) {
+  if (isGitRepo(repoDir)) {
+    return createPrInRepo(task, branchName, repoDir, vcs, subtasks, protoRefs, feedbackUpdates, existingResources, skillRefs);
+  }
+  const childRepos = findChildGitRepos(repoDir);
+  for (const repo of childRepos) {
+    const childVcs = detectVcs(repo)?.provider ?? vcs;
+    const url = await createPrInRepo(
+      task,
+      branchName,
+      repo,
+      childVcs,
+      subtasks,
+      protoRefs,
+      feedbackUpdates,
+      existingResources,
+      skillRefs
+    );
+    if (url) return url;
+  }
+  return null;
+}
 function isGitRepo(dir) {
   try {
     return existsSync7(resolve2(dir, ".git"));
@@ -1227,13 +1558,41 @@ async function extractPrUrlFromUpdates(taskId) {
   }
   return null;
 }
-function buildPrototypeSection(protoRefs) {
+function checkPrStatus(prUrl, repoDir, vcs = "github") {
+  const cmd = vcs === "gitlab" ? `glab mr view "${prUrl}" --output json 2>/dev/null` : `gh pr view "${prUrl}" --json merged,mergeable 2>/dev/null`;
+  return new Promise((resolve8) => {
+    exec(cmd, { cwd: repoDir }, (err, stdout) => {
+      if (err || !stdout.trim()) {
+        resolve8(null);
+        return;
+      }
+      try {
+        const data = JSON.parse(stdout.trim());
+        if (vcs === "gitlab") {
+          resolve8({
+            merged: data.state === "merged",
+            hasConflicts: data.has_conflicts === true
+          });
+        } else {
+          resolve8({
+            merged: data.merged === true,
+            hasConflicts: data.mergeable === "CONFLICTING"
+          });
+        }
+      } catch {
+        resolve8(null);
+      }
+    });
+  });
+}
+function buildPrototypeSection(protoRefs, workingDir) {
   if (protoRefs.length === 0) return "";
   const sections = [
     ``,
     `## Referenced Prototypes`,
     ``,
     `The following prototype designs have been linked to this task as reference. Use them to guide the implementation.`,
+    `Read the referenced files when you need to see the HTML content.`,
     ``
   ];
   for (const ref of protoRefs) {
@@ -1251,10 +1610,19 @@ function buildPrototypeSection(protoRefs) {
     for (let i = 0; i < selectedFiles.length; i++) {
       const file = selectedFiles[i];
       const variantLabel = selected.length < files.length ? `Variant ${selected[i] + 1} (selected)` : `Variant ${i + 1}`;
-      sections.push(`#### ${variantLabel}: ${file.name}`);
-      sections.push(`\`\`\`html`);
-      sections.push(file.content);
-      sections.push(`\`\`\``);
+      const tmpDir = workingDir ?? "/tmp";
+      const safeProtoId = proto.id.slice(0, 8);
+      const tmpPath = resolve2(tmpDir, `.mr-proto-${safeProtoId}-v${selected[i] ?? i}.html`);
+      try {
+        writeFileSync4(tmpPath, file.content, "utf-8");
+        sections.push(`#### ${variantLabel}: ${file.name}`);
+        sections.push(`File: \`${tmpPath}\` \u2014 read this file to see the full HTML content.`);
+      } catch {
+        sections.push(`#### ${variantLabel}: ${file.name}`);
+        sections.push(`\`\`\`html`);
+        sections.push(file.content);
+        sections.push(`\`\`\``);
+      }
       sections.push(``);
     }
   }
@@ -1320,8 +1688,9 @@ function buildFeedbackSection(updates) {
   return lines.join("\n");
 }
 function buildFeaturesSection(repoDir) {
-  const content = readFeaturesDoc(repoDir);
-  if (!content) {
+  const featuresPath = resolve2(repoDir, FEATURES_FILE2);
+  const exists = existsSync7(featuresPath);
+  if (!exists) {
     return [
       ``,
       `## Features & Goals Document`,
@@ -1341,11 +1710,8 @@ function buildFeaturesSection(repoDir) {
     ``,
     `## Features & Goals Document`,
     ``,
-    `The project maintains a features & goals document at \`.mr-features.md\`. Here is its current content:`,
-    ``,
-    "```markdown",
-    content,
-    "```",
+    `The project maintains a features & goals document at \`${featuresPath}\`.`,
+    `Read this file if you need to understand existing features or update it after your work.`,
     ``,
     `After completing your work, update this document to reflect any changes. Write the updated content to a temp file and run:`,
     `\`mr features --file /tmp/mr-features-update.md\``,
@@ -1354,11 +1720,11 @@ function buildFeaturesSection(repoDir) {
     ``
   ].join("\n");
 }
-function buildExecutionPrompt(task, repoDir, subtasks, vcs = "github", protoRefs = [], feedbackUpdates = [], existingResources = [], skillRefs = [], executionDir) {
-  const sid = shortId(task.id);
+function buildExecutionPrompt(task, repoDir, subtasks, vcs = "github", protoRefs = [], feedbackUpdates = [], existingResources = [], skillRefs = [], executionDir, startWithoutWorktree = false) {
   const slug = slugify(task.title);
-  const branchName = `mr/${sid}/${slug}`;
-  const wtPath = worktreePath(sid);
+  const owner = ownerPrefix(task);
+  const branchName = `${owner}/${slug}`;
+  const wtPath = worktreePath(`${owner}-${slug}`);
   const workingDir = executionDir ?? repoDir;
   const prBodyPath = "/tmp/mr-pr-body.md";
   const notes = task.prdContent ? `
@@ -1381,7 +1747,6 @@ ${task.notes}` : "";
     ``
   ].join("\n") : "";
   const hasFeedback = feedbackUpdates.length > 0;
-  const feedbackWtPath = hasFeedback ? worktreePath(`${sid}-fb`) : wtPath;
   const prBodyTemplate = buildPrBodyTemplate(task, pendingSubtasks, protoRefs, feedbackUpdates, existingResources, skillRefs);
   const prCreateCmd = vcs === "gitlab" ? `glab mr create --title "${task.title}" --description-file ${prBodyPath} --yes` : `gh pr create --title "${task.title}" --body-file ${prBodyPath}`;
   return [
@@ -1393,7 +1758,7 @@ ${task.notes}` : "";
     `ID: ${task.id}${notes}`,
     subtaskSection,
     buildResourcesSection(existingResources),
-    buildPrototypeSection(protoRefs),
+    buildPrototypeSection(protoRefs, workingDir),
     buildSkillsSection(skillRefs),
     buildFeedbackSection(feedbackUpdates),
     `## Instructions`,
@@ -1408,9 +1773,16 @@ ${task.notes}` : "";
     ] : hasFeedback ? [
       `2. Set up your working environment:`,
       `   - Fetch the latest from origin: \`git fetch origin\``,
-      `   - Check out the existing branch in a worktree: \`git worktree add ${feedbackWtPath} origin/${branchName}\``,
-      `   - If the origin branch doesn't exist yet, fall back to: \`git worktree add -b ${branchName} ${feedbackWtPath}\``,
-      `   - Work in the worktree directory: ${feedbackWtPath}`
+      `   - Reuse the existing task branch/worktree if it is still present.`,
+      `   - Otherwise check out the existing branch in a worktree: \`git worktree add ${wtPath} origin/${branchName}\``,
+      `   - If the origin branch doesn't exist yet, fall back to: \`git worktree add -b ${branchName} ${wtPath}\``,
+      `   - Work in the worktree directory: ${wtPath}`
+    ] : startWithoutWorktree ? [
+      `2. Start in the linked project directory first:`,
+      `   - Current working directory: ${repoDir}`,
+      `   - This task appears likely to be a no-code workflow (research, documentation, UI configuration, or resource updates), so no worktree has been pre-created.`,
+      `   - If you discover you need to edit tracked files or write code after all, create a worktree before making changes: \`git worktree add -b ${branchName} ${wtPath}\``,
+      `   - If the task spans multiple repos, create matching worktrees only in the repo(s) where edits are actually needed.`
     ] : [
       `2. Set up an isolated working environment:`,
       `   - If ${repoDir} is a git repo, create a worktree: \`git worktree add -b ${branchName} ${wtPath}\``,
@@ -1446,21 +1818,6 @@ ${task.notes}` : "";
     ``,
     `This tells the watch system to skip looking for a ${vcs === "gitlab" ? "MR" : "PR"} and records what action was taken. You should still clean up any worktrees and exit normally.`,
     ``,
-    `## Status Updates`,
-    ``,
-    `As you work, post brief status updates so progress is visible in the UI:`,
-    `\`mr update ${task.id} "your status message here"\``,
-    ``,
-    `The system automatically posts updates for: agent dispatch and task completion. Do NOT duplicate these \u2014 focus your updates on what you're actually doing:`,
-    `- What you found while exploring (e.g. "Found the auth logic in src/auth.ts, needs refactoring")`,
-    `- What specific changes you're making (e.g. "Adding validation to the signup form component")`,
-    `- Problems you hit and how you solved them (e.g. "Fixed circular dependency between User and Order models")`,
-    `- What files/components you modified (e.g. "Updated api/routes.ts and middleware/auth.ts")`,
-    ``,
-    `Be specific about your changes \u2014 don't post vague messages like "working on the task" or "exploring the codebase". Each update should tell the user something concrete about what changed or what you learned.`,
-    ``,
-    `Keep messages short (1 sentence). Post 3-5 updates total.`,
-    ``,
     ...hasFeedback ? [] : [
       `## PR Description Template`,
       ``,
@@ -1472,41 +1829,6 @@ ${task.notes}` : "";
       "```",
       ``
     ],
-    `## Screenshots`,
-    ``,
-    `Before you finish, take a screenshot of your work to attach to the task. This helps the reviewer see what changed visually.`,
-    `\`mr screenshot ${task.id} <path-to-image> -m "Description of what the screenshot shows"\``,
-    ``,
-    `You can take a screenshot on macOS (no file arg needed) or provide a path to an existing image file.`,
-    `When no file is provided, the command uses the browse daemon (headless Chromium) to screenshot the app's project page automatically.`,
-    `You can also specify a custom URL: \`mr screenshot ${task.id} --url "http://localhost:3000/some-page" -m "description"\``,
-    `If your changes are visual (UI changes), try to capture the result. If they are purely backend/logic changes, you can skip this step.`,
-    ``,
-    `## Test Plan`,
-    ``,
-    `After pushing your MR/PR, create a structured test plan so the reviewer can run automated browser tests against your changes.`,
-    `Save the test plan as a TaskResource by calling:`,
-    `\`mr update ${task.id} --resource test-plan "Test plan for ${task.title}" '<json>'\``,
-    ``,
-    `Or write it to a file and upload it. The test plan is a JSON array of browse commands:`,
-    ``,
-    "```json",
-    `[`,
-    `  { "command": "goto", "args": ["/login"], "description": "Navigate to login page" },`,
-    `  { "command": "fill", "args": ["input[type=email]", "test@example.com"], "description": "Enter email" },`,
-    `  { "command": "fill", "args": ["input[type=password]", "test-password"], "description": "Enter password" },`,
-    `  { "command": "click", "args": ["button[type=submit]"], "description": "Submit login" },`,
-    `  { "command": "wait", "args": ["2000"], "description": "Wait for redirect" },`,
-    `  { "command": "goto", "args": ["/dashboard"], "description": "Navigate to changed page" },`,
-    `  { "command": "screenshot", "description": "Capture dashboard" },`,
-    `  { "command": "assertVisible", "args": [".dashboard-widget"], "description": "Verify widget renders" },`,
-    `  { "command": "assertText", "args": ["h1", "Dashboard"], "description": "Verify page title" }`,
-    `]`,
-    "```",
-    ``,
-    `Supported commands: goto, click, fill, wait, screenshot, assertVisible, assertText, assertUrl.`,
-    `Include auth steps (login/signup URLs) if the feature requires authentication.`,
-    `If your changes don't have a testable UI flow, you can skip this step.`,
     buildFeaturesSection(repoDir),
     `Complete all steps autonomously without asking for confirmation. Exit with code 0 when done.`
   ].join("\n");
@@ -1517,16 +1839,31 @@ function buildPrdPrompt(task, repoDir, existingPrd, feedbackUpdates = []) {
 Task notes:
 ${task.notes}` : "";
   const isRevision = !!(existingPrd && feedbackUpdates.length > 0);
-  const feedbackSection = isRevision ? [
-    ``,
-    `## Existing PRD`,
-    ``,
-    `The following PRD was previously generated. You must revise it based on the user's feedback below \u2014 do NOT start from scratch.`,
-    ``,
-    existingPrd,
-    ``,
-    buildFeedbackSection(feedbackUpdates)
-  ].join("\n") : "";
+  let feedbackSection = "";
+  if (isRevision) {
+    const prdTmpPath = resolve2(repoDir, ".mr-existing-prd.md");
+    try {
+      writeFileSync4(prdTmpPath, existingPrd, "utf-8");
+    } catch {
+    }
+    const prdSummaryLines = [];
+    for (const line of (existingPrd ?? "").split("\n")) {
+      const trimmed = line.trim();
+      if (/^#{1,3}\s/.test(trimmed)) prdSummaryLines.push(trimmed);
+      else if (/^\*\*[FN]+\d+:/.test(trimmed)) prdSummaryLines.push(`  ${trimmed.split("\u2014")[0].trim()}`);
+    }
+    feedbackSection = [
+      ``,
+      `## Existing PRD`,
+      ``,
+      `A PRD was previously generated. You must revise it based on the user's feedback below \u2014 do NOT start from scratch.`,
+      ``,
+      `**Full PRD file:** \`${prdTmpPath}\` \u2014 read this file for the complete existing PRD.`,
+      ``,
+      ...prdSummaryLines.length > 0 ? [`**PRD structure summary:**`, ...prdSummaryLines, ``] : [],
+      buildFeedbackSection(feedbackUpdates)
+    ].join("\n");
+  }
   const revisionInstructions = isRevision ? [
     `1. Read the existing PRD and user feedback above carefully.`,
     `2. Revise the PRD to address every piece of feedback. Keep sections that are still valid \u2014 only modify what the feedback requires.`,
@@ -1557,77 +1894,16 @@ ${task.notes}` : "";
     `   - Technical approach and affected components`,
     `   - Edge cases`,
     `   - Implementation steps / breakdown`,
-    `   - **Open Questions** \u2014 this section MUST use the structured format below`,
-    ``,
-    `### PRD Format Conventions`,
-    ``,
-    `Follow these conventions so PRDs are scannable by humans and parseable by agents.`,
-    `All sections are optional \u2014 include only what's relevant for this task type (greenfield, feature, bug fix, refactor). Omit sections that would be boilerplate.`,
-    ``,
-    `**TL;DR Block** \u2014 Start the PRD with a \`> \` blockquote summary (2-3 sentences) immediately after the \`# PRD: Title\` heading. This gives humans instant orientation and agents a compact context summary.`,
-    ``,
-    `**Requirement IDs** \u2014 Every requirement gets a unique ID prefix and a single-sentence summary on the first line:`,
-    `\`**F1: Name** \u2014 One-sentence summary.\` followed by optional \`- Detail bullet\` lines.`,
-    `Use \`F\` prefix for functional requirements, \`NF\` for non-functional. Number sequentially within each category.`,
-    `The summary line must be a complete description \u2014 an agent should be able to extract just summary lines to build a work plan.`,
-    ...isRevision ? [`When revising, preserve existing requirement IDs. Add new requirements by continuing the numbering sequence \u2014 never restart at F1.`] : [],
-    ``,
-    `**Success Metrics as JSON** \u2014 Use a fenced \`json\` code block containing an array of objects. The UI auto-renders these as tables.`,
-    `Each object should have \`Metric\`, \`Target\`, and \`Type\` fields. Example:`,
-    "````json",
-    `[`,
-    `  { "Metric": "API response time under load", "Target": "< 200ms p95", "Type": "Performance" }`,
-    `]`,
-    "````",
-    ``,
-    `**Affected Components as JSON** \u2014 Use the same JSON table format for the technical approach section:`,
-    "````json",
-    `[`,
-    `  { "Component": "path/to/file.ts", "Change": "What changes", "Scope": "~N lines" }`,
-    `]`,
-    "````",
-    ``,
-    `**Implementation Steps as Phased Checklists** \u2014 Use \`### Phase N: Name\` headers with markdown checklists (\`- [ ]\`).`,
-    `Gives humans a timeline overview at heading level; gives agents discrete work items.`,
+    `   - **Open Questions** \u2014 this section MUST use the structured format described in the system prompt`,
     ``,
-    `**Edge Cases as Tagged List** \u2014 Each edge case leads with a bold tag: \`- **Tag** \u2014 Description.\``,
-    ``,
-    `**No Frontmatter** \u2014 Do not include YAML frontmatter. Metadata lives in the database.`,
-    ``,
-    `### Open Questions Format`,
-    ``,
-    `The "Open Questions" section of the PRD MUST end with a fenced JSON code block`,
-    `tagged \`open-questions\`. This allows the UI to present them as answerable cards.`,
-    ``,
-    `Format:`,
-    "```",
-    "```open-questions",
-    `[`,
-    `  {`,
-    `    "id": "q1",`,
-    `    "question": "Which approach should we use for X?",`,
-    `    "context": "One sentence explaining why this decision matters.",`,
-    `    "options": [`,
-    `      "Option A \u2014 brief description",`,
-    `      "Option B \u2014 brief description",`,
-    `      "Option C \u2014 brief description"`,
-    `    ]`,
-    `  }`,
-    `]`,
-    "```",
-    "```",
-    ``,
-    `Rules for open questions:`,
-    `- Each question MUST have 2-4 concrete options.`,
-    `- Options should be actionable choices, not vague ("Yes"/"No" is fine when appropriate).`,
-    `- The "context" field should be a single sentence explaining why the decision matters.`,
-    `- Use sequential IDs: q1, q2, q3, etc.`,
-    `- Place the JSON block at the very end of the "Open Questions" section.`,
-    `- You may include a brief prose introduction before the JSON block, but the block itself must be last.`,
     ...isRevision ? [
-      `- If the user's feedback answered an open question, incorporate their answer and remove that question.`,
-      `- Only include questions that are still genuinely open after considering the feedback.`
-    ] : [],
+      `Follow the PRD Format Conventions and Open Questions Format from the system prompt.`,
+      `When revising, preserve existing requirement IDs. Add new requirements by continuing the numbering sequence \u2014 never restart at F1.`,
+      `If the user's feedback answered an open question, incorporate their answer and remove that question.`,
+      `Only include questions that are still genuinely open after considering the feedback.`
+    ] : [
+      `Follow the PRD Format Conventions and Open Questions Format from the system prompt.`
+    ],
     `${nextStep(4)}. Save the PRD as a Markdown file in the working directory:`,
     `   - File name: \`prd.md\``,
     `   - Write the full PRD content to this file.`,
@@ -1784,13 +2060,23 @@ function buildRefinementPrompt(proto, parentFiles, repoDir) {
     );
   }
   const variantList = Array.from({ length: proto.variantCount }, (_, i) => `prototype-${i + 1}.html`);
-  const existingVariants = parentFiles.map((f, i) => [
-    `### Previous Variant ${i + 1} (${f.name})`,
-    `\`\`\`html`,
-    f.content,
-    `\`\`\``,
-    ``
-  ].join("\n")).join("\n");
+  const existingVariantLines = [];
+  for (let i = 0; i < parentFiles.length; i++) {
+    const f = parentFiles[i];
+    const tmpPath = resolve2(repoDir, `.mr-parent-variant-${i + 1}.html`);
+    try {
+      writeFileSync4(tmpPath, f.content, "utf-8");
+      existingVariantLines.push(`### Previous Variant ${i + 1} (${f.name})`);
+      existingVariantLines.push(`File: \`${tmpPath}\` \u2014 read this file to see the full HTML content.`);
+    } catch {
+      existingVariantLines.push(`### Previous Variant ${i + 1} (${f.name})`);
+      existingVariantLines.push(`\`\`\`html`);
+      existingVariantLines.push(f.content);
+      existingVariantLines.push(`\`\`\``);
+    }
+    existingVariantLines.push(``);
+  }
+  const existingVariants = existingVariantLines.join("\n");
   return [
     `You are a UI designer and frontend engineer. Your job is to REFINE an existing prototype based on user feedback.`,
     ``,
@@ -1907,7 +2193,7 @@ function buildIdeaPrompt(idea, repoDir) {
     `- Do NOT exit until both files have been written and verified`
   ].join("\n");
 }
-function buildAgentArgs(agent, prompt2, mode, sessionId, name) {
+function buildAgentArgs(agent, prompt2, mode, sessionId, name, resumeSession = false, systemPrompt) {
   if (agent === "codex") {
     const args = [];
     if (mode === "execute") {
@@ -1917,26 +2203,40 @@ function buildAgentArgs(agent, prompt2, mode, sessionId, name) {
     if (mode === "execute") {
       args.push("-s", "danger-full-access");
     }
-    args.push(prompt2);
+    const fullPrompt = systemPrompt ? `${prompt2}
+
+${systemPrompt}` : prompt2;
+    args.push(fullPrompt);
     return { bin: "codex", args };
   }
   if (agent === "gemini") {
-    const args = ["-p", prompt2];
+    const fullPrompt = systemPrompt ? `${prompt2}
+
+${systemPrompt}` : prompt2;
+    const args = ["-p", fullPrompt];
     if (mode === "execute") {
       args.push("--yolo");
     }
     return { bin: "gemini", args };
   }
-  const sessionArgs = sessionId ? ["--session-id", sessionId] : [];
+  const sessionArgs = sessionId ? resumeSession ? ["--resume", sessionId] : ["--session-id", sessionId] : [];
   const nameArgs = name ? ["--name", name] : [];
+  const systemArgs = systemPrompt ? ["--append-system-prompt", systemPrompt] : [];
   if (mode === "plan") {
-    return { bin: "claude", args: [...sessionArgs, ...nameArgs, "--permission-mode", "plan", "-p", prompt2] };
+    return { bin: "claude", args: [...sessionArgs, ...nameArgs, ...systemArgs, "--permission-mode", "plan", "-p", prompt2] };
   }
-  return { bin: "claude", args: [...sessionArgs, ...nameArgs, "-p", "--dangerously-skip-permissions", prompt2] };
+  return { bin: "claude", args: [...sessionArgs, ...nameArgs, ...systemArgs, "-p", "--dangerously-skip-permissions", prompt2] };
+}
+function commandExists(cmd) {
+  return new Promise((resolve8) => {
+    exec(`command -v ${cmd}`, (err) => resolve8(!err));
+  });
 }
 function runPlanningPhase(task, repoDir, agent) {
   return new Promise((res, reject) => {
-    const { bin, args } = buildAgentArgs(agent, buildPlanningPrompt(task, repoDir), "plan", void 0, task.title);
+    const planPrompt = buildPlanningPrompt(task, repoDir);
+    console.log(`${timestamp()} ${taskTag(shortId(task.id))} ${paint("dim", tokenLogLine("plan", shortId(task.id), planPrompt))}`);
+    const { bin, args } = buildAgentArgs(agent, planPrompt, "plan", void 0, task.title);
     const child = spawn4(bin, args, { cwd: repoDir, stdio: ["ignore", "pipe", "pipe"] });
     child.on("error", (err) => {
       reject(new Error(`Failed to spawn ${agent}: ${err.message}`));
@@ -1969,25 +2269,28 @@ ${output.trim()}`));
   });
 }
 function askYesNo(question) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout
     });
     rl.question(question, (answer) => {
       rl.close();
-      resolve7(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes");
+      resolve8(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes");
     });
   });
 }
-function spawnAgent(agent, repoDir, prompt2, prefix, onActivity, sessionId, name) {
-  const { bin, args } = buildAgentArgs(agent, prompt2, "execute", sessionId, name);
+function spawnAgent(agent, repoDir, prompt2, prefix, onActivity, sessionId, name, resumeSession = false, onSpawnError, systemPrompt) {
+  const jobLabel = name ?? "unknown";
+  console.log(`${timestamp()} ${prefix} ${paint("dim", tokenLogLine("agent", jobLabel, prompt2, systemPrompt))}`);
+  const { bin, args } = buildAgentArgs(agent, prompt2, "execute", sessionId, name, resumeSession, systemPrompt);
   const child = spawn4(bin, args, { cwd: repoDir, stdio: ["ignore", "pipe", "pipe"] });
   child.on("error", (err) => {
     logError(prefix, `Failed to spawn ${agent}: ${err.message}`);
     if (err.code === "ENOENT") {
       logError(prefix, `Check that "${bin}" is on PATH and "${repoDir}" exists`);
     }
+    onSpawnError?.(err);
   });
   if (agent === "codex") {
     child.stdout?.on("data", () => onActivity?.());
@@ -2027,6 +2330,7 @@ var watchCommand = new Command8("watch").description(
   let pollRunning = false;
   const approvalQueue = [];
   let approvalRunning = false;
+  const agentAvailability = /* @__PURE__ */ new Map();
   const flags = [
     `interval=${paint("cyan", opts.interval + "s")}`,
     `root=${paint("cyan", rootDir)}`,
@@ -2049,6 +2353,22 @@ var watchCommand = new Command8("watch").description(
   console.log(banner);
   console.log(`  ${flags}
 `);
+  async function isAgentAvailable(candidate) {
+    const cached = agentAvailability.get(candidate);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const available = await commandExists(candidate);
+    agentAvailability.set(candidate, available);
+    return available;
+  }
+  async function resolveAgentChain(preferred) {
+    const availability = {};
+    for (const candidate of ["claude", "codex", "gemini"]) {
+      availability[candidate] = await isAgentAvailable(candidate);
+    }
+    return getAvailableAgentFallbackChain(preferred, availability);
+  }
   async function moveTaskToError(task, prefix, reason) {
     try {
       await api.patch(`/api/tasks/${task.id}`, { status: "error" });
@@ -2063,12 +2383,13 @@ var watchCommand = new Command8("watch").description(
   async function dispatchTask(task, repoDir) {
     const sid = shortId(task.id);
     const slug = slugify(task.title);
-    const branchName = `mr/${sid}/${slug}`;
+    const owner = ownerPrefix(task);
+    const branchName = `${owner}/${slug}`;
+    const legacyBranchName = `mr/${sid}/${slug}`;
     const prefix = taskTag(sid);
     const vcs = detectVcs(repoDir)?.provider ?? "github";
     logDispatch(prefix, `"${paint("bold", task.title)}"  ${paint("gray", repoDir)}  ${paint("dim", `[${vcs}]`)}`);
     await postTaskUpdate(task.id, `Agent dispatched \u2014 starting work on "${task.title}"`, "system");
-    await pullLatestMain(repoDir, prefix);
     let subtasks = [];
     try {
       subtasks = await api.get(`/api/tasks/${task.id}/subtasks`);
@@ -2112,20 +2433,27 @@ var watchCommand = new Command8("watch").description(
     } catch {
     }
     const hasFeedback = feedbackUpdates.length > 0;
-    const desiredWorktreePath = hasFeedback ? worktreePath(`${sid}-fb`) : worktreePath(sid);
+    const wtName = `${owner}-${slug}`;
+    const desiredWorktreePath = worktreePath(wtName);
+    const startWithoutWorktree = !hasFeedback && taskLikelyDoesNotNeedCodeChanges(task);
     let executionDir = repoDir;
     let cleanupWorktreePath;
-    if (isGitRepo(repoDir)) {
-      executionDir = createWorktree(
+    if (startWithoutWorktree) {
+      logInfo(prefix, `Skipping pre-created worktree; task looks like a no-code workflow`);
+    } else if (isGitRepo(repoDir)) {
+      const worktree = createWorktree(
         repoDir,
         branchName,
         worktreeNameFromPath(desiredWorktreePath)
       );
-      cleanupWorktreePath = executionDir;
-      logInfo(prefix, `Prepared worktree ${paint("cyan", executionDir)}`);
+      executionDir = worktree.path;
+      cleanupWorktreePath = worktree.created ? executionDir : void 0;
+      logInfo(
+        prefix,
+        worktree.reusedBranchWorktree ? `Reusing existing worktree ${paint("cyan", executionDir)} for branch ${paint("dim", branchName)}` : `Prepared worktree ${paint("cyan", executionDir)}`
+      );
     }
-    const prompt2 = buildExecutionPrompt(task, repoDir, subtasks, vcs, protoRefs, feedbackUpdates, existingResources, skillRefs, executionDir);
-    const sessionId = agent === "claude" ? randomUUID() : void 0;
+    const prompt2 = buildExecutionPrompt(task, repoDir, subtasks, vcs, protoRefs, feedbackUpdates, existingResources, skillRefs, executionDir, startWithoutWorktree);
     const activeEntry = {
       process: void 0,
       title: task.title,
@@ -2138,90 +2466,181 @@ var watchCommand = new Command8("watch").description(
     const touchActivity = () => {
       activeEntry.lastActivityAt = Date.now();
     };
-    const child = spawnAgent(agent, executionDir, 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)}`);
+    const attemptOrder = await resolveAgentChain(agent);
+    if (attemptOrder.length === 0) {
+      logError(prefix, `No available agents found for fallback chain starting at ${agent}`);
+      await moveTaskToError(task, prefix, `No available agent found for fallback chain starting at ${agent}`);
+      if (activeEntry.cleanupRepoDir && activeEntry.cleanupWorktreePath) {
+        removeWorktree(activeEntry.cleanupRepoDir, activeEntry.cleanupWorktreePath);
+      }
+      queued.delete(task.id);
+      return;
     }
-    active.set(task.id, activeEntry);
-    child.on("exit", async (code) => {
-      active.delete(task.id);
-      finishing.add(task.id);
-      try {
-        if (code === 0) {
-          try {
-            const researchPath = resolve2(executionDir, "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 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`);
+    let attemptIndex = 0;
+    const launchAttempt = async (attemptAgent) => {
+      let spawnFailureReason = null;
+      const shouldResumeClaudeSession = attemptAgent === "claude" && hasFeedback && !!task.claudeSessionId;
+      const sessionId = attemptAgent === "claude" ? task.claudeSessionId ?? randomUUID() : void 0;
+      const executionSystemPrompt = composeSystemPrompt(EXECUTION_SYSTEM_SECTIONS);
+      const child = spawnAgent(
+        attemptAgent,
+        executionDir,
+        prompt2,
+        prefix,
+        touchActivity,
+        sessionId,
+        task.title,
+        shouldResumeClaudeSession,
+        (err) => {
+          spawnFailureReason = err.message;
+        },
+        executionSystemPrompt
+      );
+      activeEntry.process = child;
+      activeEntry.currentAgent = attemptAgent;
+      active.set(task.id, activeEntry);
+      if (attemptAgent === "claude" && sessionId) {
+        api.patch(`/api/tasks/${task.id}`, { claudeSessionId: sessionId }).catch(() => {
+        });
+        logInfo(
+          prefix,
+          shouldResumeClaudeSession ? `Resuming Claude session: ${paint("dim", sessionId)}` : `Claude session: ${paint("dim", sessionId)}`
+        );
+      } else {
+        api.patch(`/api/tasks/${task.id}`, { claudeSessionId: null }).catch(() => {
+        });
+      }
+      child.on("exit", async (code) => {
+        if (active.get(task.id)?.process === child) {
+          active.delete(task.id);
+        }
+        const failedAttempt = code !== 0 || spawnFailureReason !== null;
+        if (failedAttempt && !activeEntry.terminatedForError) {
+          const nextAgent = attemptOrder[attemptIndex + 1];
+          if (nextAgent) {
+            const failureDetail = spawnFailureReason ?? `exit code ${code}`;
+            logWarn(prefix, `${attemptAgent} failed (${failureDetail}) \u2014 retrying with ${nextAgent}`);
+            await postTaskUpdate(
+              task.id,
+              `${attemptAgent} failed (${failureDetail}) \u2014 retrying with ${nextAgent}`,
+              "system"
+            );
+            attemptIndex += 1;
+            await launchAttempt(nextAgent);
+            return;
+          }
+        }
+        finishing.add(task.id);
+        try {
+          if (code === 0) {
+            try {
+              const researchPath = resolve2(executionDir, "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 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}`);
                 }
-                unlinkSync(researchPath);
-              } catch (err) {
-                logWarn(prefix, `Failed to upload research resource: ${err.message}`);
               }
-            }
-            const noMrPath = resolve2(executionDir, ".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}`);
-            }
-            const prLabel = vcs === "gitlab" ? "MR" : "PR";
-            let prUrl = null;
-            if (!noMrRequested) {
-              prUrl = await findPrUrlAcrossRepos(branchName, repoDir, vcs);
-              if (!prUrl) {
-                prUrl = await extractPrUrlFromUpdates(task.id);
+              const noMrPath = resolve2(executionDir, ".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}`);
+              }
+              const prLabel = vcs === "gitlab" ? "MR" : "PR";
+              let prUrl = null;
+              if (!noMrRequested) {
+                prUrl = await findPrUrlAcrossRepos(branchName, repoDir, vcs);
+                if (!prUrl) {
+                  prUrl = await findPrUrlAcrossRepos(legacyBranchName, repoDir, vcs);
+                }
+                if (!prUrl) {
+                  prUrl = await extractPrUrlFromUpdates(task.id);
+                  if (prUrl) {
+                    logInfo(prefix, `Found ${prLabel} URL from agent updates: ${paint("cyan", prUrl)}`);
+                  }
+                }
+                if (!prUrl) {
+                  prUrl = await createPrAcrossRepos(
+                    task,
+                    branchName,
+                    repoDir,
+                    vcs,
+                    subtasks,
+                    protoRefs,
+                    feedbackUpdates,
+                    existingResources,
+                    skillRefs
+                  );
+                  if (!prUrl) {
+                    prUrl = await createPrAcrossRepos(
+                      task,
+                      legacyBranchName,
+                      repoDir,
+                      vcs,
+                      subtasks,
+                      protoRefs,
+                      feedbackUpdates,
+                      existingResources,
+                      skillRefs
+                    );
+                  }
+                  if (prUrl) {
+                    logInfo(prefix, `Created missing ${prLabel} for branch ${paint("cyan", branchName)}`);
+                    await postTaskUpdate(task.id, `Watch created the missing ${prLabel} for branch ${branchName}`, "system");
+                  }
+                }
                 if (prUrl) {
-                  logInfo(prefix, `Found ${prLabel} URL from agent updates: ${paint("cyan", 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");
                 }
               }
-              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");
-              }
+              await api.patch(`/api/tasks/${task.id}`, {
+                status: "review",
+                claudeSessionId: activeEntry.currentAgent === "claude" ? void 0 : null,
+                ...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}`);
             }
-            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) {
+            const failureDetail = spawnFailureReason ?? `exit code ${code}`;
+            const reason = `${attemptAgent} failed (${failureDetail}) \u2014 task moved to error`;
+            logError(prefix, `"${paint("bold", task.title)}" failed (${failureDetail}), moving task to error`);
+            await moveTaskToError(task, prefix, reason);
           }
-        } else if (!activeEntry.terminatedForError) {
-          const reason = `Agent failed with exit code ${code} \u2014 task moved to error`;
-          logError(prefix, `"${paint("bold", task.title)}" failed (exit ${code}), moving task to error`);
-          await moveTaskToError(task, prefix, reason);
-        }
-      } finally {
-        if (activeEntry.cleanupRepoDir && activeEntry.cleanupWorktreePath) {
-          removeWorktree(activeEntry.cleanupRepoDir, activeEntry.cleanupWorktreePath);
+        } finally {
+          if (activeEntry.cleanupRepoDir && activeEntry.cleanupWorktreePath) {
+            removeWorktree(activeEntry.cleanupRepoDir, activeEntry.cleanupWorktreePath);
+          }
+          queued.delete(task.id);
+          finishing.delete(task.id);
         }
-        queued.delete(task.id);
-        finishing.delete(task.id);
-      }
-    });
+      });
+    };
+    await launchAttempt(attemptOrder[attemptIndex]);
   }
   async function dispatchPlanModeTask(task, repoDir) {
     const sid = shortId(task.id);
@@ -2252,65 +2671,122 @@ var watchCommand = new Command8("watch").description(
       "system"
     );
     const prompt2 = buildPrdPrompt(task, repoDir, existingPlanResource?.content, feedbackUpdates);
-    const child = spawnAgent(agent, repoDir, prompt2, prefix, void 0, void 0, task.title);
-    active.set(task.id, { process: child, title: task.title, repoDir, startedAt: Date.now() });
-    child.on("exit", async (code) => {
-      active.delete(task.id);
-      finishing.add(task.id);
-      try {
-        if (code === 0) {
-          try {
-            const prdPath = resolve2(repoDir, "prd.md");
-            let prdContent;
+    const attemptOrder = await resolveAgentChain(agent);
+    if (attemptOrder.length === 0) {
+      logError(prefix, `No available agents found for fallback chain starting at ${agent}`);
+      await api.patch(`/api/tasks/${task.id}`, { status: "error" }).catch((err) => {
+        logError(prefix, `Failed to mark task as error: ${err.message}`);
+      });
+      await postTaskUpdate(task.id, `PRD generation could not start \u2014 no available agent found for fallback chain starting at ${agent}`, "system");
+      queued.delete(task.id);
+      return;
+    }
+    const activeEntry = {
+      process: void 0,
+      title: task.title,
+      repoDir,
+      startedAt: Date.now(),
+      lastActivityAt: Date.now()
+    };
+    let attemptIndex = 0;
+    const launchAttempt = async (attemptAgent) => {
+      let spawnFailureReason = null;
+      const prdSystemPrompt = composeSystemPrompt(PRD_SYSTEM_SECTIONS);
+      const child = spawnAgent(
+        attemptAgent,
+        repoDir,
+        prompt2,
+        prefix,
+        void 0,
+        void 0,
+        task.title,
+        false,
+        (err) => {
+          spawnFailureReason = err.message;
+        },
+        prdSystemPrompt
+      );
+      activeEntry.process = child;
+      activeEntry.currentAgent = attemptAgent;
+      active.set(task.id, activeEntry);
+      child.on("exit", async (code) => {
+        if (active.get(task.id)?.process === child) {
+          active.delete(task.id);
+        }
+        const failedAttempt = code !== 0 || spawnFailureReason !== null;
+        if (failedAttempt) {
+          const nextAgent = attemptOrder[attemptIndex + 1];
+          if (nextAgent) {
+            const failureDetail = spawnFailureReason ?? `exit code ${code}`;
+            logWarn(prefix, `${attemptAgent} failed (${failureDetail}) \u2014 retrying PRD generation with ${nextAgent}`);
+            await postTaskUpdate(
+              task.id,
+              `${attemptAgent} failed (${failureDetail}) \u2014 retrying PRD generation with ${nextAgent}`,
+              "system"
+            );
+            attemptIndex += 1;
+            await launchAttempt(nextAgent);
+            return;
+          }
+        }
+        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}), marked as error`);
-          try {
-            await api.patch(`/api/tasks/${task.id}`, { status: "error" });
-          } catch (err) {
-            logError(prefix, `Failed to mark task as error: ${err.message}`);
+          } else {
+            const failureDetail = spawnFailureReason ?? `exit code ${code}`;
+            logError(prefix, `"${paint("bold", task.title)}" PRD generation failed (${failureDetail}), marked as error`);
+            try {
+              await api.patch(`/api/tasks/${task.id}`, { status: "error" });
+            } catch (err) {
+              logError(prefix, `Failed to mark task as error: ${err.message}`);
+            }
+            await postTaskUpdate(task.id, `PRD generation failed via ${attemptAgent} (${failureDetail}) \u2014 task moved to error`, "system");
           }
-          await postTaskUpdate(task.id, `PRD generation failed with exit code ${code} \u2014 task moved to error`, "system");
+        } finally {
+          queued.delete(task.id);
+          finishing.delete(task.id);
         }
-      } finally {
-        queued.delete(task.id);
-        finishing.delete(task.id);
-      }
-    });
+      });
+    };
+    await launchAttempt(attemptOrder[attemptIndex]);
   }
   async function dispatchPrototypeJob(proto, repoDir) {
     const sid = shortId(proto.id);
@@ -2336,84 +2812,186 @@ var watchCommand = new Command8("watch").description(
     } else {
       prompt2 = buildPrototypePrompt(proto, repoDir);
     }
-    const child = spawnAgent(agent, repoDir, prompt2, prefix, void 0, proto.title);
-    active.set(`proto-${proto.id}`, { process: child, title: proto.title, repoDir, startedAt: Date.now() });
-    child.on("exit", async (code) => {
-      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) {
+    const key = `proto-${proto.id}`;
+    const attemptOrder = await resolveAgentChain(agent);
+    if (attemptOrder.length === 0) {
+      logError(prefix, `No available agents found for fallback chain starting at ${agent}`);
+      await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" }).catch(() => {
+      });
+      queued.delete(key);
+      return;
+    }
+    const activeEntry = {
+      process: void 0,
+      title: proto.title,
+      repoDir,
+      startedAt: Date.now(),
+      lastActivityAt: Date.now()
+    };
+    let attemptIndex = 0;
+    const launchAttempt = async (attemptAgent) => {
+      let spawnFailureReason = null;
+      const child = spawnAgent(
+        attemptAgent,
+        repoDir,
+        prompt2,
+        prefix,
+        void 0,
+        void 0,
+        proto.title,
+        false,
+        (err) => {
+          spawnFailureReason = err.message;
+        }
+      );
+      activeEntry.process = child;
+      activeEntry.currentAgent = attemptAgent;
+      active.set(key, activeEntry);
+      child.on("exit", async (code) => {
+        if (active.get(key)?.process === child) {
+          active.delete(key);
+        }
+        const failedAttempt = code !== 0 || spawnFailureReason !== null;
+        if (failedAttempt) {
+          const nextAgent = attemptOrder[attemptIndex + 1];
+          if (nextAgent) {
+            const failureDetail = spawnFailureReason ?? `exit code ${code}`;
+            logWarn(prefix, `${attemptAgent} failed (${failureDetail}) \u2014 retrying prototype generation with ${nextAgent}`);
+            attemptIndex += 1;
+            await launchAttempt(nextAgent);
+            return;
+          }
+        }
+        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(resolve2(repoDir, file.name));
+                await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" });
               } catch {
               }
             }
-          } catch (err) {
-            logError(prefix, `Failed to upload prototype: ${err.message}`);
+          } else {
+            const failureDetail = spawnFailureReason ?? `exit code ${code}`;
+            logError(prefix, `"${paint("bold", proto.title)}" prototype failed via ${attemptAgent} (${failureDetail})`);
+            try {
+              await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" });
+            } catch {
+            }
+          }
+        } finally {
+          queued.delete(key);
+          finishing.delete(key);
+        }
+      });
+    };
+    await launchAttempt(attemptOrder[attemptIndex]);
+  }
+  async function dispatchRepoCreation(project, workDir) {
+    const sid = shortId(project.id);
+    const prefix = repoTag(sid);
+    logDispatch(prefix, `"${paint("bold", project.name)}"  ${paint("gray", workDir)}`);
+    try {
+      await api.patch(`/api/projects/${project.id}`, { repoCreationStatus: "creating" });
+    } catch {
+    }
+    const prompt2 = buildRepoCreationPrompt(project, workDir);
+    const key = `repo-${project.id}`;
+    const attemptOrder = await resolveAgentChain(agent);
+    if (attemptOrder.length === 0) {
+      logError(prefix, `No available agents found for fallback chain starting at ${agent}`);
+      queued.delete(key);
+      try {
+        await api.patch(`/api/projects/${project.id}`, { repoCreationStatus: "failed" });
+      } catch {
+      }
+      return;
+    }
+    const activeEntry = {
+      process: void 0,
+      title: project.name,
+      repoDir: workDir,
+      startedAt: Date.now(),
+      lastActivityAt: Date.now()
+    };
+    let attemptIndex = 0;
+    const launchAttempt = async (attemptAgent) => {
+      let spawnFailureReason = null;
+      const child = spawnAgent(
+        attemptAgent,
+        workDir,
+        prompt2,
+        prefix,
+        void 0,
+        void 0,
+        project.name,
+        false,
+        (err) => {
+          spawnFailureReason = err.message;
+        }
+      );
+      activeEntry.process = child;
+      activeEntry.currentAgent = attemptAgent;
+      active.set(key, activeEntry);
+      child.on("exit", async (code) => {
+        if (active.get(key)?.process === child) {
+          active.delete(key);
+        }
+        const failedAttempt = code !== 0 || spawnFailureReason !== null;
+        if (failedAttempt) {
+          const nextAgent = attemptOrder[attemptIndex + 1];
+          if (nextAgent) {
+            const failureDetail = spawnFailureReason ?? `exit code ${code}`;
+            logWarn(prefix, `${attemptAgent} failed (${failureDetail}) \u2014 retrying repo creation with ${nextAgent}`);
+            attemptIndex += 1;
+            await launchAttempt(nextAgent);
+            return;
+          }
+        }
+        finishing.add(key);
+        try {
+          if (code === 0) {
+            logSuccess(prefix, `"${paint("bold", project.name)}" repo creation complete`);
+            try {
+              await api.patch(`/api/projects/${project.id}`, { repoCreationStatus: "created" });
+            } catch {
+            }
+          } else {
+            const failureDetail = spawnFailureReason ?? `exit code ${code}`;
+            logError(prefix, `"${paint("bold", project.name)}" repo creation failed via ${attemptAgent} (${failureDetail})`);
             try {
-              await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" });
+              await api.patch(`/api/projects/${project.id}`, { repoCreationStatus: "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);
-      }
-    });
-  }
-  async function dispatchRepoCreation(project, workDir) {
-    const sid = shortId(project.id);
-    const prefix = repoTag(sid);
-    logDispatch(prefix, `"${paint("bold", project.name)}"  ${paint("gray", workDir)}`);
-    try {
-      await api.patch(`/api/projects/${project.id}`, { repoCreationStatus: "creating" });
-    } catch {
-    }
-    const prompt2 = buildRepoCreationPrompt(project, workDir);
-    const child = spawnAgent(agent, workDir, prompt2, prefix, void 0, project.name);
-    active.set(`repo-${project.id}`, { process: child, title: project.name, repoDir: workDir, startedAt: Date.now() });
-    child.on("exit", async (code) => {
-      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);
         }
-      } finally {
-        queued.delete(key);
-        finishing.delete(key);
-      }
-    });
+      });
+    };
+    await launchAttempt(attemptOrder[attemptIndex]);
   }
   async function dispatchIdeaJob(idea, repoDir) {
     const sid = shortId(idea.id);
@@ -2426,96 +3004,146 @@ var watchCommand = new Command8("watch").description(
       }
     }
     const prompt2 = buildIdeaPrompt(idea, repoDir);
-    const child = spawnAgent(agent, repoDir, prompt2, prefix, void 0, idea.title);
-    active.set(`idea-${idea.id}`, { process: child, title: idea.title, repoDir, startedAt: Date.now() });
-    child.on("exit", async (code) => {
-      const key = `idea-${idea.id}`;
-      active.delete(key);
-      finishing.add(key);
+    const key = `idea-${idea.id}`;
+    const attemptOrder = await resolveAgentChain(agent);
+    if (attemptOrder.length === 0) {
+      logError(prefix, `No available agents found for fallback chain starting at ${agent}`);
+      queued.delete(key);
       try {
-        if (code === 0) {
-          try {
-            let plan;
-            let protoHtml;
-            let followUpTasks;
-            const planPath = resolve2(repoDir, "idea-plan.md");
-            const tasksPath = resolve2(repoDir, "idea-tasks.json");
-            const protoPath = resolve2(repoDir, "idea-prototype.html");
-            try {
-              plan = readFileSync5(planPath, "utf-8");
-            } catch {
-            }
-            try {
-              protoHtml = readFileSync5(protoPath, "utf-8");
-            } catch {
-            }
+        await api.patch(`/api/ideas/${idea.id}`, { status: "draft" });
+      } catch {
+      }
+      return;
+    }
+    const activeEntry = {
+      process: void 0,
+      title: idea.title,
+      repoDir,
+      startedAt: Date.now(),
+      lastActivityAt: Date.now()
+    };
+    let attemptIndex = 0;
+    const launchAttempt = async (attemptAgent) => {
+      let spawnFailureReason = null;
+      const child = spawnAgent(
+        attemptAgent,
+        repoDir,
+        prompt2,
+        prefix,
+        void 0,
+        void 0,
+        idea.title,
+        false,
+        (err) => {
+          spawnFailureReason = err.message;
+        }
+      );
+      activeEntry.process = child;
+      activeEntry.currentAgent = attemptAgent;
+      active.set(key, activeEntry);
+      child.on("exit", async (code) => {
+        if (active.get(key)?.process === child) {
+          active.delete(key);
+        }
+        const failedAttempt = code !== 0 || spawnFailureReason !== null;
+        if (failedAttempt) {
+          const nextAgent = attemptOrder[attemptIndex + 1];
+          if (nextAgent) {
+            const failureDetail = spawnFailureReason ?? `exit code ${code}`;
+            logWarn(prefix, `${attemptAgent} failed (${failureDetail}) \u2014 retrying idea generation with ${nextAgent}`);
+            attemptIndex += 1;
+            await launchAttempt(nextAgent);
+            return;
+          }
+        }
+        finishing.add(key);
+        try {
+          if (code === 0) {
             try {
-              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 {
+            const failureDetail = spawnFailureReason ?? `exit code ${code}`;
+            logError(prefix, `"${paint("bold", idea.title)}" generation failed via ${attemptAgent} (${failureDetail})`);
             try {
               await api.patch(`/api/ideas/${idea.id}`, { status: "draft" });
             } catch {
             }
           }
-        } 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);
         }
-      } finally {
-        queued.delete(key);
-        finishing.delete(key);
-      }
-    });
+      });
+    };
+    await launchAttempt(attemptOrder[attemptIndex]);
   }
   function dispatchScan(scan, prefix, key) {
     logDispatch(prefix, `Running scan for project ${paint("cyan", scan.projectId.slice(0, 8))}`);
@@ -2529,7 +3157,13 @@ var watchCommand = new Command8("watch").description(
       queued.delete(key);
       failed.set(key, err.message);
     });
-    active.set(key, { process: scanProc, title: `scan-${scan.id.slice(0, 8)}`, repoDir: rootDir, startedAt: Date.now() });
+    active.set(key, {
+      process: scanProc,
+      title: `scan-${scan.id.slice(0, 8)}`,
+      repoDir: rootDir,
+      startedAt: Date.now(),
+      lastActivityAt: Date.now()
+    });
     scanProc.stdout?.on("data", (d) => {
       const lines = d.toString().trim().split("\n");
       for (const line of lines) {
@@ -2561,7 +3195,28 @@ var watchCommand = new Command8("watch").description(
     const prefix = taskTag(sid);
     try {
       logSpinner(prefix, `Generating plan for "${paint("bold", task.title)}"\u2026`);
-      const plan = await runPlanningPhase(task, repoDir, agent);
+      const attemptOrder = await resolveAgentChain(agent);
+      if (attemptOrder.length === 0) {
+        throw new Error(`No available agent found for fallback chain starting at ${agent}`);
+      }
+      let plan;
+      let lastError;
+      for (let idx = 0; idx < attemptOrder.length; idx += 1) {
+        const attemptAgent = attemptOrder[idx];
+        try {
+          plan = await runPlanningPhase(task, repoDir, attemptAgent);
+          break;
+        } catch (err) {
+          lastError = err;
+          const nextAgent = attemptOrder[idx + 1];
+          if (nextAgent) {
+            logWarn(prefix, `${attemptAgent} planning failed (${lastError.message}) \u2014 retrying with ${nextAgent}`);
+          }
+        }
+      }
+      if (!plan) {
+        throw lastError ?? new Error("Planning failed");
+      }
       const width = 64;
       const divider = paint("gray", "\u2500".repeat(width));
       const header = `${paint("bold", "Plan")}  "${paint("bold", task.title)}"  ${taskTag(sid)}`;
@@ -2754,14 +3409,16 @@ ${divider}`);
         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;
+        let repoDir;
+        if (proto.projectId) {
+          const dir = findDirectoryForProject(config, proto.projectId, rootDir);
+          if (!dir) {
+            logWarn(prefix, `"${proto.title}": no linked directory found \u2014 skipping`);
+            continue;
+          }
+          repoDir = dir;
+        } else {
+          repoDir = rootDir;
         }
         if (!existsSync7(repoDir)) {
           logError(prefix, `"${proto.title}": linked directory "${repoDir}" does not exist \u2014 skipping`);
@@ -2779,16 +3436,25 @@ ${divider}`);
         }
         dispatchPrototypeJob(proto, repoDir);
       }
+      const MAX_CONCURRENT_TESTS = 2;
       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 activeTests = [...queued].filter((k) => k.startsWith("test-")).length;
+        if (activeTests >= MAX_CONCURRENT_TESTS) break;
         const sid = shortId(task.id);
         const prefix = testTag(sid);
         if (!task.link) {
           logWarn(prefix, `"${task.title}": no MR/PR link \u2014 skipping`);
+          failed.set(key, "no MR/PR link");
+          try {
+            await api.patch(`/api/tasks/${task.id}`, { status: "error" });
+            await postTaskUpdate(task.id, "Test skipped: task has no MR/PR link", "system");
+          } catch {
+          }
           continue;
         }
         queued.add(key);
@@ -2835,9 +3501,9 @@ ${divider}`);
               browseRunner: runBrowseCommand2,
               uploadScreenshot: async (screenshotPath, message) => {
                 try {
-                  const { readFileSync: readFileSync12 } = await import("fs");
+                  const { readFileSync: readFileSync13 } = await import("fs");
                   const cfg = loadConfig();
-                  const imageBuffer = readFileSync12(screenshotPath);
+                  const imageBuffer = readFileSync13(screenshotPath);
                   const fileName = screenshotPath.split("/").pop() || "test-screenshot.png";
                   const formData = new FormData();
                   const blob = new Blob([imageBuffer], { type: "image/png" });
@@ -2977,6 +3643,55 @@ ${divider}`);
         }
         dispatchScan(scan, prefix, key);
       }
+      let reviewTasks = [];
+      try {
+        reviewTasks = await api.get("/api/tasks?status=review");
+      } catch (err) {
+        logError(watchTag(), `Failed to fetch review tasks: ${err.message}`);
+      }
+      for (const task of reviewTasks) {
+        if (!task.link) continue;
+        if (queued.has(task.id) || finishing.has(task.id) || active.has(task.id)) continue;
+        const sid = shortId(task.id);
+        const prefix = taskTag(sid);
+        const prLabel = task.link.includes("gitlab") ? "MR" : "PR";
+        const vcs = task.link.includes("gitlab") ? "gitlab" : "github";
+        const repoDir = findDirectoryForProject(config, task.projectId, rootDir);
+        if (!repoDir) continue;
+        const status = await checkPrStatus(task.link, repoDir, vcs);
+        if (!status) continue;
+        if (status.merged) {
+          logSuccess(prefix, `${prLabel} merged \u2014 auto-completing "${paint("bold", task.title)}"`);
+          try {
+            await api.patch(`/api/tasks/${task.id}`, {
+              status: "completed",
+              completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              inProgressSince: null
+            });
+            await postTaskUpdate(task.id, `${prLabel} merged \u2014 task automatically completed`, "system");
+          } catch (err) {
+            logError(prefix, `Failed to auto-complete task: ${err.message}`);
+          }
+          continue;
+        }
+        if (status.hasConflicts) {
+          logWarn(prefix, `${prLabel} has merge conflicts \u2014 re-dispatching agent for "${paint("bold", task.title)}"`);
+          try {
+            await api.patch(`/api/tasks/${task.id}`, { status: "queued" });
+            await api.post(`/api/tasks/${task.id}/updates`, {
+              message: `Your ${prLabel} has merge conflicts with the base branch. Please resolve the conflicts by rebasing or merging main into your branch, then push the updated branch.`,
+              source: "user"
+            });
+            await postTaskUpdate(
+              task.id,
+              `${prLabel} has merge conflicts \u2014 re-dispatching agent to resolve`,
+              "system"
+            );
+          } catch (err) {
+            logError(prefix, `Failed to re-queue task for conflict resolution: ${err.message}`);
+          }
+        }
+      }
     } finally {
       pollRunning = false;
     }
@@ -3214,22 +3929,21 @@ var prototypeCommand = new Command13("prototype").description("Manage prototypes
     }
   })
 ).addCommand(
-  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) => {
+  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, when available)").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.');
-      process.exit(1);
-    }
     const variantCount = Math.max(1, Math.min(50, parseInt(opts.variants, 10) || 5));
     const prototype = await api.post("/api/prototypes", {
       title,
       prompt: opts.prompt,
       variantCount,
-      projectId
+      projectId: projectId ?? null
     });
     console.log();
     console.log(`  ${paint4("green", "\u2713")} Created prototype: ${paint4("bold", prototype.title)}`);
     console.log(`  ${paint4("gray", "ID:")} ${prototype.id}`);
+    if (!prototype.projectId) {
+      console.log(`  ${paint4("gray", "Project:")} none (will generate in the active watch directory)`);
+    }
     console.log(`  ${paint4("cyan", "\u27F3")} Generation will begin automatically via the watch agent.`);
     console.log();
   })
@@ -3272,20 +3986,20 @@ var c5 = {
 function paint5(color, text) {
   return `${c5[color]}${text}${c5.reset}`;
 }
-function commandExists(cmd) {
-  return new Promise((resolve7) => {
-    exec2(`which ${cmd}`, (err) => resolve7(!err));
+function commandExists2(cmd) {
+  return new Promise((resolve8) => {
+    exec2(`which ${cmd}`, (err) => resolve8(!err));
   });
 }
 function execQuiet(cmd) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     exec2(cmd, (err, stdout, stderr) => {
-      resolve7({ ok: !err, stdout: stdout.trim(), stderr: stderr.trim() });
+      resolve8({ ok: !err, stdout: stdout.trim(), stderr: stderr.trim() });
     });
   });
 }
 async function checkGitInstalled() {
-  const exists = await commandExists("git");
+  const exists = await commandExists2("git");
   if (!exists) {
     return {
       name: "Git",
@@ -3325,7 +4039,7 @@ async function checkNodeVersion() {
   };
 }
 async function checkGhInstalled() {
-  const exists = await commandExists("gh");
+  const exists = await commandExists2("gh");
   return {
     name: "GitHub CLI (gh)",
     ok: exists,
@@ -3334,7 +4048,7 @@ async function checkGhInstalled() {
   };
 }
 async function checkGhAuth() {
-  const exists = await commandExists("gh");
+  const exists = await commandExists2("gh");
   if (!exists) {
     return {
       name: "GitHub CLI auth",
@@ -3352,7 +4066,7 @@ async function checkGhAuth() {
   };
 }
 async function checkClaudeInstalled() {
-  const exists = await commandExists("claude");
+  const exists = await commandExists2("claude");
   return {
     name: "Claude Code (claude)",
     ok: exists,
@@ -3361,7 +4075,7 @@ async function checkClaudeInstalled() {
   };
 }
 async function checkClaudeAuth() {
-  const exists = await commandExists("claude");
+  const exists = await commandExists2("claude");
   if (!exists) {
     return {
       name: "Claude Code auth",
@@ -3379,7 +4093,7 @@ async function checkClaudeAuth() {
   };
 }
 async function checkCodexInstalled() {
-  const exists = await commandExists("codex");
+  const exists = await commandExists2("codex");
   return {
     name: "Codex CLI (codex)",
     ok: exists,
@@ -3388,7 +4102,7 @@ async function checkCodexInstalled() {
   };
 }
 async function checkCodexAuth() {
-  const exists = await commandExists("codex");
+  const exists = await commandExists2("codex");
   if (!exists) {
     return {
       name: "Codex CLI auth",
@@ -3405,7 +4119,7 @@ async function checkCodexAuth() {
   };
 }
 async function checkGeminiInstalled() {
-  const exists = await commandExists("gemini");
+  const exists = await commandExists2("gemini");
   return {
     name: "Gemini CLI (gemini)",
     ok: exists,
@@ -3414,7 +4128,7 @@ async function checkGeminiInstalled() {
   };
 }
 async function checkGeminiAuth() {
-  const exists = await commandExists("gemini");
+  const exists = await commandExists2("gemini");
   if (!exists) {
     return {
       name: "Gemini CLI auth",
@@ -3431,7 +4145,7 @@ async function checkGeminiAuth() {
   };
 }
 async function checkGlabInstalled() {
-  const exists = await commandExists("glab");
+  const exists = await commandExists2("glab");
   return {
     name: "GitLab CLI (glab)",
     ok: exists,
@@ -3441,7 +4155,7 @@ async function checkGlabInstalled() {
   };
 }
 async function checkGlabAuth() {
-  const exists = await commandExists("glab");
+  const exists = await commandExists2("glab");
   if (!exists) {
     return {
       name: "GitLab CLI auth",
@@ -3461,7 +4175,7 @@ async function checkGlabAuth() {
   };
 }
 async function checkJqInstalled() {
-  const exists = await commandExists("jq");
+  const exists = await commandExists2("jq");
   return {
     name: "jq (optional)",
     ok: exists,
@@ -3535,26 +4249,26 @@ async function autoFix(checks, agent) {
   if (claudeCheck && !claudeCheck.ok && agent === "claude") {
     console.log(paint5("cyan", "  Installing Claude Code..."));
     console.log(paint5("dim", "  Running: curl -fsSL https://claude.ai/install.sh | bash"));
-    await new Promise((resolve7) => {
+    await new Promise((resolve8) => {
       const child = spawn8("bash", ["-c", "curl -fsSL https://claude.ai/install.sh | bash"], { stdio: "inherit" });
-      child.on("exit", () => resolve7());
+      child.on("exit", () => resolve8());
     });
     console.log("");
   }
   if (ghInstalled && !ghAuthed) {
     console.log(paint5("cyan", "  Running gh auth login..."));
-    await new Promise((resolve7) => {
+    await new Promise((resolve8) => {
       const child = spawn8("gh", ["auth", "login"], { stdio: "inherit" });
-      child.on("exit", () => resolve7());
+      child.on("exit", () => resolve8());
     });
     console.log("");
   }
   if (!mrAuthed) {
     console.log(paint5("cyan", "  Running mr login..."));
     const entry = process.argv[1];
-    await new Promise((resolve7) => {
+    await new Promise((resolve8) => {
       const child = spawn8(process.execPath, [entry, "login"], { stdio: "inherit" });
-      child.on("exit", () => resolve7());
+      child.on("exit", () => resolve8());
     });
     console.log("");
   }
@@ -3802,7 +4516,7 @@ var resumeCommand = new Command17("resume").description("Resume an interactive C
 // cli/commands/browse.ts
 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 { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
 import { join as join8 } from "path";
 var BROWSE_DIR2 = join8(import.meta.dirname, "..", "..", "browse");
 function isProcessAlive(pid) {
@@ -3849,7 +4563,7 @@ async function ensureDevServer() {
     env: { ...process.env }
   });
   devProc.unref();
-  writeFileSync4(
+  writeFileSync5(
     devStateFile,
     JSON.stringify({ pid: devProc.pid, port, startedAt: (/* @__PURE__ */ new Date()).toISOString() }),
     { mode: 384 }
@@ -4091,7 +4805,7 @@ var testCommand = new Command20("test").description("Run automated browser test
 
 // cli/commands/features.ts
 import { Command as Command21 } from "commander";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync12 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync12 } from "fs";
 import { resolve as resolve5, sep as sep2 } from "path";
 var FEATURES_FILE3 = ".mr-features.md";
 var c7 = {
@@ -4132,13 +4846,13 @@ var featuresCommand = new Command21("features").description("View or update the
   if (opts.file) {
     const content2 = readFileSync9(resolve5(opts.file), "utf-8");
     const featuresPath = getFeaturesPath();
-    writeFileSync5(featuresPath, content2);
+    writeFileSync6(featuresPath, content2);
     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);
+    writeFileSync6(featuresPath, opts.update);
     console.log(`${paint7("green", "\u2713")} Updated ${paint7("cyan", featuresPath)}`);
     return;
   }
@@ -4153,12 +4867,12 @@ var featuresCommand = new Command21("features").description("View or update the
 
 // cli/commands/no-mr.ts
 import { Command as Command22 } from "commander";
-import { writeFileSync as writeFileSync6 } from "fs";
+import { writeFileSync as writeFileSync7 } from "fs";
 import { resolve as resolve6 } from "path";
 var NO_MR_FILE = ".mr-no-mr";
 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");
+  writeFileSync7(filePath, description, "utf-8");
   await api.post(`/api/tasks/${taskId}/updates`, {
     message: `No MR/PR needed \u2014 ${description}`,
     source: "agent"
@@ -4167,105 +4881,8 @@ var noMrCommand = new Command22("no-mr").description("Signal that a task does no
   console.log(`  Reason: ${description}`);
 });
 
-// cli/commands/mobile.ts
-import { Command as Command23 } from "commander";
-function paint8(color, text) {
-  const colors = {
-    cyan: "\x1B[36m",
-    green: "\x1B[32m",
-    yellow: "\x1B[33m",
-    red: "\x1B[31m",
-    dim: "\x1B[2m",
-    reset: "\x1B[0m"
-  };
-  return `${colors[color] ?? ""}${text}${colors.reset}`;
-}
-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) => {
-    const projectId = projectIdArg || getLinkedProjectId();
-    if (!projectId) {
-      console.error(
-        'No project specified. Provide a project ID or run "mr link <project-id>" first.'
-      );
-      process.exit(1);
-    }
-    console.log(
-      paint8("cyan", "mobile") + paint8("dim", " \u2014 starting conversion wizard")
-    );
-    const task = await api.post("/api/tasks", {
-      title: "Convert to Mobile App",
-      projectId,
-      status: "in_progress"
-    });
-    console.log(`  Created task: ${task.title} (${task.id})`);
-    console.log("  Analyzing web app...");
-    const analysis = await api.post("/api/wizard/mobile/analyze", {
-      projectId,
-      parentTaskId: task.id,
-      webAppUrl: opts.url
-    });
-    console.log(
-      `  Found ${analysis.analysis.screens.length} screens (${analysis.analysis.framework})`
-    );
-    if (opts.framework) {
-      console.log(
-        `  Generating architecture plan for ${opts.framework}...`
-      );
-      await api.post("/api/wizard/mobile/generate-plan", {
-        projectId,
-        parentTaskId: task.id,
-        framework: opts.framework,
-        analysisResourceId: analysis.resourceId
-      });
-      console.log("  Architecture plan created.");
-    }
-    console.log(
-      `
-  ${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 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`
-  );
-  const wizardState = resources.find(
-    (r) => r.title === "Wizard State" && r.type === "plan"
-  );
-  if (!wizardState) {
-    console.log("No wizard state found for this task.");
-    return;
-  }
-  try {
-    const state = JSON.parse(wizardState.content);
-    console.log(paint8("cyan", "Mobile Conversion Status"));
-    console.log(`  Phase: ${state.phase}`);
-    if (state.framework) {
-      console.log(`  Framework: ${state.framework}`);
-    }
-    if (state.screenDesigns?.length) {
-      const completed = state.screenDesigns.filter(
-        (d) => d.status === "complete"
-      ).length;
-      console.log(
-        `  Screens: ${completed}/${state.screenDesigns.length} complete`
-      );
-    }
-    if (state.mobileRepoUrl) {
-      console.log(`  Repo: ${state.mobileRepoUrl}`);
-    }
-  } catch {
-    console.log("Could not parse wizard state.");
-  }
-});
-mobileCommand.addCommand(statusSubcommand);
-
 // cli/commands/scan.ts
-import { Command as Command24 } from "commander";
+import { Command as Command23 } from "commander";
 
 // lib/scanner/index.ts
 import { spawn as spawn7 } from "child_process";
@@ -4494,8 +5111,8 @@ function matchesIgnorePattern(route, patterns) {
 }
 async function uploadScreenshot(imagePath, apiUrl, apiKey) {
   try {
-    const { readFileSync: readFileSync12 } = await import("fs");
-    const imageBuffer = readFileSync12(imagePath);
+    const { readFileSync: readFileSync13 } = await import("fs");
+    const imageBuffer = readFileSync13(imagePath);
     const blob = new Blob([imageBuffer], { type: "image/webp" });
     const formData = new FormData();
     formData.append("file", blob, `scan-${Date.now()}.webp`);
@@ -4702,22 +5319,19 @@ function buildSynthesisPrompt(config, context, codebaseAnalysis, crawlResults, p
   const promotedFindings = priorFindings.filter((f) => f.status === "promoted");
   const crawlSummary = crawlResults.map((r) => {
     let summary = `Route: ${r.route}
-  Title: ${r.pageTitle}
-  Headings: ${r.headings.join(", ") || "none"}`;
+  Title: ${r.pageTitle}`;
     if (r.consoleErrors.length > 0) {
       summary += `
-  Console Errors: ${r.consoleErrors.slice(0, 5).join("; ")}`;
+  Console Errors: ${r.consoleErrors.slice(0, 3).join("; ")}`;
     }
     if (r.consoleWarnings.length > 0) {
       summary += `
-  Console Warnings: ${r.consoleWarnings.slice(0, 3).join("; ")}`;
+  Console Warnings: ${r.consoleWarnings.slice(0, 2).join("; ")}`;
     }
-    if (r.screenshotUrl) {
+    if (r.loadTimeMs > 1e3) {
       summary += `
-  Screenshot: ${r.screenshotUrl}`;
+  Load time: ${r.loadTimeMs}ms (slow)`;
     }
-    summary += `
-  Load time: ${r.loadTimeMs}ms`;
     return summary;
   }).join("\n\n");
   return `You are an autonomous product manager reviewing a web application. Your job is to produce actionable, specific findings that a developer can use to improve their product.
@@ -4734,16 +5348,16 @@ ${codebaseAnalysis.routes.map((r) => `- ${r}`).join("\n")}
 ${codebaseAnalysis.prismaModels.map((m) => `- ${m}`).join("\n")}
 
 **Components:**
-${codebaseAnalysis.components.slice(0, 30).map((c10) => `- ${c10}`).join("\n")}
+${codebaseAnalysis.components.slice(0, 15).map((c10) => `- ${c10}`).join("\n")}
 
 **Recent Git Commits:**
-${codebaseAnalysis.recentCommits.slice(0, 15).map((c10) => `- ${c10}`).join("\n")}
+${codebaseAnalysis.recentCommits.slice(0, 8).map((c10) => `- ${c10}`).join("\n")}
 
 **Completed Tasks:**
-${context.completedTasks.slice(0, 20).map((t) => `- ${t.title}`).join("\n") || "None"}
+${context.completedTasks.slice(0, 10).map((t) => `- ${t.title}`).join("\n") || "None"}
 
 **Open Tasks:**
-${context.openTasks.slice(0, 10).map((t) => `- ${t.title}${t.notes ? ` (${t.notes})` : ""}`).join("\n") || "None"}
+${context.openTasks.slice(0, 5).map((t) => `- ${t.title}`).join("\n") || "None"}
 
 ${config.focusAreas.length > 0 ? `**Focus Areas (user-specified):**
 ${config.focusAreas.map((a) => `- ${a}`).join("\n")}` : ""}
@@ -4754,11 +5368,9 @@ ${crawlResults.length > 0 ? crawlSummary : "Live crawl was not performed (app ma
 
 ## Prior Findings Context
 
-${dismissedFindings.length > 0 ? `**Previously Dismissed (do NOT re-suggest these):**
-${dismissedFindings.map((f) => `- [${f.type}] ${f.title}`).join("\n")}` : "No dismissed findings."}
+${dismissedFindings.length > 0 ? `**Previously Dismissed (do NOT re-suggest):** ${dismissedFindings.map((f) => f.title).join("; ")}` : "No dismissed findings."}
 
-${promotedFindings.length > 0 ? `**Already Being Worked On (reference as "still present" if detected):**
-${promotedFindings.map((f) => `- [${f.type}] ${f.title}`).join("\n")}` : "No promoted findings."}
+${promotedFindings.length > 0 ? `**Already Being Worked On:** ${promotedFindings.map((f) => f.title).join("; ")}` : "No promoted findings."}
 
 ## Instructions
 
@@ -4946,7 +5558,7 @@ async function fetchScanContext(opts) {
   };
 }
 function runClaude(prompt2) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const child = spawn7("claude", ["-p", "--dangerously-skip-permissions", prompt2], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -4959,7 +5571,7 @@ function runClaude(prompt2) {
       errOutput += d.toString();
     });
     child.on("exit", (code) => {
-      if (code === 0) resolve7(output.trim());
+      if (code === 0) resolve8(output.trim());
       else reject(new Error(`claude exited with code ${code}
 ${errOutput.trim()}`));
     });
@@ -5014,25 +5626,25 @@ var c8 = {
   magenta: "\x1B[35m",
   gray: "\x1B[90m"
 };
-function paint9(color, text) {
+function paint8(color, text) {
   return `${c8[color]}${text}${c8.reset}`;
 }
 function timestamp2() {
-  return paint9("gray", (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false }));
+  return paint8("gray", (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false }));
 }
 function scanTag() {
-  return paint9("magenta", "[scan]");
+  return paint8("magenta", "[scan]");
 }
 function log(msg) {
   console.log(`${timestamp2()} ${scanTag()} ${msg}`);
 }
 function logOk(msg) {
-  console.log(`${timestamp2()} ${scanTag()} ${paint9("green", "\u2713")} ${msg}`);
+  console.log(`${timestamp2()} ${scanTag()} ${paint8("green", "\u2713")} ${msg}`);
 }
 function logErr(msg) {
-  console.error(`${timestamp2()} ${scanTag()} ${paint9("red", "\u2717")} ${msg}`);
+  console.error(`${timestamp2()} ${scanTag()} ${paint8("red", "\u2717")} ${msg}`);
 }
-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) => {
+var scanCommand = new Command23("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) {
     logErr('Not authenticated. Run "mr login" first.');
@@ -5040,11 +5652,11 @@ var scanCommand = new Command24("scan").description("Run a product scan on the c
   }
   const banner = [
     ``,
-    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`),
+    paint8("magenta", `  \u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2557\u2554`),
+    paint8("magenta", `  \u255A\u2550\u2557\u2551  \u2560\u2550\u2563\u2551\u2551\u2551`),
+    paint8("magenta", `  \u255A\u2550\u255D\u255A\u2550\u255D\u2569 \u2569\u255D\u255A\u255D`),
+    paint8("dim", `  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`),
+    paint8("dim", `  autonomous product scanner`),
     ``
   ].join("\n");
   console.log(banner);
@@ -5060,7 +5672,7 @@ var scanCommand = new Command24("scan").description("Run a product scan on the c
     logErr(`Failed to fetch project ${projectId}`);
     process.exit(1);
   }
-  log(`Scanning project: ${paint9("cyan", project.name)}`);
+  log(`Scanning project: ${paint8("cyan", project.name)}`);
   let projectPath = project.localPath;
   if (!projectPath) {
     for (const [dir, pid] of Object.entries(config.directories)) {
@@ -5076,7 +5688,7 @@ var scanCommand = new Command24("scan").description("Run a product scan on the c
   let reportId;
   if (opts.report) {
     reportId = opts.report;
-    log(`Using existing scan report ${paint9("yellow", reportId.slice(0, 8))}`);
+    log(`Using existing scan report ${paint8("yellow", reportId.slice(0, 8))}`);
   } else {
     try {
       const scans = await api.get(`/api/scans?projectId=${projectId}&status=processing`);
@@ -5092,7 +5704,7 @@ var scanCommand = new Command24("scan").description("Run a product scan on the c
         status: "pending"
       });
       reportId = report.id;
-      log(`Created scan report ${paint9("yellow", reportId.slice(0, 8))}`);
+      log(`Created scan report ${paint8("yellow", reportId.slice(0, 8))}`);
     } catch (err) {
       logErr(`Failed to create scan report: ${err.message}`);
       process.exit(1);
@@ -5105,7 +5717,7 @@ var scanCommand = new Command24("scan").description("Run a product scan on the c
   try {
     const current = await api.get(`/api/scans/${reportId}`);
     if (current.status === "cancelled") {
-      log(paint9("yellow", "Scan was cancelled \u2014 aborting."));
+      log(paint8("yellow", "Scan was cancelled \u2014 aborting."));
       process.exit(0);
     }
   } catch {
@@ -5121,7 +5733,7 @@ var scanCommand = new Command24("scan").description("Run a product scan on the c
       runBrowse: runBrowseCommand2,
       onLog: log,
       onProgress: (phase, detail) => {
-        log(`${paint9("dim", `[${phase}]`)} ${detail}`);
+        log(`${paint8("dim", `[${phase}]`)} ${detail}`);
       }
     });
     let wasCancelled = false;
@@ -5133,7 +5745,7 @@ var scanCommand = new Command24("scan").description("Run a product scan on the c
     } catch {
     }
     if (wasCancelled) {
-      log(paint9("yellow", "Scan was cancelled by user \u2014 discarding results."));
+      log(paint8("yellow", "Scan was cancelled by user \u2014 discarding results."));
       process.exit(0);
     }
     await api.patch(`/api/scans/${reportId}`, {
@@ -5144,32 +5756,32 @@ var scanCommand = new Command24("scan").description("Run a product scan on the c
       scanDurationMs: result.scanDurationMs,
       routesCrawled: result.routesCrawled
     });
-    logOk(`Scan complete \u2014 ${paint9("cyan", String(result.findings.length))} findings`);
+    logOk(`Scan complete \u2014 ${paint8("cyan", String(result.findings.length))} findings`);
     console.log("");
-    console.log(`  ${paint9("bold", "Summary:")} ${result.summary}`);
+    console.log(`  ${paint8("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(`  ${paint9("bold", paint9("red", `High Priority (${high.length})`))}`);
+      console.log(`  ${paint8("bold", paint8("red", `High Priority (${high.length})`))}`);
       for (const f of high) {
-        console.log(`    ${paint9("red", "\u25CF")} [${f.type}] ${f.title}`);
-        console.log(`      ${paint9("dim", f.description.slice(0, 120))}`);
+        console.log(`    ${paint8("red", "\u25CF")} [${f.type}] ${f.title}`);
+        console.log(`      ${paint8("dim", f.description.slice(0, 120))}`);
       }
       console.log("");
     }
     if (medium.length > 0) {
-      console.log(`  ${paint9("bold", paint9("yellow", `Medium Priority (${medium.length})`))}`);
+      console.log(`  ${paint8("bold", paint8("yellow", `Medium Priority (${medium.length})`))}`);
       for (const f of medium) {
-        console.log(`    ${paint9("yellow", "\u25CF")} [${f.type}] ${f.title}`);
+        console.log(`    ${paint8("yellow", "\u25CF")} [${f.type}] ${f.title}`);
       }
       console.log("");
     }
     if (low.length > 0) {
-      console.log(`  ${paint9("dim", `Low Priority (${low.length})`)} `);
+      console.log(`  ${paint8("dim", `Low Priority (${low.length})`)} `);
       for (const f of low) {
-        console.log(`    ${paint9("dim", `\u25CB [${f.type}] ${f.title}`)}`);
+        console.log(`    ${paint8("dim", `\u25CB [${f.type}] ${f.title}`)}`);
       }
       console.log("");
     }
@@ -5187,7 +5799,7 @@ var scanCommand = new Command24("scan").description("Run a product scan on the c
 });
 
 // cli/commands/idea.ts
-import { Command as Command25 } from "commander";
+import { Command as Command24 } from "commander";
 var c9 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -5200,27 +5812,27 @@ var c9 = {
   gray: "\x1B[90m",
   magenta: "\x1B[35m"
 };
-function paint10(color, text) {
+function paint9(color, text) {
   return `${c9[color]}${text}${c9.reset}`;
 }
 function statusBadge2(status) {
   switch (status) {
     case "draft":
-      return paint10("gray", "\u25CB draft");
+      return paint9("gray", "\u25CB draft");
     case "generating":
-      return paint10("cyan", "\u27F3 generating");
+      return paint9("cyan", "\u27F3 generating");
     case "generated":
-      return paint10("green", "\u2713 generated");
+      return paint9("green", "\u2713 generated");
     case "promoted":
-      return paint10("magenta", "\u2191 promoted");
+      return paint9("magenta", "\u2191 promoted");
     case "archived":
-      return paint10("dim", "\u2298 archived");
+      return paint9("dim", "\u2298 archived");
     default:
-      return paint10("gray", status);
+      return paint9("gray", status);
   }
 }
-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) => {
+var ideaCommand = new Command24("idea").description("Manage ideas \u2014 brainstorm, generate prototypes & plans").addCommand(
+  new Command24("list").description("List ideas for the linked project").option("--all", "Show ideas for all projects").option("--status <status>", "Filter by status").action(async (opts) => {
     const params = new URLSearchParams();
     if (!opts.all) {
       const projectId = getLinkedProjectId();
@@ -5231,23 +5843,23 @@ var ideaCommand = new Command25("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(paint10("gray", "No ideas found."));
+      console.log(paint9("gray", "No ideas found."));
       return;
     }
     console.log();
     for (const idea of ideas) {
       const date = new Date(idea.createdAt).toLocaleDateString();
       console.log(
-        `  ${paint10("bold", idea.title)}  ${statusBadge2(idea.status)}  ${paint10("gray", idea.id.slice(0, 8))}  ${paint10("dim", date)}`
+        `  ${paint9("bold", idea.title)}  ${statusBadge2(idea.status)}  ${paint9("gray", idea.id.slice(0, 8))}  ${paint9("dim", date)}`
       );
       if (idea.description) {
-        console.log(`  ${paint10("dim", idea.description.slice(0, 80) + (idea.description.length > 80 ? "\u2026" : ""))}`);
+        console.log(`  ${paint9("dim", idea.description.slice(0, 80) + (idea.description.length > 80 ? "\u2026" : ""))}`);
       }
       console.log();
     }
   })
 ).addCommand(
-  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) => {
+  new Command24("create").description("Create a new idea").argument("<title>", "Title of the idea").option("--description <desc>", "Description of the idea").option("--project <projectId>", "Project ID (defaults to linked project)").option("--generate", "Immediately start generating plan & prototype").action(async (title, opts) => {
     const projectId = opts.project ?? getLinkedProjectId() ?? null;
     const idea = await api.post("/api/ideas", {
       title,
@@ -5255,59 +5867,59 @@ var ideaCommand = new Command25("idea").description("Manage ideas \u2014 brainst
       projectId
     });
     console.log();
-    console.log(`  ${paint10("green", "\u2713")} Created idea: ${paint10("bold", idea.title)}`);
-    console.log(`  ${paint10("gray", "ID:")} ${idea.id}`);
+    console.log(`  ${paint9("green", "\u2713")} Created idea: ${paint9("bold", idea.title)}`);
+    console.log(`  ${paint9("gray", "ID:")} ${idea.id}`);
     if (opts.generate) {
       await api.post(`/api/ideas/${idea.id}/generate`);
-      console.log(`  ${paint10("cyan", "\u27F3")} Generation will begin automatically via the watch agent.`);
+      console.log(`  ${paint9("cyan", "\u27F3")} Generation will begin automatically via the watch agent.`);
     }
     console.log();
   })
 ).addCommand(
-  new Command25("generate").description("Start generating plan & prototype for an idea").argument("<id>", "Idea ID").action(async (id) => {
+  new Command24("generate").description("Start generating plan & prototype for an idea").argument("<id>", "Idea ID").action(async (id) => {
     const idea = await api.post(`/api/ideas/${id}/generate`);
     console.log();
-    console.log(`  ${paint10("cyan", "\u27F3")} Generating: ${paint10("bold", idea.title)}`);
-    console.log(`  ${paint10("gray", "The watch agent will pick this up shortly.")}`);
+    console.log(`  ${paint9("cyan", "\u27F3")} Generating: ${paint9("bold", idea.title)}`);
+    console.log(`  ${paint9("gray", "The watch agent will pick this up shortly.")}`);
     console.log();
   })
 ).addCommand(
-  new 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) => {
+  new Command24("feedback").description("Send feedback to iterate on an idea's generated content").argument("<id>", "Idea ID").argument("<feedback>", "Feedback text").action(async (id, feedback) => {
     const idea = await api.post(`/api/ideas/${id}/feedback`, { feedback });
     console.log();
-    console.log(`  ${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(`  ${paint9("cyan", "\u27F3")} Feedback sent for: ${paint9("bold", idea.title)}`);
+    console.log(`  ${paint9("gray", "The watch agent will re-generate with your feedback.")}`);
     console.log();
   })
 ).addCommand(
-  new Command25("promote").description("Promote an idea to a task").argument("<id>", "Idea ID").action(async (id) => {
+  new Command24("promote").description("Promote an idea to a task").argument("<id>", "Idea ID").action(async (id) => {
     const result = await api.post(`/api/ideas/${id}/promote`);
     console.log();
-    console.log(`  ${paint10("green", "\u2713")} Promoted idea to task: ${paint10("bold", result.task.title)}`);
-    console.log(`  ${paint10("gray", "Task ID:")} ${result.task.id}`);
+    console.log(`  ${paint9("green", "\u2713")} Promoted idea to task: ${paint9("bold", result.task.title)}`);
+    console.log(`  ${paint9("gray", "Task ID:")} ${result.task.id}`);
     console.log();
   })
 ).addCommand(
-  new 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) => {
+  new Command24("spin-up").description("Spin up a new project with a GitHub repo from an idea").argument("<id>", "Idea ID").option("--name <name>", "Custom project name (defaults to idea title)").action(async (id, opts) => {
     const body = {};
     if (opts.name) body.name = opts.name;
     const result = await api.post(`/api/ideas/${id}/spin-up`, body);
     console.log();
-    console.log(`  ${paint10("green", "\u2713")} Spinning up project: ${paint10("bold", result.project.name)}`);
-    console.log(`  ${paint10("gray", "Project ID:")} ${result.project.id}`);
+    console.log(`  ${paint9("green", "\u2713")} Spinning up project: ${paint9("bold", result.project.name)}`);
+    console.log(`  ${paint9("gray", "Project ID:")} ${result.project.id}`);
     if (result.tasks && result.tasks.length > 0) {
-      console.log(`  ${paint10("green", "\u2713")} Created ${result.tasks.length} follow-up task(s):`);
+      console.log(`  ${paint9("green", "\u2713")} Created ${result.tasks.length} follow-up task(s):`);
       for (const task of result.tasks) {
-        console.log(`    ${paint10("gray", "\u2022")} ${task.title}`);
+        console.log(`    ${paint9("gray", "\u2022")} ${task.title}`);
       }
     }
-    console.log(`  ${paint10("cyan", "\u27F3")} Repo creation is queued \u2014 the watch daemon will pick it up.`);
+    console.log(`  ${paint9("cyan", "\u27F3")} Repo creation is queued \u2014 the watch daemon will pick it up.`);
     console.log();
   })
 );
 
 // cli/commands/doctor.ts
-import { Command as Command26 } from "commander";
+import { Command as Command25 } from "commander";
 import { existsSync as existsSync15 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join11 } from "path";
@@ -5355,7 +5967,7 @@ async function checkProjectLink() {
     optional: true
   };
 }
-var doctorCommand = new Command26("doctor").description("Diagnose Mr. Manager CLI installation and environment").action(async () => {
+var doctorCommand = new Command25("doctor").description("Diagnose Mr. Manager CLI installation and environment").action(async () => {
   const banner = [
     ``,
     paint5("cyan", `  MR DOCTOR`),
@@ -5397,9 +6009,229 @@ var doctorCommand = new Command26("doctor").description("Diagnose Mr. Manager CL
   process.exit(1);
 });
 
+// cli/commands/prompt-audit.ts
+import { Command as Command26 } from "commander";
+import { resolve as resolve7 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync12 } from "fs";
+function auditLine(label, tokens) {
+  const bar = "\u2588".repeat(Math.min(60, Math.round(tokens / 200)));
+  return `  ${label.padEnd(30)} ${formatTokenCount(tokens).padStart(8)}  ${bar}`;
+}
+var promptAuditCommand = new Command26("prompt-audit").description("Dry-run prompt construction and report estimated token counts by job type").option("--task <id>", "Audit prompts for a specific task ID").option("--all", "Audit all supported job types with representative data", false).option("--json", "Output as JSON instead of plain text", false).action(async (opts) => {
+  const results = [];
+  if (opts.task) {
+    try {
+      const task = await api.get(`/api/tasks/${opts.task}`);
+      const [_subtasks, protoRefs, updates, resources, skills] = await Promise.all([
+        api.get(`/api/tasks/${task.id}/subtasks`).catch(() => []),
+        api.get(`/api/tasks/${task.id}/prototypes`).catch(() => []),
+        api.get(`/api/tasks/${task.id}/updates`).catch(() => []),
+        api.get(`/api/tasks/${task.id}/resources`).catch(() => []),
+        api.get(`/api/tasks/${task.id}/skills`).catch(() => [])
+      ]);
+      const feedbackUpdates = updates.filter((u) => u.source === "user");
+      const sections = [];
+      const notesContent = task.prdContent ? `
+
+## PRD (Product Requirements Document)
+
+${task.prdContent}` : task.notes ? `
+
+Task notes:
+${task.notes}` : "";
+      sections.push({ name: "task-notes/prd", tokens: estimateTokens(notesContent) });
+      let protoContent = "";
+      for (const ref of protoRefs) {
+        const files = ref.prototype?.files ?? [];
+        for (const f of files) {
+          protoContent += f.content;
+        }
+      }
+      sections.push({ name: "prototypes", tokens: estimateTokens(protoContent) });
+      let skillContent = "";
+      for (const s of skills) {
+        skillContent += s.skill.content;
+      }
+      sections.push({ name: "skills", tokens: estimateTokens(skillContent) });
+      let resourceContent = "";
+      for (const r of resources) {
+        resourceContent += r.content.slice(0, 8e3);
+      }
+      sections.push({ name: "resources", tokens: estimateTokens(resourceContent) });
+      let feedbackContent = "";
+      for (const f of feedbackUpdates) {
+        feedbackContent += f.message;
+      }
+      sections.push({ name: "feedback", tokens: estimateTokens(feedbackContent) });
+      const config = loadConfig();
+      const repoDir = Object.entries(config.directories).find(([, pid]) => pid === task.projectId)?.[0];
+      if (repoDir) {
+        const featuresPath = resolve7(repoDir, ".mr-features.md");
+        if (existsSync16(featuresPath)) {
+          const featuresContent = readFileSync12(featuresPath, "utf-8");
+          sections.push({ name: "features-doc", tokens: estimateTokens(featuresContent) });
+        }
+      }
+      sections.push({ name: "static-instructions (system)", tokens: estimateTokens(
+        "status-updates + screenshots + test-plan + no-mr + features-workflow"
+      ) });
+      const totalTokens = sections.reduce((sum, s) => sum + s.tokens, 0);
+      const promptTokens = sections.filter((s) => !s.name.includes("system")).reduce((sum, s) => sum + s.tokens, 0);
+      const systemTokens = totalTokens - promptTokens;
+      results.push({
+        jobType: "execution",
+        identifier: task.id.slice(0, 8),
+        promptTokens,
+        systemTokens,
+        totalTokens,
+        sections
+      });
+      if (task.prdContent && feedbackUpdates.length > 0) {
+        const prdSections = [
+          { name: "task-notes", tokens: estimateTokens(task.notes ?? "") },
+          { name: "existing-prd", tokens: estimateTokens(task.prdContent) },
+          { name: "feedback", tokens: estimateTokens(feedbackContent) },
+          { name: "prd-format (system)", tokens: estimateTokens("prd-format + open-questions") }
+        ];
+        const prdTotal = prdSections.reduce((sum, s) => sum + s.tokens, 0);
+        results.push({
+          jobType: "prd-revision",
+          identifier: task.id.slice(0, 8),
+          promptTokens: prdTotal,
+          systemTokens: 0,
+          totalTokens: prdTotal,
+          sections: prdSections
+        });
+      }
+    } catch (err) {
+      console.error(`Failed to fetch task: ${err.message}`);
+      process.exit(1);
+    }
+  } else if (opts.all) {
+    const syntheticSections = [
+      {
+        jobType: "execution",
+        description: "Task execution prompt (baseline without attachments)",
+        sections: [
+          { name: "core-prompt", tokens: 800 },
+          { name: "instructions", tokens: 600 },
+          { name: "pr-template", tokens: 400 },
+          { name: "features-ref", tokens: 50 }
+        ]
+      },
+      {
+        jobType: "execution+prd",
+        description: "Task execution with full PRD",
+        sections: [
+          { name: "core-prompt", tokens: 800 },
+          { name: "prd-content", tokens: 4e3 },
+          { name: "instructions", tokens: 600 }
+        ]
+      },
+      {
+        jobType: "prd-generation",
+        description: "PRD generation prompt",
+        sections: [
+          { name: "core-prompt", tokens: 300 },
+          { name: "task-notes", tokens: 500 },
+          { name: "format-ref", tokens: 50 }
+        ]
+      },
+      {
+        jobType: "prd-revision",
+        description: "PRD revision (delta mode)",
+        sections: [
+          { name: "core-prompt", tokens: 300 },
+          { name: "prd-summary", tokens: 200 },
+          { name: "feedback", tokens: 300 },
+          { name: "prd-file-ref", tokens: 30 }
+        ]
+      },
+      {
+        jobType: "prototype",
+        description: "Prototype generation prompt",
+        sections: [
+          { name: "core-prompt", tokens: 600 },
+          { name: "variant-steps", tokens: 200 }
+        ]
+      },
+      {
+        jobType: "refinement",
+        description: "Prototype refinement (file-ref mode)",
+        sections: [
+          { name: "core-prompt", tokens: 600 },
+          { name: "parent-file-refs", tokens: 50 },
+          { name: "feedback", tokens: 200 }
+        ]
+      },
+      {
+        jobType: "scanner-synthesis",
+        description: "Scanner synthesis prompt (tightened caps)",
+        sections: [
+          { name: "context", tokens: 400 },
+          { name: "routes+models", tokens: 300 },
+          { name: "components", tokens: 150 },
+          { name: "commits", tokens: 160 },
+          { name: "crawl-results", tokens: 500 },
+          { name: "prior-findings", tokens: 100 },
+          { name: "instructions", tokens: 500 }
+        ]
+      },
+      {
+        jobType: "idea",
+        description: "Idea generation prompt",
+        sections: [
+          { name: "core-prompt", tokens: 500 },
+          { name: "idea-desc", tokens: 200 }
+        ]
+      },
+      {
+        jobType: "repo-creation",
+        description: "Repository creation prompt",
+        sections: [
+          { name: "core-prompt", tokens: 400 },
+          { name: "project-desc", tokens: 200 }
+        ]
+      }
+    ];
+    console.log("Estimated prompt sizes by job type (representative baselines)");
+    console.log("\u2550".repeat(70));
+    for (const entry of syntheticSections) {
+      const total = entry.sections.reduce((sum, s) => sum + s.tokens, 0);
+      console.log(`
+${entry.jobType} \u2014 ${entry.description}`);
+      console.log(`  Total: ${formatTokenCount(total)} tokens`);
+      for (const s of entry.sections) {
+        console.log(auditLine(s.name, s.tokens));
+      }
+    }
+    console.log("");
+    return;
+  } else {
+    console.log("Usage: mr prompt-audit --task <id>  or  mr prompt-audit --all");
+    console.log("\nDry-run prompt construction and report estimated token counts.");
+    return;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(results, null, 2));
+  } else {
+    console.log("Prompt Audit Report");
+    console.log("\u2550".repeat(70));
+    for (const r of results) {
+      console.log(`
+${r.jobType} [${r.identifier}]`);
+      console.log(`  Total: ${formatTokenCount(r.totalTokens)} tokens (prompt=${formatTokenCount(r.promptTokens)} system=${formatTokenCount(r.systemTokens)})`);
+      for (const s of r.sections) {
+        console.log(auditLine(s.name, s.tokens));
+      }
+    }
+    console.log("");
+  }
+});
+
 // cli/index.ts
 var configPath = join12(homedir3(), ".mr-manager", "config.json");
-var isFirstRun = !existsSync16(configPath);
+var isFirstRun = !existsSync17(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]);
@@ -5462,8 +6294,8 @@ program.addCommand(setPathCommand);
 program.addCommand(testCommand);
 program.addCommand(featuresCommand);
 program.addCommand(noMrCommand);
-program.addCommand(mobileCommand);
 program.addCommand(scanCommand);
 program.addCommand(ideaCommand);
 program.addCommand(doctorCommand);
+program.addCommand(promptAuditCommand);
 program.parse();