@dunnewold-labs/mr-manager 0.4.50 → 0.4.52

package/dist/index.mjs

@@ -185,7 +185,7 @@ import { fileURLToPath } from "url";
 // cli/package.json
 var package_default = {
   name: "@dunnewold-labs/mr-manager",
-  version: "0.4.50",
+  version: "0.4.52",
   description: "Mr. Manager - Task and project management CLI",
   bin: {
     mr: "./dist/index.mjs"
@@ -561,7 +561,7 @@ import { join as join5 } from "path";
 
 // lib/git-worktree.ts
 import { execSync as execSync2 } from "child_process";
-import { copyFileSync, existsSync as existsSync4 } from "fs";
+import { copyFileSync, existsSync as existsSync4, rmSync } from "fs";
 import { join as join4 } from "path";
 function tryExec(command, cwd) {
   try {
@@ -619,15 +619,21 @@ function findExistingWorktreeForBranch(repoDir, branch) {
 function createWorktree(repoDir, branch, worktreeName, options = {}) {
   const wtPath = join4(repoDir, ".mr-worktrees", worktreeName);
   if (existsSync4(wtPath)) {
-    execSync2(`git checkout "${branch}"`, { cwd: wtPath, stdio: "pipe" });
-    if (options.syncRemoteBranch) {
-      syncBranchWithRemote(repoDir, wtPath, branch);
+    const branchResolves = tryExec(`git rev-parse --verify "refs/heads/${branch}"`, repoDir);
+    if (branchResolves) {
+      execSync2(`git checkout "${branch}"`, { cwd: wtPath, stdio: "pipe" });
+      if (options.syncRemoteBranch) {
+        syncBranchWithRemote(repoDir, wtPath, branch);
+      }
+      return {
+        path: wtPath,
+        created: false,
+        reusedBranchWorktree: false
+      };
     }
-    return {
-      path: wtPath,
-      created: false,
-      reusedBranchWorktree: false
-    };
+    removeWorktree(repoDir, wtPath);
+    rmSync(wtPath, { recursive: true, force: true });
+    tryExec(`git worktree prune`, repoDir);
   }
   const existingBranchWorktree = findExistingWorktreeForBranch(repoDir, branch);
   if (existingBranchWorktree) {
@@ -2457,6 +2463,7 @@ function buildPrototypePrompt(proto, repoDir, options = {}) {
   const referenceImagePaths = options.referenceImagePaths ?? [];
   const hasReferences = referenceImagePaths.length > 0;
   const exemplars = pickExemplars(proto.id);
+  const isLowFidelity = proto.fidelity === "low";
   const variantSteps = [];
   for (let i = 0; i < variantsToProduce; i++) {
     const idx = startIndex + i;
@@ -2464,7 +2471,7 @@ function buildPrototypePrompt(proto, repoDir, options = {}) {
     variantSteps.push(
       `### Variant ${idx}: ${filename}`,
       `1. ${varianceInfo.perVariantDirective}`,
-      `2. Spend a moment composing a real, opinionated design before you start typing HTML. ${hasReferences ? "Imagine the screen sitting alongside the reference designs the user attached \u2014 it should look like it belongs in the same set." : `Imagine the screen on Dribbble, holding its own next to ${exemplars}.`}`,
+      isLowFidelity ? `2. Compose a layout focusing on structure and information flow. Keep it strictly grayscale, sketchy, and low-fidelity.` : `2. Spend a moment composing a real, opinionated design before you start typing HTML. ${hasReferences ? "Imagine the screen sitting alongside the reference designs the user attached \u2014 it should look like it belongs in the same set." : `Imagine the screen on Dribbble, holding its own next to ${exemplars}.`}`,
       `3. Write the complete self-contained HTML to \`${repoDir}/${filename}\` using the Write tool.`,
       `4. Verify the file was created by reading the first few lines of \`${repoDir}/${filename}\`.`,
       ``
@@ -2474,6 +2481,38 @@ function buildPrototypePrompt(proto, repoDir, options = {}) {
     { length: variantsToProduce },
     (_, i) => `prototype-${startIndex + i}.html`
   );
+  const wireframeQualityBar = [
+    `## Wireframe & Sketch Guidelines (Balsamiq-Style)`,
+    ``,
+    `This is an intentionally LOW-FIDELITY wireframe. The goal is to focus on structure, layout, and user flow, NOT visual polish. Follow these strict styling rules:`,
+    ``,
+    `**Grayscale Aesthetic Only**`,
+    `- Use ONLY black, white, and shades of gray.`,
+    `- Absolutely NO color palette exploration, no accent colors, no gradients, and no color highlights.`,
+    ``,
+    `**Linework & Borders**`,
+    `- Borders must feel sketchy or hand-drawn. Use thick, solid borders (e.g., 2px solid black or dark gray) for elements.`,
+    `- Keep shapes simple and flat. Avoid rounded corners unless they represent a device frame or button.`,
+    `- Use flat gray boxes with diagonal lines or an "X" representing media/image placeholders.`,
+    ``,
+    `**Typography (Default Font)**`,
+    `- You MUST load the Shantell Sans font from Google Fonts via:`,
+    `  <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Shantell+Sans:wght@300..800&display=swap">`,
+    `- Set the default typeface of the entire body to: 'Shantell Sans', 'Comic Sans MS', 'Comic Neue', cursive, sans-serif.`,
+    `- Text should feel hand-drawn but readable, giving the app a sketch feeling.`,
+    ``,
+    `**Placeholders & Annotations**`,
+    `- Media (images, videos, illustrations) must render as obvious sketchy placeholders \u2014 never use real photos, Unsplash images, or polished vector illustrations. Use a rectangle with "X" drawn from corner to corner.`,
+    `- Icons should be extremely simple/sketchy or represented as simple text placeholders (e.g. "[x]", "[+]", "[menu]"). Do NOT use polished icon packs if they look too clean. Standard text brackets or extremely basic SVG paths are preferred.`,
+    `- Copy should be terse, greeked, or simple descriptive label annotations (e.g. "[Brand Logo]", "[Search Results: 10 items]", "[User Name]"). Avoid polished marketing copy or detailed UI prose.`,
+    ``,
+    `**No Shadows, Gradients, or Motion**`,
+    `- Absolutely NO box-shadows, text-shadows, gradients, backdrop-blur, or glassmorphism.`,
+    `- Absolutely NO delight-oriented motion, fade-ins, slide-ups, marquee effects, or animated gradients. Everything must be static and flat.`,
+    ``,
+    `**Device Framing (Sketch Form)**`,
+    `${prototypeType === "mobile_app" ? `- Draw a sketchy mobile frame container (centered, e.g. 375x812px) using a 2px solid black border. Render a sketchy top status bar (e.g., "[9:41 AM  Battery 100%]") and sketchy dynamic island/notch. Center the frame on a flat, light-gray canvas.` : prototypeType === "desktop_app" ? `- Draw a sketchy desktop window frame (e.g. 1024x768px or scaled container) with a 2px solid black border. Show a simple top bar with sketchy window controls (three tiny circles or text like "[o][o][o]"). Center the frame on a flat, light-gray canvas.` : `- For a web app, present the layout as a browser screen (with a sketchy address bar like "[https://app.com/]") styled with a 2px solid black border.`}`
+  ];
   const sharedQualityBar = [
     `## Craft & Polish Bar (this is the most important section \u2014 read carefully)`,
     ``,
@@ -2583,8 +2622,14 @@ function buildPrototypePrompt(proto, repoDir, options = {}) {
     logo: "Logo"
   };
   const agentNote = options.agentLabel ? `You are one of several models collaborating on this prototype set. You are the "${options.agentLabel}" track, responsible for variants ${startIndex} through ${startIndex + variantsToProduce - 1}. Bring YOUR creative perspective \u2014 don't try to be a generic averaged designer.` : `You are the sole designer on this prototype set \u2014 bring a strong, opinionated point of view.`;
-  const creativeAnchor = hasReferences ? `The user attached reference designs for this prototype \u2014 they are the single most important input. Treat them as the definitive brief for look and feel (details in the Reference Designs section below).` : `Aim for the craft level of ${exemplars} \u2014 but interpret this brief on its own terms, don't imitate any one product.`;
-  const creativeDirection = [
+  const creativeAnchor = isLowFidelity ? hasReferences ? `The user attached reference designs for this prototype. Use them ONLY to guide structure, layout, and content hierarchy. Do NOT copy their visual style, colors, shadows, fonts, or polish. Keep the output strictly as a low-fidelity wireframe.` : `Generate a low-fidelity wireframe representing the layout, hierarchy, and flow described in the prompt.` : hasReferences ? `The user attached reference designs for this prototype \u2014 they are the single most important input. Treat them as the definitive brief for look and feel (details in the Reference Designs section below).` : `Aim for the craft level of ${exemplars} \u2014 but interpret this brief on its own terms, don't imitate any one product.`;
+  const creativeDirection = isLowFidelity ? [
+    `## Wireframe Direction`,
+    `- **Focus on Hierarchy**: Make sure the most important elements have the largest text or thickest boundaries.`,
+    `- **Vary the Layout Structure**: Across variants, use different ways of organizing information (e.g. one variant could be a sidebar layout, another a grid layout, another a single-column layout).`,
+    `- **Use Shantell Sans**: Ensure the font successfully loads and applies globally to keep the Balsamiq sketch aesthetic consistent.`,
+    `- **Terse Annotations**: Ensure copy is terse, annotated, or greeked.`
+  ] : [
     `## Creative Direction & Polish`,
     `- **Be Opinionated**: Do not design generic "safe" UIs. Imagine you are designing for a product that wants to win "Site of the Day" on Awwwards or be featured in a "Best of Linear-style design" gallery.`,
     `- **Micro-interactions**: Use CSS keyframes for delightful details. A progress bar that has a shimmering gradient, a button that has a subtle "glint" effect, or a card that has a "magnetic" hover feel.`,
@@ -2592,6 +2637,15 @@ function buildPrototypePrompt(proto, repoDir, options = {}) {
     `- **Typography as Hero**: In at least one variant, let typography drive the entire layout. Use large, bold display faces with tight tracking and intentional overlapping.`,
     `- **Negative Space**: Do not be afraid of "wasting" space. Generous margins and padding often signal luxury and quality.`
   ];
+  const aestheticGuardrails = isLowFidelity ? [
+    `- Absolutely NO colors besides black, white, and grays. No gradients, no shadows, no smooth animations.`,
+    `- Do NOT use polished icon libraries (like Lucide CDN/images) if they look too crisp. Use simple text markers like "[+]" or standard hand-drawn style SVGs.`,
+    `- Ensure the body uses the 'Shantell Sans' font stack for a sketchy comic feel.`
+  ] : [
+    `- Do NOT default to a terminal / hacker / CRT / monospace-green-on-black aesthetic unless the user's prompt explicitly asks for it. This is a common failure mode \u2014 avoid it.`,
+    `- Do NOT force any single "style label" (retro, futuristic, brutalist, etc.) onto the variants unless the user asked for it. Let the prompt drive the aesthetic.`,
+    `- Choose aesthetics that fit the product and audience described in the user's prompt, not a generic developer-tool look.`
+  ];
   return [
     `${config.role}`,
     ``,
@@ -2614,7 +2668,7 @@ function buildPrototypePrompt(proto, repoDir, options = {}) {
     ``,
     `Generate exactly ${variantsToProduce} HTML file(s) covering variants ${startIndex} through ${startIndex + variantsToProduce - 1}: ${variantList.join(", ")}. Follow the steps below IN ORDER. Do NOT collapse or skip variants. Each file must be completely self-contained (inline all CSS and JS, plus any Google Fonts \`<link>\` you reference). Tailwind CDN is acceptable.`,
     ``,
-    ...sharedQualityBar,
+    ...isLowFidelity ? wireframeQualityBar : sharedQualityBar,
     ``,
     ...creativeDirection,
     ``,
@@ -2631,9 +2685,7 @@ function buildPrototypePrompt(proto, repoDir, options = {}) {
     ``,
     `## Aesthetic Guardrails`,
     ``,
-    `- Do NOT default to a terminal / hacker / CRT / monospace-green-on-black aesthetic unless the user's prompt explicitly asks for it. This is a common failure mode \u2014 avoid it.`,
-    `- Do NOT force any single "style label" (retro, futuristic, brutalist, etc.) onto the variants unless the user asked for it. Let the prompt drive the aesthetic.`,
-    `- Choose aesthetics that fit the product and audience described in the user's prompt, not a generic developer-tool look.`,
+    ...aestheticGuardrails,
     ``,
     ...variantSteps,
     `### Final verification`,
@@ -2655,6 +2707,8 @@ function buildRefinementPrompt(proto, parentFiles, repoDir, options = {}) {
   const startIndex = options.variantStartIndex ?? 1;
   const variance = typeof proto.designVariance === "number" ? proto.designVariance : 70;
   const varianceInfo = describeVariance(variance);
+  const isLowFidelity = proto.fidelity === "low";
+  const isPromotion = proto.fidelity === "high" && options.parentFidelity === "low";
   const variantSteps = [];
   for (let i = 0; i < variantsToProduce; i++) {
     const idx = startIndex + i;
@@ -2662,7 +2716,7 @@ function buildRefinementPrompt(proto, parentFiles, repoDir, options = {}) {
     variantSteps.push(
       `### Variant ${idx}: ${filename}`,
       `1. Redesign variant ${idx} based on the feedback below, while keeping the core concept that worked.`,
-      `2. Apply the same craft & polish bar as the original generation \u2014 portfolio quality, real microcopy, intentional typography, no Lorem ipsum, no broken images.`,
+      isLowFidelity ? `2. Keep the low-fidelity Balsamiq-style sketch aesthetic (grayscale, Shantell Sans font, sketchy borders, flat placeholders, no shadows/motion).` : isPromotion ? `2. Keep the structure and elements from the parent wireframe, but completely upgrade it with professional colors, typography, gradients, shadows, polished images, and real copy according to the high-fidelity craft guidelines.` : `2. Apply the same craft & polish bar as the original generation \u2014 portfolio quality, real microcopy, intentional typography, no Lorem ipsum, no broken images.`,
       `3. Write the complete self-contained HTML to \`${repoDir}/${filename}\` using the Write tool.`,
       `4. Verify the file was created by reading the first few lines of \`${repoDir}/${filename}\`.`,
       ``
@@ -2702,6 +2756,34 @@ function buildRefinementPrompt(proto, parentFiles, repoDir, options = {}) {
     desktop_app: "Desktop App",
     logo: "Logo"
   };
+  const wireframeGuidelines = isLowFidelity ? [
+    `## Wireframe & Sketch Guidelines (Balsamiq-Style)`,
+    `This is a low-fidelity wireframe refinement. Maintain these constraints:`,
+    `- Grayscale only: Use ONLY black, white, and gray colors. No accents, gradients, or color fills.`,
+    `- Shantell Sans font: Load 'Shantell Sans' from Google Fonts and set it globally as the default typeface.`,
+    `- Borders/shapes: Use sketchy/thick solid black borders (e.g. 2px). Flat rectangles with an "X" for image placeholders.`,
+    `- Annotations/terse copy: Avoid polished marketing copy; use brief labels, greeked text, or annotations.`,
+    `- No polish: No shadows, no gradients, no glassmorphism, no transitions or motion.`
+  ] : isPromotion ? [
+    `## High-Fidelity Promotion Guidelines`,
+    `You are promoting this prototype from a low-fidelity wireframe to a high-fidelity design:`,
+    `- Elevate the visual design using professional color palettes, modern typography (Google Fonts display/text pairings), layout depth (subtle shadows, borders), and realistic mock content/media.`,
+    `- Do NOT copy the grayscale wireframe styling, comic-style font, or diagonal-line placeholders.`
+  ] : [
+    `## High-Fidelity Craft & Polish Guidelines`,
+    `- Composition: real grid, intentional spacing, distinct visual hierarchy.`,
+    `- Typography: Google Fonts display + text face pairing (e.g. Inter, Geist, etc.).`,
+    `- Colors & depth: deliberate color palette, soft shadows, inner glows, subtle motion/transitions.`,
+    `- Real microcopy: no Lorem Ipsum, realistic data, realistic dates and names.`
+  ];
+  const aestheticGuardrails = isLowFidelity ? [
+    `- Absolutely NO colors besides black, white, and grays. No gradients, no shadows, no smooth animations.`,
+    `- Do NOT use polished icon libraries (like Lucide CDN/images) if they look too crisp. Use simple text markers like "[+]" or standard hand-drawn style SVGs.`,
+    `- Ensure the body uses the 'Shantell Sans' font stack for a sketchy comic feel.`
+  ] : [
+    `- Do NOT default to a terminal / hacker / CRT / monospace-green-on-black aesthetic unless the user's prompt explicitly asks for it.`,
+    `- Do NOT force any single "style label" onto the variants unless the user asked for it.`
+  ];
   return [
     `${typeRoleMap[prototypeType] ?? typeRoleMap.web_app}`,
     ``,
@@ -2724,32 +2806,33 @@ function buildRefinementPrompt(proto, parentFiles, repoDir, options = {}) {
     existingVariants,
     `## Instructions`,
     ``,
-    `You MUST generate exactly ${proto.variantCount} REFINED HTML files that incorporate the user's feedback above. Follow the steps below IN ORDER.`,
+    `You MUST generate exactly ${variantsToProduce} REFINED HTML file(s) that incorporate the user's feedback above. Follow the steps below IN ORDER.`,
     ``,
     `Study the previous variants carefully, then apply the user's feedback to improve them. Keep what works, change what the user asked to change.`,
     ``,
+    ...wireframeGuidelines,
+    ``,
     `## Design Variance: ${varianceInfo.label} (${variance}/100)`,
     ``,
     varianceInfo.summary,
     ``,
     `## Aesthetic Guardrails`,
     ``,
-    `- Do NOT default to a terminal / hacker / CRT / monospace-green-on-black aesthetic unless the user's prompt explicitly asks for it.`,
-    `- Do NOT force any single "style label" onto the variants unless the user asked for it.`,
+    ...aestheticGuardrails,
     ``,
     `Each file must be completely self-contained (inline all CSS and JS \u2014 no external dependencies). Tailwind CDN is acceptable.`,
     ``,
     ...variantSteps,
     `### Final verification`,
-    `After generating ALL ${proto.variantCount} variants, list the files in ${repoDir} and confirm that all ${proto.variantCount} files exist: ${variantList.join(", ")}. If any are missing, go back and generate the missing ones.`,
+    `After generating ALL ${variantsToProduce} variant(s), list the files in ${repoDir} and confirm that all ${variantsToProduce} file(s) exist: ${variantList.join(", ")}. If any are missing, go back and generate the missing ones.`,
     ``,
     `IMPORTANT RULES:`,
-    `- You MUST produce exactly ${proto.variantCount} files: ${variantList.join(", ")}`,
+    `- You MUST produce exactly these file(s): ${variantList.join(", ")}`,
     `- Generate them ONE AT A TIME \u2014 design each variant, write the file, then move to the next.`,
     `- Respect the Design Variance level above.`,
     `- Each file must be a complete, functional page \u2014 pure HTML/CSS/JS, no external libraries (Tailwind CDN is acceptable).`,
     `- Do NOT upload or POST the files anywhere. The watch handler will upload them automatically after you exit.`,
-    `- Do NOT exit until ALL ${proto.variantCount} files have been written and verified.`
+    `- Do NOT exit until ALL ${variantsToProduce} file(s) have been written and verified.`
   ].join("\n");
 }
 function buildAgentArgs(agent, prompt2, mode, sessionId, name, resumeSession = false, systemPrompt, maxTurns, claudeModel) {
@@ -2953,12 +3036,12 @@ var watchCommand = new Command9("watch").description(
     agentAvailability.set(candidate, available);
     return available;
   }
-  async function resolveAgentChain(preferred) {
+  async function resolveAgentChain(preferred2) {
     const availability = {};
     for (const candidate of ["claude", "codex", "antigravity"]) {
       availability[candidate] = await isAgentAvailable(candidate);
     }
-    return getAvailableAgentFallbackChain(preferred, availability);
+    return getAvailableAgentFallbackChain(preferred2, availability);
   }
   async function moveTaskToError(task, prefix, reason) {
     try {
@@ -3375,6 +3458,15 @@ var watchCommand = new Command9("watch").description(
     };
     await launchAttempt(attemptOrder[attemptIndex]);
   }
+  function dispatchTaskSafely(task, repoDir) {
+    void dispatchTask(task, repoDir).catch(async (err) => {
+      const prefix = taskTag(shortId(task.id));
+      const reason = `Task setup failed: ${err.message}`;
+      logError(prefix, reason);
+      queued.delete(task.id);
+      await moveTaskToError(task, prefix, reason);
+    });
+  }
   async function dispatchPlanModeTask(task, repoDir) {
     const sid = shortId(task.id);
     const prefix = taskTag(sid);
@@ -3547,10 +3639,12 @@ var watchCommand = new Command9("watch").description(
     const dedupedRequested = Array.from(new Set(requested));
     const key = `proto-${proto.id}`;
     let parentFiles = [];
+    let parentFidelity;
     if (proto.parentId && proto.refinementFeedback) {
       try {
         const parent = await api.get(`/api/prototypes/${proto.parentId}`);
         parentFiles = parent.files ?? [];
+        parentFidelity = parent.fidelity;
       } catch (err) {
         logError(prefix, `Failed to fetch parent prototype: ${err.message}`);
       }
@@ -3561,7 +3655,8 @@ var watchCommand = new Command9("watch").description(
           variantStartIndex: startIndex,
           variantsToProduce,
           agentLabel,
-          referenceImagePaths: refImagePaths
+          referenceImagePaths: refImagePaths,
+          parentFidelity
         });
       }
       return buildPrototypePrompt(proto, sliceDir, {
@@ -3571,254 +3666,191 @@ var watchCommand = new Command9("watch").description(
         referenceImagePaths: refImagePaths
       });
     };
-    if (dedupedRequested.length <= 1) {
-      const preferred = dedupedRequested[0] ?? agent;
-      const attemptOrder = dedupedRequested.length === 1 ? [preferred] : await resolveAgentChain(preferred);
-      if (attemptOrder.length === 0) {
-        logError(prefix, `No available agents found for ${preferred}`);
+    const totalVariants = Math.max(1, proto.variantCount);
+    let agentChainForVariant;
+    if (dedupedRequested.length >= 1) {
+      agentChainForVariant = (variantIndex) => [
+        dedupedRequested[(variantIndex - 1) % dedupedRequested.length]
+      ];
+      logDispatch(
+        prefix,
+        `streaming ${totalVariants} variant(s) across ${dedupedRequested.join(", ")}`
+      );
+    } else {
+      const chain = await resolveAgentChain(agent);
+      if (chain.length === 0) {
+        logError(prefix, `No available agents found for ${agent}`);
         await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" }).catch(() => {
         });
         cleanupRefDir(refImageDir);
         queued.delete(key);
         return;
       }
-      const prompt2 = buildPromptForSlice(1, proto.variantCount, void 0, repoDir);
-      const activeEntry2 = {
-        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;
-          }
-        );
-        activeEntry2.process = child;
-        activeEntry2.currentAgent = attemptAgent;
-        active.set(key, activeEntry2);
-        child.on("exit", async (code) => {
-          if (active.get(key)?.process === child) {
-            active.delete(key);
-          }
-          const failedAttempt = code !== 0 || spawnFailureReason !== null;
-          if (failedAttempt && !activeEntry2.terminatedForError) {
-            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"),
-                  agent: attemptAgent
-                }));
-                if (files.length === 0) {
-                  logError(prefix, `No prototype HTML files found in ${repoDir}`);
-                  await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" });
-                  return;
-                }
-                const variantModels = files.map((f) => f.agent ?? null);
-                await api.patch(`/api/prototypes/${proto.id}`, { status: "completed", files, variantModels });
-                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 {
-                  await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" });
-                } catch {
-                }
-              }
-            } 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 {
-            cleanupRefDir(refImageDir);
-            queued.delete(key);
-            finishing.delete(key);
-          }
-        });
-      };
-      await launchAttempt(attemptOrder[attemptIndex]);
-      return;
-    }
-    const totalVariants = proto.variantCount;
-    const slices = [];
-    const baseShare = Math.floor(totalVariants / dedupedRequested.length);
-    const remainder = totalVariants % dedupedRequested.length;
-    let cursor = 1;
-    for (let i = 0; i < dedupedRequested.length; i++) {
-      const a = dedupedRequested[i];
-      const count = baseShare + (i < remainder ? 1 : 0);
-      if (count <= 0) continue;
-      const dir = resolve2(repoDir, `.mr-proto-${a}`);
-      try {
-        mkdirSync3(dir, { recursive: true });
-      } catch {
-      }
-      for (const f of readdirSync(dir).filter((f2) => stalePattern.test(f2))) {
-        try {
-          unlinkSync(resolve2(dir, f));
-        } catch {
-        }
-      }
-      slices.push({ agentLabel: a, startIndex: cursor, count, dir });
-      cursor += count;
+      agentChainForVariant = () => chain;
+      logDispatch(prefix, `streaming ${totalVariants} variant(s) via ${chain[0]}`);
     }
-    if (slices.length === 0) {
-      logError(prefix, `Could not assign any variants to selected agents`);
-      await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" }).catch(() => {
-      });
-      cleanupRefDir(refImageDir);
-      queued.delete(key);
-      return;
-    }
-    logDispatch(
-      prefix,
-      `multi-agent dispatch: ${slices.map((s) => `${s.agentLabel}\xD7${s.count}`).join(", ")}`
-    );
     const activeEntry = {
       process: void 0,
       title: proto.title,
       repoDir,
       startedAt: Date.now(),
       lastActivityAt: Date.now(),
-      outputBytes: 0
+      outputBytes: 0,
+      children: /* @__PURE__ */ new Set()
     };
     active.set(key, activeEntry);
-    const sliceResults = await Promise.all(
-      slices.map((slice) => {
-        return new Promise((res) => {
-          const slicePrompt = buildPromptForSlice(slice.startIndex, slice.count, slice.agentLabel, slice.dir);
+    const protoPattern = /^prototype-\d+\.html$/;
+    const runVariant = (variantIndex) => {
+      const chain = agentChainForVariant(variantIndex);
+      const sliceDir = resolve2(repoDir, `.mr-proto-v${variantIndex}`);
+      try {
+        mkdirSync3(sliceDir, { recursive: true });
+      } catch {
+      }
+      for (const f of readdirSync(sliceDir).filter((f2) => stalePattern.test(f2))) {
+        try {
+          unlinkSync(resolve2(sliceDir, f));
+        } catch {
+        }
+      }
+      const prompt2 = buildPromptForSlice(variantIndex, 1, chain[0], sliceDir);
+      return new Promise((res) => {
+        let attemptIndex = 0;
+        const finishSlice = (ok) => {
+          try {
+            for (const f of readdirSync(sliceDir)) {
+              try {
+                unlinkSync(resolve2(sliceDir, f));
+              } catch {
+              }
+            }
+            rmdirSync(sliceDir);
+          } catch {
+          }
+          res(ok);
+        };
+        const launch = (attemptAgent) => {
           let spawnFailureReason = null;
           const child = spawnAgent(
-            slice.agentLabel,
-            slice.dir,
-            slicePrompt,
+            attemptAgent,
+            sliceDir,
+            prompt2,
             prefix,
+            () => {
+              activeEntry.lastActivityAt = Date.now();
+            },
             void 0,
-            void 0,
-            `${proto.title} [${slice.agentLabel}]`,
+            `${proto.title} [variant ${variantIndex}/${totalVariants}]`,
             false,
             (err) => {
               spawnFailureReason = err.message;
             }
           );
           activeEntry.process = child;
-          activeEntry.currentAgent = slice.agentLabel;
-          child.on("exit", (code) => {
-            const ok = code === 0 && spawnFailureReason === null;
-            if (!ok) {
-              const failureDetail = spawnFailureReason ?? `exit code ${code}`;
-              logWarn(prefix, `${slice.agentLabel} slice failed (${failureDetail})`);
+          activeEntry.currentAgent = attemptAgent;
+          activeEntry.children?.add(child);
+          child.on("exit", async (code) => {
+            activeEntry.children?.delete(child);
+            const failedAttempt = code !== 0 || spawnFailureReason !== null;
+            if (failedAttempt && !activeEntry.terminatedForError) {
+              const nextAgent = chain[attemptIndex + 1];
+              if (nextAgent) {
+                const detail = spawnFailureReason ?? `exit code ${code}`;
+                logWarn(prefix, `variant ${variantIndex}: ${attemptAgent} failed (${detail}) \u2014 retrying with ${nextAgent}`);
+                attemptIndex += 1;
+                launch(nextAgent);
+                return;
+              }
+            }
+            if (activeEntry.terminatedForError) {
+              finishSlice(false);
+              return;
+            }
+            if (code !== 0) {
+              const detail = spawnFailureReason ?? `exit code ${code}`;
+              logError(prefix, `variant ${variantIndex} failed via ${attemptAgent} (${detail})`);
+              finishSlice(false);
+              return;
+            }
+            try {
+              const found = readdirSync(sliceDir).filter((f) => protoPattern.test(f)).sort();
+              if (found.length === 0) {
+                logError(prefix, `variant ${variantIndex}: no HTML file produced`);
+                finishSlice(false);
+                return;
+              }
+              const content = readFileSync5(resolve2(sliceDir, found[0]), "utf-8");
+              const file = {
+                name: `prototype-${variantIndex}.html`,
+                content,
+                agent: attemptAgent
+              };
+              await api.post(`/api/prototypes/${proto.id}/variants`, { file });
+              logSuccess(prefix, `variant ${variantIndex}/${totalVariants} ready ${paint("gray", `(${attemptAgent})`)}`);
+              finishSlice(true);
+            } catch (err) {
+              logError(prefix, `variant ${variantIndex}: failed to upload (${err.message})`);
+              finishSlice(false);
             }
-            res({ agent: slice.agentLabel, ok, reason: spawnFailureReason });
           });
-        });
-      })
-    );
+        };
+        launch(chain[attemptIndex]);
+      });
+    };
+    const variantIndices = Array.from({ length: totalVariants }, (_, i) => i + 1);
+    const VARIANT_CONCURRENCY = Math.min(3, totalVariants);
+    let nextVariant = 0;
+    let okCount = 0;
+    const workers = Array.from({ length: VARIANT_CONCURRENCY }, async () => {
+      while (true) {
+        if (activeEntry.terminatedForError) return;
+        const idx = nextVariant++;
+        if (idx >= variantIndices.length) return;
+        const ok = await runVariant(variantIndices[idx]);
+        if (ok) okCount++;
+      }
+    });
+    await Promise.all(workers);
     if (active.get(key) === activeEntry) {
       active.delete(key);
     }
+    if (activeEntry.terminatedForError) {
+      cleanupRefDir(refImageDir);
+      queued.delete(key);
+      return;
+    }
     finishing.add(key);
     try {
-      const protoPattern = /^prototype-\d+\.html$/;
-      const collected = [];
-      for (const slice of slices) {
-        let found = [];
-        try {
-          found = readdirSync(slice.dir).filter((f) => protoPattern.test(f)).sort();
-        } catch {
-        }
-        for (const f of found) {
-          try {
-            const content = readFileSync5(resolve2(slice.dir, f), "utf-8");
-            collected.push({ name: f, content, agent: slice.agentLabel });
-          } catch (err) {
-            logError(prefix, `Failed reading ${f} from ${slice.dir}: ${err.message}`);
-          }
-        }
-      }
-      collected.sort((a, b) => {
-        const na = parseInt(a.name.match(/\d+/)?.[0] ?? "0", 10);
-        const nb = parseInt(b.name.match(/\d+/)?.[0] ?? "0", 10);
-        return na - nb;
-      });
-      const seen = /* @__PURE__ */ new Set();
-      const finalFiles = [];
-      let renumberCursor = 1;
-      for (const f of collected) {
-        let name = f.name;
-        if (seen.has(name)) {
-          while (seen.has(`prototype-${renumberCursor}.html`)) renumberCursor++;
-          name = `prototype-${renumberCursor}.html`;
-        }
-        seen.add(name);
-        finalFiles.push({ name, content: f.content, agent: f.agent });
-      }
-      const allOk = sliceResults.every((r) => r.ok);
-      if (finalFiles.length === 0) {
-        logError(prefix, `No prototype HTML files produced by any agent`);
+      if (okCount === 0) {
+        logError(prefix, `No prototype variants were produced`);
         await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" });
       } else {
-        await api.patch(`/api/prototypes/${proto.id}`, {
+        let finalFiles = [];
+        try {
+          const current = await api.get(`/api/prototypes/${proto.id}`);
+          finalFiles = (current.files ?? []).slice();
+        } catch (err) {
+          logWarn(prefix, `Could not re-read files before completing: ${err.message}`);
+        }
+        finalFiles.sort((a, b) => {
+          const na = parseInt(a.name.match(/\d+/)?.[0] ?? "0", 10);
+          const nb = parseInt(b.name.match(/\d+/)?.[0] ?? "0", 10);
+          return na - nb;
+        });
+        const patch = {
           status: "completed",
-          files: finalFiles,
           variantModels: finalFiles.map((f) => f.agent ?? null)
-        });
-        if (allOk) {
-          logSuccess(prefix, `"${paint("bold", proto.title)}" uploaded ${finalFiles.length} file(s) from ${slices.length} agent(s)`);
+        };
+        if (finalFiles.length > 0) patch.files = finalFiles;
+        await api.patch(`/api/prototypes/${proto.id}`, patch);
+        if (okCount === totalVariants) {
+          logSuccess(prefix, `"${paint("bold", proto.title)}" completed \u2014 ${okCount} variant(s) streamed in`);
         } else {
-          const failed2 = sliceResults.filter((r) => !r.ok).map((r) => r.agent).join(", ");
-          logSuccess(prefix, `"${paint("bold", proto.title)}" uploaded ${finalFiles.length} file(s) (partial \u2014 ${failed2} failed)`);
-        }
-      }
-      for (const slice of slices) {
-        try {
-          for (const f of readdirSync(slice.dir)) {
-            try {
-              unlinkSync(resolve2(slice.dir, f));
-            } catch {
-            }
-          }
-          rmdirSync(slice.dir);
-        } catch {
+          logSuccess(prefix, `"${paint("bold", proto.title)}" completed \u2014 ${okCount}/${totalVariants} variant(s) (partial)`);
         }
       }
     } catch (err) {
-      logError(prefix, `Failed to upload multi-agent prototype: ${err.message}`);
+      logError(prefix, `Failed to finalize prototype: ${err.message}`);
       try {
         await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" });
       } catch {
@@ -4052,7 +4084,7 @@ ${divider}`);
         `${paint("cyan", "?")} Approve task "${paint("bold", task.title)}"? [y/N] `
       );
       if (approved) {
-        dispatchTask(task, repoDir);
+        dispatchTaskSafely(task, repoDir);
       } else {
         logWarn(prefix, `"${paint("bold", task.title)}" denied \u2014 will not retry`);
         failed.set(task.id, "denied by user");
@@ -4215,7 +4247,7 @@ ${divider}`);
           approvalQueue.push({ task, repoDir });
           processApprovalQueue();
         } else {
-          dispatchTask(task, repoDir);
+          dispatchTaskSafely(task, repoDir);
         }
       }
       let prototypes = [];
@@ -4229,7 +4261,11 @@ ${divider}`);
         if (key.startsWith("proto-") && !inProgressProtoKeys.has(key)) {
           logWarn(watchTag(), `Prototype ${paint("yellow", key)} no longer in_progress, terminating\u2026`);
           entry.terminatedForError = true;
-          entry.process.kill("SIGTERM");
+          if (entry.children && entry.children.size > 0) {
+            for (const child of entry.children) child.kill("SIGTERM");
+          } else {
+            entry.process.kill("SIGTERM");
+          }
           active.delete(key);
           queued.delete(key);
         }
@@ -4878,23 +4914,35 @@ var prototypeCommand = new Command15("prototype").description("Manage prototypes
     for (const p of prototypes) {
       const date = new Date(p.createdAt).toLocaleDateString();
       const typeLabel2 = typeLabels[p.prototypeType] ?? p.prototypeType ?? "web";
+      const fidelityLabel = p.fidelity === "low" ? "wireframe" : "hi-fi";
       console.log(
-        `  ${paint4("bold", p.title)}  ${statusBadge(p.status)}  ${paint4("blue", `[${typeLabel2}]`)}  ${paint4("gray", p.id.slice(0, 8))}  ${paint4("dim", date)}`
+        `  ${paint4("bold", p.title)}  ${statusBadge(p.status)}  ${paint4("blue", `[${typeLabel2}/${fidelityLabel}]`)}  ${paint4("gray", p.id.slice(0, 8))}  ${paint4("dim", date)}`
       );
       console.log(`  ${paint4("dim", p.prompt.slice(0, 80) + (p.prompt.length > 80 ? "\u2026" : ""))}`);
       console.log();
     }
   })
 ).addCommand(
-  new Command15("create").description("Create a new prototype").argument("<title>", "Title of the prototype").requiredOption("--prompt <prompt>", "Design description / prompt").option("--project <projectId>", "Project ID (defaults to linked project, when available)").option("--variants <count>", "Number of variants to generate (1-50)", "5").option("--type <type>", "Prototype type: web_app, mobile_app, desktop_app, logo (default: web_app)", "web_app").action(async (title, opts) => {
+  new Command15("create").description("Create a new prototype").argument("<title>", "Title of the prototype").requiredOption("--prompt <prompt>", "Design description / prompt").option("--project <projectId>", "Project ID (defaults to linked project, when available)").option("--variants <count>", "Number of variants to generate (1-50)", "5").option("--type <type>", "Prototype type: web_app, mobile_app, desktop_app, logo (default: web_app)", "web_app").option("--fidelity <fidelity>", "Fidelity level: low, high (default: high)", "high").action(async (title, opts) => {
     const projectId = opts.project ?? getLinkedProjectId();
     const variantCount = Math.max(1, Math.min(50, parseInt(opts.variants, 10) || 5));
     const validTypes = ["web_app", "mobile_app", "desktop_app", "logo"];
     const prototypeType = validTypes.includes(opts.type) ? opts.type : "web_app";
+    const validFidelities = ["low", "high"];
+    if (opts.fidelity && !validFidelities.includes(opts.fidelity)) {
+      console.error(`Invalid fidelity value: ${opts.fidelity}. Supported values: ${validFidelities.join(", ")}`);
+      process.exit(1);
+    }
+    const fidelity = opts.fidelity || "high";
+    if (prototypeType === "logo" && fidelity === "low") {
+      console.error("Logo prototypes do not support low fidelity.");
+      process.exit(1);
+    }
     const prototype = await api.post("/api/prototypes", {
       title,
       prompt: opts.prompt,
       prototypeType,
+      fidelity,
       variantCount,
       projectId: projectId ?? null
     });
@@ -4908,6 +4956,7 @@ var prototypeCommand = new Command15("prototype").description("Manage prototypes
     console.log(`  ${paint4("green", "\u2713")} Created prototype: ${paint4("bold", prototype.title)}`);
     console.log(`  ${paint4("gray", "ID:")} ${prototype.id}`);
     console.log(`  ${paint4("gray", "Type:")} ${typeLabels[prototype.prototypeType] ?? prototype.prototypeType}`);
+    console.log(`  ${paint4("gray", "Fidelity:")} ${prototype.fidelity === "low" ? "Low (wireframe)" : "High (hi-fi)"}`);
     if (!prototype.projectId) {
       console.log(`  ${paint4("gray", "Project:")} none (will generate in the active watch directory)`);
     }
@@ -5208,7 +5257,7 @@ function printResults(checks) {
   return allOk;
 }
 async function autoFix(checks, agent) {
-  const { spawn: spawn10 } = await import("child_process");
+  const { spawn: spawn9 } = await import("child_process");
   const ghInstalled = checks.find((c14) => c14.name === "GitHub CLI (gh)").ok;
   const ghAuthed = checks.find((c14) => c14.name === "GitHub CLI auth").ok;
   const mrAuthed = checks.find((c14) => c14.name === "Mr. Manager CLI auth").ok;
@@ -5217,7 +5266,7 @@ async function autoFix(checks, agent) {
     console.log(paint5("cyan", "  Installing Claude Code..."));
     console.log(paint5("dim", "  Running: curl -fsSL https://claude.ai/install.sh | bash"));
     await new Promise((resolve9) => {
-      const child = spawn10("bash", ["-c", "curl -fsSL https://claude.ai/install.sh | bash"], { stdio: "inherit" });
+      const child = spawn9("bash", ["-c", "curl -fsSL https://claude.ai/install.sh | bash"], { stdio: "inherit" });
       child.on("exit", () => resolve9());
     });
     console.log("");
@@ -5225,7 +5274,7 @@ async function autoFix(checks, agent) {
   if (ghInstalled && !ghAuthed) {
     console.log(paint5("cyan", "  Running gh auth login..."));
     await new Promise((resolve9) => {
-      const child = spawn10("gh", ["auth", "login"], { stdio: "inherit" });
+      const child = spawn9("gh", ["auth", "login"], { stdio: "inherit" });
       child.on("exit", () => resolve9());
     });
     console.log("");
@@ -5234,7 +5283,7 @@ async function autoFix(checks, agent) {
     console.log(paint5("cyan", "  Running mr login..."));
     const entry = process.argv[1];
     await new Promise((resolve9) => {
-      const child = spawn10(process.execPath, [entry, "login"], { stdio: "inherit" });
+      const child = spawn9(process.execPath, [entry, "login"], { stdio: "inherit" });
       child.on("exit", () => resolve9());
     });
     console.log("");
@@ -6020,13 +6069,92 @@ var noMrCommand = new Command24("no-mr").description("Signal that a task does no
 
 // cli/commands/review.ts
 import { Command as Command26 } from "commander";
-import { spawn as spawn8, execSync as execSync6 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 import { existsSync as existsSync14, statSync as statSync2 } from "fs";
 
 // cli/commands/review-apply.ts
 import { Command as Command25 } from "commander";
-import { spawn as spawn7, execSync as execSync5 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 import { existsSync as existsSync13 } from "fs";
+
+// lib/review/agent.ts
+import { spawn as spawn7, exec as exec3 } from "child_process";
+var AGENT_BINARIES2 = {
+  claude: "claude",
+  codex: "codex",
+  antigravity: "agy"
+};
+function commandExists3(cmd) {
+  return new Promise((resolve9) => {
+    exec3(`command -v ${cmd}`, (err) => resolve9(!err));
+  });
+}
+async function resolveReviewAgentChain(preferred2 = "claude") {
+  const availability = {};
+  for (const candidate of ["claude", "codex", "antigravity"]) {
+    availability[candidate] = await commandExists3(AGENT_BINARIES2[candidate]);
+  }
+  return getAvailableAgentFallbackChain(preferred2, availability);
+}
+function buildArgs(agent, prompt2) {
+  if (agent === "codex") {
+    return ["-a", "never", "exec", "-s", "danger-full-access", prompt2];
+  }
+  if (agent === "antigravity") {
+    return ["-p", prompt2, "--dangerously-skip-permissions"];
+  }
+  return ["-p", "--dangerously-skip-permissions", prompt2];
+}
+function runOnce(agent, prompt2, opts) {
+  return new Promise((resolve9) => {
+    const child = spawn7(AGENT_BINARIES2[agent], buildArgs(agent, prompt2), {
+      cwd: opts.cwd,
+      stdio: opts.capture ? ["ignore", "pipe", "pipe"] : ["ignore", "inherit", "inherit"]
+    });
+    let output = "";
+    if (opts.capture) {
+      child.stdout?.on("data", (d) => {
+        output += d.toString();
+      });
+      child.stderr?.on("data", () => {
+      });
+    }
+    child.on("error", () => {
+      resolve9({ ok: false, output, spawnError: true });
+    });
+    child.on("exit", (code) => {
+      resolve9({ ok: code === 0, output: output.trim(), spawnError: false });
+    });
+  });
+}
+async function runAgentCaptured(prompt2, opts) {
+  if (opts.chain.length === 0) {
+    throw new Error("No available agents (need one of: claude, codex, agy)");
+  }
+  let lastError = "";
+  for (const agent of opts.chain) {
+    const result = await runOnce(agent, prompt2, { cwd: opts.cwd, capture: true });
+    if (result.ok && result.output) {
+      return { output: result.output, agent };
+    }
+    lastError = result.spawnError ? `${agent} could not be spawned` : `${agent} exited without usable output`;
+  }
+  throw new Error(`All agents failed (${lastError})`);
+}
+async function runAgentInteractive(prompt2, opts) {
+  if (opts.chain.length === 0) {
+    throw new Error("No available agents (need one of: claude, codex, agy)");
+  }
+  let lastError = "";
+  for (const agent of opts.chain) {
+    const result = await runOnce(agent, prompt2, { cwd: opts.cwd, capture: false });
+    if (result.ok) return { agent };
+    lastError = result.spawnError ? `${agent} could not be spawned` : `${agent} exited non-zero`;
+  }
+  throw new Error(`All agents failed (${lastError})`);
+}
+
+// cli/commands/review-apply.ts
 var c8 = {
   reset: "\x1B[0m",
   dim: "\x1B[2m",
@@ -6056,7 +6184,7 @@ function logOk(msg) {
 function logErr(msg) {
   console.error(`${timestamp2()} ${tag()} ${paint8("red", "\u2717")} ${msg}`);
 }
-var reviewApplyCommand = new Command25("apply").description("Apply review comments and findings using the Claude agent").argument("<id>", "Code review ID (the one shown in the Reviews UI)").option("--no-push", "Skip pushing the fix commit to the remote").option("--no-commit", "Apply changes but don't commit (for dry-run review)").action(async (id, opts) => {
+var reviewApplyCommand = new Command25("apply").description("Apply review comments and findings using the Claude agent").argument("<id>", "Code review ID (the one shown in the Reviews UI)").option("--no-push", "Skip pushing the fix commit to the remote").option("--no-commit", "Apply changes but don't commit (for dry-run review)").option("--in-place", "Apply edits directly in the linked checkout instead of an isolated worktree (legacy, unsafe)").action(async (id, opts) => {
   const config = loadConfig();
   if (!config.apiKey) {
     logErr('Not authenticated. Run "mr login" first.');
@@ -6077,9 +6205,12 @@ var reviewApplyCommand = new Command25("apply").description("Apply review commen
     process.exit(1);
   }
   const actionableComments = comments.filter((c14) => !excluded.has(c14.file));
-  const actionableFindings = findings.filter((f) => !excluded.has(f.file));
+  const dismissedCount = findings.filter((f) => f.status === "dismissed").length;
+  const actionableFindings = findings.filter(
+    (f) => !excluded.has(f.file) && f.status !== "dismissed"
+  );
   if (actionableComments.length === 0 && actionableFindings.length === 0) {
-    logErr("All files with comments/findings are excluded \u2014 nothing to do.");
+    logErr("No selected comments or findings to act on (all excluded or dismissed).");
     process.exit(1);
   }
   let project;
@@ -6104,19 +6235,59 @@ var reviewApplyCommand = new Command25("apply").description("Apply review commen
     logErr(`Set the project's localPath or run from inside the repo.`);
     process.exit(1);
   }
-  try {
-    execSync5(`git fetch origin ${review.branch}`, { cwd: projectPath, stdio: "ignore" });
-  } catch {
-  }
-  try {
-    execSync5(`git checkout ${review.branch}`, { cwd: projectPath, stdio: "pipe" });
-  } catch (err) {
-    logErr(`Could not checkout branch ${review.branch}: ${err.message}`);
+  const chain = await resolveReviewAgentChain("claude");
+  if (chain.length === 0) {
+    logErr("No available agent found (need one of: claude, codex, agy)");
     process.exit(1);
   }
+  const touchedFiles = Array.from(
+    new Set([
+      ...actionableComments.map((c14) => c14.file),
+      ...actionableFindings.map((f) => f.file)
+    ].filter(Boolean))
+  );
+  let workDir = projectPath;
+  let cleanup = () => {
+  };
+  if (opts.inPlace) {
+    try {
+      execSync5(`git fetch origin ${review.branch}`, { cwd: projectPath, stdio: "ignore" });
+    } catch {
+    }
+    try {
+      execSync5(`git checkout ${review.branch}`, { cwd: projectPath, stdio: "pipe" });
+    } catch (err) {
+      logErr(`Could not checkout branch ${review.branch}: ${err.message}`);
+      process.exit(1);
+    }
+  } else {
+    try {
+      const wt = createWorktree(projectPath, review.branch, `review-apply-${id}`, {
+        syncRemoteBranch: true
+      });
+      workDir = wt.path;
+    } catch (err) {
+      logErr(`Could not create worktree for ${review.branch}: ${err.message}`);
+      process.exit(1);
+    }
+    cleanup = () => removeWorktree(projectPath, workDir);
+  }
+  const failAndExit = async (message, extra = {}) => {
+    logErr(message);
+    try {
+      await api.patch(`/api/reviews/${id}`, { fixStatus: "failed", fixErrorMessage: message, ...extra });
+    } catch {
+    }
+    cleanup();
+    process.exit(1);
+  };
   log(`Project: ${paint8("cyan", project.name)}`);
   log(`Branch:  ${paint8("cyan", review.branch)}`);
+  log(`Workdir: ${paint8("dim", opts.inPlace ? `${workDir} (in-place)` : workDir)}`);
   log(`Comments: ${paint8("yellow", String(actionableComments.length))}, findings: ${paint8("yellow", String(actionableFindings.length))}`);
+  if (dismissedCount > 0) {
+    log(`Dismissed findings skipped: ${paint8("dim", String(dismissedCount))}`);
+  }
   if (excluded.size > 0) {
     log(`Excluded files: ${paint8("dim", [...excluded].join(", "))}`);
   }
@@ -6131,19 +6302,14 @@ var reviewApplyCommand = new Command25("apply").description("Apply review commen
     findings: actionableFindings,
     excluded: [...excluded]
   });
-  log("Asking Claude to apply the changes\u2026");
+  log(`Asking ${paint8("cyan", chain[0])} to apply the changes\u2026`);
   try {
-    await runClaudeInteractive(prompt2, projectPath);
+    const { agent } = await runAgentInteractive(prompt2, { cwd: workDir, chain });
+    if (agent !== chain[0]) log(`Applied with fallback agent ${paint8("cyan", agent)}`);
   } catch (err) {
-    const message = err.message || "Unknown error";
-    logErr(`Agent fix failed: ${message}`);
-    try {
-      await api.patch(`/api/reviews/${id}`, { fixStatus: "failed", fixErrorMessage: message });
-    } catch {
-    }
-    process.exit(1);
+    await failAndExit(`Agent fix failed: ${err.message || "Unknown error"}`);
   }
-  const dirty = execSync5("git status --porcelain", { cwd: projectPath, encoding: "utf-8" }).trim();
+  const dirty = execSync5("git status --porcelain", { cwd: workDir, encoding: "utf-8" }).trim();
   if (!dirty) {
     log(paint8("yellow", "Agent didn't change any files."));
     try {
@@ -6153,10 +6319,11 @@ var reviewApplyCommand = new Command25("apply").description("Apply review commen
       });
     } catch {
     }
+    cleanup();
     return;
   }
   if (opts.commit === false) {
-    logOk("Changes left unstaged for review (--no-commit).");
+    logOk(`Changes left unstaged for review (--no-commit) in ${paint8("dim", workDir)}.`);
     try {
       await api.patch(`/api/reviews/${id}`, { fixStatus: "completed" });
     } catch {
@@ -6168,35 +6335,27 @@ var reviewApplyCommand = new Command25("apply").description("Apply review commen
     findingsCount: actionableFindings.length
   });
   try {
-    execSync5("git add -A", { cwd: projectPath });
-    execSync5(`git commit -m ${JSON.stringify(commitMessage)}`, { cwd: projectPath, stdio: "pipe" });
-  } catch (err) {
-    const message = err.message || "Unknown error";
-    logErr(`Commit failed: ${message}`);
-    try {
-      await api.patch(`/api/reviews/${id}`, { fixStatus: "failed", fixErrorMessage: message });
-    } catch {
+    if (touchedFiles.length > 0) {
+      const args = touchedFiles.map((f) => JSON.stringify(f)).join(" ");
+      execSync5(`git add -- ${args}`, { cwd: workDir });
+    } else {
+      execSync5("git add -A", { cwd: workDir });
     }
-    process.exit(1);
+    execSync5(`git commit -m ${JSON.stringify(commitMessage)}`, { cwd: workDir, stdio: "pipe" });
+  } catch (err) {
+    await failAndExit(`Commit failed: ${err.message || "Unknown error"}`);
   }
-  const sha = execSync5("git rev-parse HEAD", { cwd: projectPath, encoding: "utf-8" }).trim();
+  const sha = execSync5("git rev-parse HEAD", { cwd: workDir, encoding: "utf-8" }).trim();
   logOk(`Committed ${paint8("yellow", sha.slice(0, 10))}`);
   if (opts.push !== false) {
     try {
-      execSync5(`git push origin ${review.branch}`, { cwd: projectPath, stdio: "pipe" });
+      execSync5(`git push origin ${review.branch}`, { cwd: workDir, stdio: "pipe" });
       logOk(`Pushed to origin/${review.branch}`);
     } catch (err) {
-      const message = err.message || "Unknown error";
-      logErr(`Push failed: ${message}`);
-      try {
-        await api.patch(`/api/reviews/${id}`, {
-          fixStatus: "failed",
-          fixErrorMessage: `Committed ${sha.slice(0, 10)} but push failed: ${message}`,
-          fixCommitSha: sha
-        });
-      } catch {
-      }
-      process.exit(1);
+      await failAndExit(
+        `Committed ${sha.slice(0, 10)} but push failed: ${err.message || "Unknown error"}`,
+        { fixCommitSha: sha }
+      );
     }
   }
   try {
@@ -6207,6 +6366,7 @@ var reviewApplyCommand = new Command25("apply").description("Apply review commen
     });
   } catch {
   }
+  cleanup();
   logOk("Done.");
 });
 function buildApplyPrompt(args) {
@@ -6250,17 +6410,418 @@ function buildCommitMessage(args) {
 
 Generated by mr review apply.`;
 }
-function runClaudeInteractive(prompt2, cwd) {
-  return new Promise((resolve9, reject) => {
-    const child = spawn7("claude", ["-p", "--dangerously-skip-permissions", prompt2], {
-      cwd,
-      stdio: ["ignore", "inherit", "inherit"]
-    });
-    child.on("exit", (code) => {
-      if (code === 0) resolve9();
-      else reject(new Error(`claude exited with code ${code}`));
+
+// lib/review/dimensions.ts
+var REVIEW_DIMENSIONS = [
+  {
+    key: "security",
+    title: "Security",
+    allowedTypes: ["security", "bug"],
+    focus: [
+      "Hunt exclusively for security problems:",
+      "- Injection (SQL/NoSQL/command/path), XSS, SSRF, and unsafe deserialization",
+      "- AuthN/AuthZ gaps: missing ownership checks, privilege escalation, IDOR",
+      "- Secrets or credentials committed, logged, or returned to clients",
+      "- Unsafe handling of user input, missing validation, or unescaped output",
+      "- Insecure crypto, weak randomness, or Edge-runtime incompatible Node APIs",
+      "Do NOT report style, performance, or generic refactor ideas here."
+    ].join("\n")
+  },
+  {
+    key: "correctness",
+    title: "Correctness",
+    allowedTypes: ["bug"],
+    focus: [
+      "Hunt exclusively for correctness bugs and logical errors:",
+      "- Off-by-one, null/undefined dereferences, incorrect conditionals",
+      "- Broken contracts: a changed function signature whose other call sites are now wrong",
+      "- Unhandled error paths, swallowed exceptions, race conditions",
+      "- State that can desync, missing await, or incorrect async ordering",
+      "Open neighboring files to confirm a change doesn't break an un-diffed caller.",
+      "Do NOT report style, naming, or performance micro-optimizations here."
+    ].join("\n")
+  },
+  {
+    key: "performance",
+    title: "Performance",
+    allowedTypes: ["performance", "bug"],
+    focus: [
+      "Hunt exclusively for performance problems:",
+      "- N+1 queries, missing indexes, redundant network/database round-trips",
+      "- Unnecessary re-renders, missing memoization, work done in hot loops",
+      "- Large synchronous work on a request path, unbounded memory growth",
+      "Only flag issues with a realistic, material impact. Do NOT report style or naming."
+    ].join("\n")
+  },
+  {
+    key: "style",
+    title: "Style & Maintainability",
+    allowedTypes: ["style", "suggestion", "nitpick"],
+    focus: [
+      "Look for style, readability and maintainability improvements:",
+      "- Naming, dead code, duplication, and inconsistent patterns",
+      "- Missing types, unclear abstractions, or violations of repo conventions",
+      "- Small suggestions and nitpicks (keep these low severity)",
+      "Do NOT duplicate security/correctness/performance findings \u2014 stay in your lane."
+    ].join("\n")
+  }
+];
+
+// lib/review/parse.ts
+function extractJsonObjects(text) {
+  const objects = [];
+  let depth = 0;
+  let start = -1;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{") {
+      if (depth === 0) start = i;
+      depth++;
+    } else if (ch === "}") {
+      if (depth > 0) {
+        depth--;
+        if (depth === 0 && start !== -1) {
+          objects.push(text.slice(start, i + 1));
+          start = -1;
+        }
+      }
+    }
+  }
+  return objects;
+}
+function parseReviewOutput(output) {
+  const cleaned = output.replace(/```(?:json)?/gi, "").replace(/```/g, "").trim();
+  const candidates = [cleaned, ...extractJsonObjects(cleaned)].sort(
+    (a, b) => b.length - a.length
+  );
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (parsed && typeof parsed === "object" && Array.isArray(parsed.findings)) {
+        return {
+          summary: typeof parsed.summary === "string" ? parsed.summary : "",
+          findings: parsed.findings,
+          parseFailed: false
+        };
+      }
+    } catch {
+    }
+  }
+  return { summary: "", findings: [], parseFailed: true };
+}
+
+// lib/review/merge.ts
+var SEVERITY_RANK = {
+  critical: 4,
+  high: 3,
+  medium: 2,
+  low: 1
+};
+function tokenize(text) {
+  return new Set(
+    (text || "").toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter(Boolean)
+  );
+}
+function titleSimilarity(a, b) {
+  const ta = tokenize(a);
+  const tb = tokenize(b);
+  if (ta.size === 0 && tb.size === 0) return 1;
+  if (ta.size === 0 || tb.size === 0) return 0;
+  let intersection = 0;
+  for (const t of ta) if (tb.has(t)) intersection++;
+  const union = ta.size + tb.size - intersection;
+  return intersection / union;
+}
+function severityRank(sev) {
+  return SEVERITY_RANK[sev] ?? 0;
+}
+function isDuplicate(a, b) {
+  if (a.file !== b.file) return false;
+  const aLine = a.line;
+  const bLine = b.line;
+  if (aLine != null && bLine != null) {
+    if (Math.abs(aLine - bLine) > 3) return false;
+  } else if (aLine != null || bLine != null) {
+    return titleSimilarity(a.title, b.title) >= 0.8;
+  }
+  return titleSimilarity(a.title, b.title) >= 0.5;
+}
+function preferred(a, b) {
+  const aScore = severityRank(a.severity) * 10 + (a.confidence ?? 0);
+  const bScore = severityRank(b.severity) * 10 + (b.confidence ?? 0);
+  const winner = bScore > aScore ? b : a;
+  const loser = winner === a ? b : a;
+  const dims = [winner.dimension, loser.dimension].filter(Boolean);
+  return {
+    ...winner,
+    description: (loser.description?.length ?? 0) > (winner.description?.length ?? 0) ? loser.description : winner.description,
+    suggestion: winner.suggestion || loser.suggestion,
+    dimension: Array.from(new Set(dims)).join("+") || winner.dimension,
+    confidence: Math.max(winner.confidence ?? 0, loser.confidence ?? 0) || void 0
+  };
+}
+function mergeFindings(all) {
+  const merged = [];
+  for (const finding of all) {
+    const existingIdx = merged.findIndex((m) => isDuplicate(m, finding));
+    if (existingIdx === -1) {
+      merged.push(finding);
+    } else {
+      merged[existingIdx] = preferred(merged[existingIdx], finding);
+    }
+  }
+  merged.sort((a, b) => severityRank(b.severity) - severityRank(a.severity));
+  return merged.map((f, i) => ({ ...f, id: `f${i + 1}` }));
+}
+
+// lib/review/prompt.ts
+var JSON_CONTRACT = `Return ONLY a JSON object (no markdown fences, no prose before or after) with this exact shape:
+{
+  "summary": "1-2 sentence assessment for this concern",
+  "findings": [
+    {
+      "id": "f1",
+      "type": "bug",
+      "severity": "high",
+      "title": "Brief one-line title",
+      "description": "Detailed explanation",
+      "file": "path/to/file.ts",
+      "line": 42,
+      "suggestion": "Concrete fix, with code when possible",
+      "confidence": 0.0
+    }
+  ]
+}
+"confidence" is your own 0-1 estimate that this is a real, actionable issue.
+If there are no issues for this concern, return an empty findings array with a positive summary.`;
+function buildDimensionPrompt(args) {
+  const lines = [];
+  lines.push(
+    `You are a senior code reviewer focused exclusively on ${args.dimension.title.toUpperCase()}.`,
+    `Review the git diff for branch "${args.branch}" compared to "${args.baseBranch}".`,
+    "",
+    args.dimension.focus,
+    "",
+    `Only emit findings whose "type" is one of: ${args.dimension.allowedTypes.join(", ")}.`,
+    ""
+  );
+  if (args.canReadFiles) {
+    lines.push(
+      "You are running inside a checkout of this repository. You MAY open the changed files",
+      "and their neighbors (callers, callees, related modules) to verify a finding before",
+      "reporting it \u2014 this catches issues that are invisible from the diff alone, like a",
+      "renamed function's other call sites. Prefer confirmed findings over speculation.",
+      ""
+    );
+  }
+  if (args.fileScope && args.fileScope.length > 0) {
+    lines.push(
+      "Concentrate on these files (other diff context is provided only for reference):",
+      ...args.fileScope.map((f) => `  - ${f}`),
+      ""
+    );
+  }
+  lines.push(JSON_CONTRACT, "", "Here is the diff to review:", "", "```diff", args.diff, "```");
+  return lines.join("\n");
+}
+function buildVerificationPrompt(args) {
+  const compact = args.findings.map((f) => ({
+    id: f.id,
+    type: f.type,
+    severity: f.severity,
+    title: f.title,
+    description: f.description,
+    file: f.file,
+    line: f.line
+  }));
+  const lines = [];
+  lines.push(
+    `You are an adversarial reviewer verifying findings from an automated review of branch "${args.branch}" vs "${args.baseBranch}".`,
+    "For EACH finding below, try to refute it. A finding should be kept only if it is a real,",
+    "actionable issue grounded in the actual diff. Reject hallucinations, findings that",
+    "reference code that isn't there, and pure speculation.",
+    ""
+  );
+  if (args.canReadFiles) {
+    lines.push(
+      "You are in a checkout of the repo \u2014 open files to confirm or refute each claim.",
+      ""
+    );
+  }
+  lines.push(
+    "Return ONLY a JSON object (no fences, no prose) of this shape:",
+    `{ "verdicts": [ { "id": "f1", "keep": true, "confidence": 0.0, "reason": "why" } ] }`,
+    "confidence is 0-1. Set keep=false when you cannot substantiate the finding.",
+    "",
+    "FINDINGS:",
+    JSON.stringify(compact, null, 2),
+    "",
+    "DIFF:",
+    "```diff",
+    args.diff,
+    "```"
+  );
+  return lines.join("\n");
+}
+
+// lib/review/orchestrate.ts
+function splitDiffByFile(diff) {
+  const sections = diff.split(/(?=^diff --git )/m).filter((s) => s.trim());
+  return sections.map((section) => {
+    const m = section.match(/^diff --git a\/(.+?) b\//m);
+    return { file: m?.[1] ?? "unknown", section };
+  });
+}
+async function pool(items, limit) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (cursor < items.length) {
+      const idx = cursor++;
+      results[idx] = await items[idx]();
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+function buildJobs(opts) {
+  const files = splitDiffByFile(opts.diff);
+  const shardThreshold = opts.shardThreshold ?? 12;
+  if (files.length >= shardThreshold) {
+    const shardCount = Math.min(4, Math.ceil(files.length / 6));
+    const shards = Array.from(
+      { length: shardCount },
+      () => ({ diff: "", files: [] })
+    );
+    files.forEach((f, i) => {
+      const s = shards[i % shardCount];
+      s.diff += f.section;
+      s.files.push(f.file);
     });
+    const jobs = [];
+    for (const dim of REVIEW_DIMENSIONS) {
+      for (const shard of shards) {
+        jobs.push({ dimension: dim, diff: shard.diff, fileScope: shard.files });
+      }
+    }
+    return jobs;
+  }
+  return REVIEW_DIMENSIONS.map((dimension) => ({ dimension, diff: opts.diff }));
+}
+async function orchestrateReview(opts) {
+  const log4 = opts.log ?? (() => {
+  });
+  const concurrency = opts.concurrency ?? 4;
+  const canReadFiles = Boolean(opts.cwd);
+  const runOpts = { cwd: opts.cwd, chain: opts.chain };
+  const jobs = buildJobs(opts);
+  log4(`Fanning out ${jobs.length} review subagent(s) across ${REVIEW_DIMENSIONS.length} dimensions`);
+  const summaries = [];
+  const collected = [];
+  const jobResults = await pool(
+    jobs.map((job) => async () => {
+      const prompt2 = buildDimensionPrompt({
+        dimension: job.dimension,
+        branch: opts.branch,
+        baseBranch: opts.baseBranch,
+        diff: job.diff,
+        canReadFiles,
+        fileScope: job.fileScope
+      });
+      try {
+        const { output } = await runAgentCaptured(prompt2, runOpts);
+        const parsed = parseReviewOutput(output);
+        return { job, parsed };
+      } catch (err) {
+        log4(`  ${job.dimension.key} subagent failed: ${err.message}`);
+        return { job, parsed: { summary: "", findings: [], parseFailed: true } };
+      }
+    }),
+    concurrency
+  );
+  const dimensionsRun = /* @__PURE__ */ new Set();
+  for (const { job, parsed } of jobResults) {
+    if (parsed.summary) summaries.push(`${job.dimension.title}: ${parsed.summary}`);
+    for (const f of parsed.findings) {
+      dimensionsRun.add(job.dimension.key);
+      collected.push({
+        id: f.id || "f",
+        type: f.type || job.dimension.allowedTypes[0],
+        severity: f.severity || "medium",
+        title: f.title || "Untitled finding",
+        description: f.description || "",
+        file: f.file || "unknown",
+        line: typeof f.line === "number" ? f.line : void 0,
+        endLine: typeof f.endLine === "number" ? f.endLine : void 0,
+        suggestion: f.suggestion,
+        status: "new",
+        dimension: job.dimension.key,
+        confidence: typeof f.confidence === "number" ? f.confidence : void 0
+      });
+    }
+  }
+  const rawCount = collected.length;
+  let findings = mergeFindings(collected);
+  log4(`Merged ${rawCount} raw findings into ${findings.length} after dedup`);
+  if (opts.verify && findings.length > 0) {
+    findings = await verifyFindings(findings, opts, runOpts, log4);
+  }
+  return {
+    summary: summaries.join(" "),
+    findings,
+    dimensionsRun: [...dimensionsRun],
+    rawCount
+  };
+}
+async function verifyFindings(findings, opts, runOpts, log4) {
+  const minConfidence = opts.minConfidence ?? 0.4;
+  const prompt2 = buildVerificationPrompt({
+    findings,
+    branch: opts.branch,
+    baseBranch: opts.baseBranch,
+    diff: opts.diff,
+    canReadFiles: Boolean(opts.cwd)
   });
+  let verdicts = [];
+  try {
+    const { output } = await runAgentCaptured(prompt2, runOpts);
+    const cleaned = output.replace(/```(?:json)?/gi, "").replace(/```/g, "").trim();
+    const match = cleaned.match(/\{[\s\S]*\}/);
+    if (match) {
+      const parsed = JSON.parse(match[0]);
+      verdicts = parsed.verdicts ?? [];
+    }
+  } catch (err) {
+    log4(`Verification stage failed, keeping all findings: ${err.message}`);
+    return findings;
+  }
+  const byId = new Map(verdicts.map((v) => [v.id, v]));
+  const kept = findings.filter((f) => {
+    const v = byId.get(f.id);
+    if (!v) return true;
+    if (v.keep === false) return false;
+    if (typeof v.confidence === "number") {
+      f.confidence = v.confidence;
+      return v.confidence >= minConfidence;
+    }
+    return true;
+  });
+  log4(`Verification kept ${kept.length}/${findings.length} findings`);
+  return kept.map((f, i) => ({ ...f, id: `f${i + 1}` }));
 }
 
 // cli/commands/review.ts
@@ -6330,6 +6891,7 @@ var reviewCommand = new Command26("review").description("Run an automated code r
   const canUseRemote = remote !== null && (prNumber || remote.number) !== void 0;
   let diff;
   let branch = opts.branch;
+  let reviewCwd;
   if (canUseRemote && remote) {
     const num = prNumber ?? remote.number;
     if (!num) {
@@ -6379,6 +6941,7 @@ var reviewCommand = new Command26("review").description("Run an automated code r
       process.exit(1);
     }
     log2(`Using project path: ${paint9("dim", projectPath)}`);
+    reviewCwd = projectPath;
     if (!branch) {
       try {
         branch = execSync6("git rev-parse --abbrev-ref HEAD", {
@@ -6457,17 +7020,39 @@ var reviewCommand = new Command26("review").description("Run an automated code r
   } catch {
   }
   const startTime = Date.now();
-  const MAX_DIFF_CHARS = 8e4;
-  let truncatedDiff = diff;
+  const chain = await resolveReviewAgentChain("claude");
+  if (chain.length === 0) {
+    const message = "No available agent found (need one of: claude, codex, agy)";
+    logErr2(message);
+    try {
+      await api.patch(`/api/reviews/${reportId}`, { status: "failed", errorMessage: message });
+    } catch {
+    }
+    process.exit(1);
+  }
+  log2(`Agent chain: ${paint9("cyan", chain.join(" \u2192 "))}`);
+  const MAX_DIFF_CHARS = 4e5;
+  const diffCharsTotal = diff.length;
+  let reviewDiff = diff;
+  let diffTruncated = false;
   if (diff.length > MAX_DIFF_CHARS) {
-    truncatedDiff = diff.slice(0, MAX_DIFF_CHARS) + "\n\n... (diff truncated, review covers first " + MAX_DIFF_CHARS.toLocaleString() + " characters)";
-    log2(paint9("yellow", `Diff truncated to ${MAX_DIFF_CHARS.toLocaleString()} chars for review`));
+    reviewDiff = diff.slice(0, MAX_DIFF_CHARS);
+    diffTruncated = true;
+    log2(paint9("yellow", `Diff truncated to ${MAX_DIFF_CHARS.toLocaleString()} of ${diffCharsTotal.toLocaleString()} chars`));
   }
   try {
-    log2("Running code review with Claude...");
-    const prompt2 = buildReviewPrompt(branch, baseBranch, truncatedDiff);
-    const output = await runClaude(prompt2);
-    const result = parseReviewOutput(output);
+    log2("Running fan-out code review...");
+    const orchestrated = await orchestrateReview({
+      branch,
+      baseBranch,
+      diff: reviewDiff,
+      chain,
+      cwd: reviewCwd,
+      concurrency: 4,
+      verify: true,
+      log: (m) => log2(m)
+    });
+    const result = { summary: orchestrated.summary, findings: orchestrated.findings };
     const duration = Date.now() - startTime;
     let wasCancelled = false;
     try {
@@ -6484,7 +7069,9 @@ var reviewCommand = new Command26("review").description("Run an automated code r
       summary: result.summary,
       findings: result.findings,
       filesReviewed: filesChanged,
-      reviewDurationMs: duration
+      reviewDurationMs: duration,
+      diffTruncated,
+      diffCharsTotal
     });
     logOk2(`Review completed in ${paint9("cyan", formatDuration(duration))}`);
     logOk2(`Found ${paint9("yellow", String(result.findings.length))} findings`);
@@ -6573,112 +7160,12 @@ function formatDuration(ms) {
   if (s < 60) return `${s}s`;
   return `${Math.floor(s / 60)}m ${s % 60}s`;
 }
-function buildReviewPrompt(branch, baseBranch, diff) {
-  return `You are a senior code reviewer. Review the following git diff for branch "${branch}" compared to "${baseBranch}".
-
-Analyze the code changes and produce a JSON response with your review findings.
-
-Focus on:
-- Bugs and logical errors
-- Security vulnerabilities (XSS, injection, auth issues, secrets exposure)
-- Performance issues (N+1 queries, missing indexes, unnecessary re-renders)
-- Code style and best practices violations
-- Suggestions for improvement
-- Nitpicks (minor style/naming issues)
-
-For each finding, provide:
-- A unique ID (e.g. "f1", "f2", etc.)
-- Type: "bug", "security", "performance", "style", "suggestion", or "nitpick"
-- Severity: "critical", "high", "medium", or "low"
-- Title: a brief one-line summary
-- Description: detailed explanation of the issue
-- File: the file path where the issue was found
-- Line: the approximate line number in the new code (optional)
-- Suggestion: suggested fix or improvement (optional, include actual code when possible)
-
-Return ONLY a JSON object with this structure (no markdown, no explanation before/after):
-{
-  "summary": "Brief overall assessment of the code changes (2-3 sentences)",
-  "findings": [
-    {
-      "id": "f1",
-      "type": "bug",
-      "severity": "high",
-      "title": "Brief title",
-      "description": "Detailed description",
-      "file": "path/to/file.ts",
-      "line": 42,
-      "suggestion": "Suggested fix code"
-    }
-  ]
-}
-
-If the code looks good with no issues, return an empty findings array with a positive summary.
-
-Here is the diff to review:
-
-\`\`\`diff
-${diff}
-\`\`\``;
-}
-function runClaude(prompt2) {
-  return new Promise((resolve9, reject) => {
-    const child = spawn8("claude", ["-p", "--dangerously-skip-permissions", prompt2], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let output = "";
-    let errOutput = "";
-    child.stdout?.on("data", (d) => {
-      output += d.toString();
-    });
-    child.stderr?.on("data", (d) => {
-      errOutput += d.toString();
-    });
-    child.on("exit", (code) => {
-      if (code === 0) resolve9(output.trim());
-      else reject(new Error(`claude exited with code ${code}
-${errOutput.trim()}`));
-    });
-  });
-}
-function parseReviewOutput(output) {
-  const jsonMatch = output.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) {
-    return {
-      summary: "Failed to parse review output",
-      findings: []
-    };
-  }
-  try {
-    const parsed = JSON.parse(jsonMatch[0]);
-    return {
-      summary: parsed.summary || "",
-      findings: (parsed.findings || []).map((f) => ({
-        id: f.id || `f${Math.random().toString(36).slice(2, 8)}`,
-        type: f.type || "suggestion",
-        severity: f.severity || "medium",
-        title: f.title || "Untitled finding",
-        description: f.description || "",
-        file: f.file || "unknown",
-        line: f.line,
-        endLine: f.endLine,
-        suggestion: f.suggestion,
-        status: "new"
-      }))
-    };
-  } catch {
-    return {
-      summary: "Failed to parse review JSON",
-      findings: []
-    };
-  }
-}
 
 // cli/commands/scan.ts
 import { Command as Command27 } from "commander";
 
 // lib/scanner/index.ts
-import { spawn as spawn9 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 
 // lib/scanner/config.ts
 import { readFileSync as readFileSync10, existsSync as existsSync15 } from "fs";
@@ -7296,7 +7783,7 @@ async function runScanPipeline(opts) {
     context.priorFindings,
     opts.customPrompt
   );
-  const synthesisResult = await runClaude2(prompt2);
+  const synthesisResult = await runClaude(prompt2);
   const parsed = parseSynthesisOutput(synthesisResult);
   const scanDurationMs = Date.now() - startTime;
   opts.onLog(`Scan complete in ${Math.round(scanDurationMs / 1e3)}s \u2014 ${parsed.findings.length} findings`);
@@ -7357,9 +7844,9 @@ async function fetchScanContext(opts) {
     priorFindings
   };
 }
-function runClaude2(prompt2) {
+function runClaude(prompt2) {
   return new Promise((resolve9, reject) => {
-    const child = spawn9("claude", ["-p", "--dangerously-skip-permissions", prompt2], {
+    const child = spawn8("claude", ["-p", "--dangerously-skip-permissions", prompt2], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let output = "";