@dunnewold-labs/mr-manager 0.4.38 → 0.4.39

package/dist/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // cli/index.ts
-import { Command as Command31 } from "commander";
+import { Command as Command33 } from "commander";
 import { existsSync as existsSync18 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join12 } from "path";
@@ -185,7 +185,7 @@ import { fileURLToPath } from "url";
 // cli/package.json
 var package_default = {
   name: "@dunnewold-labs/mr-manager",
-  version: "0.4.38",
+  version: "0.4.39",
   description: "Mr. Manager - Task and project management CLI",
   bin: {
     mr: "./dist/index.mjs"
@@ -551,7 +551,7 @@ import { Command as Command9 } 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, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync5, readdirSync, unlinkSync, existsSync as existsSync7, statSync, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, rmdirSync } from "fs";
 import * as readline from "readline";
 
 // lib/test-runner.ts
@@ -1869,20 +1869,40 @@ function buildPrototypeSection(protoRefs, workingDir) {
   }
   return sections.join("\n");
 }
-function buildSkillsSection(skillRefs) {
+function buildSkillsSection(skillRefs, taskId) {
   if (skillRefs.length === 0) return "";
   const sections = skillRefs.map(
-    (ref) => `### ${ref.skill.name}
+    (ref) => `### ${ref.skill.name}  
+*(skill id: \`${ref.skill.id}\`)*
 
 ${ref.skill.content}`
   );
+  const proposalTitleExample = skillRefs[0]?.skill.name ? `Skill Improvement \u2014 ${skillRefs[0].skill.name}` : `Skill Improvement \u2014 <skill name>`;
   return [
     ``,
     `## Attached Skills / Playbooks`,
     ``,
     `The following playbooks describe tools, workflows, and key considerations for this type of work. Use them as contextual guidance \u2014 adapt to the specific task rather than following rigidly.`,
     ``,
-    sections.join("\n\n---\n\n")
+    sections.join("\n\n---\n\n"),
+    ``,
+    `---`,
+    ``,
+    `### Improving These Skills`,
+    ``,
+    `As you use these skills, pay attention to gaps and rough edges: missing steps, stale commands, unclear guidance, or anything you had to figure out yourself that the skill should have told you. Capture those observations while the work is fresh.`,
+    ``,
+    `When you finish the task, decide per skill:`,
+    ``,
+    `- **Minor, clearly-correct improvements** (fixing a stale command, adding a missing step you just verified, clarifying wording): apply them directly with`,
+    `  \`mr skill update <skill-id> --file /tmp/skill-<name>.md\``,
+    `  The previous content is automatically saved as a revision, so the edit is reversible. Write the full updated markdown to the file first; the command replaces the skill content wholesale.`,
+    `- **Larger rewrites, judgment calls, or anything you're unsure about**: propose the change for human review by attaching a note resource to this task instead of editing the skill:`,
+    `  \`mr update ${taskId ?? "<task-id>"} --resource note "${proposalTitleExample}" '<markdown describing the proposed change, the skill id, and why>'\``,
+    `  Include the target skill id, a concise diff or replacement block, and the reasoning so the user can review and apply it.`,
+    ``,
+    `If the attached skills are already accurate and complete for this task, do nothing \u2014 do not invent improvements for the sake of it.`,
+    ``
   ].join("\n");
 }
 function buildResourcesSection(resources) {
@@ -1990,12 +2010,25 @@ ${task.notes}` : "";
     ``,
     `## Subtasks`,
     ``,
-    `The following subtasks need to be completed. As you finish each one, mark it done by running:`,
+    `The following subtasks have already been planned for this task. Work through them in order, and as you finish each one mark it done by running:`,
     `\`mr subtask-complete ${task.id} <subtask-id>\``,
     ``,
     ...pendingSubtasks.map((s) => `- [ ] ${s.title}  (id: ${s.id})`),
+    ``,
+    `If you discover additional steps along the way, add them with \`mr subtask-add ${task.id} "<short title>"\` so progress stays visible in the UI.`,
+    ``
+  ].join("\n") : [
+    ``,
+    `## Subtasks (you create these)`,
+    ``,
+    `This task has no subtasks yet. Before you start implementing, break the work into a short ordered checklist and create one subtask per step so progress is visible in the UI as you go.`,
+    ``,
+    `- Add each step with: \`mr subtask-add ${task.id} "<short imperative title>"\``,
+    `- Aim for roughly 3\u20137 subtasks. Each should be a concrete unit of work (e.g. "Add API endpoint for X", "Wire up UI button", "Write migration"), not a vague phase.`,
+    `- After creating each subtask the command prints its id. As you finish each step, mark it done immediately with \`mr subtask-complete ${task.id} <subtask-id>\` before moving on.`,
+    `- If new work surfaces mid-task, add another subtask rather than silently expanding scope.`,
     ``
-  ].join("\n") : "";
+  ].join("\n");
   const hasFeedback = feedbackUpdates.length > 0;
   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}`;
@@ -2009,7 +2042,7 @@ ${task.notes}` : "";
     subtaskSection,
     buildResourcesSection(existingResources),
     buildPrototypeSection(protoRefs, workingDir),
-    buildSkillsSection(skillRefs),
+    buildSkillsSection(skillRefs, task.id),
     buildFeedbackSection(feedbackUpdates),
     `## Instructions`,
     ``,
@@ -2045,7 +2078,9 @@ ${task.notes}` : "";
     `   - If you do significant research or investigation, save your findings as a resource using: \`mr update ${task.id} --resource research "Research \u2014 <short title>" '<markdown content>'\``,
     ...pendingSubtasks.length > 0 ? [
       `   - Work through each subtask in order. After completing each subtask, immediately run \`mr subtask-complete ${task.id} <subtask-id>\` to mark it done before moving on.`
-    ] : [],
+    ] : [
+      `   - Before writing code, create your subtask checklist (see the Subtasks section above) so the user can see your plan. Then work through each subtask in order, running \`mr subtask-complete ${task.id} <subtask-id>\` as soon as each one is done.`
+    ],
     ``,
     `4. Once implementation is complete, for each repo that has changes:`,
     `   a. Commit all changes with a clear, descriptive message.`,
@@ -2243,82 +2278,176 @@ ${initPrompt}`] : [],
     `Exit with code 0 when done (success or failure \u2014 do not retry indefinitely).`
   ].join("\n");
 }
-function buildPrototypePrompt(proto, repoDir) {
+function describeVariance(variance) {
+  if (variance <= 15) {
+    return {
+      label: "Very Similar",
+      summary: "All variants should feel like members of the same product family. Think of these as A/B tweaks of a single design \u2014 same overall layout, same type system, same general palette.",
+      perVariantDirective: "Keep the same overall layout, type system, and palette as the other variants. Vary only subtle details (spacing, micro-copy, accent color shade, button style, minor component swaps).",
+      axes: [
+        "- **What to vary**: spacing, accent color shade, button shape/weight, icon set, micro-copy",
+        "- **What to keep the same**: overall layout, typography scale, information architecture, core palette"
+      ]
+    };
+  }
+  if (variance <= 40) {
+    return {
+      label: "Slight Variation",
+      summary: "Variants share the same overall direction but try different compositions and palettes. Same product personality, different executions.",
+      perVariantDirective: "Keep the same general product personality and information architecture as the other variants, but change the composition, palette, and typography choices.",
+      axes: [
+        "- **What to vary**: layout composition, palette, typography pairing, component styling, density",
+        "- **What to keep the same**: product personality, information architecture, tone"
+      ]
+    };
+  }
+  if (variance <= 70) {
+    return {
+      label: "Clearly Different",
+      summary: "Each variant should feel like a distinct design direction. Different layouts, different palettes, different personalities \u2014 but all reasonable interpretations of the user's prompt.",
+      perVariantDirective: "Pick a meaningfully different design direction from the other variants \u2014 different layout, different palette, different typographic voice, different overall personality.",
+      axes: [
+        "- **Layout**: genuinely different structural choices (grid vs. asymmetric vs. single-column vs. split-pane, etc.)",
+        "- **Palette & mood**: distinct color stories and emotional tones",
+        "- **Typography**: different type pairings and hierarchies",
+        "- **Personality**: different audiences / brand voices can be implied"
+      ]
+    };
+  }
+  return {
+    label: "Drastically Different",
+    summary: "Push the variants as far apart as possible. Each one should feel like it came from a different designer with a different brief \u2014 radically different layouts, aesthetics, and interaction models. The only thing they share is fulfilling the user's core request.",
+    perVariantDirective: "Deliberately choose a radically different aesthetic, layout, and interaction model from the other variants. Each variant should feel like it belongs to a different product universe.",
+    axes: [
+      "- **Layout**: invent a structurally distinct approach for each variant",
+      "- **Aesthetic direction**: each variant should commit to a different visual identity (no two variants should feel related)",
+      "- **Interaction model**: vary scroll vs. click vs. hover-driven experiences",
+      "- **Information density**: span from sparse/editorial to dense/utilitarian",
+      "- **Personality**: target different audiences and moods across variants"
+    ]
+  };
+}
+function buildPrototypePrompt(proto, repoDir, options = {}) {
   const prototypeType = proto.prototypeType ?? "web_app";
+  const variantsToProduce = options.variantsToProduce ?? proto.variantCount;
+  const startIndex = options.variantStartIndex ?? 1;
+  const variance = typeof proto.designVariance === "number" ? proto.designVariance : 70;
+  const varianceInfo = describeVariance(variance);
   const variantSteps = [];
-  for (let i = 1; i <= proto.variantCount; i++) {
-    const filename = `prototype-${i}.html`;
+  for (let i = 0; i < variantsToProduce; i++) {
+    const idx = startIndex + i;
+    const filename = `prototype-${idx}.html`;
     variantSteps.push(
-      `### Variant ${i} of ${proto.variantCount}: ${filename}`,
-      `1. Design variant ${i} with a unique creative direction \u2014 different layout, color scheme, typography, and visual style from the other variants.`,
-      `2. Write the complete self-contained HTML to \`${repoDir}/${filename}\` using the Write tool.`,
-      `3. Verify the file was created by reading the first few lines of \`${repoDir}/${filename}\`.`,
+      `### Variant ${idx}: ${filename}`,
+      `1. ${varianceInfo.perVariantDirective}`,
+      `2. Spend a moment composing a real, opinionated design before you start typing HTML. Imagine the screen on Dribbble or in a Linear / Stripe / Vercel / Arc / Things-style portfolio.`,
+      `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}\`.`,
       ``
     );
   }
-  const variantList = Array.from({ length: proto.variantCount }, (_, i) => `prototype-${i + 1}.html`);
+  const variantList = Array.from(
+    { length: variantsToProduce },
+    (_, i) => `prototype-${startIndex + i}.html`
+  );
+  const sharedQualityBar = [
+    `## Craft & Polish Bar (this is the most important section \u2014 read carefully)`,
+    ``,
+    `These are PORTFOLIO-QUALITY prototypes, not throwaway sketches. The reviewer will judge them at a glance against work from Linear, Vercel, Stripe, Arc, Things, Things 3, Notion, Figma, Apple, Cron, Raycast, Superhuman, and indie SaaS that wins design awards. Your output must look like it belongs in that company.`,
+    ``,
+    `**Composition & layout**`,
+    `- Use a real grid with intentional spacing (multiples of 4 or 8). No cramped or arbitrary padding.`,
+    `- Establish clear hierarchy: 1 hero element, 2-3 supporting beats, ample negative space. Most variants should breathe.`,
+    `- Avoid the "centered hero + three feature cards" clich\xE9 unless you have a specific reason. Push for unexpected compositions: asymmetric splits, bento grids, editorial column layouts, full-bleed media, sticky-side panels, diagonal layouts, magazine-style pull quotes.`,
+    `- Consider "uncommon" navigation: side-scrolling, vertical headers, command-palette-first interfaces, or minimalist "zen" modes.`,
+    ``,
+    `**Typography**`,
+    `- Pair a real display face with a clean text face. Pull from Google Fonts via \`<link>\` (Inter, Geist, Space Grotesk, Instrument Serif, Fraunces, S\xF6hne-style fallbacks, JetBrains Mono, IBM Plex, Manrope, DM Sans, Playfair Display, Caladea, Bricolage Grotesque). Tailwind CDN does NOT ship custom fonts \u2014 link them yourself.`,
+    `- Use real type scales (e.g. 12 / 14 / 16 / 20 / 28 / 40 / 64). Tighten tracking on display sizes (-0.02em to -0.05em). Use weight contrast (300 vs 600), not just size.`,
+    `- Pay attention to line-height (1.5-1.6 for body, 1.1-1.2 for headers).`,
+    ``,
+    `**Color & material**`,
+    `- Pick a deliberate palette per variant. Avoid default Tailwind blue-500 / gray-900 unless that IS the design intent. Mix off-whites (#F9F9F9), warm neutrals, deep ink colors (#0A0A0B), accent pops, gradients, noise textures.`,
+    `- Use depth: soft shadows (e.g. \`0 10px 30px rgba(0,0,0,0.05)\`), subtle borders (1px @ low opacity), inner glows, glassmorphism (backdrop-blur), grain overlays, or mesh gradients. No flat-default look unless that's the chosen aesthetic.`,
+    `- Use "subtle motion" even in static colors: very soft gradients that feel like lighting, not just a color ramp.`,
+    ``,
+    `**Content (this is where most prototypes fail)**`,
+    `- Write specific, believable microcopy. NO "Lorem ipsum". NO "Feature One / Feature Two / Feature Three". NO placeholder names like "John Doe" or "Acme Inc."`,
+    `- Invent realistic product copy, sample data, names, dates, numbers, statuses, and supporting metadata that match the prompt's domain.`,
+    `- Populate lists, tables, and feeds with at least 6-12 distinct entries \u2014 empty-looking UIs feel fake.`,
+    ``,
+    `**Visual richness**`,
+    `- Include real iconography: prefer inline SVG icons (Lucide, Heroicons, Phosphor \u2014 copy paths inline). Don't stub with emoji unless the design language calls for it.`,
+    `- Use inline SVG illustrations, charts, sparklines, avatars (initials in colored circles, NOT broken \`<img>\` tags), badges, and status pills where they earn their place.`,
+    `- Any \`<img>\` you include MUST resolve. Use \`https://images.unsplash.com/photo-...\` URLs you actually know exist, or replace with SVG. NEVER use \`/path/to/image.jpg\` or other broken paths.`,
+    ``,
+    `**Motion & interaction**`,
+    `- Add tasteful CSS transitions on hover/focus (0.2s ease-out), subtle entrance animations (fade-in + slide-up), and at least one delightful detail per variant (animated gradient, hover lift, marquee, count-up, stagger animation). Keep it polished, not gimmicky.`,
+    `- Use \`@keyframes\` for sophisticated micro-interactions: a button that "pulses" slightly when hovered, or a sidebar that slides in with a spring-like feel (cubic-bezier).`,
+    ``,
+    `**Code hygiene**`,
+    `- Tailwind CDN is acceptable as the utility layer, but custom CSS in a \`<style>\` block is encouraged for the parts that make the design feel bespoke (custom fonts, gradients, keyframes, grain, etc.).`,
+    `- Keep markup semantic. Use real \`<header>\`, \`<nav>\`, \`<main>\`, \`<section>\`, \`<aside>\`, \`<footer>\` where they apply.`
+  ];
   const typeConfig = {
     web_app: {
-      role: "You are a UI designer and frontend engineer. Your job is to generate high-quality, visually distinct web app prototype variants based on the user's design request.",
+      role: "You are a senior product designer at a top-tier design-led startup, comfortable in Figma and shipping production HTML/CSS. You design at the level of Linear, Vercel, Stripe, and Arc.",
       guidelines: [
-        `- **Layout**: Grid, list, card, single-page, multi-section`,
-        `- **Style**: Minimal, bold, playful, corporate, retro, futuristic`,
-        `- **Color scheme**: Light, dark, colorful, monochrome`,
-        `- **Interaction model**: Click-heavy, scroll-based, hover effects, animated`,
-        `- **Information density**: Sparse, balanced, dense`,
-        `- **Navigation**: Sidebar, top nav, bottom nav, hamburger, tabs`
+        `- **Layout DNA**: bento grid, editorial split, command-bar driven, three-pane mail-style, dashboard with sidebar + canvas, marketing landing with pinned hero, terminal/CLI-inspired, doc-style long-form.`,
+        `- **Aesthetic**: Swiss minimal, brutalist editorial, glassmorphism, neumorphic, retro 90s web revival, hand-drawn / sketchy, dark IDE, pastel friendly, monochrome high-contrast, neo-skeuomorphic, "soft-ui" with deep shadows.`,
+        `- **Color story**: warm-cream + ink, deep navy + electric accent, off-white + serif + warm yellow, bold gradient + frosted glass, ultra-mono with one neon accent, earthy clay tones.`,
+        `- **Interaction language**: hover-rich with micro-animations, scroll-driven storytelling, command-palette first, keyboard-shortcut overlay, drag-and-drop canvas, interactive data-viz.`,
+        `- **Density**: from "Apple marketing whitespace" to "Bloomberg Terminal density" \u2014 push to opposite ends across variants.`,
+        `- **Navigation**: floating dock, hidden sidebar that appears on hover, multi-tab workspace, breadcrumb-driven, tabbed canvas, kbar, persistent footer chrome, minimalist hamburger with full-screen menu.`
       ],
       rules: [
-        `- Each file must be a complete, functional page \u2014 pure HTML/CSS/JS, no external libraries (Tailwind CDN is acceptable).`
+        `- Each file is a complete self-contained HTML page. Tailwind CDN allowed; you may also include Google Fonts via \`<link>\` and inline SVG.`
       ]
     },
     mobile_app: {
-      role: "You are a mobile UI designer and frontend engineer. Your job is to generate high-quality, visually distinct mobile app prototype variants based on the user's design request.",
+      role: "You are a senior mobile product designer who ships work that gets shared on Mobbin and Designspiration. You think in Apple HIG and Material 3 fluently and break the rules where it earns the design.",
       guidelines: [
-        `- **Viewport**: Use a mobile viewport (375px wide max, 812px tall). Center the phone frame on a neutral background.`,
-        `- **Layout**: Bottom tabs, stack navigation, cards, lists, full-screen views`,
-        `- **Style**: iOS-inspired, Material Design, custom/brand-driven, minimal`,
-        `- **Color scheme**: Light mode, dark mode, brand-colored`,
-        `- **Touch patterns**: Large tap targets (44px+), swipe gestures indicated, thumb-friendly navigation`,
-        `- **Typography**: Mobile-scale fonts (14-18px body), clear hierarchy`,
-        `- **Navigation**: Bottom tab bar, top navigation bar, hamburger drawer, floating action button`
+        `- **Frame**: Center a 375\xD7812 phone-sized canvas on a moody background (gradient, noisy off-white, soft tinted blur). Add a notch / Dynamic Island, status bar (time, signal, battery), and home indicator. Treat the surrounding canvas like a Dribbble shot \u2014 make IT feel designed too.`,
+        `- **Layout DNA**: bottom tabs with floating action, list-detail with sticky header, card-stack swipe, full-bleed feed, modal sheet over content, native iOS settings-style grouped lists, Spotify-style hero + scroll, Things 3-style focused single column, circular "control wheel" UI.`,
+        `- **Aesthetic**: glassy iOS, Material You expressive color, dark OLED app, soft pastel friendly, tactile retro, neo-skeuomorphic, Linear/Things minimal, brand-led editorial, "depth-first" with stacked cards.`,
+        `- **Touch & motion**: large tap targets (44px+), suggested swipe affordances, sheet pull handles, tab bar with bouncy active indicator, haptic-feel hover transforms, page-turn transitions.`,
+        `- **Typography**: SF Pro / Inter / Geist via Google Fonts; clear scale (11/13/15/17/22/28/34); use weight contrast.`
       ],
       rules: [
-        `- Render the app as a phone-sized frame (375\xD7812px) centered on a light gray page background.`,
-        `- Use a \`<meta name="viewport" content="width=375">\` tag.`,
-        `- Each file must be a complete, functional HTML page \u2014 pure HTML/CSS/JS, no external libraries (Tailwind CDN is acceptable).`
+        `- Render the app as a 375\xD7812 device frame centered on a designed background canvas (NOT plain white).`,
+        `- Use \`<meta name="viewport" content="width=device-width, initial-scale=1">\`. Inside, render the phone as a fixed-size container with realistic device chrome (notch, status bar, home indicator).`,
+        `- Each file is a complete self-contained HTML page. Tailwind CDN + Google Fonts via \`<link>\` allowed.`
       ]
     },
     desktop_app: {
-      role: "You are a desktop UI designer and frontend engineer. Your job is to generate high-quality, visually distinct desktop application prototype variants based on the user's design request.",
+      role: "You are a senior desktop product designer who has shipped work on Linear, Things 3, Cron, Raycast, Notion, and Arc. You design at the level of those apps and don't settle for generic.",
       guidelines: [
-        `- **Viewport**: Full-width desktop layout (1280px+). Use the full browser window.`,
-        `- **Layout**: Multi-panel, sidebar + main content, menubar, toolbar, status bar`,
-        `- **Style**: Native OS-inspired (macOS, Windows), Electron-style, productivity tool, pro/creative app`,
-        `- **Color scheme**: Light, dark, system-default`,
-        `- **Interaction**: Dense information layouts, keyboard shortcuts shown, right-click context menus, drag handles`,
-        `- **Navigation**: Left sidebar tree, top tabs, ribbon toolbar, split panes`
+        `- **Window chrome**: include realistic traffic-light controls or Windows controls, an integrated title bar, sidebar/main split, optional inspector pane.`,
+        `- **Layout DNA**: three-pane mail-style, sidebar + canvas + inspector, command-bar driven (kbar / Raycast), tabbed workspace, ribbon toolbar, split-pane editor, agenda + detail, "spatial" layout with floating windows.`,
+        `- **Aesthetic**: macOS-translucent / vibrancy, Linear ink-on-cream, Things 3 calm minimal, Arc playful, Raycast utilitarian, dark IDE, brand-led pro tool, "paper" aesthetic with textured backgrounds.`,
+        `- **Density**: from spacious / agenda-style to high-density data tables \u2014 push range across variants.`,
+        `- **Interaction**: keyboard shortcut hints visible (\`\u2318K\` style), right-click menus rendered open in some variants, drag handles, resize affordances, persistent status bar, "peek" previews on hover.`
       ],
       rules: [
-        `- Design for 1280px+ wide layouts. Use the full browser viewport width.`,
-        `- Each file must be a complete, functional HTML page \u2014 pure HTML/CSS/JS, no external libraries (Tailwind CDN is acceptable).`
+        `- Render a designed app window centered on a desktop-style background (subtle wallpaper / gradient / mesh). Window should feel like a screenshot, not a full-bleed page.`,
+        `- Each file is a complete self-contained HTML page. Tailwind CDN + Google Fonts via \`<link>\` allowed.`
       ]
     },
     logo: {
-      role: "You are a graphic designer specializing in logo and brand identity. Your job is to generate high-quality, visually distinct logo variants based on the user's brand brief.",
+      role: "You are a senior brand designer in the lineage of Pentagram, MetaLab, and Wolff Olins. Your logo work has been featured in Brand New and shows up on Awwwards-winning sites.",
       guidelines: [
-        `- **Style**: Wordmark, lettermark, icon + wordmark, abstract symbol, emblem/badge`,
-        `- **Visual language**: Minimal/geometric, organic/hand-drawn, bold/impactful, elegant/luxury, playful/friendly`,
-        `- **Color scheme**: Monochrome, duotone, full-color (max 3 colors), gradient`,
-        `- **Typography**: Serif, sans-serif, display/decorative, script`,
-        `- **Symbolism**: Use shapes, negative space, and iconography that reflect the brand concept`
+        `- **Logo type**: wordmark, lettermark, monogram, icon + wordmark, abstract symbol, emblem/badge, dynamic mark.`,
+        `- **Visual language**: geometric minimal, organic / hand-drawn, bold expressive, classical / serifed elegant, retro modernist, futuristic / tech, playful character.`,
+        `- **Color**: pure monochrome, duotone, restrained 3-color palette, gradient (used sparingly), warm-paper + ink.`,
+        `- **Typography**: pair the wordmark with a deliberate type choice \u2014 modernist sans, geometric grotesque, transitional serif, slab, display script.`,
+        `- **Symbolism**: use negative space, geometric primitives, ligatures, or conceptual marks that evoke the brand. No clip-art clich\xE9s.`
       ],
       rules: [
-        `- Each file is an HTML page that displays the logo centered on a white background with a dark mode toggle.`,
-        `- The logo itself MUST be created as inline SVG \u2014 no raster images, no external assets.`,
-        `- Show the logo at three sizes: large (400px wide), medium (200px), small (80px) stacked vertically.`,
-        `- Include a dark background preview section below the logo to test contrast.`,
-        `- The SVG must be clean and production-ready \u2014 no lorem ipsum, placeholder paths, or broken shapes.`
+        `- Each file is a single HTML page that presents the logo as a brand-system mini-showcase. Render it on a designed canvas, not a plain white box.`,
+        `- The mark itself MUST be inline SVG \u2014 no raster images, no broken \`<img>\` paths.`,
+        `- Show: (1) the primary mark large (~480px wide), (2) a wordmark / monogram lockup, (3) the mark at small sizes (200px and 64px), (4) a dark-background preview section showing the mark inverted, (5) a small color swatch row showing the palette.`,
+        `- Include a tiny "About this direction" caption (1-2 sentences) explaining the design rationale.`,
+        `- The SVG must be clean and production-ready \u2014 no placeholder paths, no broken shapes.`
       ]
     }
   };
@@ -2329,9 +2458,20 @@ function buildPrototypePrompt(proto, repoDir) {
     desktop_app: "Desktop App",
     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 creativeDirection = [
+    `## 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.`,
+    `- **Materiality**: Experiment with textures. Use a very subtle SVG grain filter on backgrounds. Use \`backdrop-filter: blur()\` for overlays. Use multiple layered box-shadows for a "diffused" light effect.`,
+    `- **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.`
+  ];
   return [
     `${config.role}`,
     ``,
+    agentNote,
+    ``,
     `Working directory: ${repoDir}`,
     ``,
     `## Prototype Request`,
@@ -2344,43 +2484,65 @@ function buildPrototypePrompt(proto, repoDir) {
     ``,
     `## Instructions`,
     ``,
-    `You MUST generate exactly ${proto.variantCount} separate HTML files. Follow the steps below IN ORDER. Do NOT skip any variant. Do NOT stop early. Complete every single variant before exiting.`,
+    `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.`,
     ``,
-    `Each file must be completely self-contained (inline all CSS and JS \u2014 no external dependencies). Tailwind CDN is acceptable.`,
+    ...sharedQualityBar,
+    ``,
+    ...creativeDirection,
+    ``,
+    `## Design Variance: ${varianceInfo.label} (${variance}/100)`,
+    ``,
+    varianceInfo.summary,
     ``,
-    `## Variation Guidelines`,
+    `Axes to vary across variants:`,
+    ...varianceInfo.axes,
+    ``,
+    `## Variation Levers (push these aggressively across variants, scaled by the variance level above)`,
     ``,
-    `When generating multiple variants, vary these aspects:`,
     ...config.guidelines,
     ``,
-    `Variants should demonstrate different interpretations, not just color swaps. Vary from very similar to wildly different approaches.`,
+    `## 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.`,
     ``,
     ...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} variants, list the files in ${repoDir} and confirm: ${variantList.join(", ")}. If any are missing or feel rushed, go back and redo them.`,
     ``,
     `IMPORTANT RULES:`,
-    `- You MUST produce exactly ${proto.variantCount} files: ${variantList.join(", ")}`,
+    `- You MUST produce exactly these files: ${variantList.join(", ")}`,
     `- Generate them ONE AT A TIME \u2014 design each variant, write the file, then move to the next.`,
-    `- Each variant must look visually DISTINCT from the others.`,
+    `- Respect the Design Variance level above \u2014 do not force drastic differences if the user asked for similar variants, and do not produce near-duplicates if they asked for drastic variance.`,
+    `- NO Lorem ipsum, NO "Feature One/Two/Three", NO broken \`<img>\` paths, NO empty-looking UIs.`,
     ...config.rules,
     `- 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} files have been written and verified.`
   ].join("\n");
 }
-function buildRefinementPrompt(proto, parentFiles, repoDir) {
+function buildRefinementPrompt(proto, parentFiles, repoDir, options = {}) {
+  const variantsToProduce = options.variantsToProduce ?? proto.variantCount;
+  const startIndex = options.variantStartIndex ?? 1;
+  const variance = typeof proto.designVariance === "number" ? proto.designVariance : 70;
+  const varianceInfo = describeVariance(variance);
   const variantSteps = [];
-  for (let i = 1; i <= proto.variantCount; i++) {
-    const filename = `prototype-${i}.html`;
+  for (let i = 0; i < variantsToProduce; i++) {
+    const idx = startIndex + i;
+    const filename = `prototype-${idx}.html`;
     variantSteps.push(
-      `### Variant ${i} of ${proto.variantCount}: ${filename}`,
-      `1. Redesign variant ${i} based on the feedback below, while maintaining the core concept.`,
-      `2. Write the complete self-contained HTML to \`${repoDir}/${filename}\` using the Write tool.`,
-      `3. Verify the file was created by reading the first few lines of \`${repoDir}/${filename}\`.`,
+      `### 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.`,
+      `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}\`.`,
       ``
     );
   }
-  const variantList = Array.from({ length: proto.variantCount }, (_, i) => `prototype-${i + 1}.html`);
+  const variantList = Array.from(
+    { length: variantsToProduce },
+    (_, i) => `prototype-${startIndex + i}.html`
+  );
   const existingVariantLines = [];
   for (let i = 0; i < parentFiles.length; i++) {
     const f = parentFiles[i];
@@ -2434,7 +2596,16 @@ function buildRefinementPrompt(proto, parentFiles, repoDir) {
     ``,
     `You MUST generate exactly ${proto.variantCount} REFINED HTML files 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. Each variant should still be visually distinct from the others.`,
+    `Study the previous variants carefully, then apply the user's feedback to improve them. Keep what works, change what the user asked to change.`,
+    ``,
+    `## 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.`,
     ``,
     `Each file must be completely self-contained (inline all CSS and JS \u2014 no external dependencies). Tailwind CDN is acceptable.`,
     ``,
@@ -2445,7 +2616,7 @@ function buildRefinementPrompt(proto, parentFiles, repoDir) {
     `IMPORTANT RULES:`,
     `- You MUST produce exactly ${proto.variantCount} files: ${variantList.join(", ")}`,
     `- Generate them ONE AT A TIME \u2014 design each variant, write the file, then move to the next.`,
-    `- Each variant must look visually DISTINCT from the others.`,
+    `- 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.`
@@ -3214,114 +3385,285 @@ var watchCommand = new Command9("watch").description(
       } catch {
       }
     }
-    let prompt2;
+    const validAgents = ["claude", "codex", "gemini"];
+    const requested = Array.isArray(proto.selectedAgents) ? proto.selectedAgents.filter(
+      (a) => validAgents.includes(a)
+    ) : [];
+    const dedupedRequested = Array.from(new Set(requested));
+    const key = `proto-${proto.id}`;
+    let parentFiles = [];
     if (proto.parentId && proto.refinementFeedback) {
-      let parentFiles = [];
       try {
         const parent = await api.get(`/api/prototypes/${proto.parentId}`);
         parentFiles = parent.files ?? [];
       } catch (err) {
         logError(prefix, `Failed to fetch parent prototype: ${err.message}`);
       }
-      prompt2 = buildRefinementPrompt(proto, parentFiles, repoDir);
-    } else {
-      prompt2 = buildPrototypePrompt(proto, repoDir);
     }
-    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}`);
+    const buildPromptForSlice = (startIndex, variantsToProduce, agentLabel, sliceDir) => {
+      if (proto.parentId && proto.refinementFeedback) {
+        return buildRefinementPrompt(proto, parentFiles, sliceDir, {
+          variantStartIndex: startIndex,
+          variantsToProduce,
+          agentLabel
+        });
+      }
+      return buildPrototypePrompt(proto, sliceDir, {
+        variantStartIndex: startIndex,
+        variantsToProduce,
+        agentLabel
+      });
+    };
+    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}`);
+        await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" }).catch(() => {
+        });
+        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")
+                }));
+                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 {
+                  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 {
+            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;
+    }
+    if (slices.length === 0) {
+      logError(prefix, `Could not assign any variants to selected agents`);
       await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" }).catch(() => {
       });
       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()
+      lastActivityAt: Date.now(),
+      outputBytes: 0
     };
-    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);
+    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);
+          let spawnFailureReason = null;
+          const child = spawnAgent(
+            slice.agentLabel,
+            slice.dir,
+            slicePrompt,
+            prefix,
+            void 0,
+            void 0,
+            `${proto.title} [${slice.agentLabel}]`,
+            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})`);
+            }
+            res({ agent: slice.agentLabel, ok, reason: spawnFailureReason });
+          });
+        });
+      })
+    );
+    if (active.get(key) === activeEntry) {
+      active.delete(key);
+    }
+    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 {
         }
-        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 prototype generation with ${nextAgent}`);
-            attemptIndex += 1;
-            await launchAttempt(nextAgent);
-            return;
+        for (const f of found) {
+          try {
+            const content = readFileSync5(resolve2(slice.dir, f), "utf-8");
+            collected.push({ name: f, content });
+          } catch (err) {
+            logError(prefix, `Failed reading ${f} from ${slice.dir}: ${err.message}`);
           }
         }
-        finishing.add(key);
+      }
+      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 });
+      }
+      const allOk = sliceResults.every((r) => r.ok);
+      if (finalFiles.length === 0) {
+        logError(prefix, `No prototype HTML files produced by any agent`);
+        await api.patch(`/api/prototypes/${proto.id}`, { status: "failed" });
+      } else {
+        await api.patch(`/api/prototypes/${proto.id}`, {
+          status: "completed",
+          files: finalFiles
+        });
+        if (allOk) {
+          logSuccess(prefix, `"${paint("bold", proto.title)}" uploaded ${finalFiles.length} file(s) from ${slices.length} agent(s)`);
+        } 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 {
-          if (code === 0) {
+          for (const f of readdirSync(slice.dir)) {
             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 {
-                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" });
+              unlinkSync(resolve2(slice.dir, f));
             } catch {
             }
           }
-        } finally {
-          queued.delete(key);
-          finishing.delete(key);
+          rmdirSync(slice.dir);
+        } catch {
         }
-      });
-    };
-    await launchAttempt(attemptOrder[attemptIndex]);
+      }
+    } catch (err) {
+      logError(prefix, `Failed to upload multi-agent prototype: ${err.message}`);
+      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);
@@ -3458,7 +3800,10 @@ var watchCommand = new Command9("watch").description(
   }
   function dispatchCodeReview(review, prefix, key) {
     logDispatch(prefix, `Running code review on branch ${paint("cyan", review.branch)}`);
-    const reviewProc = spawn4(process.execPath, [process.argv[1], "review", "--project", review.projectId, "--report", review.id, "--branch", review.branch, "--base", review.baseBranch], {
+    const reviewArgs = [process.argv[1], "review", "--project", review.projectId, "--report", review.id, "--branch", review.branch, "--base", review.baseBranch];
+    if (review.branchUrl) reviewArgs.push("--pr-url", review.branchUrl);
+    if (review.prNumber != null) reviewArgs.push("--pr-number", String(review.prNumber));
+    const reviewProc = spawn4(process.execPath, reviewArgs, {
       stdio: ["ignore", "pipe", "pipe"],
       cwd: rootDir
     });
@@ -4207,8 +4552,22 @@ var subtaskCompleteCommand = new Command13("subtask-complete").description("Mark
   console.log(`\u2713 Subtask completed: ${subtask.title}`);
 });
 
-// cli/commands/prototype.ts
+// cli/commands/subtask-add.ts
 import { Command as Command14 } from "commander";
+var subtaskAddCommand = new Command14("subtask-add").description("Add a subtask to a task (used by the agent to plan work as it starts)").argument("<task-id>", "Parent task ID").argument("<title...>", "Subtask title").action(async (taskId, titleParts) => {
+  const title = titleParts.join(" ").trim();
+  if (!title) {
+    console.error("Subtask title is required.");
+    process.exit(1);
+  }
+  const subtask = await api.post(`/api/tasks/${taskId}/subtasks`, {
+    title
+  });
+  console.log(`\u2713 Subtask added (${subtask.id}): ${subtask.title}`);
+});
+
+// cli/commands/prototype.ts
+import { Command as Command15 } from "commander";
 var c4 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -4237,8 +4596,8 @@ function statusBadge(status) {
       return paint4("gray", status);
   }
 }
-var prototypeCommand = new Command14("prototype").description("Manage prototypes").addCommand(
-  new Command14("list").description("List prototypes for the linked project").option("--all", "Show prototypes for all projects").action(async (opts) => {
+var prototypeCommand = new Command15("prototype").description("Manage prototypes").addCommand(
+  new Command15("list").description("List prototypes for the linked project").option("--all", "Show prototypes for all projects").action(async (opts) => {
     const params = new URLSearchParams();
     if (!opts.all) {
       const projectId = getLinkedProjectId();
@@ -4271,7 +4630,7 @@ var prototypeCommand = new Command14("prototype").description("Manage prototypes
     }
   })
 ).addCommand(
-  new Command14("create").description("Create a new prototype").argument("<title>", "Title of the prototype").requiredOption("--prompt <prompt>", "Design description / prompt").option("--project <projectId>", "Project ID (defaults to linked project, 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").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"];
@@ -4300,7 +4659,7 @@ var prototypeCommand = new Command14("prototype").description("Manage prototypes
     console.log();
   })
 ).addCommand(
-  new Command14("start").description("Start prototype generation (sets status to in_progress)").argument("<id>", "Prototype ID").action(async (id) => {
+  new Command15("start").description("Start prototype generation (sets status to in_progress)").argument("<id>", "Prototype ID").action(async (id) => {
     const prototype = await api.patch(`/api/prototypes/${id}`, {
       status: "in_progress"
     });
@@ -4310,7 +4669,7 @@ var prototypeCommand = new Command14("prototype").description("Manage prototypes
     console.log();
   })
 ).addCommand(
-  new Command14("retry").description("Retry a failed prototype").argument("<id>", "Prototype ID").action(async (id) => {
+  new Command15("retry").description("Retry a failed prototype").argument("<id>", "Prototype ID").action(async (id) => {
     const prototype = await api.patch(`/api/prototypes/${id}`, {
       status: "in_progress",
       files: null
@@ -4322,7 +4681,7 @@ var prototypeCommand = new Command14("prototype").description("Manage prototypes
 );
 
 // cli/commands/setup.ts
-import { Command as Command15 } from "commander";
+import { Command as Command16 } from "commander";
 import { exec as exec2 } from "child_process";
 var c5 = {
   reset: "\x1B[0m",
@@ -4625,7 +4984,7 @@ async function autoFix(checks, agent) {
     console.log("");
   }
 }
-var setupCommand = new Command15("setup").description("Check that all dependencies for mr watch are installed and configured").option("--fix", "Attempt to auto-fix issues where possible", false).option("--agent <agent>", "AI agent to check: claude, codex, or gemini (default: claude)", "claude").action(async (opts) => {
+var setupCommand = new Command16("setup").description("Check that all dependencies for mr watch are installed and configured").option("--fix", "Attempt to auto-fix issues where possible", false).option("--agent <agent>", "AI agent to check: claude, codex, or gemini (default: claude)", "claude").action(async (opts) => {
   const agent = opts.agent === "codex" ? "codex" : opts.agent === "gemini" ? "gemini" : "claude";
   const banner = [
     ``,
@@ -4675,8 +5034,8 @@ var setupCommand = new Command15("setup").description("Check that all dependenci
 });
 
 // cli/commands/update.ts
-import { Command as Command16 } from "commander";
-var updateCommand = new Command16("update").description("Post a status update to a task, or attach a resource").argument("<task-id>", "Task ID").argument("[message-or-title]", "Status update message, or resource title when using --resource").argument("[content]", "Resource content (only used with --resource)").option("--source <source>", "Update source: agent, system, or user", "agent").option("--resource <type>", "Create a task resource (e.g. test-plan, note, plan, research)").action(async (taskId, messageOrTitle, content, opts) => {
+import { Command as Command17 } from "commander";
+var updateCommand = new Command17("update").description("Post a status update to a task, or attach a resource").argument("<task-id>", "Task ID").argument("[message-or-title]", "Status update message, or resource title when using --resource").argument("[content]", "Resource content (only used with --resource)").option("--source <source>", "Update source: agent, system, or user", "agent").option("--resource <type>", "Create a task resource (e.g. test-plan, note, plan, research)").action(async (taskId, messageOrTitle, content, opts) => {
   if (opts.resource) {
     if (!messageOrTitle || !content) {
       console.error(`Usage: mr update <task-id> --resource <type> "<title>" '<content>'`);
@@ -4702,11 +5061,11 @@ var updateCommand = new Command16("update").description("Post a status update to
 });
 
 // cli/commands/screenshot.ts
-import { Command as Command17 } from "commander";
+import { Command as Command18 } from "commander";
 import { readFileSync as readFileSync6, existsSync as existsSync8, unlinkSync as unlinkSync2 } from "fs";
 import { join as join7 } from "path";
 import { tmpdir } from "os";
-var screenshotCommand = new Command17("screenshot").description(
+var screenshotCommand = new Command18("screenshot").description(
   "Take or attach a screenshot to a task update (agents use this to show their work)"
 ).argument("<task-id>", "Task ID").argument("[file]", "Path to an image file (if omitted, uses headless browser to screenshot the app)").option("-m, --message <message>", "Optional message to include with the screenshot").option("-u, --url <url>", "Custom URL to screenshot (defaults to the task's project page)").action(async (taskId, file, opts) => {
   let filePath = file;
@@ -4797,7 +5156,7 @@ var screenshotCommand = new Command17("screenshot").description(
 });
 
 // cli/commands/resume.ts
-import { Command as Command18 } from "commander";
+import { Command as Command19 } from "commander";
 import { spawn as spawn5 } from "child_process";
 import { resolve as resolve3 } from "path";
 var c6 = {
@@ -4814,7 +5173,7 @@ var c6 = {
 function paint6(color, text) {
   return `${c6[color]}${text}${c6.reset}`;
 }
-var resumeCommand = new Command18("resume").description("Resume an interactive Claude session for a task (non-headless)").argument("<task-id>", "Task ID whose Claude session to resume").option("--dir <directory>", "Override the working directory for the session").action(async (taskId, opts) => {
+var resumeCommand = new Command19("resume").description("Resume an interactive Claude session for a task (non-headless)").argument("<task-id>", "Task ID whose Claude session to resume").option("--dir <directory>", "Override the working directory for the session").action(async (taskId, opts) => {
   const task = await api.get(`/api/tasks/${taskId}`);
   if (!task.claudeSessionId) {
     console.error(
@@ -4883,7 +5242,7 @@ var resumeCommand = new Command18("resume").description("Resume an interactive C
 });
 
 // cli/commands/browse.ts
-import { Command as Command19 } from "commander";
+import { Command as Command20 } from "commander";
 import { execSync as execSync4, spawn as spawn6 } from "child_process";
 import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import { createHash } from "crypto";
@@ -4998,7 +5357,7 @@ async function ensureDevServer(options = {}) {
   }
   throw new Error(`Dev server failed to start within 60s. Command: ${devCmd} in ${projectCwd}`);
 }
-var browseCommand = new Command19("browse").description("Control a headless browser for QA and testing").argument("[command]", "Browse command (goto, click, fill, screenshot, etc.)").argument("[args...]", "Command arguments").option(
+var browseCommand = new Command20("browse").description("Control a headless browser for QA and testing").argument("[command]", "Browse command (goto, click, fill, screenshot, etc.)").argument("[args...]", "Command arguments").option(
   "--task-id <id>",
   "Attach output to a task update (for screenshot and recording-stop commands)"
 ).option("--dev", "Auto-start local dev server before browsing").option("--dev-cwd <path>", "Working directory for the dev server (defaults to mr-manager root)").option("--dev-cmd <command>", "Dev server command to run (auto-detected from package.json if omitted)").option("--dev-port-flag <flag>", "CLI flag name used to set port (e.g. --port). Omit to use PORT env var.").allowUnknownOption(true).action(
@@ -5141,10 +5500,10 @@ var browseCommand = new Command19("browse").description("Control a headless brow
 );
 
 // cli/commands/set-path.ts
-import { Command as Command20 } from "commander";
+import { Command as Command21 } from "commander";
 import { resolve as resolve5 } from "path";
 import { existsSync as existsSync10 } from "fs";
-var setPathCommand = new Command20("set-path").description("Set or update the local repo path for a project").argument("<project-id>", "Project ID").argument("<path>", "Absolute or relative path to the local repo").action(async (projectId, pathArg) => {
+var setPathCommand = new Command21("set-path").description("Set or update the local repo path for a project").argument("<project-id>", "Project ID").argument("<path>", "Absolute or relative path to the local repo").action(async (projectId, pathArg) => {
   const absolutePath = resolve5(pathArg);
   if (!existsSync10(absolutePath)) {
     console.error(`Error: Path does not exist: ${absolutePath}`);
@@ -5162,9 +5521,9 @@ var setPathCommand = new Command20("set-path").description("Set or update the lo
 });
 
 // cli/commands/test.ts
-import { Command as Command21 } from "commander";
+import { Command as Command22 } from "commander";
 import { readFileSync as readFileSync8, existsSync as existsSync11 } from "fs";
-var testCommand = new Command21("test").description("Run automated browser test for a task's MR/PR").argument("<task-id>", "Task ID to test").option("--plan <file>", "Path to a custom test plan JSON file").option("--no-recording", "Disable proof recording for this run").action(async (taskId, opts) => {
+var testCommand = new Command22("test").description("Run automated browser test for a task's MR/PR").argument("<task-id>", "Task ID to test").option("--plan <file>", "Path to a custom test plan JSON file").option("--no-recording", "Disable proof recording for this run").action(async (taskId, opts) => {
   const config = loadConfig();
   console.log("[test] Fetching task...");
   let task;
@@ -5326,7 +5685,7 @@ var testCommand = new Command21("test").description("Run automated browser test
 });
 
 // cli/commands/features.ts
-import { Command as Command22 } from "commander";
+import { Command as Command23 } from "commander";
 import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync12 } from "fs";
 import { resolve as resolve6, sep as sep2 } from "path";
 var FEATURES_FILE3 = ".mr-features.md";
@@ -5360,7 +5719,7 @@ function readFeatures2() {
   if (!existsSync12(path)) return null;
   return readFileSync9(path, "utf-8");
 }
-var featuresCommand = new Command22("features").description("View or update the project features & goals document (.mr-features.md)").option("--update <content>", "Replace the features document with the given content").option("--file <path>", "Read content from a file and use it to update the features document").option("--path", "Print the path to the features file").action(async (opts) => {
+var featuresCommand = new Command23("features").description("View or update the project features & goals document (.mr-features.md)").option("--update <content>", "Replace the features document with the given content").option("--file <path>", "Read content from a file and use it to update the features document").option("--path", "Print the path to the features file").action(async (opts) => {
   if (opts.path) {
     console.log(getFeaturesPath());
     return;
@@ -5388,11 +5747,11 @@ var featuresCommand = new Command22("features").description("View or update the
 });
 
 // cli/commands/no-mr.ts
-import { Command as Command23 } from "commander";
+import { Command as Command24 } from "commander";
 import { writeFileSync as writeFileSync6 } from "fs";
 import { resolve as resolve7 } from "path";
 var NO_MR_FILE = ".mr-no-mr";
-var noMrCommand = new Command23("no-mr").description("Signal that a task does not require a merge/pull request and describe what was done instead").argument("<task-id>", "Task ID").argument("<description>", "Description of what was done instead of creating an MR/PR").action(async (taskId, description) => {
+var noMrCommand = new Command24("no-mr").description("Signal that a task does not require a merge/pull request and describe what was done instead").argument("<task-id>", "Task ID").argument("<description>", "Description of what was done instead of creating an MR/PR").action(async (taskId, description) => {
   const filePath = resolve7(process.cwd(), NO_MR_FILE);
   writeFileSync6(filePath, description, "utf-8");
   await api.post(`/api/tasks/${taskId}/updates`, {
@@ -5404,7 +5763,7 @@ var noMrCommand = new Command23("no-mr").description("Signal that a task does no
 });
 
 // cli/commands/review.ts
-import { Command as Command24 } from "commander";
+import { Command as Command25 } from "commander";
 import { spawn as spawn7, execSync as execSync5 } from "child_process";
 import { existsSync as existsSync13, statSync as statSync2 } from "fs";
 var c8 = {
@@ -5437,7 +5796,7 @@ function logOk(msg) {
 function logErr(msg) {
   console.error(`${timestamp2()} ${tag()} ${paint8("red", "\u2717")} ${msg}`);
 }
-var reviewCommand = new Command24("review").description("Run an automated code review on a branch").option("--project <id>", "Project ID (defaults to linked project)").option("--report <id>", "Use an existing review report ID (created by UI trigger)").option("--branch <name>", "Branch to review (defaults to current branch)").option("--base <name>", "Base branch to diff against (defaults to main)").action(async (opts) => {
+var reviewCommand = new Command25("review").description("Run an automated code review on a branch").option("--project <id>", "Project ID (defaults to linked project)").option("--report <id>", "Use an existing review report ID (created by UI trigger)").option("--branch <name>", "Branch to review (defaults to current branch)").option("--base <name>", "Base branch to diff against (defaults to main)").option("--pr-url <url>", "Pull/merge request URL; when set, diff is fetched via gh/glab and no local checkout is needed").option("--pr-number <n>", "Pull/merge request number (used with --pr-url)").action(async (opts) => {
   const config = loadConfig();
   if (!config.apiKey) {
     logErr('Not authenticated. Run "mr login" first.');
@@ -5465,100 +5824,102 @@ var reviewCommand = new Command24("review").description("Run an automated code r
     logErr(`Failed to fetch project ${projectId}`);
     process.exit(1);
   }
-  const candidates = [];
-  if (project.localPath) candidates.push({ path: project.localPath, source: "project.localPath" });
-  for (const [dir, pid] of Object.entries(config.directories)) {
-    if (pid === projectId) candidates.push({ path: dir, source: "linked directory" });
-  }
-  candidates.push({ path: process.cwd(), source: "cwd" });
-  let projectPath;
-  let pathSource = "";
-  const triedPaths = [];
-  for (const { path, source } of candidates) {
-    if (existsSync13(path)) {
-      projectPath = path;
-      pathSource = source;
-      break;
+  const baseBranch = opts.base || "main";
+  const prUrl = opts.prUrl;
+  const prNumberRaw = opts.prNumber;
+  const prNumber = prNumberRaw ? Number(prNumberRaw) : void 0;
+  const remote = prUrl ? parsePrUrl(prUrl) : null;
+  const canUseRemote = remote !== null && (prNumber || remote.number) !== void 0;
+  let diff;
+  let branch = opts.branch;
+  if (canUseRemote && remote) {
+    const num = prNumber ?? remote.number;
+    if (!num) {
+      logErr(`Could not determine PR number from URL: ${prUrl}`);
+      process.exit(1);
     }
-    triedPaths.push(`${path} (${source})`);
-  }
-  if (!projectPath) {
-    logErr(`No valid project path found. Tried:`);
-    for (const p of triedPaths) logErr(`  - ${p}`);
-    logErr(`Run "mr link" from the correct directory, or update the project's localPath.`);
-    process.exit(1);
-  }
-  if (triedPaths.length > 0) {
-    log(paint8("yellow", `Skipped stale path(s): ${triedPaths.join(", ")}`));
-    log(`Falling back to ${pathSource}`);
-  }
-  try {
-    if (!statSync2(projectPath).isDirectory()) {
-      logErr(`Project path is not a directory: ${projectPath}`);
+    log(`Fetching diff from ${paint8("cyan", remote.host)} for ${paint8("yellow", `#${num}`)} in ${paint8("dim", `${remote.owner}/${remote.repo}`)}`);
+    try {
+      diff = fetchRemoteDiff(remote, num);
+    } catch (err) {
+      logErr(`Failed to fetch diff from ${remote.host}: ${err.message}`);
+      logErr(`Ensure ${remote.host === "github" ? "`gh`" : "`glab`"} is installed and authenticated.`);
+      process.exit(1);
+    }
+    if (!branch) branch = `pr-${num}`;
+    log(`Reviewing PR ${paint8("cyan", `#${num}`)} against ${paint8("dim", baseBranch)}`);
+  } else {
+    let projectPath = project.localPath;
+    if (!projectPath) {
+      for (const [dir, pid] of Object.entries(config.directories)) {
+        if (pid === projectId) {
+          projectPath = dir;
+          break;
+        }
+      }
+    }
+    if (!projectPath) {
+      projectPath = process.cwd();
+    }
+    if (!existsSync13(projectPath)) {
+      logErr(`Project path does not exist: ${projectPath}`);
+      logErr(`Update the project's localPath, attach a PR URL to the review, or run "mr link" from the correct directory.`);
       process.exit(1);
     }
-  } catch (err) {
-    logErr(`Cannot stat project path ${projectPath}: ${err.message}`);
-    process.exit(1);
-  }
-  if (!existsSync13(`${projectPath}/.git`)) {
-    logErr(`Project path is not a git repository: ${projectPath}`);
-    logErr(`Update the project's localPath to point to the local checkout.`);
-    process.exit(1);
-  }
-  log(`Using project path: ${paint8("dim", projectPath)}`);
-  let branch = opts.branch;
-  if (!branch) {
     try {
-      branch = execSync5("git rev-parse --abbrev-ref HEAD", {
-        cwd: projectPath,
-        encoding: "utf-8"
-      }).trim();
-    } catch {
-      logErr("Could not determine current branch. Pass --branch <name>.");
+      if (!statSync2(projectPath).isDirectory()) {
+        logErr(`Project path is not a directory: ${projectPath}`);
+        process.exit(1);
+      }
+    } catch (err) {
+      logErr(`Cannot stat project path ${projectPath}: ${err.message}`);
       process.exit(1);
     }
-  }
-  const baseBranch = opts.base || "main";
-  log(`Reviewing branch: ${paint8("cyan", branch)} against ${paint8("dim", baseBranch)}`);
-  log(`Project: ${paint8("cyan", project.name)}`);
-  let diff;
-  try {
-    diff = execSync5(`git diff ${baseBranch}...${branch} -- . ':!*.lock' ':!package-lock.json' ':!pnpm-lock.yaml'`, {
-      cwd: projectPath,
-      encoding: "utf-8",
-      maxBuffer: 10 * 1024 * 1024
-    }).trim();
-  } catch (err) {
+    if (!existsSync13(`${projectPath}/.git`)) {
+      logErr(`Project path is not a git repository: ${projectPath}`);
+      logErr(`Update the project's localPath to point to the local checkout, or attach a PR URL to the review.`);
+      process.exit(1);
+    }
+    log(`Using project path: ${paint8("dim", projectPath)}`);
+    if (!branch) {
+      try {
+        branch = execSync5("git rev-parse --abbrev-ref HEAD", {
+          cwd: projectPath,
+          encoding: "utf-8"
+        }).trim();
+      } catch {
+        logErr("Could not determine current branch. Pass --branch <name>.");
+        process.exit(1);
+      }
+    }
+    log(`Reviewing branch: ${paint8("cyan", branch)} against ${paint8("dim", baseBranch)}`);
     try {
-      execSync5(`git fetch origin ${baseBranch}`, { cwd: projectPath, encoding: "utf-8", stdio: "pipe" });
-      diff = execSync5(`git diff origin/${baseBranch}...${branch} -- . ':!*.lock' ':!package-lock.json' ':!pnpm-lock.yaml'`, {
+      diff = execSync5(`git diff ${baseBranch}...${branch} -- . ':!*.lock' ':!package-lock.json' ':!pnpm-lock.yaml'`, {
         cwd: projectPath,
         encoding: "utf-8",
         maxBuffer: 10 * 1024 * 1024
       }).trim();
-    } catch {
-      logErr(`Failed to get diff between ${baseBranch} and ${branch}: ${err.message}`);
-      process.exit(1);
+    } catch (err) {
+      try {
+        execSync5(`git fetch origin ${baseBranch}`, { cwd: projectPath, encoding: "utf-8", stdio: "pipe" });
+        diff = execSync5(`git diff origin/${baseBranch}...${branch} -- . ':!*.lock' ':!package-lock.json' ':!pnpm-lock.yaml'`, {
+          cwd: projectPath,
+          encoding: "utf-8",
+          maxBuffer: 10 * 1024 * 1024
+        }).trim();
+      } catch {
+        logErr(`Failed to get diff between ${baseBranch} and ${branch}: ${err.message}`);
+        process.exit(1);
+      }
     }
   }
+  log(`Project: ${paint8("cyan", project.name)}`);
   if (!diff) {
     logOk("No changes found between branches. Nothing to review.");
     process.exit(0);
   }
-  const filesChanged = (() => {
-    try {
-      const stat = execSync5(`git diff --stat ${baseBranch}...${branch} -- . ':!*.lock' ':!package-lock.json' ':!pnpm-lock.yaml'`, {
-        cwd: projectPath,
-        encoding: "utf-8"
-      }).trim();
-      const lines = stat.split("\n");
-      return Math.max(0, lines.length - 1);
-    } catch {
-      const fileHeaders = diff.match(/^diff --git/gm);
-      return fileHeaders?.length ?? 0;
-    }
-  })();
+  diff = stripLockFileDiffs(diff);
+  const filesChanged = (diff.match(/^diff --git/gm) ?? []).length;
   log(`Diff size: ${paint8("yellow", `${diff.length.toLocaleString()} chars`)}, ${paint8("yellow", `${filesChanged} files`)}`);
   let reportId;
   if (opts.report) {
@@ -5645,6 +6006,54 @@ var reviewCommand = new Command24("review").description("Run an automated code r
     process.exit(1);
   }
 });
+function parsePrUrl(url) {
+  try {
+    const u = new URL(url);
+    const parts = u.pathname.replace(/^\/+|\/+$/g, "").split("/");
+    if (u.hostname === "github.com" || u.hostname.endsWith(".github.com")) {
+      const owner = parts[0];
+      const repo = parts[1];
+      const kind = parts[2];
+      const number = parts[3] ? Number(parts[3]) : void 0;
+      if (!owner || !repo || kind !== "pull") return null;
+      return { host: "github", owner, repo, number: Number.isFinite(number) ? number : void 0 };
+    }
+    const dashIdx = parts.indexOf("-");
+    if (dashIdx > 0 && parts[dashIdx + 1] === "merge_requests") {
+      const owner = parts.slice(0, dashIdx - 1).join("/");
+      const repo = parts[dashIdx - 1];
+      const number = parts[dashIdx + 2] ? Number(parts[dashIdx + 2]) : void 0;
+      if (!owner || !repo) return null;
+      return { host: "gitlab", owner, repo, number: Number.isFinite(number) ? number : void 0 };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function fetchRemoteDiff(remote, number) {
+  if (remote.host === "github") {
+    return execSync5(`gh pr diff ${number} --repo ${remote.owner}/${remote.repo}`, {
+      encoding: "utf-8",
+      maxBuffer: 20 * 1024 * 1024
+    }).trim();
+  }
+  const project = `${remote.owner}/${remote.repo}`;
+  return execSync5(`glab mr diff ${number} --repo ${project} --raw`, {
+    encoding: "utf-8",
+    maxBuffer: 20 * 1024 * 1024
+  }).trim();
+}
+function stripLockFileDiffs(diff) {
+  const skipPatterns = [/\.lock$/, /(^|\/)package-lock\.json$/, /(^|\/)pnpm-lock\.yaml$/, /(^|\/)yarn\.lock$/];
+  const sections = diff.split(/(?=^diff --git )/m);
+  return sections.filter((section) => {
+    const header = section.match(/^diff --git a\/(.+?) b\//m);
+    if (!header) return true;
+    const path = header[1];
+    return !skipPatterns.some((p) => p.test(path));
+  }).join("").trim();
+}
 function formatDuration(ms) {
   if (ms < 1e3) return `${ms}ms`;
   const s = Math.round(ms / 1e3);
@@ -5753,7 +6162,7 @@ function parseReviewOutput(output) {
 }
 
 // cli/commands/scan.ts
-import { Command as Command25 } from "commander";
+import { Command as Command26 } from "commander";
 
 // lib/scanner/index.ts
 import { spawn as spawn8 } from "child_process";
@@ -6185,7 +6594,7 @@ var SeedDataManager = class {
 };
 
 // lib/scanner/prompts.ts
-function buildSynthesisPrompt(config, context, codebaseAnalysis, crawlResults, priorFindings) {
+function buildSynthesisPrompt(config, context, codebaseAnalysis, crawlResults, priorFindings, customPrompt) {
   const dismissedFindings = priorFindings.filter((f) => f.status === "dismissed");
   const promotedFindings = priorFindings.filter((f) => f.status === "promoted");
   const crawlSummary = crawlResults.map((r) => {
@@ -6233,6 +6642,9 @@ ${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")}` : ""}
 
+${customPrompt && customPrompt.trim().length > 0 ? `**User-Specified Scan Direction (take priority \u2014 focus the scan around this):**
+${customPrompt.trim()}` : ""}
+
 ## Live Crawl Results
 
 ${crawlResults.length > 0 ? crawlSummary : "Live crawl was not performed (app may not be running)."}
@@ -6360,12 +6772,16 @@ async function runScanPipeline(opts) {
     }
   }
   opts.onLog("Synthesizing findings with Claude...");
+  if (opts.customPrompt && opts.customPrompt.trim().length > 0) {
+    opts.onLog("Using custom scan direction from user");
+  }
   const prompt2 = buildSynthesisPrompt(
     config,
     context,
     codebaseAnalysis,
     crawlResults,
-    context.priorFindings
+    context.priorFindings,
+    opts.customPrompt
   );
   const synthesisResult = await runClaude2(prompt2);
   const parsed = parseSynthesisOutput(synthesisResult);
@@ -6515,7 +6931,7 @@ function logOk2(msg) {
 function logErr2(msg) {
   console.error(`${timestamp3()} ${scanTag()} ${paint9("red", "\u2717")} ${msg}`);
 }
-var scanCommand = new Command25("scan").description("Run a product scan on the current project \u2014 analyzes codebase, crawls the app, and surfaces findings").option("--project <id>", "Project ID (defaults to linked project)").option("--report <id>", "Use an existing scan report ID (created by UI trigger)").option("--no-crawl", "Skip live crawl (codebase analysis only)").action(async (opts) => {
+var scanCommand = new Command26("scan").description("Run a product scan on the current project \u2014 analyzes codebase, crawls the app, and surfaces findings").option("--project <id>", "Project ID (defaults to linked project)").option("--report <id>", "Use an existing scan report ID (created by UI trigger)").option("--prompt <prompt>", "Custom scan direction/prompt to focus the scan on").option("--no-crawl", "Skip live crawl (codebase analysis only)").action(async (opts) => {
   const config = loadConfig();
   if (!config.apiKey) {
     logErr2('Not authenticated. Run "mr login" first.');
@@ -6557,9 +6973,17 @@ var scanCommand = new Command25("scan").description("Run a product scan on the c
     projectPath = process.cwd();
   }
   let reportId;
+  let customPrompt = typeof opts.prompt === "string" && opts.prompt.trim().length > 0 ? opts.prompt.trim() : null;
   if (opts.report) {
     reportId = opts.report;
     log2(`Using existing scan report ${paint9("yellow", reportId.slice(0, 8))}`);
+    try {
+      const existing = await api.get(`/api/scans/${reportId}`);
+      if (!customPrompt && existing.customPrompt) {
+        customPrompt = existing.customPrompt;
+      }
+    } catch {
+    }
   } else {
     try {
       const scans = await api.get(`/api/scans?projectId=${projectId}&status=processing`);
@@ -6572,7 +6996,8 @@ var scanCommand = new Command25("scan").description("Run a product scan on the c
     try {
       const report = await api.post("/api/scans", {
         projectId,
-        status: "pending"
+        status: "pending",
+        customPrompt
       });
       reportId = report.id;
       log2(`Created scan report ${paint9("yellow", reportId.slice(0, 8))}`);
@@ -6605,7 +7030,8 @@ var scanCommand = new Command25("scan").description("Run a product scan on the c
       onLog: log2,
       onProgress: (phase, detail) => {
         log2(`${paint9("dim", `[${phase}]`)} ${detail}`);
-      }
+      },
+      customPrompt
     });
     let wasCancelled = false;
     try {
@@ -6670,7 +7096,7 @@ var scanCommand = new Command25("scan").description("Run a product scan on the c
 });
 
 // cli/commands/doctor.ts
-import { Command as Command26 } from "commander";
+import { Command as Command27 } from "commander";
 import { existsSync as existsSync16 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join11 } from "path";
@@ -6718,7 +7144,7 @@ async function checkProjectLink() {
     optional: true
   };
 }
-var doctorCommand = new Command26("doctor").description("Diagnose Mr. Manager CLI installation and environment").action(async () => {
+var doctorCommand = new Command27("doctor").description("Diagnose Mr. Manager CLI installation and environment").action(async () => {
   const banner = [
     ``,
     paint5("cyan", `  MR DOCTOR`),
@@ -6761,14 +7187,14 @@ var doctorCommand = new Command26("doctor").description("Diagnose Mr. Manager CL
 });
 
 // cli/commands/prompt-audit.ts
-import { Command as Command27 } from "commander";
+import { Command as Command28 } from "commander";
 import { resolve as resolve8 } from "path";
 import { existsSync as existsSync17, 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 Command27("prompt-audit").description("Dry-run prompt construction and report estimated token counts by job type").option("--task <id>", "Audit prompts for a specific task ID").option("--all", "Audit all supported job types with representative data", false).option("--json", "Output as JSON instead of plain text", false).action(async (opts) => {
+var promptAuditCommand = new Command28("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 {
@@ -6977,7 +7403,8 @@ ${r.jobType} [${r.identifier}]`);
 });
 
 // cli/commands/skill.ts
-import { Command as Command28 } from "commander";
+import { Command as Command29 } from "commander";
+import { createInterface as createInterface3 } from "readline/promises";
 var c10 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -6986,7 +7413,32 @@ var c10 = {
   green: "\x1B[32m",
   yellow: "\x1B[33m"
 };
-var skillCommand = new Command28("skill").description("Manage skills \u2014 reusable playbooks for AI agents");
+async function resolveSkill(idOrName) {
+  try {
+    return await api.get(
+      `/api/skills/${encodeURIComponent(idOrName)}`
+    );
+  } catch (err) {
+    if (!(err instanceof ApiError) || err.status !== 404) throw err;
+  }
+  const skills = await api.get("/api/skills");
+  const matches = skills.filter((s) => s.name === idOrName);
+  if (matches.length === 0) {
+    throw new Error(`No skill found with id or name "${idOrName}".`);
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `Multiple skills named "${idOrName}". Pass an id instead:
+${matches.map((m) => `  ${m.id}`).join("\n")}`
+    );
+  }
+  return await api.get(`/api/skills/${matches[0].id}`);
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}b`;
+  return `${(bytes / 1024).toFixed(1)}kb`;
+}
+var skillCommand = new Command29("skill").description("Manage skills \u2014 reusable playbooks for AI agents");
 skillCommand.command("list").alias("ls").description("List all skills").option("--category <category>", "Filter by category").action(async (opts) => {
   const params = new URLSearchParams();
   if (opts.category) params.set("category", opts.category);
@@ -7043,6 +7495,97 @@ skillCommand.command("create").description("Create a new skill from a markdown f
     `${c10.green}Created skill:${c10.reset} ${c10.bold}${skill.name}${c10.reset} ${c10.dim}(${skill.id})${c10.reset}`
   );
 });
+skillCommand.command("update").description(
+  "Update an existing skill's content, metadata, or scope. The previous content is saved as a revision."
+).argument("<idOrName>", "Skill id or name").option("-f, --file <path>", "Replace content from a markdown file").option("--content <text>", "Inline replacement content").option("-d, --description <desc>", "Update description").option("-c, --category <cat>", "Update category").option("--name <name>", "Rename the skill").option("-p, --project", "Re-scope to the linked project").option("--global", "Re-scope to global (clears projectId)").action(async (idOrName, opts) => {
+  if (opts.project && opts.global) {
+    console.error("Pass only one of --project or --global, not both.");
+    process.exit(1);
+  }
+  if (opts.file && opts.content !== void 0) {
+    console.error("Pass only one of --file or --content, not both.");
+    process.exit(1);
+  }
+  let existing;
+  try {
+    existing = await resolveSkill(idOrName);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+  const patch = {};
+  if (opts.file) {
+    const { readFileSync: readFileSync13 } = await import("fs");
+    try {
+      patch.content = readFileSync13(opts.file, "utf-8").trim();
+    } catch (err) {
+      console.error(`Failed to read file: ${err.message}`);
+      process.exit(1);
+    }
+  } else if (opts.content !== void 0) {
+    patch.content = String(opts.content).trim();
+  }
+  if (opts.description !== void 0) patch.description = opts.description;
+  if (opts.category !== void 0) patch.category = opts.category;
+  if (opts.name !== void 0) patch.name = opts.name;
+  if (opts.project) {
+    const projectId = getLinkedProjectId();
+    if (!projectId) {
+      console.error(
+        'No project linked to this directory. Run "mr link <project-id>" first.'
+      );
+      process.exit(1);
+    }
+    patch.projectId = projectId;
+  } else if (opts.global) {
+    patch.projectId = null;
+  }
+  if (Object.keys(patch).length === 0) {
+    console.error(
+      "Nothing to update. Pass at least one of --file, --content, --description, --category, --name, --project, --global."
+    );
+    process.exit(1);
+  }
+  const updated = await api.patch(
+    `/api/skills/${existing.id}`,
+    patch
+  );
+  const beforeContent = existing.content ?? "";
+  const afterContent = typeof patch.content === "string" ? patch.content : beforeContent;
+  const contentChanged = typeof patch.content === "string" && patch.content !== beforeContent;
+  const sizeDiff = typeof patch.content === "string" ? ` ${c10.dim}(${formatSize(Buffer.byteLength(beforeContent, "utf-8"))} -> ${formatSize(Buffer.byteLength(afterContent, "utf-8"))})${c10.reset}` : "";
+  const priorRevisions = existing.revisions?.length ?? 0;
+  const revisionsAfter = priorRevisions + (contentChanged ? 1 : 0);
+  const revisionNote = contentChanged ? ` ${c10.dim}kept ${revisionsAfter} prior revision${revisionsAfter === 1 ? "" : "s"}${c10.reset}` : "";
+  console.log(
+    `${c10.green}Updated skill:${c10.reset} ${c10.bold}${updated.name}${c10.reset}${sizeDiff}${revisionNote}`
+  );
+  console.log(`  ${c10.dim}id: ${updated.id}${c10.reset}`);
+});
+skillCommand.command("delete").alias("rm").description("Delete a skill").argument("<idOrName>", "Skill id or name").option("--yes", "Skip confirmation prompt").action(async (idOrName, opts) => {
+  let skill;
+  try {
+    skill = await resolveSkill(idOrName);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+  if (!opts.yes) {
+    const rl = createInterface3({ input: process.stdin, output: process.stdout });
+    const answer = (await rl.question(
+      `Delete skill ${c10.bold}${skill.name}${c10.reset} ${c10.dim}(${skill.id})${c10.reset}? [y/N] `
+    )).trim().toLowerCase();
+    rl.close();
+    if (answer !== "y" && answer !== "yes") {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  await api.del(`/api/skills/${skill.id}`);
+  console.log(
+    `${c10.yellow}Deleted skill:${c10.reset} ${c10.bold}${skill.name}${c10.reset} ${c10.dim}(${skill.id})${c10.reset}`
+  );
+});
 skillCommand.command("generate").alias("gen").description("Generate a new skill using AI from a text prompt").argument("<prompt>", "Describe the skill to generate").option("-p, --project", "Scope to the linked project").action(async (prompt2, opts) => {
   let projectId = null;
   if (opts.project) {
@@ -7077,7 +7620,7 @@ skillCommand.command("generate").alias("gen").description("Generate a new skill
 });
 
 // cli/commands/resource.ts
-import { Command as Command29 } from "commander";
+import { Command as Command30 } from "commander";
 var c11 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -7097,7 +7640,7 @@ function typeLabel(type) {
   const color = TYPE_COLORS[type] ?? c11.dim;
   return `${color}${type}${c11.reset}`;
 }
-var resourceCommand = new Command29("resource").description("Manage resources \u2014 documents, plans, research, and notes");
+var resourceCommand = new Command30("resource").description("Manage resources \u2014 documents, plans, research, and notes");
 resourceCommand.command("list").alias("ls").description("List resources for the linked project (or all)").option("--all", "List all resources across projects").action(async (opts) => {
   const params = new URLSearchParams();
   if (opts.all) {
@@ -7195,13 +7738,13 @@ resourceCommand.command("generate").alias("gen").description("Generate a resourc
 });
 
 // cli/commands/tests.ts
-import { Command as Command30 } from "commander";
+import { Command as Command31 } from "commander";
 var c12 = {
   reset: "\x1B[0m",
   dim: "\x1B[2m",
   yellow: "\x1B[33m"
 };
-var testsCommand = new Command30("tests").description("List MR Test scenarios for the linked project").action(async () => {
+var testsCommand = new Command31("tests").description("List MR Test scenarios for the linked project").action(async () => {
   const projectId = getLinkedProjectId();
   if (!projectId) {
     console.error(
@@ -7232,6 +7775,35 @@ var testsCommand = new Command30("tests").description("List MR Test scenarios fo
   }
 });
 
+// cli/commands/walkthrough.ts
+import { Command as Command32 } from "commander";
+var SKILL_NAME = "Generate Walkthrough Video";
+var walkthroughCommand = new Command32("walkthrough").description("Attach the Generate Walkthrough Video skill to a task and queue it").argument("<task-id>", "Task ID to generate a walkthrough for").option("--prod", "Allow recording against production (requires explicit confirmation)").action(async (taskId, opts) => {
+  const skills = await api.get("/api/skills");
+  const skill = skills.find((s) => s.name === SKILL_NAME);
+  if (!skill) {
+    console.error(
+      `Skill "${SKILL_NAME}" not found. Run \`mr setup\` to seed starter skills.`
+    );
+    process.exit(1);
+  }
+  try {
+    await api.post(`/api/tasks/${taskId}/skills`, { skillId: skill.id });
+  } catch (err) {
+    const msg = err.message;
+    if (!msg.includes("already attached")) {
+      console.error(`Failed to attach skill: ${msg}`);
+      process.exit(1);
+    }
+  }
+  await api.post(`/api/tasks/${taskId}/updates`, {
+    message: opts.prod ? "Walkthrough video queued (production target \u2014 confirm via watcher)" : "Walkthrough video queued",
+    source: "agent"
+  });
+  console.log(`\u2713 Attached "${SKILL_NAME}" to task ${taskId}`);
+  console.log("  Run `mr watch` to process the queue.");
+});
+
 // cli/index.ts
 var configPath = join12(homedir3(), ".mr-manager", "config.json");
 var isFirstRun = !existsSync18(configPath);
@@ -7270,7 +7842,7 @@ if (isFirstRun && !shouldBypass) {
   console.log("");
   process.exit(0);
 }
-var program = new Command31();
+var program = new Command33();
 program.name("mr").description("Mr. Manager - Task and project management CLI").version(CLI_VERSION);
 program.addCommand(initCommand);
 program.addCommand(authCommand);
@@ -7288,6 +7860,7 @@ program.addCommand(undelegateCommand);
 program.addCommand(createCommand);
 program.addCommand(completeCommand);
 program.addCommand(subtaskCompleteCommand);
+program.addCommand(subtaskAddCommand);
 program.addCommand(prototypeCommand);
 program.addCommand(setupCommand);
 program.addCommand(updateCommand);
@@ -7305,4 +7878,5 @@ program.addCommand(promptAuditCommand);
 program.addCommand(skillCommand);
 program.addCommand(resourceCommand);
 program.addCommand(testsCommand);
+program.addCommand(walkthroughCommand);
 program.parse();