diff --git a/src/ModSync.Core/Parsing/DraftInstructionService.cs b/src/ModSync.Core/Parsing/DraftInstructionService.cs
index 33bf1317..d0805c63 100644
--- a/src/ModSync.Core/Parsing/DraftInstructionService.cs
+++ b/src/ModSync.Core/Parsing/DraftInstructionService.cs
@@ -73,38 +73,57 @@ public static IReadOnlyList<DraftInstructionResult> GenerateDraftInstructions(
 
             foreach (ModComponent component in components)
             {
-                if (component.Instructions.Count > 0 || string.IsNullOrWhiteSpace(component.Directions))
+                if (component.Instructions.Count > 0)
                 {
                     continue;
                 }
 
-                ObservableCollection<Instruction> parsed;
-                try
-                {
-                    parsed = parser.ParseInstructions(
-                        component.Directions,
-                        string.IsNullOrWhiteSpace(component.DownloadInstructions) ? null : component.DownloadInstructions,
-                        component);
-                }
-                catch (Exception ex)
+                int added = 0;
+
+                if (!string.IsNullOrWhiteSpace(component.Directions))
                 {
-                    // Graceful degradation: unparseable prose keeps today's behavior (no instructions drafted).
-                    verbose($"[DraftInstructions] Failed to parse prose for '{component.Name}': {ex.Message}");
-                    continue;
+                    ObservableCollection<Instruction> parsed;
+                    try
+                    {
+                        parsed = parser.ParseInstructions(
+                            component.Directions,
+                            string.IsNullOrWhiteSpace(component.DownloadInstructions) ? null : component.DownloadInstructions,
+                            component);
+                    }
+                    catch (Exception ex)
+                    {
+                        // Graceful degradation: unparseable prose may still get an InstallationMethod fallback.
+                        verbose($"[DraftInstructions] Failed to parse prose for '{component.Name}': {ex.Message}");
+                        parsed = new ObservableCollection<Instruction>();
+                    }
+
+                    foreach (Instruction instruction in parsed)
+                    {
+                        if (!TrySanitizeInstruction(instruction))
+                        {
+                            verbose($"[DraftInstructions] Dropped non-sandboxed draft ({instruction.Action}) for '{component.Name}'");
+                            continue;
+                        }
+
+                        instruction.SetParentComponent(component);
+                        component.Instructions.Add(instruction);
+                        added++;
+                    }
                 }
 
-                int added = 0;
-                foreach (Instruction instruction in parsed)
+                // K2 Full and similar guides often describe TSLPatcher/HoloPatcher installs via
+                // Installation Method alone, or preference prose ("recommend the X option") that yields
+                // no regex hits. Still draft a sandboxed Patcher (or loose-file Move) for review.
+                if (added == 0)
                 {
-                    if (!TrySanitizeInstruction(instruction))
+                    Instruction fallback = TryCreateMethodFallbackInstruction(component);
+                    if (fallback != null && TrySanitizeInstruction(fallback))
                     {
-                        verbose($"[DraftInstructions] Dropped non-sandboxed draft ({instruction.Action}) for '{component.Name}'");
-                        continue;
+                        fallback.SetParentComponent(component);
+                        component.Instructions.Add(fallback);
+                        added++;
+                        verbose($"[DraftInstructions] Applied InstallationMethod fallback ({fallback.Action}) for '{component.Name}'");
                     }
-
-                    instruction.SetParentComponent(component);
-                    component.Instructions.Add(instruction);
-                    added++;
                 }
 
                 if (added > 0)
@@ -118,6 +137,76 @@ public static IReadOnlyList<DraftInstructionResult> GenerateDraftInstructions(
             return results;
         }
 
+        /// <summary>
+        /// When prose does not parse into instructions, invent a minimal sandboxed draft from
+        /// <see cref="ModComponent.InstallationMethod"/> and/or patcher keywords in Directions.
+        /// </summary>
+        [CanBeNull]
+        private static Instruction TryCreateMethodFallbackInstruction([NotNull] ModComponent component)
+        {
+            string method = component.InstallationMethod ?? string.Empty;
+            string directions = component.Directions ?? string.Empty;
+            string combined = method + " " + directions;
+
+            if (LooksLikePatcherInstall(combined))
+            {
+                return new Instruction
+                {
+                    Action = Instruction.ActionType.Patcher,
+                    Source = new List<string> { ModDirectoryPlaceholder },
+                    Destination = KotorDirectoryPlaceholder,
+                    Overwrite = true,
+                };
+            }
+
+            if (LooksLikeLooseFileInstall(method)
+                && !LooksLikePatcherInstall(directions)
+                && method.IndexOf("executable", StringComparison.OrdinalIgnoreCase) < 0)
+            {
+                string destination = directions.IndexOf("movies", StringComparison.OrdinalIgnoreCase) >= 0
+                    ? KotorDirectoryPlaceholder + @"\Movies"
+                    : KotorDirectoryPlaceholder + @"\Override";
+
+                return new Instruction
+                {
+                    Action = Instruction.ActionType.Move,
+                    Source = new List<string> { ModDirectoryPlaceholder + @"\*" },
+                    Destination = destination,
+                    Overwrite = directions.IndexOf("do not overwrite", StringComparison.OrdinalIgnoreCase) < 0
+                        && directions.IndexOf("don't overwrite", StringComparison.OrdinalIgnoreCase) < 0,
+                };
+            }
+
+            if (method.IndexOf("executable", StringComparison.OrdinalIgnoreCase) >= 0
+                || directions.IndexOf("executable", StringComparison.OrdinalIgnoreCase) >= 0)
+            {
+                return new Instruction
+                {
+                    Action = Instruction.ActionType.Execute,
+                    Source = new List<string> { ModDirectoryPlaceholder + @"\*" },
+                    Destination = string.Empty,
+                    Overwrite = true,
+                };
+            }
+
+            return null;
+        }
+
+        private static bool LooksLikePatcherInstall([NotNull] string text)
+        {
+            string lower = text.ToLowerInvariant();
+            return lower.IndexOf("tslpatcher", StringComparison.Ordinal) >= 0
+                || lower.IndexOf("holopatcher", StringComparison.Ordinal) >= 0
+                || lower.IndexOf("multi-run", StringComparison.Ordinal) >= 0;
+        }
+
+        private static bool LooksLikeLooseFileInstall([NotNull] string text)
+        {
+            string lower = text.ToLowerInvariant();
+            return lower.IndexOf("loose-file", StringComparison.Ordinal) >= 0
+                || lower.IndexOf("loose file", StringComparison.Ordinal) >= 0;
+        }
+
         /// <summary>
         /// Normalizes placeholders and enforces the path-sandboxing rules on a draft instruction:
         /// every Source entry and any non-empty Destination must start with
diff --git a/src/ModSync.Core/Parsing/NaturalLanguageInstructionParser.cs b/src/ModSync.Core/Parsing/NaturalLanguageInstructionParser.cs
index 8bc42d7b..19587ca1 100644
--- a/src/ModSync.Core/Parsing/NaturalLanguageInstructionParser.cs
+++ b/src/ModSync.Core/Parsing/NaturalLanguageInstructionParser.cs
@@ -26,6 +26,50 @@ public sealed class NaturalLanguageInstructionParser
         // These patterns cover ALL variations found in KOTOR mod build documentation
         private static readonly List<InstructionPattern> s_instructionPatterns = new List<InstructionPattern>
         {
+			// === K2 FULL / NEOCITIES COMMON PHRASES (high priority) ===
+			// "Install the files within/from the (included) Override folder/directory"
+			new InstructionPattern(
+                @"install\s+(?:the\s+)?files?\s+(?:within|from|in)\s+(?:the\s+)?(?:included\s+)?override\s+(?:folder|directory)",
+                Instruction.ActionType.Move,
+                RegexOptions.IgnoreCase
+            ),
+			// "Install the contents of every/all folder(s) but X"
+			new InstructionPattern(
+                @"install\s+(?:the\s+)?contents?\s+of\s+(?:every|all|each)\s+folders?",
+                Instruction.ActionType.Move,
+                RegexOptions.IgnoreCase
+            ),
+			// "Use the files in the \"Alternate Textures\" folder"
+			new InstructionPattern(
+                @"use\s+(?:the\s+)?files?\s+in\s+(?:the\s+)?[""'](?<source>[^""']+)[""']\s+folder",
+                Instruction.ActionType.Move,
+                RegexOptions.IgnoreCase
+            ),
+			// "Go into the NPC Replacement folder and move all the loose files to the override"
+			new InstructionPattern(
+                @"go\s+into\s+(?:the\s+)?[""']?(?<source>[\w\s\-_]+?)[""']?\s+folder\s+and\s+move\s+(?:all\s+)?(?:the\s+)?(?:loose\s+)?files?\s+to\s+(?:the\s+|your\s+)?(?<destination>[\w\s\-_/\\]+)",
+                Instruction.ActionType.Move,
+                RegexOptions.IgnoreCase
+            ),
+			// "files from this mod go in your movies folder" / "move ... to movies"
+			new InstructionPattern(
+                @"(?:files?\s+(?:from\s+this\s+mod\s+)?go\s+in\s+(?:your\s+)?movies\s+folder|(?:move|copy|place|put)\s+(?:the\s+)?(?:files?|contents?|everything)\s+(?:to|into)\s+(?:your\s+)?(?:game'?s?\s+)?movies(?:\s+folder)?)",
+                Instruction.ActionType.Move,
+                RegexOptions.IgnoreCase
+            ),
+			// Implied bulk move: "before moving the files to your override" / "moving to your Override"
+			new InstructionPattern(
+                @"(?:before\s+)?mov(?:e|ing)\s+(?:the\s+)?(?:files?|contents?)\s+to\s+(?:your\s+)?(?:game'?s?\s+)?(?<destination>override|movies)(?:\s+(?:folder|directory))?",
+                Instruction.ActionType.Move,
+                RegexOptions.IgnoreCase
+            ),
+			// "Download the .tpc/.tga variant" then install to override (common Ultimate HR phrasing)
+			new InstructionPattern(
+                @"download\s+the\s+\.?(?<variant>tpc|tga)\s+variant",
+                Instruction.ActionType.Move,
+                RegexOptions.IgnoreCase
+            ),
+
 			// === HIGHLY SPECIFIC MOVE/COPY PATTERNS (must come first) ===
 			// "Move everything from X, Y, and Z folders to override"
 			new InstructionPattern(
@@ -206,6 +250,36 @@ public sealed class NaturalLanguageInstructionParser
                 @"run\s+the\s+holopatcher\s+executable(?:\.\s+select\s+the\s+(?<option>.+?)\s+install)?",
                 Instruction.ActionType.Patcher,
                 RegexOptions.IgnoreCase
+            ),
+			// "Run the HoloPatcher/TSLPatcher" (with or without "executable")
+			new InstructionPattern(
+                @"run\s+(?:the\s+)?(?<source>holopatcher|tslpatcher)(?:\s+executable)?",
+                Instruction.ActionType.Patcher,
+                RegexOptions.IgnoreCase
+            ),
+			// "Run the installer first"
+			new InstructionPattern(
+                @"run\s+the\s+(?:installer|patcher)\s+first",
+                Instruction.ActionType.Patcher,
+                RegexOptions.IgnoreCase
+            ),
+			// Install quoted option: install "Standard." / install the "Standard + Sith Assassin Visas" option
+			new InstructionPattern(
+                @"(?:simply\s+)?install\s+(?:the\s+)?[""'](?<option>[^""']+)[""'](?:\s+option)?",
+                Instruction.ActionType.Patcher,
+                RegexOptions.IgnoreCase
+            ),
+			// "Use the 'No M4-78EP Installed' option"
+			new InstructionPattern(
+                @"use\s+(?:the\s+)?[""'](?<option>[^""']+)[""']\s+option",
+                Instruction.ActionType.Patcher,
+                RegexOptions.IgnoreCase
+            ),
+			// "Apply the main installation" / "Apply any of the following"
+			new InstructionPattern(
+                @"apply\s+(?:the\s+)?(?<option>main\s+installation|default\s+install|patch|contents?)",
+                Instruction.ActionType.Patcher,
+                RegexOptions.IgnoreCase
             ),
 			// "Go into X folder and apply Y"
 			new InstructionPattern(
@@ -482,6 +556,29 @@ public ObservableCollection<Instruction> ParseInstructions(
                 }
             }
 
+            // Overwrite guidance often appears in a neighboring sentence ("Download the .tpc variant...
+            // For this mod only, do not overwrite if prompted!"). Apply to drafted Move/Copy actions.
+            if (s_entityPatterns["no_overwrite"].IsMatch(normalizedInstructions))
+            {
+                foreach (Instruction instruction in instructions)
+                {
+                    if (instruction.Action == Instruction.ActionType.Move || instruction.Action == Instruction.ActionType.Copy)
+                    {
+                        instruction.Overwrite = false;
+                    }
+                }
+            }
+            else if (s_entityPatterns["overwrite"].IsMatch(normalizedInstructions))
+            {
+                foreach (Instruction instruction in instructions)
+                {
+                    if (instruction.Action == Instruction.ActionType.Move || instruction.Action == Instruction.ActionType.Copy)
+                    {
+                        instruction.Overwrite = true;
+                    }
+                }
+            }
+
             // Parse download instructions for options/recommendations
             if (!string.IsNullOrWhiteSpace(downloadInstructions))
             {
@@ -608,6 +705,15 @@ private static bool IsInformationalOnly([NotNull] string unit)
         {
             string lower = unit.ToLowerInvariant();
 
+            // Commentary that still names an install destination is actionable (common in K2 Full).
+            bool hasInstallDestination =
+                lower.Contains("movies folder")
+                || lower.Contains("to your override")
+                || lower.Contains("to the override")
+                || lower.Contains("override folder")
+                || lower.Contains("holopatcher")
+                || lower.Contains("tslpatcher");
+
             // Commentary patterns
             if (lower.StartsWith("bear in mind", StringComparison.Ordinal) ||
                 lower.StartsWith("keep in mind", StringComparison.Ordinal) ||
@@ -621,7 +727,7 @@ private static bool IsInformationalOnly([NotNull] string unit)
                 lower.Contains("up to you") ||
                 lower.Contains("which of these you choose"))
             {
-                return true;
+                return !hasInstallDestination;
             }
 
             // Questions
@@ -743,6 +849,27 @@ private Instruction CreateInstructionFromMatch(
                 }
             }
 
+            // Special-case: "install files within Override folder" → source is the mod's Override tree.
+            if (pattern.ActionType == Instruction.ActionType.Move
+                && Regex.IsMatch(unit, @"install\s+(?:the\s+)?files?\s+(?:within|from|in)\s+(?:the\s+)?(?:included\s+)?override", RegexOptions.IgnoreCase))
+            {
+                instruction.Source = new List<string> { @"<<modDirectory>>\Override\*" };
+                instruction.Destination = @"<<kotorDirectory>>\Override";
+            }
+
+            // Patcher/Extract/bulk-move prose often omits an explicit path. Supply sandboxed defaults.
+            EnsureDefaultSourcesAndDestination(instruction, unit, match);
+
+            // Movies destination when the unit points at the movies folder but destination was not captured.
+            if (pattern.ActionType == Instruction.ActionType.Move
+                && unit.IndexOf("movies", StringComparison.OrdinalIgnoreCase) >= 0)
+            {
+                if (Regex.IsMatch(unit, @"movies\s+folder|to\s+(?:your\s+)?movies|go\s+in\s+(?:your\s+)?movies", RegexOptions.IgnoreCase))
+                {
+                    instruction.Destination = @"<<kotorDirectory>>\Movies";
+                }
+            }
+
             // === Validate Instruction ===
             if (!ValidateInstruction(instruction))
             {
@@ -753,6 +880,85 @@ private Instruction CreateInstructionFromMatch(
             return instruction;
         }
 
+        /// <summary>
+        /// Fills sandboxed default Source/Destination for actions that guides describe without paths.
+        /// </summary>
+        private static void EnsureDefaultSourcesAndDestination(
+            [NotNull] Instruction instruction,
+            [NotNull] string unit,
+            [NotNull] Match match)
+        {
+            if (instruction.Action == Instruction.ActionType.Patcher)
+            {
+                if (instruction.Source is null || instruction.Source.Count == 0)
+                {
+                    // Prefer an explicit holopatcher/tslpatcher token when captured; otherwise the mod root.
+                    if (match.Groups["source"].Success)
+                    {
+                        string raw = match.Groups["source"].Value.Trim();
+                        if (raw.Equals("holopatcher", StringComparison.OrdinalIgnoreCase)
+                            || raw.Equals("tslpatcher", StringComparison.OrdinalIgnoreCase)
+                            || raw.Equals("installer", StringComparison.OrdinalIgnoreCase)
+                            || raw.Equals("patcher", StringComparison.OrdinalIgnoreCase))
+                        {
+                            instruction.Source = new List<string> { @"<<modDirectory>>" };
+                        }
+                        else
+                        {
+                            instruction.Source = new List<string> { $"<<modDirectory>>\\{raw}" };
+                        }
+                    }
+                    else
+                    {
+                        instruction.Source = new List<string> { @"<<modDirectory>>" };
+                    }
+                }
+
+                if (string.IsNullOrWhiteSpace(instruction.Destination))
+                {
+                    instruction.Destination = @"<<kotorDirectory>>";
+                }
+
+                return;
+            }
+
+            if (instruction.Action == Instruction.ActionType.Extract)
+            {
+                if (instruction.Source is null || instruction.Source.Count == 0)
+                {
+                    instruction.Source = new List<string> { @"<<modDirectory>>\*.zip" };
+                }
+
+                return;
+            }
+
+            if (instruction.Action == Instruction.ActionType.Move || instruction.Action == Instruction.ActionType.Copy)
+            {
+                if (instruction.Source is null || instruction.Source.Count == 0)
+                {
+                    // "download the .tpc variant" / bulk move with no named folder → all loose files in mod root.
+                    if (match.Groups["variant"].Success)
+                    {
+                        string variant = match.Groups["variant"].Value.Trim().ToLowerInvariant();
+                        instruction.Source = new List<string> { $"<<modDirectory>>\\*.{variant}" };
+                    }
+                    else if (match.Groups["source"].Success)
+                    {
+                        // Already handled above via ExtractSources; leave empty if that failed.
+                    }
+                    else
+                    {
+                        instruction.Source = new List<string> { @"<<modDirectory>>\*" };
+                    }
+                }
+
+                if (string.IsNullOrWhiteSpace(instruction.Destination))
+                {
+                    instruction.Destination = InferDestination(unit, instruction.Action);
+                }
+            }
+        }
+
         /// <summary>
         /// Validates that an instruction has all required fields.
         /// </summary>
@@ -770,7 +976,8 @@ private static bool ValidateInstruction([NotNull] Instruction instruction)
                 instruction.Action == Instruction.ActionType.Delete ||
                 instruction.Action == Instruction.ActionType.Rename ||
                 instruction.Action == Instruction.ActionType.Extract ||
-                instruction.Action == Instruction.ActionType.Execute)
+                instruction.Action == Instruction.ActionType.Execute ||
+                instruction.Action == Instruction.ActionType.Patcher)
             {
                 if (instruction.Source is null || instruction.Source.Count == 0)
                 {
diff --git a/src/ModSync.Tests/GuideIngestionTests.cs b/src/ModSync.Tests/GuideIngestionTests.cs
index ec0e52e8..354016b3 100644
--- a/src/ModSync.Tests/GuideIngestionTests.cs
+++ b/src/ModSync.Tests/GuideIngestionTests.cs
@@ -48,6 +48,31 @@ public sealed class GuideIngestionTests
         private const string MoveExceptProse =
             "The file has the wrong readme; move all the files in the Creatures folder, except for the readme and Gizka.jpg (any .jpg/.png files are always previews and can be deleted), to the override.";
 
+        // K2 Full / neocities phrases that previously yielded 0 drafts.
+        private const string K2OverrideFolderProse =
+            "Install the files within the Override folder.";
+
+        private const string K2IncludedOverrideProse =
+            "Install the files from the included Override directory only.";
+
+        private const string K2HoloPatcherSelectProse =
+            "Run the HoloPatcher executable. Select the default install, not M4-78.";
+
+        private const string K2InstallQuotedOptionProse =
+            "If you would like to have Visas's class as Sith Assassin, install the \"Standard + Sith Assassin Visas\" option. Otherwise, simply install \"Standard.\"";
+
+        private const string K2MoviesFolderProse =
+            "Bear in mind that the files from this mod go in your movies folder, not override.";
+
+        private const string K2TpcVariantMoveProse =
+            "Download the .tpc variant of the mod. For this mod only, do not overwrite if prompted!";
+
+        private const string K2GoIntoFolderMoveProse =
+            "Ignore the \"Player Bodies\" folder. Go into the NPC Replacement folder and move all the loose files to the override directory. Ignore the optional folder.";
+
+        private const string K2CommunityPatchFoldersProse =
+            "If you are using the K2 Community Patch, install the contents of every folder but Straight Fixes (that was already in the K2CP).";
+
         private const string MarkdownGuide = @"### Guide Ingestion Test Mod
 
 **Name:** [Guide Ingestion Test Mod](https://example.com/guide-ingestion-test-mod.zip)
@@ -234,6 +259,165 @@ public void DraftInstructions_MoveExceptProse_ProducesSandboxedMove()
             }
         }
 
+        [Test]
+        public void DraftInstructions_K2OverrideFolderProse_ProducesSandboxedMove()
+        {
+            ModComponent component = CreateComponent(K2OverrideFolderProse);
+
+            IReadOnlyList<DraftInstructionResult> results = DraftInstructionService.GenerateDraftInstructions(new[] { component });
+
+            Assert.That(results, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions.Any(i =>
+                i.Action == Instruction.ActionType.Move
+                && i.Source.Any(s => s.IndexOf("Override", StringComparison.OrdinalIgnoreCase) >= 0)
+                && i.Destination.IndexOf("Override", StringComparison.OrdinalIgnoreCase) >= 0), Is.True);
+
+            foreach (Instruction instruction in component.Instructions)
+            {
+                AssertInstructionIsSandboxed(instruction);
+            }
+        }
+
+        [Test]
+        public void DraftInstructions_K2IncludedOverrideProse_ProducesSandboxedMove()
+        {
+            ModComponent component = CreateComponent(K2IncludedOverrideProse);
+
+            IReadOnlyList<DraftInstructionResult> results = DraftInstructionService.GenerateDraftInstructions(new[] { component });
+
+            Assert.That(results, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions.Any(i => i.Action == Instruction.ActionType.Move), Is.True);
+
+            foreach (Instruction instruction in component.Instructions)
+            {
+                AssertInstructionIsSandboxed(instruction);
+            }
+        }
+
+        [Test]
+        public void DraftInstructions_K2HoloPatcherSelectProse_ProducesSandboxedPatcher()
+        {
+            ModComponent component = CreateComponent(K2HoloPatcherSelectProse);
+
+            IReadOnlyList<DraftInstructionResult> results = DraftInstructionService.GenerateDraftInstructions(new[] { component });
+
+            Assert.That(results, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions.Any(i =>
+                i.Action == Instruction.ActionType.Patcher
+                && i.Source.Count > 0
+                && i.Source[0].StartsWith(ModDirectoryPlaceholder, StringComparison.Ordinal)), Is.True);
+
+            foreach (Instruction instruction in component.Instructions)
+            {
+                AssertInstructionIsSandboxed(instruction);
+            }
+        }
+
+        [Test]
+        public void DraftInstructions_K2InstallQuotedOptionProse_ProducesSandboxedPatcher()
+        {
+            ModComponent component = CreateComponent(K2InstallQuotedOptionProse);
+
+            IReadOnlyList<DraftInstructionResult> results = DraftInstructionService.GenerateDraftInstructions(new[] { component });
+
+            Assert.That(results, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions.Any(i => i.Action == Instruction.ActionType.Patcher), Is.True);
+
+            foreach (Instruction instruction in component.Instructions)
+            {
+                AssertInstructionIsSandboxed(instruction);
+            }
+        }
+
+        [Test]
+        public void DraftInstructions_K2MoviesFolderProse_ProducesMoviesDestination()
+        {
+            ModComponent component = CreateComponent(K2MoviesFolderProse);
+
+            IReadOnlyList<DraftInstructionResult> results = DraftInstructionService.GenerateDraftInstructions(new[] { component });
+
+            Assert.That(results, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions.Any(i =>
+                i.Action == Instruction.ActionType.Move
+                && i.Destination.IndexOf("Movies", StringComparison.OrdinalIgnoreCase) >= 0), Is.True);
+
+            foreach (Instruction instruction in component.Instructions)
+            {
+                AssertInstructionIsSandboxed(instruction);
+            }
+        }
+
+        [Test]
+        public void DraftInstructions_K2TpcVariantMoveProse_ProducesSandboxedMoveWithoutOverwrite()
+        {
+            ModComponent component = CreateComponent(K2TpcVariantMoveProse);
+
+            IReadOnlyList<DraftInstructionResult> results = DraftInstructionService.GenerateDraftInstructions(new[] { component });
+
+            Assert.That(results, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions.Any(i =>
+                i.Action == Instruction.ActionType.Move
+                && i.Overwrite == false), Is.True);
+
+            foreach (Instruction instruction in component.Instructions)
+            {
+                AssertInstructionIsSandboxed(instruction);
+            }
+        }
+
+        [Test]
+        public void DraftInstructions_K2GoIntoFolderMoveProse_ProducesSandboxedMove()
+        {
+            ModComponent component = CreateComponent(K2GoIntoFolderMoveProse);
+
+            IReadOnlyList<DraftInstructionResult> results = DraftInstructionService.GenerateDraftInstructions(new[] { component });
+
+            Assert.That(results, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions.Any(i =>
+                i.Action == Instruction.ActionType.Move
+                && i.Source.Any(s => s.IndexOf("NPC Replacement", StringComparison.OrdinalIgnoreCase) >= 0)), Is.True);
+
+            foreach (Instruction instruction in component.Instructions)
+            {
+                AssertInstructionIsSandboxed(instruction);
+            }
+        }
+
+        [Test]
+        public void DraftInstructions_K2CommunityPatchFoldersProse_ProducesSandboxedMove()
+        {
+            ModComponent component = CreateComponent(K2CommunityPatchFoldersProse);
+
+            IReadOnlyList<DraftInstructionResult> results = DraftInstructionService.GenerateDraftInstructions(new[] { component });
+
+            Assert.That(results, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions.Any(i => i.Action == Instruction.ActionType.Move), Is.True);
+
+            foreach (Instruction instruction in component.Instructions)
+            {
+                AssertInstructionIsSandboxed(instruction);
+            }
+        }
+
+        [Test]
+        public void DraftInstructions_PatcherInstallationMethodFallback_WhenPreferenceOnlyProse()
+        {
+            var component = new ModComponent
+            {
+                Name = "Preference-Only Patcher Mod",
+                Guid = Guid.NewGuid(),
+                InstallationMethod = "HoloPatcher Mod",
+                Directions = "Recommend Drew's fix, as it preserves more of the original dialogue.",
+            };
+
+            IReadOnlyList<DraftInstructionResult> results = DraftInstructionService.GenerateDraftInstructions(new[] { component });
+
+            Assert.That(results, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions[0].Action, Is.EqualTo(Instruction.ActionType.Patcher));
+            AssertInstructionIsSandboxed(component.Instructions[0]);
+        }
+
         [Test]
         public void DraftInstructions_ComponentWithExistingInstructions_IsNeverTouched()
         {
@@ -266,6 +450,74 @@ public void DraftInstructions_UnparseableProse_DegradesGracefullyToNoDrafts()
             });
         }
 
+        [Test]
+        public void DraftInstructions_EmptyDirectionsLooseFileMod_UsesInstallationMethodFallback()
+        {
+            ModComponent component = CreateComponent(string.Empty);
+            component.InstallationMethod = "Loose-File Mod";
+
+            IReadOnlyList<DraftInstructionResult> results = DraftInstructionService.GenerateDraftInstructions(new[] { component });
+
+            Assert.That(results, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions[0].Action, Is.EqualTo(Instruction.ActionType.Move));
+            AssertInstructionIsSandboxed(component.Instructions[0]);
+        }
+
+        [Test]
+        public void DraftInstructions_EmptyDirectionsTslpatcherMod_UsesPatcherFallback()
+        {
+            ModComponent component = CreateComponent(string.Empty);
+            component.InstallationMethod = "TSLPatcher Mod";
+
+            IReadOnlyList<DraftInstructionResult> results = DraftInstructionService.GenerateDraftInstructions(new[] { component });
+
+            Assert.That(results, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions[0].Action, Is.EqualTo(Instruction.ActionType.Patcher));
+            AssertInstructionIsSandboxed(component.Instructions[0]);
+        }
+
+        [Test]
+        public void DraftInstructions_RecommendationOnlyLooseFileProse_UsesLooseFileFallback()
+        {
+            ModComponent component = CreateComponent(
+                "Recommend the version without overlays, but it's personal preference.");
+            component.InstallationMethod = "Loose-File Mod";
+
+            IReadOnlyList<DraftInstructionResult> results = DraftInstructionService.GenerateDraftInstructions(new[] { component });
+
+            Assert.That(results, Has.Count.EqualTo(1));
+            Assert.That(component.Instructions[0].Action, Is.EqualTo(Instruction.ActionType.Move));
+            AssertInstructionIsSandboxed(component.Instructions[0]);
+        }
+
+        [Test]
+        public void DraftInstructions_K2SiteProsePatterns_DraftSandboxedInstructions()
+        {
+            var cases = new (string Prose, Instruction.ActionType Expected)[]
+            {
+                ("Install the files within the Override folder.", Instruction.ActionType.Move),
+                ("Download the .tpc variant of the mod. For this mod only, do not overwrite if prompted!", Instruction.ActionType.Move),
+                ("Run the HoloPatcher executable. Select the default install, not M4-78.", Instruction.ActionType.Patcher),
+                ("If you would like to have Visas's class as Sith Assassin, install the \"Standard + Sith Assassin Visas\" option. Otherwise, simply install \"Standard.\"", Instruction.ActionType.Patcher),
+            };
+
+            foreach ((string prose, Instruction.ActionType expected) in cases)
+            {
+                ModComponent component = CreateComponent(prose);
+                component.InstallationMethod = expected == Instruction.ActionType.Patcher ? "HoloPatcher Mod" : "Loose-File Mod";
+
+                IReadOnlyList<DraftInstructionResult> results = DraftInstructionService.GenerateDraftInstructions(new[] { component });
+
+                Assert.That(results, Has.Count.EqualTo(1), $"Expected draft for prose: {prose}");
+                Assert.That(component.Instructions.Any(i => i.Action == expected), Is.True, $"Expected {expected} for: {prose}");
+                foreach (Instruction instruction in component.Instructions)
+                {
+                    AssertInstructionIsSandboxed(instruction);
+                }
+            }
+        }
+
         [Test]
         public void DraftInstructions_EmptyDirections_ProducesNoDrafts()
         {
@@ -548,7 +800,8 @@ public void K2FullGuideFixture_ParseDirections_DraftsSandboxedInstructions()
             GuideIngestResult ingested = GuideIngestService.Instance.IngestFromText(markdown, formatHint: "markdown", parseDirections: true);
 
             Assert.That(ingested.Components.Count, Is.GreaterThanOrEqualTo(100));
-            Assert.That(ingested.DraftResults, Is.Not.Empty, "NLP should draft instructions for at least one K2 Full component");
+            Assert.That(ingested.DraftResults.Count, Is.GreaterThanOrEqualTo(130),
+                "K2 Full fixture should draft instructions for the majority of real mod entries");
 
             foreach (DraftInstructionResult draft in ingested.DraftResults)
             {