diff --git a/src/services/ghost/__tests__/GhostRecentOperations.spec.ts b/src/services/ghost/__tests__/GhostRecentOperations.spec.ts
index a9485bb94f6..7c7780d51e4 100644
--- a/src/services/ghost/__tests__/GhostRecentOperations.spec.ts
+++ b/src/services/ghost/__tests__/GhostRecentOperations.spec.ts
@@ -124,8 +124,8 @@ describe("GhostRecentOperations", () => {
 		const { userPrompt } = autoTriggerStrategy.getPrompts(autocompleteInput, prefix, suffix, languageId)
 
 		// Verify that the prompt includes the recent operations section
-		// The new strategy system uses "## Recent Typing" format
-		expect(userPrompt).toContain("## Recent Typing")
+		// The strategy system uses "<RECENT_EDITS>" XML format
+		expect(userPrompt).toContain("<RECENT_EDITS>")
 	})
 
 	it("should not include recent operations in the prompt when not available", async () => {
diff --git a/src/services/ghost/__tests__/GhostServiceManager.spec.ts b/src/services/ghost/__tests__/GhostServiceManager.spec.ts
index dbc6d54c698..75f5bbb9376 100644
--- a/src/services/ghost/__tests__/GhostServiceManager.spec.ts
+++ b/src/services/ghost/__tests__/GhostServiceManager.spec.ts
@@ -111,15 +111,14 @@ describe("GhostServiceManager", () => {
 			expect(result.suggestions.hasSuggestions()).toBe(false)
 		})
 
-		it("should handle invalid XML format", async () => {
+		it("should handle invalid COMPLETION format", async () => {
 			const initialContent = `console.log('test');`
 			const { context } = await setupTestDocument("invalid.js", initialContent)
 
-			// Test invalid XML format
-			const invalidXML = "This is not a valid XML format"
+			const invalidCOMPLETION = "This is not a valid COMPLETION format"
 			const position = context.range?.start ?? context.document.positionAt(0)
 			const { prefix, suffix } = extractPrefixSuffix(context.document, position)
-			const result = parseGhostResponse(invalidXML, prefix, suffix)
+			const result = parseGhostResponse(invalidCOMPLETION, prefix, suffix)
 			expect(result.suggestions.hasSuggestions()).toBe(false)
 		})
 
@@ -133,14 +132,12 @@ describe("GhostServiceManager", () => {
 				openFiles: [],
 			}
 
-			// Use XML format
-			const xmlResponse = `<change><search><![CDATA[console.log('test');]]></search><replace><![CDATA[// Added comment
-console.log('test');]]></replace></change>`
+			const completionResponse = `<COMPLETION>// Added comment
+console.log('test');</COMPLETION>`
 
 			const position = context.range?.start ?? context.document.positionAt(0)
 			const { prefix, suffix } = extractPrefixSuffix(context.document, position)
-			const result = parseGhostResponse(xmlResponse, prefix, suffix)
-			// Should work with the XML format
+			const result = parseGhostResponse(completionResponse, prefix, suffix)
 			expect(result.suggestions.hasSuggestions()).toBe(true)
 		})
 	})
diff --git a/src/services/ghost/classic-auto-complete/AutoTriggerStrategy.ts b/src/services/ghost/classic-auto-complete/AutoTriggerStrategy.ts
index fa95dcf54a3..f2ab1b669f8 100644
--- a/src/services/ghost/classic-auto-complete/AutoTriggerStrategy.ts
+++ b/src/services/ghost/classic-auto-complete/AutoTriggerStrategy.ts
@@ -1,45 +1,94 @@
 import { AutocompleteInput } from "../types"
 import { CURSOR_MARKER } from "./ghostConstants"
-import { isCommentLine, cleanComment } from "./CommentHelpers"
 import type { TextDocument, Range } from "vscode"
 
 export function getBaseSystemInstructions(): string {
-	return `CRITICAL OUTPUT FORMAT:
-You must respond with XML-formatted changes ONLY. No explanations or text outside XML tags.
-
-Format: <change><search><![CDATA[exact_code]]></search><replace><![CDATA[new_code]]></replace></change>
-
-MANDATORY XML STRUCTURE RULES:
-- Every <change> tag MUST have a closing </change> tag
-- Every <search> tag MUST have a closing </search> tag
-- Every <replace> tag MUST have a closing </replace> tag
-- Every <![CDATA[ MUST have a closing ]]>
-- XML tags should be properly formatted and nested
-- Multiple <change> blocks allowed for different modifications
-
-CHANGE ORDERING PRIORITY:
-- CRITICAL: Order all <change> blocks by proximity to the cursor marker (<<<AUTOCOMPLETE_HERE>>>)
-- Put changes closest to the cursor marker FIRST in your response
-- This allows immediate display of the most relevant suggestions to the user
-- Changes further from the cursor should come later in the response
-- Measure proximity by line distance from the cursor marker position
-
-CONTENT MATCHING RULES:
-- Search content must match EXACTLY (including whitespace, indentation, and line breaks)
-- Use CDATA wrappers for all code content
-- Preserve all line breaks and formatting within CDATA sections
-- Never generate overlapping changes
-- The <search> block must contain exact text that exists in the code
-- If you can't find exact match, don't generate that change
-
-EXAMPLE:
-<change><search><![CDATA[function example() {
-	 // old code
-}]]></search><replace><![CDATA[function example() {
-	 // new code
-}]]></replace></change>
-
---
+	return `You are a HOLE FILLER. You are provided with a file containing holes, formatted as '{{FILL_HERE}}'. Your TASK is to complete with a string to replace this hole with, inside a <COMPLETION/> XML tag, including context-aware indentation, if needed. All completions MUST be truthful, accurate, well-written and correct.
+
+## Context Tags
+<LANGUAGE>: file language | <RECENT_EDITS>: recent changes | <QUERY>: code with {{FILL_HERE}}
+
+## EXAMPLE QUERY:
+
+<QUERY>
+function sum_evens(lim) {
+  var sum = 0;
+  for (var i = 0; i < lim; ++i) {
+    {{FILL_HERE}}
+  }
+  return sum;
+}
+</QUERY>
+
+TASK: Fill the {{FILL_HERE}} hole.
+
+## CORRECT COMPLETION
+
+<COMPLETION>if (i % 2 === 0) {
+      sum += i;
+    }</COMPLETION>
+
+## EXAMPLE QUERY:
+
+<QUERY>
+def sum_list(lst):
+  total = 0
+  for x in lst:
+  {{FILL_HERE}}
+  return total
+
+print sum_list([1, 2, 3])
+</QUERY>
+
+## CORRECT COMPLETION:
+
+<COMPLETION>  total += x</COMPLETION>
+
+## EXAMPLE QUERY:
+
+<QUERY>
+// data Tree a = Node (Tree a) (Tree a) | Leaf a
+
+// sum :: Tree Int -> Int
+// sum (Node lft rgt) = sum lft + sum rgt
+// sum (Leaf val)     = val
+
+// convert to TypeScript:
+{{FILL_HERE}}
+</QUERY>
+
+## CORRECT COMPLETION:
+
+<COMPLETION>type Tree<T>
+  = {$:"Node", lft: Tree<T>, rgt: Tree<T>}
+  | {$:"Leaf", val: T};
+
+function sum(tree: Tree<number>): number {
+  switch (tree.$) {
+    case "Node":
+      return sum(tree.lft) + sum(tree.rgt);
+    case "Leaf":
+      return tree.val;
+  }
+}</COMPLETION>
+
+## EXAMPLE QUERY:
+
+The 5th {{FILL_HERE}} is Jupiter.
+
+## CORRECT COMPLETION:
+
+<COMPLETION>planet from the Sun</COMPLETION>
+
+## EXAMPLE QUERY:
+
+function hypothenuse(a, b) {
+  return Math.sqrt({{FILL_HERE}}b ** 2);
+}
+
+## CORRECT COMPLETION:
+
+<COMPLETION>a ** 2 + </COMPLETION>
 
 `
 }
@@ -56,20 +105,6 @@ export function addCursorMarker(document: TextDocument, range?: Range): string {
 }
 
 export class AutoTriggerStrategy {
-	shouldTreatAsComment(prefix: string, languageId: string): boolean {
-		const lines = prefix.split("\n")
-		const currentLine = lines[lines.length - 1].trim() || ""
-		const previousLine = lines.length > 1 ? lines[lines.length - 2].trim() : ""
-
-		if (isCommentLine(currentLine, languageId)) {
-			return true
-		} else if (currentLine === "" && previousLine) {
-			return isCommentLine(previousLine, languageId)
-		} else {
-			return false
-		}
-	}
-
 	getPrompts(
 		autocompleteInput: AutocompleteInput,
 		prefix: string,
@@ -79,24 +114,17 @@ export class AutoTriggerStrategy {
 		systemPrompt: string
 		userPrompt: string
 	} {
-		if (this.shouldTreatAsComment(prefix, languageId)) {
-			return {
-				systemPrompt: this.getCommentsSystemInstructions(),
-				userPrompt: this.getCommentsUserPrompt(prefix, suffix, languageId),
-			}
-		} else {
-			return {
-				systemPrompt: this.getSystemInstructions(),
-				userPrompt: this.getUserPrompt(autocompleteInput, prefix, suffix, languageId),
-			}
+		return {
+			systemPrompt: this.getSystemInstructions(),
+			userPrompt: this.getUserPrompt(autocompleteInput, prefix, suffix, languageId),
 		}
 	}
 
 	getSystemInstructions(): string {
 		return (
 			getBaseSystemInstructions() +
-			`Task: Subtle Auto-Completion
-Provide non-intrusive completions after a typing pause. Be conservative and helpful.
+			`Task: Auto-Completion
+Provide a subtle, non-intrusive completion after a typing pause.
 
 `
 		)
@@ -106,108 +134,24 @@ Provide non-intrusive completions after a typing pause. Be conservative and help
 	 * Build minimal prompt for auto-trigger
 	 */
 	getUserPrompt(autocompleteInput: AutocompleteInput, prefix: string, suffix: string, languageId: string): string {
-		let prompt = ""
+		let prompt = `<LANGUAGE>${languageId}</LANGUAGE>\n\n`
 
-		// Start with recent typing context from autocompleteInput
 		if (autocompleteInput.recentlyEditedRanges && autocompleteInput.recentlyEditedRanges.length > 0) {
-			prompt += "## Recent Typing\n"
+			prompt += "<RECENT_EDITS>\n"
 			autocompleteInput.recentlyEditedRanges.forEach((range, index) => {
 				const description = `Edited ${range.filepath} at line ${range.range.start.line}`
 				prompt += `${index + 1}. ${description}\n`
 			})
-			prompt += "\n"
+			prompt += "</RECENT_EDITS>\n\n"
 		}
 
-		// Add current position from autocompleteInput
-		const line = autocompleteInput.pos.line + 1
-		const char = autocompleteInput.pos.character + 1
-		prompt += `## Current Position\n`
-		prompt += `Line ${line}, Character ${char}\n\n`
-
-		// Add the full document with cursor marker
-		const codeWithCursor = `${prefix}${CURSOR_MARKER}${suffix}`
-		prompt += "## Full Code\n"
-		prompt += `\`\`\`${languageId}\n${codeWithCursor}\n\`\`\`\n\n`
-
-		// Add specific instructions
-		prompt += "## Instructions\n"
-		prompt += `Provide a minimal, obvious completion at the cursor position (${CURSOR_MARKER}).\n`
-		prompt += `IMPORTANT: Your <search> block must include the cursor marker ${CURSOR_MARKER} to target the exact location.\n`
-		prompt += `Include surrounding text with the cursor marker to avoid conflicts with similar code elsewhere.\n`
-		prompt += "Complete only what the user appears to be typing.\n"
-		prompt += "Single line preferred, no new features.\n"
-		prompt += "If nothing obvious to complete, provide NO suggestion.\n"
+		prompt += `<QUERY>
+${prefix}{{FILL_HERE}}${suffix}
+</QUERY>
 
-		return prompt
-	}
+TASK: Fill the {{FILL_HERE}} hole. Answer only with the CORRECT completion, and NOTHING ELSE. Do it now.
+Return the COMPLETION tags`
 
-	getCommentsSystemInstructions(): string {
-		return (
-			getBaseSystemInstructions() +
-			`You are an expert code generation assistant that implements code based on comments.
-
-## Core Responsibilities:
-1. Read and understand the comment's intent
-2. Generate complete, working code that fulfills the comment's requirements
-3. Follow the existing code style and patterns
-4. Add appropriate error handling
-5. Include necessary imports or dependencies
-
-## Code Generation Guidelines:
-- Generate only the code that directly implements the comment
-- Match the indentation level of the comment
-- Use descriptive variable and function names
-- Follow language-specific best practices
-- Add type annotations where appropriate
-- Consider edge cases mentioned in the comment
-- If the comment describes multiple steps, implement them all
-
-## Comment Types to Handle:
-- TODO comments: Implement the described task
-- FIXME comments: Fix the described issue
-- Implementation comments: Generate the described functionality
-- Algorithm descriptions: Implement the described algorithm
-- API/Interface descriptions: Implement the described interface
-
-## Output Requirements:
-- Generate ONLY executable code that implements the comment
-- PRESERVE all existing code and comments in the provided context
-- Do not repeat the comment you are implementing in your output
-- Do not add explanatory comments unless necessary for complex logic
-- Ensure the code is production-ready
-- When using search/replace format, include ALL existing code to preserve it`
-		)
-	}
-
-	getCommentsUserPrompt(prefix: string, suffix: string, languageId: string): string {
-		// Extract the comment from the prefix
-		const lines = prefix.split("\n")
-		const lastLine = lines[lines.length - 1]
-		const previousLine = lines.length > 1 ? lines[lines.length - 2] : ""
-
-		// Determine which line contains the comment
-		const commentLine = isCommentLine(lastLine, languageId) ? lastLine : previousLine
-		const comment = cleanComment(commentLine, languageId)
-
-		const codeWithCursor = `${prefix}${CURSOR_MARKER}${suffix}`
-
-		let prompt = `## Comment-Driven Development
-- Language: ${languageId}
-- Comment to Implement:
-\`\`\`
-${comment}
-\`\`\`
-
-## Full Code
-\`\`\`${languageId}
-${codeWithCursor}
-\`\`\`
-
-## Instructions
-Generate code that implements the functionality described in the comment.
-The code should be placed at the cursor position (${CURSOR_MARKER}).
-Focus on implementing exactly what the comment describes.
-`
 		return prompt
 	}
 }
diff --git a/src/services/ghost/classic-auto-complete/GhostStreamingParser.ts b/src/services/ghost/classic-auto-complete/GhostStreamingParser.ts
index 566a9003913..789d6945e60 100644
--- a/src/services/ghost/classic-auto-complete/GhostStreamingParser.ts
+++ b/src/services/ghost/classic-auto-complete/GhostStreamingParser.ts
@@ -1,6 +1,4 @@
-import * as vscode from "vscode"
 import { GhostSuggestionsState } from "./GhostSuggestions"
-import { CURSOR_MARKER } from "./ghostConstants"
 
 export interface StreamingParseResult {
 	suggestions: GhostSuggestionsState
@@ -8,233 +6,35 @@ export interface StreamingParseResult {
 	hasNewSuggestions: boolean
 }
 
-export interface ParsedChange {
-	search: string
-	replace: string
-}
-
-function removeCursorMarker(content: string): string {
-	return content.replaceAll(CURSOR_MARKER, "")
-}
-
-/**
- * Conservative XML sanitization - only fixes the specific case from user feedback
- */
-export function sanitizeXMLConservative(buffer: string): string {
-	let sanitized = buffer
-
-	// Fix malformed CDATA sections first - this is the main bug from user logs
-	// Replace </![CDATA[ with ]]> to fix malformed CDATA closures
-	sanitized = sanitized.replace(/<\/!\[CDATA\[/g, "]]>")
-
-	// Only fix the specific case: missing </change> tag when we have complete search/replace pairs
-	const changeOpenCount = (sanitized.match(/<change>/g) || []).length
-	const changeCloseCount = (sanitized.match(/<\/change>/g) || []).length
-
-	// Check if we have an incomplete </change> tag (like "</change" without the final ">")
-	const incompleteChangeClose = sanitized.includes("</change") && !sanitized.includes("</change>")
-
-	// Handle two cases:
-	// 1. Missing </change> tag entirely (changeCloseCount === 0 && !incompleteChangeClose)
-	// 2. Incomplete </change> tag (incompleteChangeClose)
-	if (changeOpenCount === 1 && changeCloseCount === 0) {
-		const searchCloseCount = (sanitized.match(/<\/search>/g) || []).length
-		const replaceCloseCount = (sanitized.match(/<\/replace>/g) || []).length
-
-		// Only fix if we have complete search/replace pairs
-		if (searchCloseCount === 1 && replaceCloseCount === 1) {
-			if (incompleteChangeClose) {
-				// Fix incomplete </change tag by adding the missing ">"
-				sanitized = sanitized.replace("</change", "</change>")
-			} else {
-				// Add missing </change> tag entirely
-				const trimmed = sanitized.trim()
-				// Make sure we're not in the middle of streaming an incomplete tag
-				if (!trimmed.endsWith("<")) {
-					sanitized += "</change>"
-				}
-			}
-		}
-	}
-
-	return sanitized
-}
-
-/**
- * Check if the response appears to be complete
- */
-function isResponseComplete(buffer: string): boolean {
-	const incompleteChangeMatch = /<change(?:\s[^>]*)?>(?:(?!<\/change>)[\s\S])*$/i.test(buffer)
-	const incompleteSearchMatch = /<search(?:\s[^>]*)?>(?:(?!<\/search>)[\s\S])*$/i.test(buffer)
-	const incompleteReplaceMatch = /<replace(?:\s[^>]*)?>(?:(?!<\/replace>)[\s\S])*$/i.test(buffer)
-	const incompleteCDataMatch = /<!\[CDATA\[(?:(?!\]\]>)[\s\S])*$/i.test(buffer)
-
-	return !(incompleteChangeMatch || incompleteSearchMatch || incompleteReplaceMatch || incompleteCDataMatch)
-}
-
-export interface MatchResult {
-	startIndex: number
-	matchLength: number
-}
-
-/**
- * Find the best match for search content in the document, handling whitespace differences and cursor markers
- * Returns both the start index and the actual length of the matched content
- */
-export function findBestMatch(content: string, searchPattern: string): MatchResult {
-	// Validate inputs
-	if (!content || !searchPattern) {
-		return { startIndex: -1, matchLength: 0 }
-	}
-
-	// Strategy 1: Try exact match (fastest path)
-	let index = content.indexOf(searchPattern)
-	if (index !== -1) {
-		return { startIndex: index, matchLength: searchPattern.length }
-	}
-
-	// Strategy 2: Fuzzy match with whitespace normalization
-	const contentLen = content.length
-	const patternLen = searchPattern.length
-
-	// Try starting the match at each position in content
-	for (let contentStart = 0; contentStart < contentLen; contentStart++) {
-		let contentPos = contentStart
-		let patternPos = 0
-
-		// Try to match the entire pattern starting from contentStart
-		while (patternPos < patternLen && contentPos < contentLen) {
-			const contentChar = content[contentPos]
-			const patternChar = searchPattern[patternPos]
-
-			const contentIsNewline = isNewline(contentChar)
-			const patternIsNewline = isNewline(patternChar)
-
-			// Special case: pattern has newline but content has non-newline whitespace
-			// Skip trailing whitespace in content before newline
-			if (patternIsNewline && isNonNewlineWhitespace(contentChar)) {
-				const savedContentPos = contentPos
-				contentPos = skipChars(content, contentPos, isNonNewlineWhitespace)
-
-				if (contentPos < contentLen && isNewline(content[contentPos])) {
-					continue
-				}
-
-				contentPos = savedContentPos
-				break
-			}
-
-			if (contentIsNewline !== patternIsNewline) {
-				break
-			}
-
-			if (contentIsNewline && patternIsNewline) {
-				contentPos = skipChars(content, contentPos, isNewline)
-				patternPos = skipChars(searchPattern, patternPos, isNewline)
-				continue
-			}
-
-			const contentIsWhitespace = isNonNewlineWhitespace(contentChar)
-			const patternIsWhitespace = isNonNewlineWhitespace(patternChar)
-
-			if (contentIsWhitespace && patternIsWhitespace) {
-				contentPos = skipChars(content, contentPos, isNonNewlineWhitespace)
-				patternPos = skipChars(searchPattern, patternPos, isNonNewlineWhitespace)
-				continue
-			}
-
-			if (contentChar === patternChar) {
-				contentPos++
-				patternPos++
-				continue
-			}
-
-			// Characters don't match and can't be normalized - this starting position fails
-			break
-		}
-
-		// Check if we matched the entire pattern, or if we only have trailing whitespace left in pattern
-		if (patternPos === patternLen) {
-			return { startIndex: contentStart, matchLength: contentPos - contentStart }
-		}
-
-		// Allow trailing whitespace/newlines in the pattern
-		if (patternPos < patternLen) {
-			patternPos = skipChars(searchPattern, patternPos, (c) => isNewline(c) || isNonNewlineWhitespace(c))
-			if (patternPos === patternLen) {
-				return { startIndex: contentStart, matchLength: contentPos - contentStart }
-			}
-		}
-	}
-
-	return { startIndex: -1, matchLength: 0 } // No match found
-}
-
-/**
- * Check if a character is a newline (\n, \r, or part of \r\n)
- */
-function isNewline(char: string): boolean {
-	return char === "\n" || char === "\r"
-}
-
 /**
- * Check if a character is non-newline whitespace (space or tab)
- */
-function isNonNewlineWhitespace(char: string): boolean {
-	return char === " " || char === "\t"
-}
-
-/**
- * Skip consecutive characters that match the predicate and return the next position
- */
-function skipChars(text: string, startPos: number, predicate: (char: string) => boolean): number {
-	let pos = startPos
-	while (pos < text.length && predicate(text[pos])) {
-		pos++
-	}
-	return pos
-}
-
-/**
- * Sanitize response if needed and return sanitized response with completion status
- */
-function sanitizeResponseIfNeeded(response: string): { sanitizedResponse: string; isComplete: boolean } {
-	let sanitizedResponse = response
-	let isComplete = isResponseComplete(sanitizedResponse)
-
-	if (!isComplete) {
-		sanitizedResponse = sanitizeXMLConservative(sanitizedResponse)
-		isComplete = isResponseComplete(sanitizedResponse) // Re-check completion after sanitization
-	}
-
-	return { sanitizedResponse, isComplete }
-}
-
-/**
- * Parse the response
+ * Parse the response - only handles responses with <COMPLETION> tags
  */
 export function parseGhostResponse(fullResponse: string, prefix: string, suffix: string): StreamingParseResult {
-	const { sanitizedResponse, isComplete } = sanitizeResponseIfNeeded(fullResponse)
-
-	const newChanges = extractCompletedChanges(sanitizedResponse)
-	let hasNewSuggestions = newChanges.length > 0
+	const suggestions = new GhostSuggestionsState()
+	let hasNewSuggestions = false
 
-	// Generate suggestions from all completed changes
-	const modifiedContent = generateModifiedContent(newChanges, prefix, suffix, prefix + suffix)
+	let fimText: string = ""
+	let isComplete: boolean = true
 
-	const modifiedContent_has_prefix_and_suffix =
-		modifiedContent?.startsWith(prefix) && modifiedContent.endsWith(suffix)
+	// Match content strictly between <COMPLETION> and </COMPLETION> tags
+	const completionMatch = fullResponse.match(/<COMPLETION>([\s\S]*?)<\/COMPLETION>/i)
 
-	const suggestions = new GhostSuggestionsState()
+	if (completionMatch) {
+		// Extract the captured group (content between tags)
+		fimText = completionMatch[1] || ""
+		isComplete = true
+	}
+	// Remove any accidentally captured tag remnants
+	fimText = fimText.replace(/<\/?COMPLETION>/gi, "")
 
-	if (modifiedContent_has_prefix_and_suffix && modifiedContent) {
-		// Mark as FIM option
-		const middle = modifiedContent.slice(prefix.length, modifiedContent.length - suffix.length)
+	// Create suggestion if there's actual content
+	if (fimText.length > 0) {
 		suggestions.setFillInAtCursor({
-			text: middle,
+			text: fimText,
 			prefix,
 			suffix,
 		})
+		hasNewSuggestions = true
 	}
 
 	return {
@@ -243,122 +43,3 @@ export function parseGhostResponse(fullResponse: string, prefix: string, suffix:
 		hasNewSuggestions,
 	}
 }
-
-/**
- * Extract completed <change> blocks from the buffer
- */
-function extractCompletedChanges(searchText: string): ParsedChange[] {
-	const changeRegex =
-		/<change>\s*<search>\s*<!\[CDATA\[([\s\S]*?)\]\]>\s*<\/search>\s*<replace>\s*<!\[CDATA\[([\s\S]*?)\]\]>\s*<\/replace>\s*<\/change>/g
-
-	return Array.from(searchText.matchAll(changeRegex), (match) => ({
-		search: match[1],
-		replace: match[2],
-	}))
-}
-
-/**
- * Generate modified content by applying changes to the document
- */
-function generateModifiedContent(
-	changes: ParsedChange[],
-	prefix: string,
-	suffix: string,
-	currentContent: string,
-): string | undefined {
-	if (changes.length === 0) {
-		return undefined
-	}
-
-	// Add cursor marker to document content if it's not already there
-	// This ensures that when LLM searches for <<<AUTOCOMPLETE_HERE>>>, it can find it
-	let modifiedContent = currentContent
-	const needsCursorMarker =
-		changes.some((change) => change.search.includes(CURSOR_MARKER)) && !currentContent.includes(CURSOR_MARKER)
-	if (needsCursorMarker) {
-		// Construct content with cursor marker at the position between prefix and suffix
-		modifiedContent = prefix + CURSOR_MARKER + suffix
-	}
-
-	// Process changes: preserve search content as-is, clean replace content for application
-	const filteredChanges = changes.map((change) => ({
-		search: change.search, // Keep cursor markers for matching against document
-		replace: removeCursorMarker(change.replace), // Clean for content application
-	}))
-
-	// Apply changes in reverse order to maintain line numbers
-	const appliedChanges: Array<{
-		searchContent: string
-		replaceContent: string
-		startIndex: number
-		endIndex: number
-	}> = []
-
-	for (const change of filteredChanges) {
-		const matchResult = findBestMatch(modifiedContent, change.search)
-
-		if (matchResult.startIndex !== -1) {
-			// Check for overlapping changes before applying
-			const endIndex = matchResult.startIndex + matchResult.matchLength
-			const hasOverlap = appliedChanges.some((existingChange) => {
-				// Check if ranges overlap
-				const existingStart = existingChange.startIndex
-				const existingEnd = existingChange.endIndex
-				return matchResult.startIndex < existingEnd && endIndex > existingStart
-			})
-
-			if (hasOverlap) {
-				console.warn("Skipping overlapping change:", change.search.substring(0, 50))
-				continue // Skip this change to avoid duplicates
-			}
-
-			// Handle the case where search pattern ends with newline but we need to preserve additional whitespace
-			let adjustedReplaceContent = change.replace
-
-			// If the search pattern ends with a newline, check if there are additional empty lines after it
-			if (change.search.endsWith("\n")) {
-				let nextCharIndex = endIndex
-				let extraNewlines = ""
-
-				// Count consecutive newlines after the search pattern
-				while (nextCharIndex < modifiedContent.length && modifiedContent[nextCharIndex] === "\n") {
-					extraNewlines += "\n"
-					nextCharIndex++
-				}
-
-				// If we found extra newlines, preserve them by adding them to the replacement
-				if (extraNewlines.length > 0) {
-					// Only add the extra newlines if the replacement doesn't already end with enough newlines
-					if (!adjustedReplaceContent.endsWith("\n" + extraNewlines)) {
-						adjustedReplaceContent = adjustedReplaceContent.trimEnd() + "\n" + extraNewlines
-					}
-				}
-			}
-
-			appliedChanges.push({
-				searchContent: change.search,
-				replaceContent: adjustedReplaceContent,
-				startIndex: matchResult.startIndex,
-				endIndex: endIndex,
-			})
-		}
-	}
-
-	// Sort by start index in descending order to apply changes from end to beginning
-	appliedChanges.sort((a, b) => b.startIndex - a.startIndex)
-
-	// Apply the changes
-	for (const change of appliedChanges) {
-		modifiedContent =
-			modifiedContent.substring(0, change.startIndex) +
-			change.replaceContent +
-			modifiedContent.substring(change.endIndex)
-	}
-
-	// Remove cursor marker from the final content if we added it
-	if (needsCursorMarker) {
-		modifiedContent = removeCursorMarker(modifiedContent)
-	}
-
-	return modifiedContent
-}
diff --git a/src/services/ghost/classic-auto-complete/__tests__/AutoTriggerStrategy.test.ts b/src/services/ghost/classic-auto-complete/__tests__/AutoTriggerStrategy.test.ts
index ca3a298f5d6..7b5452cf1bf 100644
--- a/src/services/ghost/classic-auto-complete/__tests__/AutoTriggerStrategy.test.ts
+++ b/src/services/ghost/classic-auto-complete/__tests__/AutoTriggerStrategy.test.ts
@@ -25,128 +25,97 @@ describe("AutoTriggerStrategy", () => {
 		strategy = new AutoTriggerStrategy()
 	})
 
-	describe("shouldTreatAsComment", () => {
-		it("should return true when current line is a comment", () => {
-			const prefix = "// TODO: implement"
-			const result = strategy.shouldTreatAsComment(prefix, "typescript")
-			expect(result).toBe(true)
-		})
-
-		it("should return true when current line is empty and previous line is a comment", () => {
-			const prefix = "// TODO: implement\n"
-			const result = strategy.shouldTreatAsComment(prefix, "typescript")
-			expect(result).toBe(true)
-		})
-
-		it("should return false when current line is not a comment", () => {
-			const prefix = "const x = 1;"
-			const result = strategy.shouldTreatAsComment(prefix, "typescript")
-			expect(result).toBe(false)
-		})
-
-		it("should return false when current line is empty and previous line is not a comment", () => {
-			const prefix = "const x = 1;\n"
-			const result = strategy.shouldTreatAsComment(prefix, "typescript")
-			expect(result).toBe(false)
-		})
-
-		it("should return false when prefix is empty", () => {
-			const prefix = ""
-			const result = strategy.shouldTreatAsComment(prefix, "typescript")
-			expect(result).toBe(false)
-		})
-
-		it("should handle Python comments", () => {
-			const prefix = "# TODO: implement"
-			const result = strategy.shouldTreatAsComment(prefix, "python")
-			expect(result).toBe(true)
-		})
-
-		it("should handle block comments", () => {
-			const prefix = "/* TODO: implement */"
-			const result = strategy.shouldTreatAsComment(prefix, "javascript")
-			expect(result).toBe(true)
-		})
+	describe("getPrompts", () => {
+		it("should generate prompts with QUERY/FILL_HERE format", () => {
+			const { systemPrompt, userPrompt } = strategy.getPrompts(
+				createAutocompleteInput("/test.ts", 0, 13),
+				"const x = 1;\n",
+				"",
+				"typescript",
+			)
 
-		it("should handle multi-line prefix with comment on last line", () => {
-			const prefix = "const x = 1;\nconst y = 2;\n// TODO: implement sum"
-			const result = strategy.shouldTreatAsComment(prefix, "typescript")
-			expect(result).toBe(true)
-		})
+			// Verify system prompt contains auto-trigger keywords
+			expect(systemPrompt).toContain("Auto-Completion")
+			expect(systemPrompt).toContain("non-intrusive")
 
-		it("should handle multi-line prefix with empty last line after comment", () => {
-			const prefix = "const x = 1;\n// TODO: implement sum\n"
-			const result = strategy.shouldTreatAsComment(prefix, "typescript")
-			expect(result).toBe(true)
+			// Verify user prompt uses QUERY/FILL_HERE format
+			expect(userPrompt).toContain("<QUERY>")
+			expect(userPrompt).toContain("{{FILL_HERE}}")
+			expect(userPrompt).toContain("</QUERY>")
+			expect(userPrompt).toContain("COMPLETION")
 		})
-	})
 
-	describe("getPrompts - comment-driven behavior", () => {
-		it("should use comment-specific prompts when cursor is on empty line after comment", () => {
-			const { systemPrompt, userPrompt } = strategy.getPrompts(
-				createAutocompleteInput("/test.ts", 1, 0),
-				"// TODO: implement sum function\n",
+		it("should document context tags in system prompt", () => {
+			const { systemPrompt } = strategy.getPrompts(
+				createAutocompleteInput("/test.ts", 0, 13),
+				"const x = 1;\n",
 				"",
 				"typescript",
 			)
 
-			// Verify system prompt contains comment-specific keywords
-			expect(systemPrompt.toLowerCase()).toContain("comment")
-			expect(systemPrompt).toContain("TODO")
-			expect(systemPrompt).toContain("implement")
-
-			// Verify user prompt contains comment context
-			expect(userPrompt).toContain("Comment-Driven Development")
-			expect(userPrompt).toContain("implement sum function")
+			// Verify system prompt documents the XML tags
+			expect(systemPrompt).toContain("Context Tags")
+			expect(systemPrompt).toContain("<LANGUAGE>")
+			expect(systemPrompt).toContain("<RECENT_EDITS>")
+			expect(systemPrompt).toContain("<QUERY>")
 		})
 
-		it("should use comment-specific prompts when cursor is on comment line", () => {
-			const { systemPrompt, userPrompt } = strategy.getPrompts(
-				createAutocompleteInput("/test.ts", 0, 26),
-				"// FIXME: handle edge case",
-				"\n",
+		it("should include language ID in prompt with XML tags", () => {
+			const { userPrompt } = strategy.getPrompts(
+				createAutocompleteInput("/test.ts", 0, 13),
+				"const x = 1;\n",
+				"",
 				"typescript",
 			)
 
-			// Verify system prompt contains comment-specific keywords
-			expect(systemPrompt.toLowerCase()).toContain("comment")
-			expect(systemPrompt).toContain("FIXME")
+			expect(userPrompt).toContain("<LANGUAGE>typescript</LANGUAGE>")
+		})
 
-			// Verify user prompt contains comment context
-			expect(userPrompt).toContain("Comment-Driven")
-			expect(userPrompt).toContain("handle edge case")
+		it("should include recently edited ranges in prompt with XML tags", () => {
+			const input = createAutocompleteInput("/test.ts", 5, 0)
+			input.recentlyEditedRanges = [
+				{
+					filepath: "/test.ts",
+					range: { start: { line: 2, character: 0 }, end: { line: 3, character: 0 } },
+					timestamp: Date.now(),
+					lines: ["function sum(a, b) {"],
+					symbols: new Set(["sum"]),
+				},
+			]
+
+			const { userPrompt } = strategy.getPrompts(input, "const x = 1;\n", "", "typescript")
+
+			expect(userPrompt).toContain("<RECENT_EDITS>")
+			expect(userPrompt).toContain("</RECENT_EDITS>")
+			expect(userPrompt).toContain("Edited /test.ts at line 2")
 		})
-	})
 
-	describe("getPrompts - auto-trigger behavior", () => {
-		it("should use auto-trigger prompts for regular code completion", () => {
-			const { systemPrompt, userPrompt } = strategy.getPrompts(
+		it("should handle empty recently edited ranges", () => {
+			const { userPrompt } = strategy.getPrompts(
 				createAutocompleteInput("/test.ts", 0, 13),
 				"const x = 1;\n",
 				"",
 				"typescript",
 			)
 
-			// Verify system prompt contains auto-trigger keywords
-			expect(systemPrompt).toContain("Auto-Completion")
-			expect(systemPrompt).toContain("non-intrusive")
-
-			// Verify user prompt contains auto-trigger instructions
-			expect(userPrompt).toContain("minimal, obvious completion")
-			expect(userPrompt).toContain("Single line preferred")
+			expect(userPrompt).not.toContain("<RECENT_EDITS>")
+			expect(userPrompt).toContain("<LANGUAGE>typescript</LANGUAGE>")
 		})
 
-		it("should not treat empty line without preceding comment as comment-driven", () => {
-			const { systemPrompt } = strategy.getPrompts(
+		it("should handle comments in code", () => {
+			const { systemPrompt, userPrompt } = strategy.getPrompts(
 				createAutocompleteInput("/test.ts", 1, 0),
-				"const x = 1;\n",
-				"\n",
+				"// TODO: implement sum function\n",
+				"",
 				"typescript",
 			)
 
-			// Should use auto-trigger, not comment-driven
+			// Should use same prompt format
 			expect(systemPrompt).toContain("Auto-Completion")
-			expect(systemPrompt).not.toContain("Comment-Driven")
+			expect(userPrompt).toContain("<QUERY>")
+			expect(userPrompt).toContain("{{FILL_HERE}}")
+			expect(userPrompt).toContain("</QUERY>")
+			expect(userPrompt).toContain("COMPLETION")
 		})
 	})
 })
diff --git a/src/services/ghost/classic-auto-complete/__tests__/GhostStreamingParser.fuzzy-length-bug.test.ts b/src/services/ghost/classic-auto-complete/__tests__/GhostStreamingParser.fuzzy-length-bug.test.ts
deleted file mode 100644
index f83d4868612..00000000000
--- a/src/services/ghost/classic-auto-complete/__tests__/GhostStreamingParser.fuzzy-length-bug.test.ts
+++ /dev/null
@@ -1,164 +0,0 @@
-import { parseGhostResponse, findBestMatch, type MatchResult } from "../GhostStreamingParser"
-import { extractPrefixSuffix } from "../../types"
-import * as vscode from "vscode"
-
-// Mock vscode module
-vi.mock("vscode", () => ({
-	Uri: {
-		file: (path: string) => ({ toString: () => path, fsPath: path }),
-	},
-	workspace: {
-		asRelativePath: (uri: any) => uri.toString(),
-	},
-}))
-
-describe("GhostStreamingParser - Fuzzy Match Length Bug", () => {
-	describe("Bug: Using search.length instead of actual matched length", () => {
-		it("should demonstrate that actual code gets left behind when content has many extra spaces", () => {
-			// Document content with MANY extra spaces
-			const documentContent =
-				"function         test(         x,         y         )         {         return         x         +         y;         }"
-
-			// Create mock document
-			const mockDocument = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => documentContent,
-				languageId: "typescript",
-				positionAt: (offset: number) => ({ line: 0, character: offset }),
-				offsetAt: (position: any) => position.character,
-			} as any
-
-			// LLM provides a change with normalized spacing (single spaces)
-			const change = `<change><search><![CDATA[function test( x, y ) { return x + y; }]]></search><replace><![CDATA[function test(x, y) { return x * y; }]]></replace></change>`
-
-			// Use extractPrefixSuffix to get proper prefix/suffix
-			const position = mockDocument.positionAt(0)
-			const { prefix, suffix } = extractPrefixSuffix(mockDocument, position)
-			const result = parseGhostResponse(change, prefix, suffix)
-
-			// The change was found and applied
-			expect(result.hasNewSuggestions).toBe(true)
-
-			// Note: FIM won't be set because after replacement, the modified content
-			// doesn't match the original prefix+suffix pattern (this is expected)
-			// But we can verify the bug existed by checking that hasNewSuggestions is true,
-			// meaning the fuzzy match worked and the replacement was attempted.
-
-			// The bug with many spaces:
-			// Original: "function         test(         x,         y         )         {         return         x         +         y;         }"
-			// Search pattern: "function test( x, y ) { return x + y; }" (length = 41)
-			// Fuzzy matched content: entire original string (length = 113, has MANY extra spaces)
-			//
-			// BEFORE THE FIX (buggy behavior):
-			// - endIndex = startIndex + search.length = 0 + 41 = 41
-			// - Replaces only first 41 chars: "function         test(         x,      "
-			// - Leaves behind: "   y         )         {         return         x         +         y;         }"
-			// - Result: "function test(x, y) { return x * y; }   y         )         {         return         x         +         y;         }"
-			//   This is WRONG - we have leftover code "y ) { return x + y; }" that should have been replaced!
-			//
-			// AFTER THE FIX (correct behavior):
-			// - endIndex = matchResult.startIndex + matchResult.matchLength = 0 + 113
-			// - Replaces all 113 chars correctly
-			// - Result: "function test(x, y) { return x * y; }"
-
-			// The fix ensures fuzzy matching returns the actual matched length,
-			// preventing code fragments from being left behind
-		})
-
-		it("should show even more dramatic example with multiline code", () => {
-			// Document with excessive spacing in a realistic code block
-			const documentContent = `if         (         condition         )         {
-	console.log(         "test"         );
-	return         true;
-}`
-
-			// Create mock document
-			const mockDocument = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => documentContent,
-				languageId: "typescript",
-				positionAt: (offset: number) => ({ line: 0, character: offset }),
-				offsetAt: (position: any) => position.character,
-			} as any
-
-			// LLM provides normalized version
-			const change = `<change><search><![CDATA[if ( condition ) {
-	console.log( "test" );
-	return true;
-}]]></search><replace><![CDATA[if (condition) {
-	console.log("updated");
-	return false;
-}]]></replace></change>`
-
-			const position = mockDocument.positionAt(0)
-			const { prefix, suffix } = extractPrefixSuffix(mockDocument, position)
-			const result = parseGhostResponse(change, prefix, suffix)
-
-			// The change was found and applied
-			expect(result.hasNewSuggestions).toBe(true)
-
-			// The bug (before fix):
-			// Search pattern length is much shorter than the actual spaced-out content
-			// So we'd leave behind parts of the original code like:
-			// "if (condition) {\n\tconsole.log(\"updated\");\n\treturn false;\n}         )         {\n\tconsole.log(         \"test\"         );\n\treturn         true;\n}"
-			// Notice the leftover "         )         {" and other fragments!
-
-			// After the fix:
-			// The entire fuzzy-matched content is replaced correctly
-		})
-
-		it("should demonstrate with realistic variable declaration", () => {
-			// Document content with weird formatting
-			const documentContent =
-				"const         myVariable         =         calculateSomething(         param1,         param2,         param3         );"
-
-			// Create mock document
-			const mockDocument = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => documentContent,
-				languageId: "typescript",
-				positionAt: (offset: number) => ({ line: 0, character: offset }),
-				offsetAt: (position: any) => position.character,
-			} as any
-
-			// LLM wants to change the function call
-			const change = `<change><search><![CDATA[const myVariable = calculateSomething( param1, param2, param3 );]]></search><replace><![CDATA[const myVariable = calculateSomething(param1, param2, param3);]]></replace></change>`
-
-			const position = mockDocument.positionAt(0)
-			const { prefix, suffix } = extractPrefixSuffix(mockDocument, position)
-			const result = parseGhostResponse(change, prefix, suffix)
-
-			// The change was found and applied
-			expect(result.hasNewSuggestions).toBe(true)
-
-			// Bug (before fix) would leave behind: "const myVariable = calculateSomething(param1, param2, param3);         param3         );"
-			// The "         param3         );" is leftover code that should have been replaced!
-
-			// After the fix:
-			// The entire fuzzy-matched content is replaced correctly, no fragments left behind
-		})
-	})
-
-	describe("Root cause analysis", () => {
-		it("should show findBestMatch now returns both start index and match length", () => {
-			// The fix: findBestMatch now returns both start index and actual matched length
-			const content = "function         test()         {         return         true;         }"
-			const search = "function test() { return true; }"
-
-			const matchResult = findBestMatch(content, search)
-
-			// We get the start index: 0
-			expect(matchResult.startIndex).toBe(0)
-
-			// And now we also get the actual length of the matched content
-			// search.length = 32
-			// Actual matched content length = 72 (has MANY extra spaces)
-			expect(matchResult.matchLength).toBe(72)
-
-			// This ensures that in generateModifiedContent, we use:
-			// const endIndex = matchResult.startIndex + matchResult.matchLength
-			// Instead of the buggy:
-			// const endIndex = searchIndex + change.search.length
-		})
-	})
-})
diff --git a/src/services/ghost/classic-auto-complete/__tests__/GhostStreamingParser.sanitization.test.ts b/src/services/ghost/classic-auto-complete/__tests__/GhostStreamingParser.sanitization.test.ts
deleted file mode 100644
index de5a6525eb9..00000000000
--- a/src/services/ghost/classic-auto-complete/__tests__/GhostStreamingParser.sanitization.test.ts
+++ /dev/null
@@ -1,132 +0,0 @@
-import { sanitizeXMLConservative } from "../GhostStreamingParser"
-import { GhostSuggestionContext } from "../../types"
-import * as vscode from "vscode"
-
-// Mock vscode workspace
-vi.mock("vscode", async () => {
-	const actual = await vi.importActual("vscode")
-	return {
-		...actual,
-		workspace: {
-			asRelativePath: vi.fn().mockReturnValue("test/file.ts"),
-		},
-		Range: vi.fn().mockImplementation((startLine, startChar, endLine, endChar) => ({
-			start: { line: startLine, character: startChar },
-			end: { line: endLine, character: endChar },
-		})),
-	}
-})
-
-describe("GhostStreamingParser - XML Sanitization", () => {
-	let mockContext: GhostSuggestionContext
-
-	beforeEach(() => {
-		// Create mock document
-		const mockDocument = {
-			getText: vi.fn().mockReturnValue("function mutliply(<<<AUTOCOMPLETE_HERE>>>>"),
-			uri: { fsPath: "/test/file.ts", toString: () => "file:///test/file.ts" } as vscode.Uri,
-			offsetAt: vi.fn().mockReturnValue(17), // Position after "function mutliply("
-		} as unknown as vscode.TextDocument
-
-		mockContext = {
-			document: mockDocument,
-			range: { start: { line: 0, character: 17 }, end: { line: 0, character: 17 } } as vscode.Range,
-		}
-	})
-
-	describe("sanitizeXMLConservative", () => {
-		it("should fix incomplete closing tag </change without > when stream is complete", () => {
-			const incompleteXML = `<change><search><![CDATA[function mutliply(<<<AUTOCOMPLETE_HERE>>>>
-]]></search><replace><![CDATA[function mutliply(a, b) {
-]]></replace></change`
-
-			// Test sanitization directly
-			const sanitized = sanitizeXMLConservative(incompleteXML)
-			expect(sanitized).toContain("</change>")
-			expect(sanitized).toBe(incompleteXML.replace("</change", "</change>"))
-			// Verify the incomplete tag was fixed
-			expect(incompleteXML).toMatch(/\/change$/)
-			expect(sanitized).toMatch(/\/change>$/)
-		})
-
-		it("should add missing </change> tag entirely when stream is complete", () => {
-			const incompleteXML = `<change><search><![CDATA[function mutliply(<<<AUTOCOMPLETE_HERE>>>>
-]]></search><replace><![CDATA[function mutliply(a, b) {
-]]></replace>`
-
-			// Test sanitization directly
-			const sanitized = sanitizeXMLConservative(incompleteXML)
-			expect(sanitized).toContain("</change>")
-			expect(sanitized).toBe(incompleteXML + "</change>")
-		})
-
-		it("should not fix when search/replace pairs are incomplete", () => {
-			const incompleteXML = `<change><search><![CDATA[function mutliply(<<<AUTOCOMPLETE_HERE>>>>
-]]></search><replace><![CDATA[function mutliply(a, b) {
-]]></change`
-
-			// Test sanitization directly - should NOT modify when replace is incomplete
-			const sanitized = sanitizeXMLConservative(incompleteXML)
-			expect(sanitized).toBe(incompleteXML)
-		})
-
-		it("should not fix when multiple change blocks are present", () => {
-			const incompleteXML = `<change><search><![CDATA[test1]]></search><replace><![CDATA[test1]]></replace></change><change><search><![CDATA[test2]]></search><replace><![CDATA[test2]]></replace></change`
-
-			// Test sanitization directly - should NOT modify when multiple changes present
-			const sanitized = sanitizeXMLConservative(incompleteXML)
-			expect(sanitized).toBe(incompleteXML)
-		})
-
-		it("should not fix when buffer ends with incomplete tag marker", () => {
-			const incompleteXML = `<change><search><![CDATA[function mutliply(<<<AUTOCOMPLETE_HERE>>>>
-]]></search><replace><![CDATA[function mutliply(a, b) {
-]]></replace><`
-
-			// Test sanitization directly - should NOT modify when ending with incomplete tag
-			const sanitized = sanitizeXMLConservative(incompleteXML)
-			expect(sanitized).toBe(incompleteXML)
-		})
-
-		it("should apply sanitization when stream is complete", () => {
-			// Build up the full response from chunks
-			const fullResponse = `<change><search><![CDATA[function mutliply(<<<AUTOCOMPLETE_HERE>>>>]]></search><replace><![CDATA[function mutliply(a, b) {]]></replace></change`
-
-			// Test sanitization directly
-			const sanitized = sanitizeXMLConservative(fullResponse)
-			expect(sanitized).toContain("</change>")
-			expect(sanitized).toBe(fullResponse.replace("</change", "</change>"))
-		})
-
-		it("should handle already complete XML without modification", () => {
-			const completeXML = `<change><search><![CDATA[function mutliply(<<<AUTOCOMPLETE_HERE>>>>
-]]></search><replace><![CDATA[function mutliply(a, b) {
-]]></replace></change>`
-
-			// Test sanitization directly - should NOT modify already complete XML
-			const sanitized = sanitizeXMLConservative(completeXML)
-			expect(sanitized).toBe(completeXML)
-		})
-
-		it("should handle malformed CDATA sections - the actual bug from user logs", () => {
-			// This reproduces the EXACT malformed CDATA issue from user logs
-			const malformedCDataXML = `<change><search><![CDATA[function getRedirectUrl(txn: CreditTransaction | undefined) {
-		<<<AUTOCOMPLETE_HERE>>>
-
-		const params = new URLSearchParams();</![CDATA[</search><replace><![CDATA[function getRedirectUrl(txn: CreditTransaction | undefined) {
-		if (!txn) {
-		  return '/organizations';
-		}
-
-		const params = new URLSearchParams();</![CDATA[</replace></change>`
-
-			// Test sanitization directly - should fix malformed CDATA
-			const sanitized = sanitizeXMLConservative(malformedCDataXML)
-			expect(sanitized).not.toContain("</![CDATA[")
-			expect(sanitized).toContain("]]>")
-			// Verify the malformed CDATA closures are replaced
-			const expectedSanitized = malformedCDataXML.replace(/<\/!\[CDATA\[/g, "]]>")
-			expect(sanitized).toBe(expectedSanitized)
-		})
-	})
-})
diff --git a/src/services/ghost/classic-auto-complete/__tests__/GhostStreamingParser.test.ts b/src/services/ghost/classic-auto-complete/__tests__/GhostStreamingParser.test.ts
index 053ad2050da..b891f51b62b 100644
--- a/src/services/ghost/classic-auto-complete/__tests__/GhostStreamingParser.test.ts
+++ b/src/services/ghost/classic-auto-complete/__tests__/GhostStreamingParser.test.ts
@@ -1,885 +1,174 @@
-import { parseGhostResponse, findBestMatch } from "../GhostStreamingParser"
-import { extractPrefixSuffix } from "../../types"
-import * as vscode from "vscode"
-
-// Mock vscode module
-vi.mock("vscode", () => ({
-	Uri: {
-		file: (path: string) => ({ toString: () => path, fsPath: path }),
-	},
-	workspace: {
-		asRelativePath: (uri: any) => uri.toString(),
-	},
-}))
+import { describe, it, expect } from "vitest"
+import { parseGhostResponse } from "../GhostStreamingParser"
 
 describe("GhostStreamingParser", () => {
-	let mockDocument: vscode.TextDocument
-	let document: vscode.TextDocument
-	let range: vscode.Range | undefined
-
-	beforeEach(() => {
-		// Create mock document
-		mockDocument = {
-			uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-			getText: () => `function test() {
-	return true;
-}`,
-			languageId: "typescript",
-			positionAt: (offset: number) => ({ line: 0, character: offset }),
-			offsetAt: (position: any) => position.character,
-		} as vscode.TextDocument
-
-		document = mockDocument
-		range = undefined
-	})
-
-	describe("finishStream", () => {
-		it("should handle incomplete XML", () => {
-			const incompleteXml = "<change><search><![CDATA["
-			const position = range?.start ?? document.positionAt(0)
-			const { prefix, suffix } = extractPrefixSuffix(document, position)
-			const result = parseGhostResponse(incompleteXml, prefix, suffix)
-
-			expect(result.hasNewSuggestions).toBe(false)
-			expect(result.isComplete).toBe(false)
-			expect(result.suggestions.hasSuggestions()).toBe(false)
-		})
+	const prefix = "function test() {\n  "
+	const suffix = "\n}"
 
-		it("should parse complete change blocks", () => {
-			const completeChange = `<change><search><![CDATA[function test() {
-	return true;
-}]]></search><replace><![CDATA[function test() {
-	// Added comment
-	return true;
-}]]></replace></change>`
-
-			// The change modifies the whole document, so we need prefix="" and suffix=document
-			// After the change is applied, the result won't match prefix+suffix anymore
-			// So this test should check hasNewSuggestions but suggestions won't have FIM
-			const prefix = ""
-			const suffix = document.getText()
-			const result = parseGhostResponse(completeChange, prefix, suffix)
+	describe("Response parsing with COMPLETION tags", () => {
+		it("should extract content between COMPLETION tags", () => {
+			const response = "<COMPLETION>return 42</COMPLETION>"
+			const result = parseGhostResponse(response, prefix, suffix)
 
 			expect(result.hasNewSuggestions).toBe(true)
-			// FIM won't be set because modified content doesn't end with original suffix
-			expect(result.suggestions.hasSuggestions()).toBe(false)
-		})
-
-		it("should handle complete response built from multiple chunks", () => {
-			const fullResponse = `<change><search><![CDATA[function test() {
-	return true;
-}]]></search><replace><![CDATA[function test() {
-	// Added comment
-	return true;
-}]]></replace></change>`
-
-			// The change modifies the whole document
-			const prefix = ""
-			const suffix = document.getText()
-			const result = parseGhostResponse(fullResponse, prefix, suffix)
+			expect(result.isComplete).toBe(true)
+			expect(result.suggestions.hasSuggestions()).toBe(true)
 
-			expect(result.hasNewSuggestions).toBe(true)
-			// FIM won't be set because modified content doesn't end with original suffix
-			expect(result.suggestions.hasSuggestions()).toBe(false)
+			const suggestion = result.suggestions.getFillInAtCursor()
+			expect(suggestion?.text).toBe("return 42")
+			expect(suggestion?.prefix).toBe(prefix)
+			expect(suggestion?.suffix).toBe(suffix)
 		})
 
-		it("should handle multiple complete changes", () => {
-			const fullResponse = `<change><search><![CDATA[function test() {]]></search><replace><![CDATA[function test() {
-	// First change]]></replace></change><change><search><![CDATA[return true;]]></search><replace><![CDATA[return false; // Second change]]></replace></change>`
-
-			const position = range?.start ?? document.positionAt(0)
-			const { prefix, suffix } = extractPrefixSuffix(document, position)
-			const result = parseGhostResponse(fullResponse, prefix, suffix)
+		it("should handle multiline content in COMPLETION tags", () => {
+			const response = "<COMPLETION>const x = 1;\nconst y = 2;\nreturn x + y;</COMPLETION>"
+			const result = parseGhostResponse(response, prefix, suffix)
 
 			expect(result.hasNewSuggestions).toBe(true)
-		})
-
-		it("should detect when response is complete", () => {
-			const completeResponse = `<change><search><![CDATA[function test() {
-	return true;
-}]]></search><replace><![CDATA[function test() {
-	// Added comment
-	return true;
-}]]></replace></change>`
-
-			const position = range?.start ?? document.positionAt(0)
-			const { prefix, suffix } = extractPrefixSuffix(document, position)
-			const result = parseGhostResponse(completeResponse, prefix, suffix)
+			expect(result.suggestions.hasSuggestions()).toBe(true)
 
-			expect(result.isComplete).toBe(true)
+			const suggestion = result.suggestions.getFillInAtCursor()
+			expect(suggestion?.text).toBe("const x = 1;\nconst y = 2;\nreturn x + y;")
 		})
 
-		it("should detect incomplete response", () => {
-			const incompleteResponse = `<change><search><![CDATA[function test() {
-	return true;
-}]]></search><replace><![CDATA[function test() {
-	// Added comment`
+		it("should handle incomplete COMPLETION tag (streaming)", () => {
+			const response = "<COMPLETION>return 42"
+			const result = parseGhostResponse(response, prefix, suffix)
 
-			const position = range?.start ?? document.positionAt(0)
-			const { prefix, suffix } = extractPrefixSuffix(document, position)
-			const result = parseGhostResponse(incompleteResponse, prefix, suffix)
+			expect(result.hasNewSuggestions).toBe(false)
+			expect(result.isComplete).toBe(true)
+			expect(result.suggestions.hasSuggestions()).toBe(false)
 
-			expect(result.isComplete).toBe(false)
+			const suggestion = result.suggestions.getFillInAtCursor()
+			expect(suggestion?.text).toBeUndefined()
 		})
 
-		it("should handle cursor marker in search content for matching", () => {
-			// Mock document WITHOUT cursor marker (parser should add it)
-			const mockDocumentWithoutCursor = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => `function test() {
-	return true;
-}`,
-				languageId: "typescript",
-				offsetAt: (position: any) => 20, // Mock cursor position
-			} as vscode.TextDocument
-
-			const mockRange = {
-				start: { line: 1, character: 1 },
-				end: { line: 1, character: 1 },
-				isEmpty: true,
-				isSingleLine: true,
-			} as vscode.Range
-
-			const contextWithCursor = {
-				document: mockDocumentWithoutCursor,
-				range: mockRange,
-			}
-
-			const changeWithCursor = `<change><search><![CDATA[<<<AUTOCOMPLETE_HERE>>>]]></search><replace><![CDATA[// New function
-function fibonacci(n: number): number {
-		if (n <= 1) return n;
-		return fibonacci(n - 1) + fibonacci(n - 2);
-}]]></replace></change>`
-
-			const position = mockRange.start
-			const { prefix, suffix } = extractPrefixSuffix(mockDocumentWithoutCursor, position)
-			const result = parseGhostResponse(changeWithCursor, prefix, suffix)
+		it("should remove any accidental tag remnants", () => {
+			const response = "<COMPLETION>return 42<COMPLETION></COMPLETION>"
+			const result = parseGhostResponse(response, prefix, suffix)
 
 			expect(result.hasNewSuggestions).toBe(true)
-			expect(result.suggestions.hasSuggestions()).toBe(true)
+			const suggestion = result.suggestions.getFillInAtCursor()
+			expect(suggestion?.text).toBe("return 42")
 		})
 
-		it("should handle document that already contains cursor marker", () => {
-			// Mock document that already contains cursor marker
-			const mockDocumentWithCursor = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => `function test() {
-	<<<AUTOCOMPLETE_HERE>>>
-}`,
-				languageId: "typescript",
-				positionAt: (offset: number) => ({ line: 0, character: offset }),
-				offsetAt: (position: any) => position.character,
-			} as vscode.TextDocument
-
-			const contextWithCursor = {
-				document: mockDocumentWithCursor,
-			}
-
-			const changeWithCursor = `<change><search><![CDATA[<<<AUTOCOMPLETE_HERE>>>]]></search><replace><![CDATA[// New function
-function fibonacci(n: number): number {
-		if (n <= 1) return n;
-		return fibonacci(n - 1) + fibonacci(n - 2);
-}]]></replace></change>`
-
-			// The change modifies the document
-			const prefix = ""
-			const suffix = mockDocumentWithCursor.getText()
-			const result = parseGhostResponse(changeWithCursor, prefix, suffix)
+		it("should handle case-insensitive tags", () => {
+			const response = "<completion>return 42</completion>"
+			const result = parseGhostResponse(response, prefix, suffix)
 
 			expect(result.hasNewSuggestions).toBe(true)
-			// FIM won't be set because modified content doesn't end with original suffix
-			expect(result.suggestions.hasSuggestions()).toBe(false)
+			const suggestion = result.suggestions.getFillInAtCursor()
+			expect(suggestion?.text).toBe("return 42")
 		})
+	})
 
-		it("should handle malformed XML gracefully", () => {
-			const malformedXml = `<change><search><![CDATA[test]]><replace><![CDATA[replacement]]></replace></change>`
-
-			const position = range?.start ?? document.positionAt(0)
-			const { prefix, suffix } = extractPrefixSuffix(document, position)
-			const result = parseGhostResponse(malformedXml, prefix, suffix)
+	describe("Response parsing without COMPLETION tags (no suggestions)", () => {
+		it("should NOT create suggestions when no tags present", () => {
+			const response = "return 42"
+			const result = parseGhostResponse(response, prefix, suffix)
 
-			// Should not crash and should not produce suggestions
 			expect(result.hasNewSuggestions).toBe(false)
+			expect(result.isComplete).toBe(true)
 			expect(result.suggestions.hasSuggestions()).toBe(false)
 		})
 
-		it("should handle empty response", () => {
-			const position = range?.start ?? document.positionAt(0)
-			const { prefix, suffix } = extractPrefixSuffix(document, position)
-			const result = parseGhostResponse("", prefix, suffix)
+		it("should NOT create suggestions for multiline response without tags", () => {
+			const response = "const x = 1;\nconst y = 2;\nreturn x + y;"
+			const result = parseGhostResponse(response, prefix, suffix)
 
 			expect(result.hasNewSuggestions).toBe(false)
-			expect(result.isComplete).toBe(true) // Empty is considered complete
 			expect(result.suggestions.hasSuggestions()).toBe(false)
 		})
 
-		it("should handle whitespace-only response", () => {
-			const position = range?.start ?? document.positionAt(0)
-			const { prefix, suffix } = extractPrefixSuffix(document, position)
-			const result = parseGhostResponse("   \n\t  ", prefix, suffix)
+		it("should NOT create suggestions for markdown code blocks without tags", () => {
+			const response = "```typescript\nreturn 42\n```"
+			const result = parseGhostResponse(response, prefix, suffix)
 
 			expect(result.hasNewSuggestions).toBe(false)
-			expect(result.isComplete).toBe(true)
 			expect(result.suggestions.hasSuggestions()).toBe(false)
 		})
 	})
 
-	describe("findBestMatch", () => {
-		describe("exact matches", () => {
-			it("should find exact match at start", () => {
-				const content = "function test() {\n\treturn true;\n}"
-				const search = "function test()"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should find exact match in middle", () => {
-				const content = "function test() {\n\treturn true;\n}"
-				const search = "return true;"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(19)
-			})
-
-			it("should find exact match at end", () => {
-				const content = "function test() {\n\treturn true;\n}"
-				const search = "}"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(32)
-			})
-
-			it("should find exact multiline match", () => {
-				const content = "function test() {\n\treturn true;\n}"
-				const search = "function test() {\n\treturn true;\n}"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-		})
-
-		describe("whitespace variations", () => {
-			it("should handle tabs vs spaces", () => {
-				const content = "function test() {\n\treturn true;\n}"
-				const search = "function test() {\n    return true;\n}" // Spaces instead of tab
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should handle extra spaces in content", () => {
-				const content = "function  test()  {\n\treturn true;\n}" // Extra spaces
-				const search = "function test() {\n\treturn true;\n}"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should handle different line endings (\\n vs \\r\\n)", () => {
-				const content = "function test() {\r\n\treturn true;\r\n}"
-				const search = "function test() {\n\treturn true;\n}"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should handle trailing whitespace differences", () => {
-				const content = "function test() {  \n\treturn true;\n}"
-				const search = "function test() {\n\treturn true;\n}"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should handle leading whitespace differences", () => {
-				const content = "  function test() {\n\treturn true;\n}"
-				const search = "function test() {\n\treturn true;\n}"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(2)
-			})
-
-			it("should handle multiple consecutive spaces vs single space", () => {
-				const content = "const x    =    5;"
-				const search = "const x = 5;"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should handle trailing newline in search pattern", () => {
-				const content = "function test() {\n\treturn true;\n}"
-				const search = "return true;\n"
-
-				const result = findBestMatch(content, search)
-				// Fuzzy matcher handles this by normalizing whitespace
-				expect(result.startIndex).toBe(19)
-			})
-
-			it("should handle trailing newline when content has more newlines", () => {
-				const content = "function test() {\n\treturn true;\n\n\n}"
-				const search = "return true;\n"
+	describe("Edge cases", () => {
+		it("should handle empty response", () => {
+			const response = ""
+			const result = parseGhostResponse(response, prefix, suffix)
 
-				const result = findBestMatch(content, search)
-				// Fuzzy matcher handles this by normalizing whitespace
-				expect(result.startIndex).toBe(19)
-			})
+			expect(result.hasNewSuggestions).toBe(false)
+			expect(result.isComplete).toBe(true)
+			expect(result.suggestions.hasSuggestions()).toBe(false)
 		})
 
-		describe("newline matching", () => {
-			it("should NOT match newline with space", () => {
-				const content = "line1\nline2"
-				const search = "line1 line2"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(-1)
-			})
-
-			it("should NOT match newline with tab", () => {
-				const content = "line1\nline2"
-				const search = "line1\tline2"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(-1)
-			})
-
-			it("should NOT match space with newline", () => {
-				const content = "line1 line2"
-				const search = "line1\nline2"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(-1)
-			})
-
-			it("should match \\n with \\r\\n", () => {
-				const content = "line1\r\nline2"
-				const search = "line1\nline2"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should match \\r\\n with \\n", () => {
-				const content = "line1\nline2"
-				const search = "line1\r\nline2"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should match \\r with \\n", () => {
-				const content = "line1\rline2"
-				const search = "line1\nline2"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should handle multiple newlines correctly", () => {
-				const content = "line1\n\nline2"
-				const search = "line1\n\nline2"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should still handle spaces and tabs flexibly (non-newline whitespace)", () => {
-				const content = "const x  =  5;"
-				const search = "const x\t=\t5;"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
+		it("should NOT create suggestions for whitespace-only response without tags", () => {
+			const response = "   \n\t  "
+			const result = parseGhostResponse(response, prefix, suffix)
 
-			it("should handle mixed whitespace correctly", () => {
-				const content = "function test() {\n\treturn  true;\n}"
-				const search = "function test() {\n    return true;\n}"
-
-				const result = findBestMatch(content, search)
-				// Should match because tabs/spaces are flexible but newlines must match
-				expect(result.startIndex).toBe(0)
-			})
+			expect(result.hasNewSuggestions).toBe(false)
+			expect(result.suggestions.hasSuggestions()).toBe(false)
 		})
 
-		describe("edge cases", () => {
-			it("should return -1 for empty content", () => {
-				const content = ""
-				const search = "test"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(-1)
-			})
-
-			it("should return -1 for empty pattern", () => {
-				const content = "function test() {}"
-				const search = ""
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(-1)
-			})
+		it("should handle custom prefix/suffix with COMPLETION tags", () => {
+			const customPrefix = "const greeting = "
+			const customSuffix = ";"
+			const response = '<COMPLETION>"Hello, World!"</COMPLETION>'
 
-			it("should return -1 when pattern is longer than content", () => {
-				const content = "short"
-				const search = "this is a much longer pattern"
+			const result = parseGhostResponse(response, customPrefix, customSuffix)
 
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(-1)
-			})
-
-			it("should return -1 for no match", () => {
-				const content = "function test() {\n\treturn true;\n}"
-				const search = "nonexistent code"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(-1)
-			})
-
-			it("should handle pattern with only whitespace", () => {
-				const content = "a   b"
-				const search = "   "
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBeGreaterThanOrEqual(0)
-			})
-
-			it("should handle content with only whitespace", () => {
-				const content = "   \n\t  "
-				const search = "test"
+			expect(result.hasNewSuggestions).toBe(true)
+			expect(result.suggestions.hasSuggestions()).toBe(true)
 
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(-1)
-			})
+			const suggestion = result.suggestions.getFillInAtCursor()
+			expect(suggestion?.text).toBe('"Hello, World!"')
+			expect(suggestion?.prefix).toBe(customPrefix)
+			expect(suggestion?.suffix).toBe(customSuffix)
 		})
 
-		describe("real-world scenarios", () => {
-			it("should handle code with inconsistent indentation", () => {
-				// Use explicit \t and spaces to ensure correct test case
-				const content = 'function example() {\n\tif (true) {\n\t\tconsole.log("test");\n\t}\n}'
-				const search = 'function example() {\n    if (true) {\n        console.log("test");\n    }\n}'
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should handle code with mixed tabs and spaces", () => {
-				const content = "function test() {\n\t  return true;\n}"
-				const search = "function test() {\n    return true;\n}"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should handle actual different line endings in code", () => {
-				const content = "function test() {\r\n\treturn true;\r\n}"
-				const search = "function test() {\n\treturn true;\n}"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
+		it("should handle empty COMPLETION tags", () => {
+			const response = "<COMPLETION></COMPLETION>"
+			const result = parseGhostResponse(response, prefix, suffix)
 
-			it("should find match when content has extra trailing whitespace", () => {
-				const content = "const x = 5;   \nconst y = 10;"
-				const search = "const x = 5;\nconst y = 10;"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should handle partial matches correctly", () => {
-				const content = "function test() { return true; }\nfunction test2() { return false; }"
-				const search = "function test2() { return false; }"
-
-				const result = findBestMatch(content, search)
-				expect(result.startIndex).toBe(33)
-			})
+			expect(result.hasNewSuggestions).toBe(false)
+			expect(result.suggestions.hasSuggestions()).toBe(false)
 		})
 
-		describe("performance", () => {
-			it("should handle large content efficiently", () => {
-				const content = "x".repeat(10000) + "needle" + "y".repeat(10000)
-				const search = "needle"
-
-				const startTime = performance.now()
-				const result = findBestMatch(content, search)
-				const endTime = performance.now()
+		it("should handle whitespace-only content in COMPLETION tags", () => {
+			const response = "<COMPLETION>   </COMPLETION>"
+			const result = parseGhostResponse(response, prefix, suffix)
 
-				expect(result.startIndex).toBe(10000)
-				expect(endTime - startTime).toBeLessThan(50) // Should complete quickly
-			})
-
-			it("should handle large pattern efficiently", () => {
-				const pattern = "x".repeat(1000)
-				const content = "y".repeat(5000) + pattern + "z".repeat(5000)
-
-				const startTime = performance.now()
-				const result = findBestMatch(content, pattern)
-				const endTime = performance.now()
-
-				expect(result.startIndex).toBe(5000)
-				expect(endTime - startTime).toBeLessThan(100)
-			})
-
-			it("should handle worst-case scenario (no match with similar patterns)", () => {
-				const content = "a".repeat(1000) + "b"
-				const search = "a".repeat(1000) + "c"
-
-				const startTime = performance.now()
-				const result = findBestMatch(content, search)
-				const endTime = performance.now()
-
-				expect(result.startIndex).toBe(-1)
-				expect(endTime - startTime).toBeLessThan(200)
-			})
-		})
-
-		describe("trimmed search fallback", () => {
-			it("should NOT find match with leading whitespace in pattern (fuzzy matcher limitation)", () => {
-				const content = "function test() {}"
-				const search = "  function test() {}"
-
-				const result = findBestMatch(content, search)
-				// Fuzzy matcher doesn't handle leading whitespace in pattern that doesn't exist in content
-				expect(result.startIndex).toBe(-1)
-			})
-
-			it("should find match with trailing whitespace in pattern", () => {
-				const content = "function test() {}"
-				const search = "function test() {}  "
-
-				const result = findBestMatch(content, search)
-				// Fuzzy matcher now allows trailing whitespace in pattern
-				expect(result.startIndex).toBe(0)
-			})
-
-			it("should NOT find match with both leading and trailing whitespace in pattern (fuzzy matcher limitation)", () => {
-				const content = "function test() {}"
-				const search = "  function test() {}  "
-
-				const result = findBestMatch(content, search)
-				// Fuzzy matcher doesn't handle leading/trailing whitespace in pattern that doesn't exist in content
-				expect(result.startIndex).toBe(-1)
-			})
+			expect(result.hasNewSuggestions).toBe(true)
+			expect(result.suggestions.hasSuggestions()).toBe(true)
 		})
 
-		describe("bug: break prevents matching later in string", () => {
-			it("should find match later in content when first position fails", () => {
-				// This test demonstrates the bug at lines 169-170
-				// The content has "wrong" at the start, then the actual match "function test()" later
-				const content = "wrong function test() { return true; }"
-				const search = "function test()"
-
-				const result = findBestMatch(content, search)
-
-				// Expected: Should find the match at position 6 (after "wrong ")
-				// Actual: Returns -1 because the break statement prevents trying subsequent positions
-				expect(result.startIndex).toBe(6)
-			})
-
-			it("should find match after whitespace mismatch", () => {
-				// Another case: pattern starts with space, content doesn't
-				const content = "abc def ghi"
-				const search = "def"
-
-				const result = findBestMatch(content, search)
-
-				// Expected: Should find "def" at position 4
-				// Actual: May fail due to early break
-				expect(result.startIndex).toBe(4)
-			})
-
-			it("should find match when first character differs", () => {
-				const content = "x function test() {}"
-				const search = "function test()"
-
-				const result = findBestMatch(content, search)
-
-				// Expected: Should find the match at position 2 (after "x ")
-				// Actual: Returns -1 due to break on first character mismatch
-				expect(result.startIndex).toBe(2)
-			})
-
-			it("should find match after multiple failed attempts", () => {
-				const content = "aaa bbb ccc target ddd"
-				const search = "target"
-
-				const result = findBestMatch(content, search)
-
-				// Expected: Should find "target" at position 12
-				// Actual: Should work since exact match is tried first, but fuzzy fallback would fail
-				expect(result.startIndex).toBe(12)
-			})
-
-			it("should find fuzzy match later in content", () => {
-				// This is the critical test case that shows the bug
-				// Content has extra spaces at start, then the pattern we're looking for
-				const content = "  x  function  test()"
-				const search = "function test()"
-
-				const result = findBestMatch(content, search)
-
-				// Expected: Should find fuzzy match starting at position 5 (after "  x  ")
-				// Actual: Returns -1 because break prevents trying position 5
-				expect(result.startIndex).toBe(5)
-			})
+		it("should handle response with extra text before COMPLETION tag", () => {
+			const response = "Here is the code:\n<COMPLETION>return 42</COMPLETION>"
+			const result = parseGhostResponse(response, prefix, suffix)
 
-			it("should handle newline mismatch and continue searching", () => {
-				const content = "line1 line2\nfunction test() {}"
-				const search = "function test()"
-
-				const result = findBestMatch(content, search)
-
-				// Expected: Should find the match at position 12 (after "line1 line2\n")
-				// Actual: May fail if fuzzy matcher breaks early
-				expect(result.startIndex).toBe(12)
-			})
+			expect(result.hasNewSuggestions).toBe(true)
+			const suggestion = result.suggestions.getFillInAtCursor()
+			expect(suggestion?.text).toBe("return 42")
 		})
-	})
-
-	describe("error handling", () => {
-		it("should handle context without document", () => {
-			const invalidDocument = undefined as any
 
-			const change = `<change><search><![CDATA[test]]></search><replace><![CDATA[replacement]]></replace></change>`
+		it("should handle response with extra text after COMPLETION tag", () => {
+			const response = "<COMPLETION>return 42</COMPLETION>\nThat's the code!"
+			const result = parseGhostResponse(response, prefix, suffix)
 
-			// This should throw or handle gracefully - expect it to throw
-			expect(() => {
-				const position = range?.start ?? invalidDocument.positionAt(0)
-				const { prefix, suffix } = extractPrefixSuffix(invalidDocument, position)
-				parseGhostResponse(change, prefix, suffix)
-			}).toThrow()
+			expect(result.hasNewSuggestions).toBe(true)
+			const suggestion = result.suggestions.getFillInAtCursor()
+			expect(suggestion?.text).toBe("return 42")
 		})
 	})
 
 	describe("performance", () => {
 		it("should handle large responses efficiently", () => {
-			const largeChange = `<change><search><![CDATA[${"x".repeat(10000)}]]></search><replace><![CDATA[${"y".repeat(10000)}]]></replace></change>`
+			const largeContent = "x".repeat(10000)
+			const response = `<COMPLETION>${largeContent}</COMPLETION>`
 
 			const startTime = performance.now()
-			const position = range?.start ?? document.positionAt(0)
-			const { prefix, suffix } = extractPrefixSuffix(document, position)
-			const result = parseGhostResponse(largeChange, prefix, suffix)
+			const result = parseGhostResponse(response, prefix, suffix)
 			const endTime = performance.now()
 
-			expect(endTime - startTime).toBeLessThan(100) // Should complete in under 100ms
+			expect(endTime - startTime).toBeLessThan(100)
 			expect(result.hasNewSuggestions).toBe(true)
 		})
-
-		it("should handle large concatenated responses efficiently", () => {
-			const largeResponse = Array(1000).fill("x").join("")
-			const startTime = performance.now()
-
-			const position = range?.start ?? document.positionAt(0)
-			const { prefix, suffix } = extractPrefixSuffix(document, position)
-			parseGhostResponse(largeResponse, prefix, suffix)
-			const endTime = performance.now()
-
-			expect(endTime - startTime).toBeLessThan(200) // Should complete in under 200ms
-		})
-	})
-
-	describe("Fill-In-Middle (FIM) behavior", () => {
-		it("should set FIM when modifiedContent has both prefix and suffix", () => {
-			const mockDocWithPrefix = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => `const prefix = "start";\nconst suffix = "end";`,
-				languageId: "typescript",
-				positionAt: (offset: number) => ({ line: 0, character: offset }),
-			} as vscode.TextDocument
-
-			const change = `<change><search><![CDATA[const prefix = "start";\nconst suffix = "end";]]></search><replace><![CDATA[const prefix = "start";\nconst middle = "inserted";\nconst suffix = "end";]]></replace></change>`
-
-			const prefix = 'const prefix = "start";\n'
-			const suffix = 'const suffix = "end";'
-
-			const result = parseGhostResponse(change, prefix, suffix)
-
-			expect(result.suggestions.hasSuggestions()).toBe(true)
-			// Check that FIM was set
-			const fimContent = result.suggestions.getFillInAtCursor()
-			expect(fimContent).toEqual({
-				text: 'const middle = "inserted";\n',
-				prefix: 'const prefix = "start";\n',
-				suffix: 'const suffix = "end";',
-			})
-		})
-
-		it("should NOT set FIM when prefix doesn't match", () => {
-			const mockDoc = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => `const prefix = "start";\nconst suffix = "end";`,
-				languageId: "typescript",
-				positionAt: (offset: number) => ({ line: 0, character: offset }),
-			} as vscode.TextDocument
-
-			const change = `<change><search><![CDATA[const prefix = "start";\nconst suffix = "end";]]></search><replace><![CDATA[const prefix = "start";\nconst middle = "inserted";\nconst suffix = "end";]]></replace></change>`
-
-			const prefix = "WRONG_PREFIX"
-			const suffix = 'const suffix = "end";'
-
-			const result = parseGhostResponse(change, prefix, suffix)
-
-			// The change will still be applied and FIM will be set
-			// but with the wrong prefix/suffix (not matching the modified content)
-			expect(result.suggestions.hasSuggestions()).toBe(true)
-			const fimContent = result.suggestions.getFillInAtCursor()
-			// FIM is set but with empty text because prefix+suffix don't match the modified content
-			expect(fimContent?.text).toBe("")
-		})
-
-		it("should NOT set FIM when suffix doesn't match", () => {
-			const mockDoc = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => `const prefix = "start";\nconst suffix = "end";`,
-				languageId: "typescript",
-				positionAt: (offset: number) => ({ line: 0, character: offset }),
-			} as vscode.TextDocument
-
-			const change = `<change><search><![CDATA[const prefix = "start";\nconst suffix = "end";]]></search><replace><![CDATA[const prefix = "start";\nconst middle = "inserted";\nconst suffix = "end";]]></replace></change>`
-
-			const prefix = 'const prefix = "start";\n'
-			const suffix = "WRONG_SUFFIX"
-
-			const result = parseGhostResponse(change, prefix, suffix)
-
-			// The change will still be applied and FIM will be set
-			// but with the wrong prefix/suffix (not matching the modified content)
-			expect(result.suggestions.hasSuggestions()).toBe(true)
-			const fimContent = result.suggestions.getFillInAtCursor()
-			// FIM is set but with empty text because prefix+suffix don't match the modified content
-			expect(fimContent?.text).toBe("")
-		})
-
-		it("should NOT set FIM when both prefix and suffix don't match", () => {
-			const mockDoc = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => `const prefix = "start";\nconst suffix = "end";`,
-				languageId: "typescript",
-				positionAt: (offset: number) => ({ line: 0, character: offset }),
-			} as vscode.TextDocument
-
-			const change = `<change><search><![CDATA[const prefix = "start";\nconst suffix = "end";]]></search><replace><![CDATA[const prefix = "start";\nconst middle = "inserted";\nconst suffix = "end";]]></replace></change>`
-
-			const prefix = "WRONG_PREFIX"
-			const suffix = "WRONG_SUFFIX"
-
-			const result = parseGhostResponse(change, prefix, suffix)
-
-			// The change will still be applied and FIM will be set
-			// but with the wrong prefix/suffix (not matching the modified content)
-			expect(result.suggestions.hasSuggestions()).toBe(true)
-			const fimContent = result.suggestions.getFillInAtCursor()
-			// FIM is set but with empty text because prefix+suffix don't match the modified content
-			expect(fimContent?.text).toBe("")
-		})
-
-		it("should handle empty prefix and suffix", () => {
-			const mockDoc = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => `const middle = "content";`,
-				languageId: "typescript",
-				positionAt: (offset: number) => ({ line: 0, character: offset }),
-			} as vscode.TextDocument
-
-			const change = `<change><search><![CDATA[const middle = "content";]]></search><replace><![CDATA[const middle = "updated";]]></replace></change>`
-
-			// The change modifies the whole document
-			const prefix = ""
-			const suffix = 'const middle = "content";'
-
-			const result = parseGhostResponse(change, prefix, suffix)
-
-			// FIM won't be set because modified content doesn't end with original suffix
-			expect(result.suggestions.hasSuggestions()).toBe(false)
-		})
-
-		it("should extract correct middle content when FIM matches", () => {
-			const mockDoc = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => `function test() {\n\treturn true;\n}`,
-				languageId: "typescript",
-				positionAt: (offset: number) => ({ line: 0, character: offset }),
-			} as vscode.TextDocument
-
-			const change = `<change><search><![CDATA[function test() {\n\treturn true;\n}]]></search><replace><![CDATA[function test() {\n\tconst x = 5;\n\treturn true;\n}]]></replace></change>`
-
-			// The change modifies the whole document
-			const prefix = ""
-			const suffix = "function test() {\n\treturn true;\n}"
-
-			const result = parseGhostResponse(change, prefix, suffix)
-
-			// FIM won't be set because modified content doesn't end with original suffix
-			expect(result.suggestions.hasSuggestions()).toBe(false)
-		})
-
-		it("should NOT set FIM when modifiedContent is undefined", () => {
-			const mockDoc = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => `const x = 1;`,
-				languageId: "typescript",
-				positionAt: (offset: number) => ({ line: 0, character: offset }),
-			} as vscode.TextDocument
-
-			// Change that won't match anything in the document
-			const change = `<change><search><![CDATA[NONEXISTENT]]></search><replace><![CDATA[REPLACEMENT]]></replace></change>`
-
-			const prefix = "const x = 1;"
-			const suffix = ""
-
-			const result = parseGhostResponse(change, prefix, suffix)
-
-			const fimContent = result.suggestions.getFillInAtCursor()
-			// When no changes are applied, FIM is set to empty string (the entire unchanged document matches prefix+suffix)
-			expect(fimContent).toEqual({
-				text: "",
-				prefix: "const x = 1;",
-				suffix: "",
-			})
-		})
-
-		it("should handle multiline prefix and suffix correctly", () => {
-			const mockDoc = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => `class Test {\n\tconstructor() {\n\t\tthis.value = 0;\n\t}\n}`,
-				languageId: "typescript",
-				positionAt: (offset: number) => ({ line: 0, character: offset }),
-			} as vscode.TextDocument
-
-			const change = `<change><search><![CDATA[class Test {\n\tconstructor() {\n\t\tthis.value = 0;\n\t}\n}]]></search><replace><![CDATA[class Test {\n\tconstructor() {\n\t\tthis.value = 0;\n\t\tthis.name = "test";\n\t}\n}]]></replace></change>`
-
-			// The change modifies the whole document
-			const prefix = ""
-			const suffix = "class Test {\n\tconstructor() {\n\t\tthis.value = 0;\n\t}\n}"
-
-			const result = parseGhostResponse(change, prefix, suffix)
-
-			// FIM won't be set because modified content doesn't end with original suffix
-			expect(result.suggestions.hasSuggestions()).toBe(false)
-		})
-
-		it("should handle prefix/suffix with special characters", () => {
-			const mockDoc = {
-				uri: { toString: () => "/test/file.ts", fsPath: "/test/file.ts" },
-				getText: () => `const regex = /test/g;\nconst result = "match";`,
-				languageId: "typescript",
-				positionAt: (offset: number) => ({ line: 0, character: offset }),
-			} as vscode.TextDocument
-
-			const change = `<change><search><![CDATA[const regex = /test/g;\nconst result = "match";]]></search><replace><![CDATA[const regex = /test/g;\nconst middle = "inserted";\nconst result = "match";]]></replace></change>`
-
-			const prefix = "const regex = /test/g;\n"
-			const suffix = 'const result = "match";'
-
-			const result = parseGhostResponse(change, prefix, suffix)
-
-			expect(result.suggestions.hasSuggestions()).toBe(true)
-			const fimContent = result.suggestions.getFillInAtCursor()
-			expect(fimContent).toEqual({
-				text: 'const middle = "inserted";\n',
-				prefix: "const regex = /test/g;\n",
-				suffix: 'const result = "match";',
-			})
-		})
 	})
 })
diff --git a/src/services/ghost/classic-auto-complete/__tests__/GhostStreamingParser.user-issue.test.ts b/src/services/ghost/classic-auto-complete/__tests__/GhostStreamingParser.user-issue.test.ts
deleted file mode 100644
index 72eb58566dd..00000000000
--- a/src/services/ghost/classic-auto-complete/__tests__/GhostStreamingParser.user-issue.test.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-import { sanitizeXMLConservative } from "../GhostStreamingParser"
-
-describe("sanitizeXMLConservative - User Issue Fix", () => {
-	it("should fix the exact user issue: incomplete </change tag", () => {
-		// This is the exact XML from the user's issue
-		const userIssueXML = `<change><search><![CDATA[function mutliply(<<<AUTOCOMPLETE_HERE>>>>
-]]></search><replace><![CDATA[function mutliply(a, b) {
-]]></replace></change`
-
-		const sanitized = sanitizeXMLConservative(userIssueXML)
-
-		// Verify the closing tag was added
-		expect(sanitized).toContain("</change>")
-		expect(sanitized).toBe(`<change><search><![CDATA[function mutliply(<<<AUTOCOMPLETE_HERE>>>>
-]]></search><replace><![CDATA[function mutliply(a, b) {
-]]></replace></change>`)
-	})
-
-	it("should handle XML completely missing the closing >", () => {
-		// Even more broken XML - missing the final ">" entirely
-		const brokenXML = `<change><search><![CDATA[function mutliply(<<<AUTOCOMPLETE_HERE>>>>
-]]></search><replace><![CDATA[function mutliply(a, b) {
-]]></replace></change`
-
-		const sanitized = sanitizeXMLConservative(brokenXML)
-
-		// Should fix the incomplete tag
-		expect(sanitized).toContain("</change>")
-		expect(sanitized).toBe(`<change><search><![CDATA[function mutliply(<<<AUTOCOMPLETE_HERE>>>>
-]]></search><replace><![CDATA[function mutliply(a, b) {
-]]></replace></change>`)
-	})
-
-	it("should not modify already complete XML", () => {
-		const completeXML = `<change><search><![CDATA[function mutliply(<<<AUTOCOMPLETE_HERE>>>>
-]]></search><replace><![CDATA[function mutliply(a, b) {
-]]></replace></change>`
-
-		const sanitized = sanitizeXMLConservative(completeXML)
-
-		// Should remain unchanged
-		expect(sanitized).toBe(completeXML)
-	})
-
-	it("should fix malformed CDATA sections", () => {
-		const malformedCDATA = `<change><search><![CDATA[test content</![CDATA[</search><replace><![CDATA[new content]]></replace></change>`
-
-		const sanitized = sanitizeXMLConservative(malformedCDATA)
-
-		// Should replace </![CDATA[ with ]]>
-		expect(sanitized).toContain("]]>")
-		expect(sanitized).not.toContain("</![CDATA[")
-	})
-
-	it("should not add closing tag when stream is incomplete (ends with <)", () => {
-		const incompleteStream = `<change><search><![CDATA[test]]></search><replace><![CDATA[new]]></replace><`
-
-		const sanitized = sanitizeXMLConservative(incompleteStream)
-
-		// Should not add closing tag when clearly in the middle of streaming
-		expect(sanitized).toBe(incompleteStream)
-	})
-
-	it("should not modify XML with multiple changes", () => {
-		const multipleChanges = `<change><search><![CDATA[test1]]></search><replace><![CDATA[new1]]></replace></change><change><search><![CDATA[test2]]></search><replace><![CDATA[new2]]></replace></change>`
-
-		const sanitized = sanitizeXMLConservative(multipleChanges)
-
-		// Should remain unchanged when multiple complete changes exist
-		expect(sanitized).toBe(multipleChanges)
-	})
-
-	it("should only fix when search and replace are complete", () => {
-		const incompleteSearchReplace = `<change><search><![CDATA[test]]></search><replace><![CDATA[new`
-
-		const sanitized = sanitizeXMLConservative(incompleteSearchReplace)
-
-		// Should not add closing tag when search/replace are incomplete
-		expect(sanitized).toBe(incompleteSearchReplace)
-	})
-})
diff --git a/src/test-llm-autocompletion/__tests__/strategy-tester.test.ts b/src/test-llm-autocompletion/__tests__/strategy-tester.test.ts
deleted file mode 100644
index 24ce2cdca37..00000000000
--- a/src/test-llm-autocompletion/__tests__/strategy-tester.test.ts
+++ /dev/null
@@ -1,539 +0,0 @@
-import { StrategyTester } from "../strategy-tester.js"
-import { LLMClient } from "../llm-client.js"
-
-// Mock vscode module
-vi.mock("vscode", () => ({
-	Uri: {
-		parse: (path: string) => ({ toString: () => path, fsPath: path }),
-	},
-	Range: class Range {
-		constructor(
-			public start: any,
-			public end: any,
-		) {}
-	},
-	Position: class Position {
-		constructor(
-			public line: number,
-			public character: number,
-		) {}
-	},
-	workspace: {
-		asRelativePath: (uri: any) => uri.toString(),
-	},
-}))
-
-/**
- * Comprehensive tests for StrategyTester.parseCompletion and applyOperations methods
- *
- * These tests verify the refactored diff-based application logic that:
- * 1. Parses XML responses using GhostStreamingParser
- * 2. Extracts diff operations from the parsed result
- * 3. Applies operations to reconstruct modified code
- *
- * Note: The parser uses fuzzy matching to find search patterns in the document,
- * so the search content in XML must closely match the original content.
- */
-describe("StrategyTester.parseCompletion", () => {
-	let strategyTester: StrategyTester
-	let mockLLMClient: LLMClient
-
-	beforeEach(() => {
-		// Setup mock LLM client - not needed for parseCompletion tests
-		mockLLMClient = {
-			sendPrompt: vi.fn(),
-		} as any
-
-		strategyTester = new StrategyTester(mockLLMClient)
-	})
-
-	describe("basic functionality", () => {
-		it.skip("should return null for empty XML response", () => {
-			const originalContent = "const x = 1"
-			const xmlResponse = ""
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBeNull()
-		})
-
-		it.skip("should return null for malformed XML", () => {
-			const originalContent = "const x = 1"
-			const xmlResponse = "<change><search>incomplete"
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBeNull()
-		})
-
-		it.skip("should return null when no suggestions are parsed", () => {
-			const originalContent = "const x = 1"
-			const xmlResponse = "<change></change>"
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBeNull()
-		})
-
-		it.skip("should return null for empty operations array", () => {
-			const originalContent = "const x = 1"
-			// XML with search/replace that doesn't match anything in the document
-			const xmlResponse = `<change><search><![CDATA[nonexistent code that will never match]]></search><replace><![CDATA[replacement]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBeNull()
-		})
-	})
-
-	describe("diff operations - additions", () => {
-		it.skip("should handle simple addition (adding new lines)", () => {
-			const originalContent = "const x = 1"
-			// Search must match the original content exactly for the parser to find it
-			const xmlResponse = `<change><search><![CDATA[const x = 1]]></search><replace><![CDATA[const x = 1
-const y = 2]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe("const x = 1\nconst y = 2")
-		})
-
-		it.skip("should handle multiple line additions", () => {
-			const originalContent = "const x = 1"
-			const xmlResponse = `<change><search><![CDATA[const x = 1]]></search><replace><![CDATA[const x = 1
-const y = 2
-const z = 3]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe("const x = 1\nconst y = 2\nconst z = 3")
-		})
-
-		it.skip("should handle addition in middle of file", () => {
-			const originalContent = "const x = 1\nconst z = 3"
-			const xmlResponse = `<change><search><![CDATA[const x = 1
-const z = 3]]></search><replace><![CDATA[const x = 1
-const y = 2
-const z = 3]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe("const x = 1\nconst y = 2\nconst z = 3")
-		})
-	})
-
-	describe("diff operations - deletions", () => {
-		it.skip("should handle simple deletion (removing lines)", () => {
-			const originalContent = "const x = 1\nconst y = 2"
-			const xmlResponse = `<change><search><![CDATA[const x = 1
-const y = 2]]></search><replace><![CDATA[const x = 1]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe("const x = 1")
-		})
-
-		it.skip("should handle deletion in middle of file", () => {
-			const originalContent = "const x = 1\nconst y = 2\nconst z = 3"
-			const xmlResponse = `<change><search><![CDATA[const x = 1
-const y = 2
-const z = 3]]></search><replace><![CDATA[const x = 1
-const z = 3]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe("const x = 1\nconst z = 3")
-		})
-	})
-
-	describe("diff operations - modifications", () => {
-		it.skip("should handle modification (delete + add on same line)", () => {
-			const originalContent = "var x = 1"
-			const xmlResponse = `<change><search><![CDATA[var x = 1]]></search><replace><![CDATA[const x = 1]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe("const x = 1")
-		})
-
-		it.skip("should handle function modification", () => {
-			const originalContent = `function test() {
-	var x = 1
-	return x
-}`
-			const xmlResponse = `<change><search><![CDATA[function test() {
-	var x = 1
-	return x
-}]]></search><replace><![CDATA[function test() {
-	const x = 1
-	return x
-}]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`function test() {
-	const x = 1
-	return x
-}`)
-		})
-
-		it.skip("should handle multiple modifications across different lines", () => {
-			const originalContent = `var x = 1
-var y = 2
-var z = 3`
-			// Multiple change blocks for multiple modifications
-			const xmlResponse = `<change><search><![CDATA[var x = 1]]></search><replace><![CDATA[const x = 1]]></replace></change><change><search><![CDATA[var y = 2]]></search><replace><![CDATA[const y = 2]]></replace></change><change><search><![CDATA[var z = 3]]></search><replace><![CDATA[const z = 3]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`const x = 1
-const y = 2
-const z = 3`)
-		})
-	})
-
-	describe("diff operations - mixed operations", () => {
-		it.skip("should handle mixed additions and deletions", () => {
-			const originalContent = `const x = 1
-const y = 2
-const z = 3`
-			const xmlResponse = `<change><search><![CDATA[const x = 1
-const y = 2
-const z = 3]]></search><replace><![CDATA[const x = 1
-const w = 1.5
-const z = 3]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`const x = 1
-const w = 1.5
-const z = 3`)
-		})
-
-		it.skip("should handle complex multi-line changes", () => {
-			const originalContent = `function calculate(a, b) {
-	var sum = a + b
-	return sum
-}`
-			const xmlResponse = `<change><search><![CDATA[function calculate(a, b) {
-	var sum = a + b
-	return sum
-}]]></search><replace><![CDATA[function calculate(a, b) {
-	// Calculate the sum
-	const sum = a + b
-	console.log('Sum:', sum)
-	return sum
-}]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`function calculate(a, b) {
-	// Calculate the sum
-	const sum = a + b
-	console.log('Sum:', sum)
-	return sum
-}`)
-		})
-	})
-
-	describe("edge cases", () => {
-		it.skip("should handle empty lines in operations", () => {
-			const originalContent = `const x = 1
-
-const y = 2`
-			const xmlResponse = `<change><search><![CDATA[const x = 1
-
-const y = 2]]></search><replace><![CDATA[const x = 1
-const y = 2]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`const x = 1
-const y = 2`)
-		})
-
-		it.skip("should handle operations with special characters", () => {
-			const originalContent = `const regex = /test/`
-			const xmlResponse = `<change><search><![CDATA[const regex = /test/]]></search><replace><![CDATA[const regex = /test$/]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`const regex = /test$/`)
-		})
-
-		it.skip("should preserve indentation in operations", () => {
-			const originalContent = `function test() {
-	if (true) {
-		return 1
-	}
-}`
-			const xmlResponse = `<change><search><![CDATA[	if (true) {
-		return 1
-	}]]></search><replace><![CDATA[	if (true) {
-		console.log('test')
-		return 1
-	}]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`function test() {
-	if (true) {
-		console.log('test')
-		return 1
-	}
-}`)
-		})
-
-		it.skip("should handle CDATA sections with special XML characters", () => {
-			const originalContent = `const html = "<div>test</div>"`
-			const xmlResponse = `<change><search><![CDATA[const html = "<div>test</div>"]]></search><replace><![CDATA[const html = "<div>test & more</div>"]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`const html = "<div>test & more</div>"`)
-		})
-
-		it.skip("should handle single line file", () => {
-			const originalContent = `const x = 1`
-			const xmlResponse = `<change><search><![CDATA[const x = 1]]></search><replace><![CDATA[const x = 2]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`const x = 2`)
-		})
-	})
-
-	describe("error handling", () => {
-		it.skip("should handle parser errors gracefully (return null)", () => {
-			const originalContent = "const x = 1"
-			const xmlResponse = "<invalid>xml</that><breaks>parser"
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBeNull()
-		})
-
-		it.skip("should handle XML without CDATA sections", () => {
-			const originalContent = "const x = 1"
-			const xmlResponse = `<change><search>const x = 1</search><replace>const x = 2</replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			// Parser requires CDATA sections, so this should return null
-			expect(result).toBeNull()
-		})
-	})
-
-	describe("integration with real XML responses", () => {
-		it.skip("should handle single change block", () => {
-			const originalContent = `function test() {
-	return true
-}`
-			const xmlResponse = `<change><search><![CDATA[function test() {
-	return true
-}]]></search><replace><![CDATA[function test() {
-	// Added comment
-	return true
-}]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`function test() {
-	// Added comment
-	return true
-}`)
-		})
-
-		it.skip("should handle multiple change blocks", () => {
-			const originalContent = `function test() {
-	return true
-}
-
-function other() {
-	return false
-}`
-			const xmlResponse = `<change><search><![CDATA[function test() {
-	return true
-}]]></search><replace><![CDATA[function test() {
-	// Test function
-	return true
-}]]></replace></change><change><search><![CDATA[function other() {
-	return false
-}]]></search><replace><![CDATA[function other() {
-	// Other function
-	return false
-}]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`function test() {
-	// Test function
-	return true
-}
-
-function other() {
-	// Other function
-	return false
-}`)
-		})
-
-		it.skip("should handle complex multi-line changes with CDATA", () => {
-			const originalContent = `class Calculator {
-	add(a, b) {
-		return a + b
-	}
-}`
-			const xmlResponse = `<change><search><![CDATA[class Calculator {
-	add(a, b) {
-		return a + b
-	}
-}]]></search><replace><![CDATA[class Calculator {
-	/**
-	 * Add two numbers
-	 */
-	add(a, b) {
-		const result = a + b
-		console.log('Result:', result)
-		return result
-	}
-}]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`class Calculator {
-	/**
-	 * Add two numbers
-	 */
-	add(a, b) {
-		const result = a + b
-		console.log('Result:', result)
-		return result
-	}
-}`)
-		})
-
-		it.skip("should handle changes with nested XML-like content", () => {
-			const originalContent = `const template = "<div></div>"`
-			const xmlResponse = `<change><search><![CDATA[const template = "<div></div>"]]></search><replace><![CDATA[const template = "<div><span>Hello</span></div>"]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`const template = "<div><span>Hello</span></div>"`)
-		})
-
-		it.skip("should handle sequential operations on adjacent lines", () => {
-			const originalContent = `const a = 1
-const b = 2
-const c = 3`
-			const xmlResponse = `<change><search><![CDATA[const a = 1
-const b = 2
-const c = 3]]></search><replace><![CDATA[const a = 10
-const b = 20
-const c = 30]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`const a = 10
-const b = 20
-const c = 30`)
-		})
-	})
-
-	describe("realistic code transformation scenarios", () => {
-		/**
-		 * Test realistic refactoring: Converting callback to async/await
-		 */
-		it.skip("should handle callback to async/await refactoring", () => {
-			const originalContent = `function fetchData(callback) {
-	getData((err, data) => {
-		if (err) {
-			callback(err)
-		} else {
-			callback(null, data)
-		}
-	})
-}`
-			const xmlResponse = `<change><search><![CDATA[function fetchData(callback) {
-	getData((err, data) => {
-		if (err) {
-			callback(err)
-		} else {
-			callback(null, data)
-		}
-	})
-}]]></search><replace><![CDATA[async function fetchData() {
-	try {
-		const data = await getData()
-		return data
-	} catch (err) {
-		throw err
-	}
-}]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`async function fetchData() {
-	try {
-		const data = await getData()
-		return data
-	} catch (err) {
-		throw err
-	}
-}`)
-		})
-
-		/**
-		 * Test realistic refactoring: Adding error handling
-		 */
-		it.skip("should handle adding error handling to existing code", () => {
-			const originalContent = `function processData(data) {
-	const result = transform(data)
-	return result
-}`
-			const xmlResponse = `<change><search><![CDATA[function processData(data) {
-	const result = transform(data)
-	return result
-}]]></search><replace><![CDATA[function processData(data) {
-	try {
-		const result = transform(data)
-		return result
-	} catch (error) {
-		console.error('Error processing data:', error)
-		throw error
-	}
-}]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`function processData(data) {
-	try {
-		const result = transform(data)
-		return result
-	} catch (error) {
-		console.error('Error processing data:', error)
-		throw error
-	}
-}`)
-		})
-
-		/**
-		 * Test realistic refactoring: Adding TypeScript types
-		 */
-		it.skip("should handle adding TypeScript type annotations", () => {
-			const originalContent = `function add(a, b) {
-	return a + b
-}`
-			const xmlResponse = `<change><search><![CDATA[function add(a, b) {
-	return a + b
-}]]></search><replace><![CDATA[function add(a: number, b: number): number {
-	return a + b
-}]]></replace></change>`
-
-			const result = strategyTester.parseCompletion(originalContent, xmlResponse)
-
-			expect(result).toBe(`function add(a: number, b: number): number {
-	return a + b
-}`)
-		})
-	})
-})
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.10.txt b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.10.txt
new file mode 100644
index 00000000000..e34232ec24c
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.10.txt
@@ -0,0 +1,15 @@
+class ApiClient {
+	async post(endpoint, data) {
+		const response = await fetch(this.baseUrl + endpoint, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify(data),
+		});
+		if (!response.ok) {
+			throw new Error(`HTTP error! status: ${response.status}`);
+		}
+		return response.json();
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.11.txt b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.11.txt
new file mode 100644
index 00000000000..dec0b30959c
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.11.txt
@@ -0,0 +1,12 @@
+class ApiClient {
+	async post(endpoint, data) {
+		const response = await fetch(this.baseUrl + endpoint, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify(data),
+		});
+		return response.json();
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.12.txt b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.12.txt
new file mode 100644
index 00000000000..722fd6407b4
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.12.txt
@@ -0,0 +1,12 @@
+class ApiClient {
+	async post(endpoint, data) {
+		const response = await fetch(this.baseUrl + endpoint, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify(data),
+		});
+		const result = await response.json();
+		return result;
+	}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.13.txt b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.13.txt
new file mode 100644
index 00000000000..5e8f11392d1
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.13.txt
@@ -0,0 +1,14 @@
+class ApiClient {
+	async post(endpoint, data) {
+		const response = await fetch(this.baseUrl + endpoint, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify(data),
+		});
+		if (!response.ok) {
+			throw new Error(`HTTP error! status: ${response.status}`);
+		}
+		return await response.json();
+	}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.14.txt b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.14.txt
new file mode 100644
index 00000000000..19ed8c724df
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.14.txt
@@ -0,0 +1,12 @@
+class ApiClient {
+	async post(endpoint, data) {
+		const response = await fetch(this.baseUrl + endpoint, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify(data),
+		});
+		const json = await response.json();
+		return json;
+	}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.15.txt b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.15.txt
new file mode 100644
index 00000000000..6b0f59ccaf3
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.15.txt
@@ -0,0 +1,9 @@
+class ApiClient {
+	async post(endpoint, data) {
+		const response = await fetch(this.baseUrl + endpoint, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify(data),
+		});
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.7.txt b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.7.txt
new file mode 100644
index 00000000000..6ad845ca2b7
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.7.txt
@@ -0,0 +1,17 @@
+class ApiClient {
+	async post(endpoint, data) {
+		const response = await fetch(this.baseUrl + endpoint, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify(data),
+		});
+
+		if (!response.ok) {
+			throw new Error(`HTTP error! status: ${response.status}`);
+		}
+
+		return await response.json();
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.8.txt b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.8.txt
new file mode 100644
index 00000000000..422deced4fa
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.8.txt
@@ -0,0 +1,15 @@
+class ApiClient {
+	async post(endpoint, data) {
+		const response = await fetch(this.baseUrl + endpoint, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify(data),
+		});
+		if (!response.ok) {
+			throw new Error(`HTTP error! status: ${response.status}`);
+		}
+		return await response.json();
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.9.txt b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.9.txt
new file mode 100644
index 00000000000..1f049fdff6e
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.approved.9.txt
@@ -0,0 +1,12 @@
+class ApiClient {
+	async post(endpoint, data) {
+		const response = await fetch(this.baseUrl + endpoint, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify(data),
+		});
+		return await response.json();
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.rejected.3.txt b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.rejected.3.txt
new file mode 100644
index 00000000000..1a2285f95b3
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/rest-api-client.rejected.3.txt
@@ -0,0 +1,12 @@
+class ApiClient {
+	async post(endpoint, data) {
+		const response = await fetch(this.baseUrl + endpoint, {
+			method: 'POST',
+						headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify(data),
+		});
+		return await response.json();
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.10.txt b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.10.txt
new file mode 100644
index 00000000000..c7910daaddc
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.10.txt
@@ -0,0 +1,11 @@
+async function fetchWithRetry(url, maxRetries = 3) {
+	for (let attempt = 0; attempt < maxRetries; attempt++) {
+		try {
+			return await fetch(url);
+		} catch (error) {
+			if (attempt === maxRetries - 1) throw error;
+			await new Promise(resolve => setTimeout(resolve, 1000));
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.11.txt b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.11.txt
new file mode 100644
index 00000000000..65cced83a44
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.11.txt
@@ -0,0 +1,10 @@
+async function fetchWithRetry(url, maxRetries = 3) {
+	for (let attempt = 0; attempt < maxRetries; attempt++) {
+		try {
+			return await fetch(url);
+		} catch (error) {
+			if (attempt === maxRetries - 1) throw error;
+			await new Promise(resolve => setTimeout(resolve, 1000));
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.12.txt b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.12.txt
new file mode 100644
index 00000000000..c6ca0df445e
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.12.txt
@@ -0,0 +1,7 @@
+async function fetchWithRetry(url, maxRetries = 3) {
+	for (let attempt = 0; attempt < maxRetries; attempt++) {
+		try {
+			return await fetch(url);
+		} catch (error) {
+			if (attempt === maxRetries - 1) throw error;
+			await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1));
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.13.txt b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.13.txt
new file mode 100644
index 00000000000..a0dd9bee938
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.13.txt
@@ -0,0 +1,7 @@
+async function fetchWithRetry(url, maxRetries = 3) {
+	for (let attempt = 0; attempt < maxRetries; attempt++) {
+		try {
+			return await fetch(url);
+		} catch (error) {
+			if (attempt === maxRetries - 1) throw error;
+			await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, attempt)
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.6.txt b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.6.txt
new file mode 100644
index 00000000000..eebf0d0d252
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.6.txt
@@ -0,0 +1,8 @@
+async function fetchWithRetry(url, maxRetries = 3) {
+	for (let attempt = 0; attempt < maxRetries; attempt++) {
+		try {
+			return await fetch(url);
+		} catch (error) {
+			if (attempt === maxRetries - 1) throw error;
+			await new Promise(resolve => setTimeout(resolve, 1000));
+```
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.7.txt b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.7.txt
new file mode 100644
index 00000000000..f6207fc8faf
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.7.txt
@@ -0,0 +1,7 @@
+async function fetchWithRetry(url, maxRetries = 3) {
+	for (let attempt = 0; attempt < maxRetries; attempt++) {
+		try {
+			return await fetch(url);
+		} catch (error) {
+			if (attempt === maxRetries - 1) throw error;
+			await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1)));
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.8.txt b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.8.txt
new file mode 100644
index 00000000000..b983f7b3b36
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.8.txt
@@ -0,0 +1,10 @@
+async function fetchWithRetry(url, maxRetries = 3) {
+	for (let attempt = 0; attempt < maxRetries; attempt++) {
+		try {
+			return await fetch(url);
+		} catch (error) {
+			if (attempt === maxRetries - 1) throw error;
+			await new Promise(resolve => setTimeout(resolve, 1000)); // Wait for 1 second before retrying
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.9.txt b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.9.txt
new file mode 100644
index 00000000000..0fb941a5dc6
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/api-patterns/retry-logic.approved.9.txt
@@ -0,0 +1,7 @@
+async function fetchWithRetry(url, maxRetries = 3) {
+	for (let attempt = 0; attempt < maxRetries; attempt++) {
+		try {
+			return await fetch(url);
+		} catch (error) {
+			if (attempt === maxRetries - 1) throw error;
+			await new Promise(resolve => setTimeout(resolve, 1000)); // 1 second delay
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.approved.5.txt b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.approved.5.txt
new file mode 100644
index 00000000000..bb201d714e1
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.approved.5.txt
@@ -0,0 +1,4 @@
+function test() {
+	console.log('hello');
+
+	console.log('world')
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.approved.6.txt b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.approved.6.txt
new file mode 100644
index 00000000000..7d677384b68
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.approved.6.txt
@@ -0,0 +1,3 @@
+function test() {
+	console.log('hello');
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.3.txt b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.3.txt
new file mode 100644
index 00000000000..64771a484f6
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.3.txt
@@ -0,0 +1,2 @@
+function test() {
+	console.log('hello')}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.4.txt b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.4.txt
new file mode 100644
index 00000000000..2b37ea4aee5
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.4.txt
@@ -0,0 +1,2 @@
+function test() {
+	console.log('hello')world')
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.5.txt b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.5.txt
new file mode 100644
index 00000000000..0ef20786b16
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.5.txt
@@ -0,0 +1,3 @@
+function test() {
+	console.log('hello')world
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.6.txt b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.6.txt
new file mode 100644
index 00000000000..2c5ec628b47
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.6.txt
@@ -0,0 +1,3 @@
+function test() {
+	console.log('hello')	return 'world'
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.7.txt b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.7.txt
new file mode 100644
index 00000000000..c6807892e87
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.7.txt
@@ -0,0 +1,3 @@
+function test() {
+	console.log('hello')	console.log('world')
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.8.txt b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.8.txt
new file mode 100644
index 00000000000..1c9d66c5285
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/basic-syntax/closing-brace.rejected.8.txt
@@ -0,0 +1,3 @@
+function test() {
+	console.log('hello')	// Add any additional code here
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/basic-syntax/closing-bracket.approved.10.txt b/src/test-llm-autocompletion/approvals/basic-syntax/closing-bracket.approved.10.txt
new file mode 100644
index 00000000000..bb3b9e04b7f
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/basic-syntax/closing-bracket.approved.10.txt
@@ -0,0 +1 @@
+const arr = [1, 2, 3, 4, 5, 6]
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/basic-syntax/closing-bracket.approved.8.txt b/src/test-llm-autocompletion/approvals/basic-syntax/closing-bracket.approved.8.txt
new file mode 100644
index 00000000000..63933cbd12b
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/basic-syntax/closing-bracket.approved.8.txt
@@ -0,0 +1 @@
+const arr = [1, 2, 3, 4, 5]
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/basic-syntax/closing-bracket.approved.9.txt b/src/test-llm-autocompletion/approvals/basic-syntax/closing-bracket.approved.9.txt
new file mode 100644
index 00000000000..664ef86a256
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/basic-syntax/closing-bracket.approved.9.txt
@@ -0,0 +1 @@
+const arr = [1, 2, 3, 4, 5, 6
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.approved.4.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.approved.4.txt
new file mode 100644
index 00000000000..050d47cece8
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.approved.4.txt
@@ -0,0 +1,7 @@
+class User {
+	constructor(username, email, role) {
+		this.username = username;
+		this.email = email;
+		this.role = role;
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.approved.5.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.approved.5.txt
new file mode 100644
index 00000000000..ae3dbddc03c
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.approved.5.txt
@@ -0,0 +1,7 @@
+class User {
+	constructor(username, email, role) {
+		this.username = username;
+		this.email = email, role) {
+		this.role = role;
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.approved.6.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.approved.6.txt
new file mode 100644
index 00000000000..c2689df0e23
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.approved.6.txt
@@ -0,0 +1,4 @@
+class User {
+	constructor(username, email, role) {
+		this.username = username;
+		this.email = email,
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rb.approved.4.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rb.approved.4.txt
new file mode 100644
index 00000000000..fe4df40954f
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rb.approved.4.txt
@@ -0,0 +1,7 @@
+class User
+	def initialize(username, email, role)
+		@username = username
+		@email = email
+		@role = role
+	end
+end
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rb.rejected.2.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rb.rejected.2.txt
new file mode 100644
index 00000000000..3e3d163e8b5
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rb.rejected.2.txt
@@ -0,0 +1,4 @@
+class User
+	def initialize(username, email, role)
+		@username = username
+		@email = email, role
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.2.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.2.txt
new file mode 100644
index 00000000000..98571dcafb3
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.2.txt
@@ -0,0 +1,7 @@
+class User {
+	constructor(username, email, role) {
+		this.username = username;
+		this.email = email,
+		this.role = role;
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.3.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.3.txt
new file mode 100644
index 00000000000..bbad8267875
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.3.txt
@@ -0,0 +1,4 @@
+class User {
+	constructor(username, email, role) {
+		this.username = username;
+		this.email = email, this.role = role
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.4.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.4.txt
new file mode 100644
index 00000000000..5a0faaeb93c
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.4.txt
@@ -0,0 +1,4 @@
+class User {
+	constructor(username, email, role) {
+		this.username = username;
+		this.email = email, this.role = role;
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.5.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.5.txt
new file mode 100644
index 00000000000..add624cc564
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.5.txt
@@ -0,0 +1,4 @@
+class User {
+	constructor(username, email, role) {
+		this.username = username;
+		this.email = email, role = role;
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.6.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.6.txt
new file mode 100644
index 00000000000..a96231e4b2f
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-constructor.rejected.6.txt
@@ -0,0 +1,4 @@
+class User {
+	constructor(username, email, role) {
+		this.username = username;
+		this.email = email, role
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-inheritance.approved.7.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-inheritance.approved.7.txt
new file mode 100644
index 00000000000..4771ddbc851
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-inheritance.approved.7.txt
@@ -0,0 +1,12 @@
+class Animal {
+	constructor(name) {
+		this.name = name;
+	}
+}
+
+class Dog extends Animal {
+	constructor(name, breed) {
+		super(name);
+		this.breed = breed;
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-inheritance.rb.approved.4.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-inheritance.rb.approved.4.txt
new file mode 100644
index 00000000000..75991601ef8
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-inheritance.rb.approved.4.txt
@@ -0,0 +1,12 @@
+class Animal
+	def initialize(name)
+		@name = name
+	end
+end
+
+class Dog < Animal
+	def initialize(name, breed)
+		super(name)
+		@breed = breed
+	end
+end
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-inheritance.rejected.3.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-inheritance.rejected.3.txt
new file mode 100644
index 00000000000..020090de036
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-inheritance.rejected.3.txt
@@ -0,0 +1,10 @@
+class Animal {
+	constructor(name) {
+		this.name = name;
+	}
+}
+
+class Dog extends Animal {
+	constructor(name, breed) {
+				super(name);
+		this.breed = breed;
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-method-override.rb.approved.2.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-method-override.rb.approved.2.txt
new file mode 100644
index 00000000000..6e9839844cd
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-method-override.rb.approved.2.txt
@@ -0,0 +1,16 @@
+class Shape
+	def area
+		0
+	end
+end
+
+class Rectangle < Shape
+	def initialize(width, height)
+		@width = width
+		@height = height
+	end
+	
+	def area
+		@width * @height
+	end
+end
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-method-override.rb.approved.3.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-method-override.rb.approved.3.txt
new file mode 100644
index 00000000000..93ce2595e2a
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-method-override.rb.approved.3.txt
@@ -0,0 +1,15 @@
+class Shape
+	def area
+		0
+	end
+end
+
+class Rectangle < Shape
+	def initialize(width, height)
+		@width = width
+		@height = height
+	end
+	
+	def area
+		@width * @height
+	end
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-method-override.rb.rejected.2.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-method-override.rb.rejected.2.txt
new file mode 100644
index 00000000000..7b86a572658
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-method-override.rb.rejected.2.txt
@@ -0,0 +1,16 @@
+class Shape
+	def area
+		0
+	end
+end
+
+class Rectangle < Shape
+	def initialize(width, height)
+		@width = width
+		@height = height
+	end
+	
+	def area
+		
+		@width * @height
+	end
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/class-patterns/class-method-override.rb.rejected.3.txt b/src/test-llm-autocompletion/approvals/class-patterns/class-method-override.rb.rejected.3.txt
new file mode 100644
index 00000000000..ea0ddf96792
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/class-patterns/class-method-override.rb.rejected.3.txt
@@ -0,0 +1,17 @@
+class Shape
+	def area
+		0
+	end
+end
+
+class Rectangle < Shape
+	def initialize(width, height)
+		@width = width
+		@height = height
+	end
+	
+	def area
+		
+		@width * @height
+	end
+end
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.approved.8.txt b/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.approved.8.txt
new file mode 100644
index 00000000000..ac3a391ddd2
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.approved.8.txt
@@ -0,0 +1,7 @@
+function divide(a, b) {
+  // FIXME: Handle division by zero
+ if (b === 0) {
+    throw new Error("Division by zero is not allowed");
+  }
+  return a / b;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.1.txt b/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.1.txt
new file mode 100644
index 00000000000..83f07b2c5c0
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.1.txt
@@ -0,0 +1,6 @@
+function divide(a, b) {
+  // FIXME: Handle division by zeroif (b === 0) {
+  throw new Error("Division by zero");
+}
+  return a / b;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.2.txt b/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.2.txt
new file mode 100644
index 00000000000..181cb8ed9fc
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.2.txt
@@ -0,0 +1,6 @@
+function divide(a, b) {
+  // FIXME: Handle division by zero\n  if (b === 0) {
+    throw new Error("Division by zero is not allowed");
+  }
+  return a / b;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.3.txt b/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.3.txt
new file mode 100644
index 00000000000..bd35a7b2614
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.3.txt
@@ -0,0 +1,6 @@
+function divide(a, b) {
+  // FIXME: Handle division by zeroif (b === 0) {
+    throw new Error('Division by zero');
+  }
+  return a / b;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.4.txt b/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.4.txt
new file mode 100644
index 00000000000..ff441073456
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.4.txt
@@ -0,0 +1,6 @@
+function divide(a, b) {
+  // FIXME: Handle division by zero if (b === 0) {
+    throw new Error("Division by zero is not allowed");
+  }
+  return a / b;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.5.txt b/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.5.txt
new file mode 100644
index 00000000000..939f00594d0
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/fixme-bug.rejected.5.txt
@@ -0,0 +1,8 @@
+function divide(a, b) {
+  // FIXME: Handle division by zero {
+  if (b === 0) {
+    throw new Error("Division by zero is not allowed");
+  }
+}
+  return a / b;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/implement-function-add-numbers.approved.1.txt b/src/test-llm-autocompletion/approvals/comment-driven/implement-function-add-numbers.approved.1.txt
new file mode 100644
index 00000000000..f991815b04a
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/implement-function-add-numbers.approved.1.txt
@@ -0,0 +1,4 @@
+// Implement functino to add two numbers
+function add(a, b) {
+  return a + b;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/implement-function-add-numbers.rejected.1.txt b/src/test-llm-autocompletion/approvals/comment-driven/implement-function-add-numbers.rejected.1.txt
new file mode 100644
index 00000000000..7a81b508c8f
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/implement-function-add-numbers.rejected.1.txt
@@ -0,0 +1,3 @@
+// Implement functino to add two numbers {
+  return a + b;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/implement-function-combine-functions.approved.1.txt b/src/test-llm-autocompletion/approvals/comment-driven/implement-function-combine-functions.approved.1.txt
new file mode 100644
index 00000000000..c4358313810
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/implement-function-combine-functions.approved.1.txt
@@ -0,0 +1,15 @@
+
+function addNumbers(a, b) {
+    return a + b
+}
+
+function multiplyBy5(a) {
+    return a * 5
+}
+
+// Implement function to combine above functions
+
+function combineFunctions(a, b) {
+    const sum = addNumbers(a, b);
+    return multiplyBy5(sum);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/implement-function-combine-functions.approved.2.txt b/src/test-llm-autocompletion/approvals/comment-driven/implement-function-combine-functions.approved.2.txt
new file mode 100644
index 00000000000..e4833196ed0
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/implement-function-combine-functions.approved.2.txt
@@ -0,0 +1,13 @@
+
+function addNumbers(a, b) {
+    return a + b
+}
+
+function multiplyBy5(a) {
+    return a * 5
+}
+
+// Implement function to combine above functions
+function combineFunctions(a, b) {
+    return multiplyBy5(addNumbers(a, b));
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/implement-function-combine-functions.approved.3.txt b/src/test-llm-autocompletion/approvals/comment-driven/implement-function-combine-functions.approved.3.txt
new file mode 100644
index 00000000000..877a76efa86
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/implement-function-combine-functions.approved.3.txt
@@ -0,0 +1,14 @@
+
+function addNumbers(a, b) {
+    return a + b
+}
+
+function multiplyBy5(a) {
+    return a * 5
+}
+
+// Implement function to combine above functions
+function combinedFunction(a, b) {
+    const sum = addNumbers(a, b);
+    return multiplyBy5(sum);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.approved.10.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.approved.10.txt
new file mode 100644
index 00000000000..315ad3888c7
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.approved.10.txt
@@ -0,0 +1,17 @@
+class DataService {
+  // TODO: Implement caching mechanism to reduce API calls
+  private cache = new Map();
+
+  async fetchData(id) {
+    if (this.cache.has(id)) {
+      return this.cache.get(id);
+    }
+
+    const data = await api.get(`/data/${id}`);
+    this.cache.set(id, data);
+    return data;
+  }
+  async fetchData(id) {
+    return await api.get(`/data/${id}`);
+  }
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.approved.11.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.approved.11.txt
new file mode 100644
index 00000000000..cb34559bcae
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.approved.11.txt
@@ -0,0 +1,17 @@
+class DataService {
+  // TODO: Implement caching mechanism to reduce API calls
+  private cache: Map<string, any> = new Map();
+
+  async fetchData(id) {
+    if (this.cache.has(id)) {
+      return this.cache.get(id);
+    }
+
+    const data = await api.get(`/data/${id}`);
+    this.cache.set(id, data);
+    return data;
+  }
+  async fetchData(id) {
+    return await api.get(`/data/${id}`);
+  }
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.rejected.2.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.rejected.2.txt
new file mode 100644
index 00000000000..ad5e8a92db6
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.rejected.2.txt
@@ -0,0 +1,18 @@
+class DataService {
+  // TODO: Implement caching mechanism to reduce API calls```
+  private cache: Map<string, any> = new Map();
+
+  async fetchData(id) {
+    if (this.cache.has(id)) {
+      return this.cache.get(id);
+    }
+
+    const data = await api.get(`/data/${id}`);
+    this.cache.set(id, data);
+    return data;
+  }
+```
+  async fetchData(id) {
+    return await api.get(`/data/${id}`);
+  }
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.rejected.3.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.rejected.3.txt
new file mode 100644
index 00000000000..5b3bc0608da
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.rejected.3.txt
@@ -0,0 +1,18 @@
+class DataService {
+  // TODO: Implement caching mechanism to reduce API calls```
+  private cache = new Map();
+
+  async fetchData(id) {
+    if (this.cache.has(id)) {
+      return this.cache.get(id);
+    }
+
+    const data = await api.get(`/data/${id}`);
+    this.cache.set(id, data);
+    return data;
+  }
+```
+  async fetchData(id) {
+    return await api.get(`/data/${id}`);
+  }
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.rejected.4.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.rejected.4.txt
new file mode 100644
index 00000000000..e5b9c3105e3
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-caching.rejected.4.txt
@@ -0,0 +1,16 @@
+class DataService {
+  // TODO: Implement caching mechanism to reduce API callsprivate cache = new Map();
+
+  async fetchData(id) {
+    if (this.cache.has(id)) {
+      return this.cache.get(id);
+    }
+
+    const data = await api.get(`/data/${id}`);
+    this.cache.set(id, data);
+    return data;
+  }
+  async fetchData(id) {
+    return await api.get(`/data/${id}`);
+  }
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.approved.10.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.approved.10.txt
new file mode 100644
index 00000000000..e7a5ffce8bd
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.approved.10.txt
@@ -0,0 +1,9 @@
+function handleSearch(query) {
+  // TODO: Add debounce to prevent excessive API calls
+  const debounceTimer = setTimeout(() => {
+    searchAPI(query);
+  }, 500);
+  return () => clearTimeout(debounceTimer);
+
+  searchAPI(query);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.approved.7.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.approved.7.txt
new file mode 100644
index 00000000000..eef556d24c3
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.approved.7.txt
@@ -0,0 +1,9 @@
+function handleSearch(query) {
+  // TODO: Add debounce to prevent excessive API calls
+  const debouncedSearch = debounce((query) => {
+    searchAPI(query);
+  }, 500);
+
+  debouncedSearch(query);
+  searchAPI(query);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.approved.8.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.approved.8.txt
new file mode 100644
index 00000000000..4d834aaf293
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.approved.8.txt
@@ -0,0 +1,6 @@
+function handleSearch(query) {
+  // TODO: Add debounce to prevent excessive API calls
+  const debouncedSearch = debounce(searchAPI, 500);
+  debouncedSearch(query);
+  searchAPI(query);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.approved.9.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.approved.9.txt
new file mode 100644
index 00000000000..ee6bea311c3
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.approved.9.txt
@@ -0,0 +1,9 @@
+function handleSearch(query) {
+  // TODO: Add debounce to prevent excessive API calls
+  const debounceTimer = setTimeout(() => {
+    searchAPI(query);
+  }, 500);
+
+  return () => clearTimeout(debounceTimer);
+  searchAPI(query);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.4.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.4.txt
new file mode 100644
index 00000000000..74dfbf0c1be
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.4.txt
@@ -0,0 +1,10 @@
+function handleSearch(query) {
+  // TODO: Add debounce to prevent excessive API calls```
+  const debouncedSearch = debounce((query) => {
+    searchAPI(query);
+  }, 500);
+
+  debouncedSearch(query);
+```
+  searchAPI(query);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.5.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.5.txt
new file mode 100644
index 00000000000..fabb6ebb829
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.5.txt
@@ -0,0 +1,16 @@
+function handleSearch(query) {
+  // TODO: Add debounce to prevent excessive API calls```
+  const debounce = (func, delay) => {
+    let timeoutId;
+    return function(...args) {
+      clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => func.apply(this, args), delay);
+    };
+  };
+
+  const debouncedSearch = debounce(searchAPI, 300);
+
+  debouncedSearch(query);
+```
+  searchAPI(query);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.6.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.6.txt
new file mode 100644
index 00000000000..ad5cf7c19f7
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.6.txt
@@ -0,0 +1,10 @@
+function handleSearch(query) {
+  // TODO: Add debounce to prevent excessive API calls```
+  const debounceTimer = setTimeout(() => {
+    searchAPI(query);
+  }, 500);
+
+  return () => clearTimeout(debounceTimer);
+```
+  searchAPI(query);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.7.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.7.txt
new file mode 100644
index 00000000000..50cce59159e
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.7.txt
@@ -0,0 +1,15 @@
+function handleSearch(query) {
+  // TODO: Add debounce to prevent excessive API callsconst debounce = (func, delay) => {
+    let timeoutId;
+    return (...args) => {
+      clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => {
+        func(...args);
+      }, delay);
+    };
+  };
+
+  const debouncedSearch = debounce(searchAPI, 500);
+  debouncedSearch(query);
+  searchAPI(query);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.8.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.8.txt
new file mode 100644
index 00000000000..87363c15c0c
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.8.txt
@@ -0,0 +1,5 @@
+function handleSearch(query) {
+  // TODO: Add debounce to prevent excessive API calls
+  .then(results => displayResults(results));
+  searchAPI(query);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.9.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.9.txt
new file mode 100644
index 00000000000..d13480edae1
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-debounce.rejected.9.txt
@@ -0,0 +1,8 @@
+function handleSearch(query) {
+  // TODO: Add debounce to prevent excessive API calls
+  let timeoutId;
+  clearTimeout(timeoutId);
+  timeoutId = setTimeout(() => searchAPI(query), 500);
+
+  searchAPI(query);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.approved.10.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.approved.10.txt
new file mode 100644
index 00000000000..589eb9771cd
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.approved.10.txt
@@ -0,0 +1,12 @@
+function processData(data) {
+  // TODO: Implement error handling
+  try {
+    // Process data here
+    const processedData = data.map(item => item * 2);
+    return processedData;
+  } catch (error) {
+    console.error('Error processing data:', error);
+    throw error;
+  }
+  return processedData;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.approved.11.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.approved.11.txt
new file mode 100644
index 00000000000..dff697e3f66
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.approved.11.txt
@@ -0,0 +1,12 @@
+function processData(data) {
+  // TODO: Implement error handling
+  try {
+    // Process the data here
+    const processedData = data.map(item => item * 2);
+    return processedData;
+  } catch (error) {
+    console.error('Error processing data:', error);
+    throw error;
+  }
+  return processedData;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.approved.12.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.approved.12.txt
new file mode 100644
index 00000000000..0cef1266089
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.approved.12.txt
@@ -0,0 +1,13 @@
+function processData(data) {
+  // TODO: Implement error handling
+
+  if (!data) {
+    throw new Error("Data is required");
+  }
+
+  const processedData = data.map(item => {
+    // Process each item
+    return item;
+  });
+  return processedData;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.approved.13.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.approved.13.txt
new file mode 100644
index 00000000000..b990343d43a
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.approved.13.txt
@@ -0,0 +1,13 @@
+function processData(data) {
+  // TODO: Implement error handling
+  try {
+    // Process the data here
+    const processedData = data.map(item => item * 2);
+    return processedData;
+  } catch (error) {
+    console.error('Error processing data:', error);
+    throw error;
+  }
+
+  return processedData;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.rejected.3.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.rejected.3.txt
new file mode 100644
index 00000000000..0f3c4a2a264
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.rejected.3.txt
@@ -0,0 +1,12 @@
+function processData(data) {
+  // TODO: Implement error handling```
+  try {
+    const processedData = // ... existing processing logic
+    return processedData;
+  } catch (error) {
+    console.error('Error processing data:', error);
+    throw error; // or handle the error as needed
+  }
+```
+  return processedData;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.rejected.4.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.rejected.4.txt
new file mode 100644
index 00000000000..09fea3ce690
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.rejected.4.txt
@@ -0,0 +1,12 @@
+function processData(data) {
+  // TODO: Implement error handling```
+  try {
+    const processedData = // ... existing processing code ...
+    return processedData;
+  } catch (error) {
+    console.error('Error processing data:', error);
+    throw error; // or handle the error as needed
+  }
+```
+  return processedData;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.rejected.5.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.rejected.5.txt
new file mode 100644
index 00000000000..57294a3779c
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-error-handling.rejected.5.txt
@@ -0,0 +1,18 @@
+function processData(data) {
+  // TODO: Implement error handling```
+  try {
+    const processedData = data.map(item => {
+      if (!item || typeof item !== 'object') {
+        throw new Error('Invalid data item');
+      }
+      // Process the item here
+      return processedItem;
+    });
+    return processedData;
+  } catch (error) {
+    console.error('Error processing data:', error);
+    throw error; // Re-throw the error for the caller to handle
+  }
+```
+  return processedData;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.11.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.11.txt
new file mode 100644
index 00000000000..7f35f99a518
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.11.txt
@@ -0,0 +1,7 @@
+function processOrder(order) {
+  // TODO: Add comprehensive logging for order processing
+  console.log(`Processing order: ${JSON.stringify(order)}`);
+  logger.info(`Order validation started for order ID: ${order.id}`);
+  const result = validateOrder(order);
+  return result;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.12.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.12.txt
new file mode 100644
index 00000000000..65d5a8f6304
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.12.txt
@@ -0,0 +1,7 @@
+function processOrder(order) {
+  // TODO: Add comprehensive logging for order processing
+  console.log(`Processing order: ${JSON.stringify(order)}`);
+  const startTime = Date.now();
+  const result = validateOrder(order);
+  return result;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.13.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.13.txt
new file mode 100644
index 00000000000..0f061bb2cac
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.13.txt
@@ -0,0 +1,19 @@
+function processOrder(order) {
+  // TODO: Add comprehensive logging for order processing
+
+  console.log(`Processing order: ${JSON.stringify(order)}`);
+  const startTime = Date.now();
+
+  try {
+    const result = validateOrder(order);
+    const endTime = Date.now();
+    console.log(`Order processed successfully in ${endTime - startTime}ms`);
+    return result;
+  } catch (error) {
+    const endTime = Date.now();
+    console.error(`Order processing failed after ${endTime - startTime}ms: ${error.message}`);
+    throw error;
+  }
+  const result = validateOrder(order);
+  return result;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.14.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.14.txt
new file mode 100644
index 00000000000..fee85b68bd5
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.14.txt
@@ -0,0 +1,8 @@
+function processOrder(order) {
+  // TODO: Add comprehensive logging for order processing
+  console.log(`Processing order: ${JSON.stringify(order)}`);
+  console.time('OrderProcessing');
+
+  const result = validateOrder(order);
+  return result;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.15.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.15.txt
new file mode 100644
index 00000000000..71680613382
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.approved.15.txt
@@ -0,0 +1,8 @@
+function processOrder(order) {
+  // TODO: Add comprehensive logging for order processing
+  console.log(`Processing order: ${JSON.stringify(order)}`);
+  console.time('orderProcessing');
+
+  const result = validateOrder(order);
+  return result;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.rejected.4.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.rejected.4.txt
new file mode 100644
index 00000000000..90dab60444a
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.rejected.4.txt
@@ -0,0 +1,7 @@
+function processOrder(order) {
+  // TODO: Add comprehensive logging for order processing```
+  console.log(`Processing order: ${JSON.stringify(order)}`);
+```
+  const result = validateOrder(order);
+  return result;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.rejected.5.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.rejected.5.txt
new file mode 100644
index 00000000000..144daed67ed
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-logging.rejected.5.txt
@@ -0,0 +1,8 @@
+function processOrder(order) {
+  // TODO: Add comprehensive logging for order processing```
+  console.log(`Processing order: ${JSON.stringify(order)}`);
+  const startTime = Date.now();
+```
+  const result = validateOrder(order);
+  return result;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-pagination.approved.7.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-pagination.approved.7.txt
new file mode 100644
index 00000000000..6c32c81eb77
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-pagination.approved.7.txt
@@ -0,0 +1,7 @@
+function fetchUsers(page, limit) {
+  // TODO: Implement pagination with offset and limit
+  const offset = (page - 1) * limit;
+  return db.query('SELECT * FROM users LIMIT ? OFFSET ?', [limit, offset]);
+
+  return db.query('SELECT * FROM users');
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-pagination.rejected.2.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-pagination.rejected.2.txt
new file mode 100644
index 00000000000..f815f6a0f7a
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-pagination.rejected.2.txt
@@ -0,0 +1,7 @@
+function fetchUsers(page, limit) {
+  // TODO: Implement pagination with offset and limit```
+  const offset = (page - 1) * limit;
+  return db.query('SELECT * FROM users LIMIT ? OFFSET ?', [limit, offset]);
+```
+  return db.query('SELECT * FROM users');
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-pagination.rejected.3.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-pagination.rejected.3.txt
new file mode 100644
index 00000000000..9d65117cf70
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-pagination.rejected.3.txt
@@ -0,0 +1,5 @@
+function fetchUsers(page, limit) {
+  // TODO: Implement pagination with offset and limitconst offset = (page - 1) * limit;
+  return db.query('SELECT * FROM users LIMIT ? OFFSET ?', [limit, offset]);
+  return db.query('SELECT * FROM users');
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.13.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.13.txt
new file mode 100644
index 00000000000..6f32f28ec7e
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.13.txt
@@ -0,0 +1,13 @@
+function handleAPIRequest(req, res) {
+  // TODO: Implement rate limiting to prevent abuse
+  const rateLimit = require('express-rate-limit');
+
+  const limiter = rateLimit({
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 100 // limit each IP to 100 requests per windowMs
+  });
+
+  // Apply the rate limiting middleware to all requests
+  limiter(req, res, () => {
+  processRequest(req, res);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.14.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.14.txt
new file mode 100644
index 00000000000..392fa49d8ec
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.14.txt
@@ -0,0 +1,15 @@
+function handleAPIRequest(req, res) {
+  // TODO: Implement rate limiting to prevent abuse
+  const rateLimit = require('express-rate-limit');
+
+  const limiter = rateLimit({
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 100 // limit each IP to 100 requests per windowMs
+  });
+
+  // Apply the rate limiting middleware to API calls
+  limiter(req, res, () => {
+    processRequest(req, res);
+  });
+  processRequest(req, res);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.15.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.15.txt
new file mode 100644
index 00000000000..24d27247127
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.15.txt
@@ -0,0 +1,15 @@
+function handleAPIRequest(req, res) {
+  // TODO: Implement rate limiting to prevent abuse
+  const rateLimit = require('express-rate-limit');
+
+  const limiter = rateLimit({
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 100 // limit each IP to 100 requests per windowMs
+  });
+
+  // Apply the rate limiting middleware to all requests
+  limiter(req, res, () => {
+    processRequest(req, res);
+  });
+  processRequest(req, res);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.16.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.16.txt
new file mode 100644
index 00000000000..bf3d0d22592
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.16.txt
@@ -0,0 +1,8 @@
+function handleAPIRequest(req, res) {
+  // TODO: Implement rate limiting to prevent abuse
+  // Implement rate limiting logic here
+  // For example, using a library like 'express-rate-limit'
+  // or a custom solution with Redis or an in-memory store
+
+  processRequest(req, res);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.17.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.17.txt
new file mode 100644
index 00000000000..f3ba3d40dc6
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.17.txt
@@ -0,0 +1,8 @@
+function handleAPIRequest(req, res) {
+  // TODO: Implement rate limiting to prevent abuse
+  // Check if the user has exceeded the rate limit
+  if (isRateLimited(req)) {
+    return res.status(429).send('Too many requests');
+  }
+  processRequest(req, res);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.18.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.18.txt
new file mode 100644
index 00000000000..b1c5bc03dec
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.approved.18.txt
@@ -0,0 +1,14 @@
+function handleAPIRequest(req, res) {
+  // TODO: Implement rate limiting to prevent abuse
+  // Check if the user has exceeded the rate limit
+  const rateLimit = getRateLimit(req.ip);
+  if (rateLimit > MAX_REQUESTS_PER_MINUTE) {
+    res.status(429).send('Too many requests');
+    return;
+  }
+
+  // Increment the rate limit counter
+  incrementRateLimit(req.ip);
+
+  processRequest(req, res);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.rejected.2.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.rejected.2.txt
new file mode 100644
index 00000000000..2513abcd9a6
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.rejected.2.txt
@@ -0,0 +1,19 @@
+function handleAPIRequest(req, res) {
+  // TODO: Implement rate limiting to prevent abuse```
+  // Rate limiting implementation
+  const rateLimit = require('express-rate-limit');
+
+  const limiter = rateLimit({
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 100 // limit each IP to 100 requests per windowMs
+  });
+
+  // Apply the rate limiting middleware to all requests
+  limiter(req, res, (err) => {
+    if (err) {
+      return res.status(429).json({ error: 'Too many requests, please try again later.' });
+    }
+  });
+```
+  processRequest(req, res);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.rejected.3.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.rejected.3.txt
new file mode 100644
index 00000000000..4f47fa1ecb1
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-rate-limiting.rejected.3.txt
@@ -0,0 +1,17 @@
+function handleAPIRequest(req, res) {
+  // TODO: Implement rate limiting to prevent abuse```
+  const rateLimit = require('express-rate-limit');
+
+  const limiter = rateLimit({
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 100 // limit each IP to 100 requests per windowMs
+  });
+
+  // Apply the rate limiting middleware to all requests
+  limiter(req, res, () => {
+    // If the rate limit is exceeded, the callback will not be called
+    // So we can safely proceed with processing the request
+  });
+```
+  processRequest(req, res);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.approved.10.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.approved.10.txt
new file mode 100644
index 00000000000..7a59cfa16a5
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.approved.10.txt
@@ -0,0 +1,25 @@
+async function fetchWithRetry(url) {
+  // TODO: Implement retry logic with exponential backoff
+  let retryCount = 0;
+  const maxRetries = 3;
+  const initialDelay = 1000;
+
+  while (retryCount < maxRetries) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      return response.json();
+    } catch (error) {
+      if (retryCount === maxRetries - 1) {
+        throw error;
+      }
+      const delay = initialDelay * Math.pow(2, retryCount);
+      await new Promise(resolve => setTimeout(resolve, delay));
+      retryCount++;
+    }
+  }
+  const response = await fetch(url);
+  return response.json();
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.approved.11.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.approved.11.txt
new file mode 100644
index 00000000000..cd873520d8b
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.approved.11.txt
@@ -0,0 +1,26 @@
+async function fetchWithRetry(url) {
+  // TODO: Implement retry logic with exponential backoff
+  let retries = 0;
+  const maxRetries = 3;
+  const baseDelay = 1000;
+
+  while (retries < maxRetries) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      return response.json();
+    } catch (error) {
+      retries++;
+      if (retries === maxRetries) {
+        throw error;
+      }
+      const delay = baseDelay * Math.pow(2, retries - 1);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+
+  const response = await fetch(url);
+  return response.json();
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.approved.12.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.approved.12.txt
new file mode 100644
index 00000000000..fb57e9619c5
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.approved.12.txt
@@ -0,0 +1,27 @@
+async function fetchWithRetry(url) {
+  // TODO: Implement retry logic with exponential backoff
+  let retryCount = 0;
+  const maxRetries = 3;
+  const initialDelay = 1000;
+
+  while (retryCount < maxRetries) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      return response.json();
+    } catch (error) {
+      console.error(`Attempt ${retryCount + 1} failed: ${error.message}`);
+      retryCount++;
+      if (retryCount < maxRetries) {
+        const delay = initialDelay * Math.pow(2, retryCount);
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+  }
+  throw new Error(`Failed to fetch after ${maxRetries} attempts`);
+
+  const response = await fetch(url);
+  return response.json();
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.approved.9.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.approved.9.txt
new file mode 100644
index 00000000000..52a3d37e6db
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.approved.9.txt
@@ -0,0 +1,25 @@
+async function fetchWithRetry(url) {
+  // TODO: Implement retry logic with exponential backoff
+  let retries = 0;
+  const maxRetries = 3;
+  let delay = 1000; // Initial delay in milliseconds
+
+  while (retries < maxRetries) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      return response.json();
+    } catch (error) {
+      retries++;
+      if (retries === maxRetries) {
+        throw error;
+      }
+      await new Promise(resolve => setTimeout(resolve, delay));
+      delay *= 2; // Exponential backoff
+    }
+  }
+  const response = await fetch(url);
+  return response.json();
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.rejected.3.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.rejected.3.txt
new file mode 100644
index 00000000000..1fb90a1fc70
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.rejected.3.txt
@@ -0,0 +1,26 @@
+async function fetchWithRetry(url) {
+  // TODO: Implement retry logic with exponential backoff```
+  let retryCount = 0;
+  const maxRetries = 3;
+  const baseDelay = 1000; // 1 second
+
+  while (retryCount < maxRetries) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      return response.json();
+    } catch (error) {
+      retryCount++;
+      if (retryCount === maxRetries) {
+        throw error;
+      }
+      const delay = baseDelay * Math.pow(2, retryCount - 1);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+```
+  const response = await fetch(url);
+  return response.json();
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.rejected.4.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.rejected.4.txt
new file mode 100644
index 00000000000..481246e041d
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-retry-logic.rejected.4.txt
@@ -0,0 +1,24 @@
+async function fetchWithRetry(url) {
+  // TODO: Implement retry logic with exponential backoff  const maxRetries = 3;
+  let retryCount = 0;
+  let delay = 1000; // Initial delay in milliseconds
+
+  while (retryCount < maxRetries) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      return response.json();
+    } catch (error) {
+      retryCount++;
+      if (retryCount === maxRetries) {
+        throw error;
+      }
+      await new Promise(resolve => setTimeout(resolve, delay));
+      delay *= 2; // Exponential backoff
+    }
+  }
+  const response = await fetch(url);
+  return response.json();
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.approved.7.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.approved.7.txt
new file mode 100644
index 00000000000..7a9709607f4
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.approved.7.txt
@@ -0,0 +1,5 @@
+function renderUserComment(comment) {
+  // TODO: Sanitize input to prevent XSS attacks
+  comment = comment.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  document.getElementById('comments').innerHTML = comment;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.approved.8.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.approved.8.txt
new file mode 100644
index 00000000000..7906a8682b3
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.approved.8.txt
@@ -0,0 +1,6 @@
+function renderUserComment(comment) {
+  // TODO: Sanitize input to prevent XSS attacks
+  const sanitizedComment = comment.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  document.getElementById('comments').innerHTML = sanitizedComment;
+  document.getElementById('comments').innerHTML = comment;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.approved.9.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.approved.9.txt
new file mode 100644
index 00000000000..83ff14893f5
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.approved.9.txt
@@ -0,0 +1,8 @@
+function renderUserComment(comment) {
+  // TODO: Sanitize input to prevent XSS attacks:
+
+  // Sanitize the comment to prevent XSS attacks
+  const sanitizedComment = comment.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  document.getElementById('comments').innerHTML = sanitizedComment;
+  document.getElementById('comments').innerHTML = comment;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.rejected.1.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.rejected.1.txt
new file mode 100644
index 00000000000..ab252c1f653
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.rejected.1.txt
@@ -0,0 +1,6 @@
+function renderUserComment(comment) {
+  // TODO: Sanitize input to prevent XSS attacks```
+  comment = comment.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+```
+  document.getElementById('comments').innerHTML = comment;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.rejected.2.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.rejected.2.txt
new file mode 100644
index 00000000000..b66297faa8b
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-sanitize-input.rejected.2.txt
@@ -0,0 +1,7 @@
+function renderUserComment(comment) {
+  // TODO: Sanitize input to prevent XSS attacks
+// TODO: Sanitize input to prevent XSS attacks
+  const sanitizedComment = comment.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  document.getElementById('comments').innerHTML = sanitizedComment;
+  document.getElementById('comments').innerHTML = comment;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.approved.10.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.approved.10.txt
new file mode 100644
index 00000000000..fccd31093cc
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.approved.10.txt
@@ -0,0 +1,8 @@
+function registerUser(email, password) {
+  // TODO: Add input validation for email and password
+// Check if email is valid and password meets requirements
+  if (!validateEmail(email) || !validatePassword(password)) {
+    throw new Error('Invalid email or password');
+  }
+  return createUser(email, password);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.approved.11.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.approved.11.txt
new file mode 100644
index 00000000000..c8722d479bb
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.approved.11.txt
@@ -0,0 +1,12 @@
+function registerUser(email, password) {
+  // TODO: Add input validation for email and password
+// Check if email is valid and password meets requirements
+  if (!validateEmail(email)) {
+    throw new Error('Invalid email address');
+  }
+
+  if (password.length < 8) {
+    throw new Error('Password must be at least 8 characters long');
+  }
+  return createUser(email, password);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.approved.8.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.approved.8.txt
new file mode 100644
index 00000000000..a073a042b7e
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.approved.8.txt
@@ -0,0 +1,16 @@
+function registerUser(email, password) {
+  // TODO: Add input validation for email and password
+  if (!email || !password) {
+    throw new Error('Email and password are required');
+  }
+
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(email)) {
+    throw new Error('Invalid email format');
+  }
+
+  if (password.length < 8) {
+    throw new Error('Password must be at least 8 characters long');
+  }
+  return createUser(email, password);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.approved.9.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.approved.9.txt
new file mode 100644
index 00000000000..3180bde8769
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.approved.9.txt
@@ -0,0 +1,16 @@
+function registerUser(email, password) {
+  // TODO: Add input validation for email and password
+
+  if (!email || !password) {
+    throw new Error('Email and password are required');
+  }
+
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+    throw new Error('Invalid email format');
+  }
+
+  if (password.length < 8) {
+    throw new Error('Password must be at least 8 characters long');
+  }
+  return createUser(email, password);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.rejected.3.txt b/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.rejected.3.txt
new file mode 100644
index 00000000000..e7c06ac2747
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/comment-driven/todo-validation.rejected.3.txt
@@ -0,0 +1,5 @@
+function registerUser(email, password) {
+  // TODO: Add input validation for email and password
+// Check if email is valid and password meets requirements
+  return createUser(email, password);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/complex/chained-methods.approved.5.txt b/src/test-llm-autocompletion/approvals/complex/chained-methods.approved.5.txt
new file mode 100644
index 00000000000..413aef0edce
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/complex/chained-methods.approved.5.txt
@@ -0,0 +1,3 @@
+const result = [1, 2, 3]
+	.map(x => x * 2)
+	.filter(x => x > 3)
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/complex/chained-methods.approved.6.txt b/src/test-llm-autocompletion/approvals/complex/chained-methods.approved.6.txt
new file mode 100644
index 00000000000..1697638551b
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/complex/chained-methods.approved.6.txt
@@ -0,0 +1,3 @@
+const result = [1, 2, 3]
+	.map(x => x * 2)
+	.reduce((acc, val) => acc + val, 0)
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/complex/nested-object.approved.6.txt b/src/test-llm-autocompletion/approvals/complex/nested-object.approved.6.txt
new file mode 100644
index 00000000000..5ddc2f25727
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/complex/nested-object.approved.6.txt
@@ -0,0 +1,6 @@
+const config = {
+	server: {
+	  port: 3000,
+		host: 'localhost'
+	}
+};
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/complex/nested-object.rejected.3.txt b/src/test-llm-autocompletion/approvals/complex/nested-object.rejected.3.txt
new file mode 100644
index 00000000000..e01a8141a3f
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/complex/nested-object.rejected.3.txt
@@ -0,0 +1,6 @@
+const config = {
+	server: {
+	  port: 3000,
+		host: 'localhost',
+	},
+};
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/control-flow/for-loop.approved.8.txt b/src/test-llm-autocompletion/approvals/control-flow/for-loop.approved.8.txt
new file mode 100644
index 00000000000..3c0a57e5b2a
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/control-flow/for-loop.approved.8.txt
@@ -0,0 +1,3 @@
+for (let i = 0; i < 10; i++) {
+  console.log(i);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/control-flow/for-loop.rb.approved.4.txt b/src/test-llm-autocompletion/approvals/control-flow/for-loop.rb.approved.4.txt
new file mode 100644
index 00000000000..64999187e38
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/control-flow/for-loop.rb.approved.4.txt
@@ -0,0 +1,3 @@
+arr = [1, 2, 3, 4, 5]
+arr.each do |item|
+  puts item
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/control-flow/for-loop.rb.rejected.3.txt b/src/test-llm-autocompletion/approvals/control-flow/for-loop.rb.rejected.3.txt
new file mode 100644
index 00000000000..a2807ba3062
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/control-flow/for-loop.rb.rejected.3.txt
@@ -0,0 +1,3 @@
+arr = [1, 2, 3, 4, 5]
+arr.each do |item|
+console.log(item);
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/control-flow/if-statement.approved.11.txt b/src/test-llm-autocompletion/approvals/control-flow/if-statement.approved.11.txt
new file mode 100644
index 00000000000..4ac86c028a2
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/control-flow/if-statement.approved.11.txt
@@ -0,0 +1,4 @@
+const x = 10;
+if (x > 5) {
+  console.log("x is greater than 5");
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/control-flow/if-statement.rb.approved.8.txt b/src/test-llm-autocompletion/approvals/control-flow/if-statement.rb.approved.8.txt
new file mode 100644
index 00000000000..2eab90e398c
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/control-flow/if-statement.rb.approved.8.txt
@@ -0,0 +1,3 @@
+x = 10
+if x > 5
+    print("x is greater than 5")
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/control-flow/if-statement.rb.approved.9.txt b/src/test-llm-autocompletion/approvals/control-flow/if-statement.rb.approved.9.txt
new file mode 100644
index 00000000000..5ee9ba90540
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/control-flow/if-statement.rb.approved.9.txt
@@ -0,0 +1,3 @@
+x = 10
+if x > 5
+	puts "x is greater than 5"
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/control-flow/if-statement.rb.rejected.4.txt b/src/test-llm-autocompletion/approvals/control-flow/if-statement.rb.rejected.4.txt
new file mode 100644
index 00000000000..b5c8998a6db
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/control-flow/if-statement.rb.rejected.4.txt
@@ -0,0 +1,5 @@
+x = 10
+if x > 5
+{
+    console.log("x is greater than 5");
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/control-flow/return-statement.rb.approved.1.txt b/src/test-llm-autocompletion/approvals/control-flow/return-statement.rb.approved.1.txt
new file mode 100644
index 00000000000..2f04d9ba7af
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/control-flow/return-statement.rb.approved.1.txt
@@ -0,0 +1,4 @@
+def calculate_total(items)
+	sum = 0
+	items.each { |item| sum += item }
+	return sum
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/data-transformation/array-reduce-complex.approved.4.txt b/src/test-llm-autocompletion/approvals/data-transformation/array-reduce-complex.approved.4.txt
new file mode 100644
index 00000000000..f2ce5287eb3
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/data-transformation/array-reduce-complex.approved.4.txt
@@ -0,0 +1,5 @@
+const orders = [{id: 1, items: [{price: 10}, {price: 20}]}, {id: 2, items: [{price: 15}]}];
+const totalRevenue = orders.reduce((acc, order) => {
+	const orderTotal = order.items.reduce((sum, item) => sum + item.price, 0);
+	return acc + orderTotal;
+}, 0);
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/data-transformation/array-reduce-complex.approved.5.txt b/src/test-llm-autocompletion/approvals/data-transformation/array-reduce-complex.approved.5.txt
new file mode 100644
index 00000000000..29369d8da61
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/data-transformation/array-reduce-complex.approved.5.txt
@@ -0,0 +1,5 @@
+const orders = [{id: 1, items: [{price: 10}, {price: 20}]}, {id: 2, items: [{price: 15}]}];
+const totalRevenue = orders.reduce((acc, order) => {
+	const orderTotal = order.items.reduce((sum, item) => sum + item.price, 0);
+		return acc + orderTotal;
+	}, 0);
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/data-transformation/array-reduce-complex.approved.6.txt b/src/test-llm-autocompletion/approvals/data-transformation/array-reduce-complex.approved.6.txt
new file mode 100644
index 00000000000..21a27a60782
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/data-transformation/array-reduce-complex.approved.6.txt
@@ -0,0 +1,3 @@
+const orders = [{id: 1, items: [{price: 10}, {price: 20}]}, {id: 2, items: [{price: 15}]}];
+const totalRevenue = orders.reduce((acc, order) => {
+	const orderTotal = order.items.reduce((sum, item) => sum + item.price, 0)
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/data-transformation/data-pipeline.approved.3.txt b/src/test-llm-autocompletion/approvals/data-transformation/data-pipeline.approved.3.txt
new file mode 100644
index 00000000000..8380fc67ba4
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/data-transformation/data-pipeline.approved.3.txt
@@ -0,0 +1,5 @@
+const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+const result = data
+	.filter(n => n % 2 === 0)
+	.map(n => n * 2)
+	.reduce((acc, n) => acc + n, 0);
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/data-transformation/data-pipeline.approved.4.txt b/src/test-llm-autocompletion/approvals/data-transformation/data-pipeline.approved.4.txt
new file mode 100644
index 00000000000..e1814874dc5
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/data-transformation/data-pipeline.approved.4.txt
@@ -0,0 +1,5 @@
+const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+const result = data
+	.filter(n => n % 2 === 0)
+	.map(n => n * 2)
+	.reduce((acc, n) => acc + n, 0
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/error-handling/promise-rejection.approved.7.txt b/src/test-llm-autocompletion/approvals/error-handling/promise-rejection.approved.7.txt
new file mode 100644
index 00000000000..8fc29170d5a
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/error-handling/promise-rejection.approved.7.txt
@@ -0,0 +1,8 @@
+fetchUser(userId)
+	.then(user => {
+		return processUser(user);
+	})
+	.catch((error) => {
+		console.error('Error fetching user:', error);
+		throw error;
+	})
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/error-handling/promise-rejection.approved.8.txt b/src/test-llm-autocompletion/approvals/error-handling/promise-rejection.approved.8.txt
new file mode 100644
index 00000000000..8ad60ab6428
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/error-handling/promise-rejection.approved.8.txt
@@ -0,0 +1,7 @@
+fetchUser(userId)
+	.then(user => {
+		return processUser(user);
+	})
+	.catch((error) => {
+	handleError(error);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/error-handling/promise-rejection.approved.9.txt b/src/test-llm-autocompletion/approvals/error-handling/promise-rejection.approved.9.txt
new file mode 100644
index 00000000000..d9936a358a3
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/error-handling/promise-rejection.approved.9.txt
@@ -0,0 +1,5 @@
+fetchUser(userId)
+	.then(user => {
+		return processUser(user);
+	})
+	.catch(error => handleError(error))
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/error-handling/rescue-handling.rb.approved.10.txt b/src/test-llm-autocompletion/approvals/error-handling/rescue-handling.rb.approved.10.txt
new file mode 100644
index 00000000000..f74e8472c48
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/error-handling/rescue-handling.rb.approved.10.txt
@@ -0,0 +1,12 @@
+def process_data(data)
+	begin
+		result = JSON.parse(data)
+		if result.is_a?(Hash)
+			result.each do |key, value|
+				puts "#{key}: #{value}"
+			end
+		end
+	rescue JSON::ParserError => e
+		puts "Invalid JSON data: #{e.message}"
+	end
+end
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/error-handling/rescue-handling.rb.approved.11.txt b/src/test-llm-autocompletion/approvals/error-handling/rescue-handling.rb.approved.11.txt
new file mode 100644
index 00000000000..39d1d44efc7
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/error-handling/rescue-handling.rb.approved.11.txt
@@ -0,0 +1,8 @@
+def process_data(data)
+	begin
+		result = JSON.parse(data)
+		rescue JSON::ParserError => e
+			puts "Error parsing JSON: #{e.message}"
+			nil
+		end
+	end
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/error-handling/rescue-handling.rb.approved.9.txt b/src/test-llm-autocompletion/approvals/error-handling/rescue-handling.rb.approved.9.txt
new file mode 100644
index 00000000000..6fde4c08843
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/error-handling/rescue-handling.rb.approved.9.txt
@@ -0,0 +1,9 @@
+def process_data(data)
+	begin
+		result = JSON.parse(data)
+		rescue JSON::ParserError => e
+			puts "Error parsing JSON: #{e.message}"
+			nil
+		end
+	end
+end
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/error-handling/try-catch-finally.approved.6.txt b/src/test-llm-autocompletion/approvals/error-handling/try-catch-finally.approved.6.txt
new file mode 100644
index 00000000000..3207e1b93c9
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/error-handling/try-catch-finally.approved.6.txt
@@ -0,0 +1,9 @@
+function processData(data) {
+	try {
+		const result = JSON.parse(data);
+		return result;
+	} catch (error) {
+		console.error('Error parsing JSON:', error);
+		throw error;
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/error-handling/try-catch-finally.approved.7.txt b/src/test-llm-autocompletion/approvals/error-handling/try-catch-finally.approved.7.txt
new file mode 100644
index 00000000000..44497a6be38
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/error-handling/try-catch-finally.approved.7.txt
@@ -0,0 +1,11 @@
+function processData(data) {
+	try {
+		const result = JSON.parse(data);
+		if (result) {
+			return result;
+		}
+	} catch (error) {
+		console.error('Error parsing JSON:', error);
+		throw error;
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/error-handling/try-catch-finally.approved.8.txt b/src/test-llm-autocompletion/approvals/error-handling/try-catch-finally.approved.8.txt
new file mode 100644
index 00000000000..732ea7d8e9c
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/error-handling/try-catch-finally.approved.8.txt
@@ -0,0 +1,8 @@
+function processData(data) {
+	try {
+		const result = JSON.parse(data);
+		return result;
+	} catch (error) {
+		console.error("Error parsing JSON:", error);
+		throw error;
+	}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/error-handling/try-catch-finally.rejected.2.txt b/src/test-llm-autocompletion/approvals/error-handling/try-catch-finally.rejected.2.txt
new file mode 100644
index 00000000000..fbb5651ad8e
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/error-handling/try-catch-finally.rejected.2.txt
@@ -0,0 +1,9 @@
+function processData(data) {
+	try {
+		const result = JSON.parse(data);
+				return result;
+	} catch (error) {
+		console.error('Error parsing data:', error);
+		throw error;
+	}
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/function-call/function-call-args.approved.7.txt b/src/test-llm-autocompletion/approvals/function-call/function-call-args.approved.7.txt
new file mode 100644
index 00000000000..aae104771f1
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/function-call/function-call-args.approved.7.txt
@@ -0,0 +1,2 @@
+function greet(name) { return 'Hello ' + name; }
+greet('John');
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/function-call/function-call-args.approved.8.txt b/src/test-llm-autocompletion/approvals/function-call/function-call-args.approved.8.txt
new file mode 100644
index 00000000000..9434e1601ac
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/function-call/function-call-args.approved.8.txt
@@ -0,0 +1,2 @@
+function greet(name) { return 'Hello ' + name; }
+greet("John");
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/function-call/function-call-args.approved.9.txt b/src/test-llm-autocompletion/approvals/function-call/function-call-args.approved.9.txt
new file mode 100644
index 00000000000..3ca5de24b62
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/function-call/function-call-args.approved.9.txt
@@ -0,0 +1,2 @@
+function greet(name) { return 'Hello ' + name; }
+greet("World"
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/function-declaration/arrow-function.approved.6.txt b/src/test-llm-autocompletion/approvals/function-declaration/arrow-function.approved.6.txt
new file mode 100644
index 00000000000..1e7a312b7ff
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/function-declaration/arrow-function.approved.6.txt
@@ -0,0 +1,3 @@
+const add = (a, b) {
+  return a + b;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/function-declaration/arrow-function.approved.7.txt b/src/test-llm-autocompletion/approvals/function-declaration/arrow-function.approved.7.txt
new file mode 100644
index 00000000000..c51980cd836
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/function-declaration/arrow-function.approved.7.txt
@@ -0,0 +1,3 @@
+const add = (a, b) : number => {
+  return a + b;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/function-declaration/arrow-function.rejected.2.txt b/src/test-llm-autocompletion/approvals/function-declaration/arrow-function.rejected.2.txt
new file mode 100644
index 00000000000..5fc76fb19c0
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/function-declaration/arrow-function.rejected.2.txt
@@ -0,0 +1 @@
+const add = (a, b) =&gt; a + b;
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/function-declaration/function-body.approved.7.txt b/src/test-llm-autocompletion/approvals/function-declaration/function-body.approved.7.txt
new file mode 100644
index 00000000000..2ec92cf86db
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/function-declaration/function-body.approved.7.txt
@@ -0,0 +1,3 @@
+function calculateSum(a, b) {
+  return a + b;
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/function-declaration/function-body.rb.approved.5.txt b/src/test-llm-autocompletion/approvals/function-declaration/function-body.rb.approved.5.txt
new file mode 100644
index 00000000000..3117dcf9175
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/function-declaration/function-body.rb.approved.5.txt
@@ -0,0 +1,2 @@
+def calculate_sum(a, b)
+    return a + b
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/function-declaration/function-body.rb.approved.6.txt b/src/test-llm-autocompletion/approvals/function-declaration/function-body.rb.approved.6.txt
new file mode 100644
index 00000000000..d9f39011dcf
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/function-declaration/function-body.rb.approved.6.txt
@@ -0,0 +1,2 @@
+def calculate_sum(a, b)
+	a + b
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/function-declaration/function-body.rb.rejected.4.txt b/src/test-llm-autocompletion/approvals/function-declaration/function-body.rb.rejected.4.txt
new file mode 100644
index 00000000000..fc83812ad80
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/function-declaration/function-body.rb.rejected.4.txt
@@ -0,0 +1,3 @@
+def calculate_sum(a, b)
+    :
+    return a + b
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/import-statement/import-curly-brace.approved.4.txt b/src/test-llm-autocompletion/approvals/import-statement/import-curly-brace.approved.4.txt
new file mode 100644
index 00000000000..50a0363fbf6
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/import-statement/import-curly-brace.approved.4.txt
@@ -0,0 +1 @@
+import useState from 'react'
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/import-statement/import-from.approved.3.txt b/src/test-llm-autocompletion/approvals/import-statement/import-from.approved.3.txt
new file mode 100644
index 00000000000..ec8e4611e93
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/import-statement/import-from.approved.3.txt
@@ -0,0 +1 @@
+import { useState } from react
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/import-statement/import-from.approved.4.txt b/src/test-llm-autocompletion/approvals/import-statement/import-from.approved.4.txt
new file mode 100644
index 00000000000..2feeb4e1715
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/import-statement/import-from.approved.4.txt
@@ -0,0 +1 @@
+import { useState } from "react"
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/inline-completion/function-parameter.approved.5.txt b/src/test-llm-autocompletion/approvals/inline-completion/function-parameter.approved.5.txt
new file mode 100644
index 00000000000..28ee9ae5a9a
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/inline-completion/function-parameter.approved.5.txt
@@ -0,0 +1,3 @@
+function greet(name, age: string) {
+  console.log(`Hello ${name}!`);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/inline-completion/function-parameter.approved.6.txt b/src/test-llm-autocompletion/approvals/inline-completion/function-parameter.approved.6.txt
new file mode 100644
index 00000000000..2e3579c05ba
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/inline-completion/function-parameter.approved.6.txt
@@ -0,0 +1,3 @@
+function greet(name, greeting = "Hello") {
+  console.log(`Hello ${name}!`);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/inline-completion/function-parameter.approved.7.txt b/src/test-llm-autocompletion/approvals/inline-completion/function-parameter.approved.7.txt
new file mode 100644
index 00000000000..5e4937e4925
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/inline-completion/function-parameter.approved.7.txt
@@ -0,0 +1,3 @@
+function greet(name, greeting = "Welcome") {
+  console.log(`Hello ${name}!`);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/inline-completion/function-parameter.rejected.4.txt b/src/test-llm-autocompletion/approvals/inline-completion/function-parameter.rejected.4.txt
new file mode 100644
index 00000000000..5f1aeaa5bd0
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/inline-completion/function-parameter.rejected.4.txt
@@ -0,0 +1,3 @@
+function greet(name, name: string) {
+  console.log(`Hello ${name}!`);
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/inline-completion/property-access.approved.3.txt b/src/test-llm-autocompletion/approvals/inline-completion/property-access.approved.3.txt
new file mode 100644
index 00000000000..06bde9f8e2c
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/inline-completion/property-access.approved.3.txt
@@ -0,0 +1,2 @@
+const user = { name: 'John', age: 30 };
+console.log(user.name, age);
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/inline-completion/property-access.rejected.1.txt b/src/test-llm-autocompletion/approvals/inline-completion/property-access.rejected.1.txt
new file mode 100644
index 00000000000..615963eade2
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/inline-completion/property-access.rejected.1.txt
@@ -0,0 +1,2 @@
+const user = { name: 'John', age: 30 };
+console.log(user.name));
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/inline-completion/variable-assignment-value.approved.5.txt b/src/test-llm-autocompletion/approvals/inline-completion/variable-assignment-value.approved.5.txt
new file mode 100644
index 00000000000..bd1cb800d24
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/inline-completion/variable-assignment-value.approved.5.txt
@@ -0,0 +1,2 @@
+const total = items.reduce((acc, item) => acc + item, 0);
+const items = [1, 2, 3, 4, 5];
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/larger-examples/sudoku.html.approved.7.txt b/src/test-llm-autocompletion/approvals/larger-examples/sudoku.html.approved.7.txt
new file mode 100644
index 00000000000..143bc92e676
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/larger-examples/sudoku.html.approved.7.txt
@@ -0,0 +1,740 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Sudoku++</title>
+  <style>
+    :root{
+      /* Surfaces */
+      --bg:        #0b0e1a;        /* app background */
+      --panel:     #12172a;        /* cards/toolbars */
+      --panel-strong: #1a2140;
+      --grid:      #2a335a;
+      --cell:      #0f1430;
+
+      /* Text */
+      --text-hi:   #edf1ff;        /* main text on dark */
+      --text-lo:   #a9b3d9;        /* muted text */
+      --given:     #c9d4ff;        /* given numbers */
+      --user:      #eef1ff;        /* user numbers */
+      --muted:     #8899cc;        /* notes text */
+
+      /* Accents */
+      --accent:    #2aa5ff;        /* primary */
+      --accent-2:  #1f86d6;        /* primary darker */
+
+      /* States */
+      --conflict-bg: #5a1d2a;      /* desat red, dark */
+      --conflict-fg: #ffdee3;      /* light fg on conflict */
+      --good:      #7ad7a3;
+      --warn:      #f5c36a;
+      --danger:    #ff8b7a;
+    }
+
+    @media (prefers-reduced-motion: reduce){
+      *{animation: none !important; transition: none !important}
+    }
+
+    html, body{height:100%}
+    body{
+      margin:0; background: var(--bg);
+      color: var(--text-hi); font: 16px/1.4 system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, "Helvetica Neue", Arial, "Noto Sans", "Apple Color Emoji","Segoe UI Emoji";
+      display:flex; align-items:center; justify-content:center; padding: 16px;
+    }
+
+    .app{
+      width: min(100%, 1100px);
+      display: grid;
+      gap: 12px;
+      grid-template-rows: auto 1fr;
+      height: calc(100vh - 32px);
+    }
+
+    .main-content {
+        display: grid;
+        grid-template-columns: 1fr auto;
+        gap: 16px;
+        min-height: 0;
+    }
+
+    .topbar{ display:flex; align-items:center; gap:8px; background: var(--panel); padding:12px; border-radius:16px; backdrop-filter: blur(8px); border:1px solid var(--panel-strong)}
+    .grow{flex:1}
+    .title{font-weight:700; letter-spacing:.5px}
+
+    .btn{ appearance:none; background: #1b2447; border: 1px solid #2a335a; color:#fff; padding:8px 12px; border-radius:12px; cursor:pointer; box-shadow: 0 1px 0 rgba(255,255,255,.05) inset; }
+    .btn:hover{ filter:brightness(1.1) }
+    .btn:active{ transform: translateY(1px) }
+    .btn.primary{ border-color: transparent; background: linear-gradient(180deg, var(--accent), var(--accent-2)); color: #fff; }
+    .btn.toggle[aria-pressed="true"]{ outline:2px solid var(--accent); }
+
+    .select{ appearance:none; border:1px solid var(--panel-strong); background: var(--panel); color:#fff; padding:8px 10px; border-radius:12px; }
+
+    .board-wrap{
+      display: grid;
+      gap: 12px;
+      grid-template-rows: 1fr auto auto;
+      min-height: 0;
+    }
+
+    .board{
+      --size: 9; display:grid; grid-template-columns: repeat(var(--size), 1fr); border:2px solid var(--grid); border-radius:16px; overflow:hidden; background:var(--grid); position:relative;
+      place-self: center;
+      max-width: 100%;
+      max-height: 100%;
+    }
+    .cell{ background:var(--cell); min-height:40px; aspect-ratio:1; display:grid; place-items:center; font-weight:600; font-size: clamp(16px, 2.2vmin, 24px); color:var(--user); position:relative; outline:none; border:1px solid rgba(255,255,255,0.05); user-select: none; }
+    .cell.given{ color:var(--given); background: #10163a; font-weight: 700; }
+    .cell.selected{ box-shadow: inset 0 0 0 3px var(--accent) }
+    .cell.same-number{ background: linear-gradient(180deg, rgba(42,165,255,0.12), rgba(42,165,255,0.03)), var(--cell); }
+    .cell.row-col, .cell.box{ background: linear-gradient(180deg, rgba(255,255,255,0.04), rgba(255,255,255,0.01)), var(--cell); }
+
+    .cell.conflict{ background: var(--conflict-bg); color: var(--conflict-fg); }
+    .cell.locked{ pointer-events:none; opacity:.8 }
+    .board.solved .cell{ pointer-events:none }
+
+    .cell .notes{ position:absolute; inset:4px; display:grid; grid-auto-rows: 1fr; gap:2px; font-size: clamp(8px, 1.2vmin, 12px); opacity:.9; color: var(--muted) }
+    .cell .notes span{ display:flex; align-items:center; justify-content:center; }
+    .board[data-size="4"] .cell .notes { grid-template-columns: repeat(2, 1fr); }
+    .board[data-size="6"] .cell .notes { grid-template-columns: repeat(3, 1fr); }
+    .board[data-size="9"] .cell .notes { grid-template-columns: repeat(3, 1fr); }
+    .board[data-size="12"] .cell .notes { grid-template-columns: repeat(4, 1fr); }
+
+
+    /* 4x4 borders */
+    .board[data-size="4"] .cell { border-width: 1px; }
+    .board[data-size="4"] .cell:nth-child(2n) { border-right-width: 2px; }
+    .board[data-size="4"] .cell:nth-child(4n) { border-right-width: 2px; }
+    .board[data-size="4"] .cell:nth-child(n+13) { border-bottom-width: 2px; }
+    .board[data-size="4"] .cell:nth-child(-n+4) { border-top-width: 2px; }
+    .board[data-size="4"] .cell:nth-child(4n+1) { border-left-width: 2px; }
+    .board[data-size="4"] .cell:nth-child(n+5):nth-child(-n+8) { border-bottom-width: 2px; }
+
+    /* 6x6 borders */
+    .board[data-size="6"] .cell { border-width: 1px; }
+    .board[data-size="6"] .cell:nth-child(3n) { border-right-width: 2px; }
+    .board[data-size="6"] .cell:nth-child(6n) { border-right-width: 2px; }
+    .board[data-size="6"] .cell:nth-child(n+31) { border-bottom-width: 2px; }
+    .board[data-size="6"] .cell:nth-child(-n+6) { border-top-width: 2px; }
+    .board[data-size="6"] .cell:nth-child(6n+1) { border-left-width: 2px; }
+    .board[data-size="6"] .cell:nth-child(n+13):nth-child(-n+18) { border-bottom-width: 2px; }
+
+    /* 9x9 borders */
+    .board[data-size="9"] .cell{ border-width:1px }
+    .board[data-size="9"] .cell:nth-child(3n+1){ border-left-width:2px }
+    .board[data-size="9"] .cell:nth-child(-n+9){ border-top-width:2px }
+    .board[data-size="9"] .cell:nth-child(9n){ border-right-width:2px }
+    .board[data-size="9"] .cell:nth-child(n+73){ border-bottom-width:2px }
+    .board[data-size="9"] .cell:nth-child(3n){ border-right-width:2px }
+    .board[data-size="9"] .cell:nth-child(n+19):nth-child(-n+27),
+    .board[data-size="9"] .cell:nth-child(n+46):nth-child(-n+54){ border-bottom-width:2px }
+
+    /* 12x12 borders */
+    .board[data-size="12"] .cell { border-width: 1px; }
+    .board[data-size="12"] .cell:nth-child(4n) { border-right-width: 2px; }
+    .board[data-size="12"] .cell:nth-child(12n) { border-right-width: 2px; }
+    .board[data-size="12"] .cell:nth-child(n+133) { border-bottom-width: 2px; }
+    .board[data-size="12"] .cell:nth-child(-n+12) { border-top-width: 2px; }
+    .board[data-size="12"] .cell:nth-child(12n+1) { border-left-width: 2px; }
+    .board[data-size="12"] .cell:nth-child(n+25):nth-child(-n+36),
+    .board[data-size="12"] .cell:nth-child(n+61):nth-child(-n+72),
+    .board[data-size="12"] .cell:nth-child(n+97):nth-child(-n+108) { border-bottom-width: 2px; }
+
+    .sidebar { width: 260px; }
+
+    .num-pad {
+        display: flex;
+        flex-direction: column;
+        gap: 12px;
+        background: var(--panel);
+        padding: 12px;
+        border-radius: 14px;
+        border: 1px solid var(--panel-strong);
+    }
+    .num-pad .keypad-grid { display: grid; gap: 8px; }
+    .num-pad .keypad-actions { display: grid; grid-template-columns: 1fr; gap: 8px; }
+    .num-pad button { font-size: 1.1em; font-weight: 600; min-height: 48px; }
+
+    .info{ background: var(--panel); border:1px solid var(--panel-strong); border-radius:14px; padding:10px; min-height: 40px; color:#e7ebff }
+    .footer{ color: var(--text-lo); font-size: 13px; text-align:center }
+
+    /* Focus styles */
+    .cell:focus-visible{ outline:2px solid var(--accent); outline-offset:-2px; z-index:3 }
+
+    /* Modal */
+    .modal{ position: fixed; inset:0; display:none; align-items:center; justify-content:center; background: rgba(0,0,0,0.45) }
+    .modal.open{ display:flex }
+    .dialog{ background: #0e1330; color:#fff; border:1px solid var(--panel-strong); border-radius:16px; padding:18px; width:min(92vw, 480px); box-shadow: 0 20px 60px rgba(0,0,0,.5)}
+    .dialog h2{ margin:0 0 8px 0 }
+    .dialog .actions{ display:flex; gap:8px; justify-content:flex-end; margin-top:12px }
+
+    .toolbar-right{ display:flex; gap:8px; align-items:center }
+    .badge{ font-size:12px; color: var(--text-lo) }
+    .sr-only{ position:absolute!important; width:1px!important; height:1px!important; padding:0!important; margin:-1px!important; overflow:hidden!important; clip:rect(0,0,0,0)!important; white-space:nowrap!important; border:0!important; }
+
+    @media (max-width: 850px) {
+        .main-content { grid-template-columns: 1fr; }
+        .sidebar { width: 100%; }
+        .num-pad {
+            position: sticky;
+            bottom: 1rem;
+            z-index: 10;
+        }
+    }
+  </style>
+</head>
+<body>
+  <div class="app">
+    <div class="topbar" role="toolbar" aria-label="Sudoku toolbar">
+      <div class="title">Sudoku++</div>
+      <div class="badge" id="coordBadge">—</div>
+      <div class="grow"></div>
+      <button id="notesBtn" class="btn toggle" aria-pressed="false" title="Toggle notes (Shift)">Notes</button>
+      <button id="newBtn" class="btn" title="N">New</button>
+      <button id="hintBtn" class="btn" title="H">Hint</button>
+      <button id="checkBtn" class="btn" title="C">Check</button>
+      <div class="toolbar-right">
+        <label class="sr-only" for="sizeSel">Size</label>
+        <select id="sizeSel" class="select" aria-label="Board size">
+          <option value="4">4×4</option>
+          <option value="6">6×6</option>
+          <option value="9" selected>9×9</option>
+          <option value="12">12×12</option>
+        </select>
+        <label class="sr-only" for="diffSel">Difficulty</label>
+        <select id="diffSel" class="select" aria-label="Difficulty">
+          <option value="easy">Easy</option>
+          <option value="medium" selected>Medium</option>
+          <option value="hard">Hard</option>
+          <option value="expert">Expert</option>
+        </select>
+        <div id="timer" aria-live="polite" class="badge" title="Elapsed time">00:00</div>
+      </div>
+    </div>
+
+    <div class="main-content">
+        <div class="board-wrap">
+          <div id="board" class="board" data-size="9" aria-label="Sudoku board" role="grid"></div>
+          <div id="info" class="info" aria-live="polite" aria-atomic="true">Loading…</div>
+          <div class="footer"></div>
+        </div>
+        <div class="sidebar">
+            <div class="num-pad" id="numPad" aria-label="Number pad"></div>
+        </div>
+    </div>
+  </div>
+
+  <!-- Modal -->
+  <div id="modal" class="modal" aria-hidden="true">
+    <div id="dialog" class="dialog" role="dialog" aria-modal="true" aria-labelledby="dialogTitle" aria-describedby="dialogDesc" tabindex="-1">
+      <h2 id="dialogTitle">Congratulations!</h2>
+      <p id="dialogDesc">You solved the puzzle.</p>
+      <div class="actions">
+        <button id="closeModal" class="btn">Close</button>
+        <button id="newFromModal" class="btn primary">New Game</button>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    // --- Utilities & Symbols
+    const SYMBOLS = size => Array.from({length: size}, (_, i) => {
+      if (size <= 9) return String(i+1);
+      return i < 9 ? String(i+1) : String.fromCharCode(65 + (i - 9));
+    });
+    const displayOf = (n, size) => n === 0 ? '' : SYMBOLS(size)[n-1];
+
+    // --- Game State
+    const gameState = {
+      size: 9,
+      get boxSizeR() {
+        if (this.size === 4) return 2;
+        if (this.size === 6) return 2;
+        if (this.size === 9) return 3;
+        if (this.size === 12) return 3;
+        return 3;
+      },
+      get boxSizeC() {
+        if (this.size === 4) return 2;
+        if (this.size === 6) return 3;
+        if (this.size === 9) return 3;
+        if (this.size === 12) return 4;
+        return 3;
+      },
+      board: [],
+      given: [],
+      selected: null, // [r,c]
+      notesMode: false,
+      notes: new Map(), // key: r-c => Set(numbers)
+      solved: false,
+      undo: [],
+      redo: [],
+      startTime: null,
+      timerId: null,
+    };
+
+    const boardEl = document.getElementById('board');
+    const infoEl = document.getElementById('info');
+    const numPadEl = document.getElementById('numPad');
+    const sizeSel = document.getElementById('sizeSel');
+    const diffSel = document.getElementById('diffSel');
+    const timerEl = document.getElementById('timer');
+    const notesBtn = document.getElementById('notesBtn');
+    const coordBadge = document.getElementById('coordBadge');
+
+    // ---- Sudoku Logic
+    function cloneBoard(b){ return b.map(row => row.slice()); }
+    function findEmpty(b){ for(let r=0;r<gameState.size;r++){ for(let c=0;c<gameState.size;c++){ if(b[r][c]===0) return [r,c]; } } return null; }
+
+    function isValid(b, r, c, n){
+      const { size, boxSizeR, boxSizeC } = gameState;
+      for(let i=0;i<size;i++){
+        if(i!==c && b[r][i]===n) return false;
+        if(i!==r && b[i][c]===n) return false;
+      }
+      const br0 = Math.floor(r/boxSizeR)*boxSizeR, bc0 = Math.floor(c/boxSizeC)*boxSizeC;
+      for(let i=0;i<boxSizeR;i++){
+        for(let j=0;j<boxSizeC;j++){
+          const rr=br0+i, cc=bc0+j;
+          if((rr!==r || cc!==c) && b[rr][cc]===n) return false;
+        }
+      }
+      return true;
+    }
+
+    function solve(b){
+      const pos = findEmpty(b);
+      if(!pos) return true;
+      const [r,c] = pos;
+      for(let n=1;n<=gameState.size;n++){
+        if(isValid(b,r,c,n)){
+          b[r][c]=n;
+          if(solve(b)) return true;
+          b[r][c]=0;
+        }
+      }
+      return false;
+    }
+
+    function countSolutions(b, limit=2){
+      const pos = findEmpty(b);
+      if(!pos) return 1;
+      const [r,c] = pos;
+      let count=0;
+      for(let n=1;n<=gameState.size && count<limit;n++){
+        if(isValid(b,r,c,n)){
+          b[r][c]=n;
+          count += countSolutions(b, limit - count);
+          b[r][c]=0;
+        }
+      }
+      return count;
+    }
+
+    function generateSolved(){
+      const { size } = gameState;
+      const b = Array.from({length:size}, ()=>Array(size).fill(0));
+      const nums = [...Array(size).keys()].map(i=>i+1);
+      function shuffled(arr){ return arr.map(v=>[Math.random(),v]).sort((a,b)=>a[0]-b[0]).map(([_,v])=>v); }
+      function helper(){
+        const pos = findEmpty(b); if(!pos) return true; const [r,c]=pos;
+        for(const n of shuffled(nums)){
+          if(isValid(b,r,c,n)){ b[r][c]=n; if(helper()) return true; b[r][c]=0; }
+        }
+        return false;
+      }
+      helper();
+      return b;
+    }
+
+    function makePuzzle(solved){
+      const size=gameState.size;
+      const b = cloneBoard(solved);
+      const cells = [...Array(size*size).keys()];
+      const start = performance.now();
+      const TIME_BUDGET = 300; // ms
+
+      function idxToRC(idx){ return [Math.floor(idx/size), idx%size]; }
+      function mirror(idx){ const r=Math.floor(idx/size), c=idx%size; return r*size + (size-1-c); }
+
+      let removals = difficultyRemovals(size, diffSel.value);
+      let tries = 0, maxTries = size > 9 ? 4000 : 2000;
+
+      while(removals>0 && tries<maxTries && cells.length){
+        if(performance.now() - start > TIME_BUDGET) break;
+        tries++;
+        const i = Math.floor(Math.random()*cells.length);
+        const idx = cells.splice(i,1)[0];
+        const idx2 = mirror(idx);
+        const mPos = cells.indexOf(idx2);
+        if(mPos !== -1) cells.splice(mPos,1);
+
+        const [r1,c1]=idxToRC(idx); const [r2,c2]=idxToRC(idx2);
+        const backup1=b[r1][c1], backup2=b[r2][c2];
+        if(backup1===0 && backup2===0) continue;
+        b[r1][c1]=0; b[r2][c2]=0;
+        if(countSolutions(cloneBoard(b),2)===1){ removals -= (idx===idx2?1:2); }
+        else{ b[r1][c1]=backup1; b[r2][c2]=backup2; }
+      }
+      return b;
+    }
+
+    function difficultyRemovals(size, diff){
+      const base4 = { easy: 6, medium: 8, hard: 10, expert: 11 };
+      const base6 = { easy: 16, medium: 20, hard: 22, expert: 24 };
+      const base9 = { easy: 40, medium: 50, hard: 56, expert: 60 };
+      const base12 = { easy: 70, medium: 85, hard: 95, expert: 105 };
+
+      if (size === 4) return base4[diff] || 8;
+      if (size === 6) return base6[diff] || 20;
+      if (size === 12) return base12[diff] || 85;
+      return base9[diff] || 50;
+    }
+
+    // --- Rendering
+    function keyFor(r,c){ return r+"-"+c; }
+
+    function renderNumPad(){
+      numPadEl.innerHTML = '';
+
+      const gridEl = document.createElement('div');
+      gridEl.className = 'keypad-grid';
+      numPadEl.appendChild(gridEl);
+
+      const actionsEl = document.createElement('div');
+      actionsEl.className = 'keypad-actions';
+      numPadEl.appendChild(actionsEl);
+
+      const { size } = gameState;
+      const symbols = SYMBOLS(size);
+
+      let cols = 3;
+      if (size === 4) cols = 2;
+      if (size === 6) cols = 3;
+      if (size === 9) cols = 3;
+      if (size === 12) cols = 4;
+      gridEl.style.gridTemplateColumns = `repeat(${cols}, 1fr)`;
+
+      for(let i=1; i<=size; i++){
+        const btn = document.createElement('button');
+        btn.className = 'btn';
+        btn.textContent = symbols[i-1];
+        btn.dataset.num = String(i);
+        btn.addEventListener('click', (e)=> placeNumber(i, e));
+        gridEl.appendChild(btn);
+      }
+
+      const clr = document.createElement('button');
+      clr.className = 'btn';
+      clr.textContent = 'Clear';
+      clr.addEventListener('click', clearCell);
+      actionsEl.appendChild(clr);
+    }
+
+    function updateFooterText() {
+        const footer = document.querySelector('.footer');
+        const size = gameState.size;
+        let placeKeys = '1–' + size;
+        if (size > 9) {
+            placeKeys = '1–9, A–' + SYMBOLS(size)[size-1];
+        }
+        footer.textContent = `Keyboard: arrows to move, ${placeKeys} to place, Backspace to clear. N = New, H = Hint, C = Check, Z / Shift+Z = Undo/Redo. Hold Shift or toggle Notes to pencil marks.`;
+    }
+
+    function renderBoard(){
+      const size=gameState.size; const symbols=SYMBOLS(size);
+      boardEl.style.setProperty('--size', size);
+      boardEl.dataset.size=String(size);
+      boardEl.innerHTML='';
+      for(let r=0;r<size;r++){
+        for(let c=0;c<size;c++){
+          const val=gameState.board[r][c];
+          const cell=document.createElement('div');
+          cell.className='cell';
+          cell.setAttribute('role','gridcell');
+          cell.tabIndex = gameState.given[r][c] ? -1 : 0;
+          if(gameState.given[r][c]) cell.classList.add('given');
+          cell.dataset.r=String(r); cell.dataset.c=String(c);
+          cell.textContent = val? symbols[val-1] : '';
+          const k=keyFor(r,c);
+          if(!val && gameState.notes.get(k)?.size){
+            const notesWrap=document.createElement('div'); notesWrap.className='notes';
+            const set = gameState.notes.get(k);
+            for(let i=1;i<= size; i++){
+              const sp=document.createElement('span'); sp.textContent = set.has(i)? symbols[i-1] : '';
+              notesWrap.appendChild(sp);
+            }
+            cell.appendChild(notesWrap);
+          }
+          boardEl.appendChild(cell);
+        }
+      }
+      updateHighlights();
+      updateCoordBadge();
+    }
+
+    function updateCellText(r,c){
+      const cell = boardEl.querySelector(`.cell[data-r="${r}"][data-c="${c}"]`);
+      if(!cell) return;
+      cell.innerHTML='';
+      const v=gameState.board[r][c];
+      cell.textContent = displayOf(v, gameState.size);
+      if(!v){
+        const k=keyFor(r,c), set=gameState.notes.get(k);
+        if(set?.size){
+          const wrap=document.createElement('div'); wrap.className='notes';
+          const symbols=SYMBOLS(gameState.size);
+          for(let i=1;i<= gameState.size; i++){
+            const sp=document.createElement('span'); sp.textContent = set.has(i)? symbols[i-1] : '';
+            wrap.appendChild(sp);
+          }
+          cell.appendChild(wrap);
+        }
+      }
+    }
+
+    function setSelected(r,c){
+      gameState.selected=[r,c];
+      for(const el of boardEl.querySelectorAll('.cell.selected')) el.classList.remove('selected');
+      const cell = boardEl.querySelector(`.cell[data-r="${r}"][data-c="${c}"]`);
+      if(cell){ cell.classList.add('selected'); cell.setAttribute('aria-selected','true'); cell.focus(); }
+      updateHighlights();
+      updateCoordBadge();
+    }
+
+    function updateCoordBadge(){
+      if(!gameState.selected){ coordBadge.textContent='—'; return; }
+      const [r,c]=gameState.selected; const v=gameState.board[r][c];
+      coordBadge.textContent = `r${r+1} c${c+1} ${v? '· '+displayOf(v,gameState.size):''}`;
+    }
+
+    function updateHighlights(){
+      const size=gameState.size;
+      const sel=gameState.selected;
+      for (const el of boardEl.querySelectorAll('.cell')) {
+        el.classList.remove('row-col','box','same-number');
+        el.removeAttribute('aria-selected');
+      }
+      if(!sel) return;
+
+      const [r,c]=sel;
+      const { boxSizeR, boxSizeC } = gameState;
+      const selectedEl = boardEl.querySelector(`.cell[data-r="${r}"][data-c="${c}"]`);
+      selectedEl?.setAttribute('aria-selected','true');
+
+      for(const el of boardEl.querySelectorAll(`.cell[data-r="${r}"]`)) el.classList.add('row-col');
+      for(const el of boardEl.querySelectorAll(`.cell[data-c="${c}"]`)) el.classList.add('row-col');
+      const br0=Math.floor(r/boxSizeR)*boxSizeR, bc0=Math.floor(c/boxSizeC)*boxSizeC;
+      for(let i=0;i<boxSizeR;i++) for(let j=0;j<boxSizeC;j++){
+        boardEl.querySelector(`.cell[data-r="${br0+i}"][data-c="${bc0+j}"]`)?.classList.add('box');
+      }
+
+      const same = gameState.board[r][c];
+      if(same){
+        for(let rr=0; rr<size; rr++){
+          for(let cc=0; cc<size; cc++){
+            if(gameState.board[rr][cc]===same){
+              boardEl.querySelector(`.cell[data-r="${rr}"][data-c="${cc}"]`)?.classList.add('same-number');
+            }
+          }
+        }
+      }
+    }
+
+    function clearCell(){ if(!gameState.selected) return; const [r,c]=gameState.selected; if(gameState.given[r][c]) return; applyMove({type:'set', r,c, prev:gameState.board[r][c], next:0}); setNumber(r,c,0); updateCellText(r,c); postPlace(r,c); }
+
+    function placeNumber(n, e){
+      if(!gameState.selected) return;
+      const [r,c]=gameState.selected;
+      if(gameState.given[r][c]) return;
+      const usingNotes = gameState.notesMode || (e?.shiftKey === true);
+      if(usingNotes){ toggleNote(r,c,n,true); return; }
+      applyMove({type:'set', r,c, prev:gameState.board[r][c], next:n});
+      setNumber(r,c,n); updateCellText(r,c); postPlace(r,c);
+    }
+
+    function toggleNote(r,c,n,explicit=false){ if(gameState.board[r][c]) return; const k=keyFor(r,c); if(!gameState.notes.has(k)) gameState.notes.set(k,new Set()); const set=gameState.notes.get(k); if(set.has(n)) set.delete(n); else set.add(n); updateCellText(r,c); if(explicit && typeof navigator.vibrate === 'function') navigator.vibrate(15); }
+
+    function setNumber(r,c,n){
+      const b=gameState.board;
+      b[r][c]=n;
+      gameState.notes.delete(keyFor(r,c));
+      if(n){
+        const { size, boxSizeR, boxSizeC } = gameState;
+        for(let i=0;i<size;i++){
+          gameState.notes.get(keyFor(r,i))?.delete(n); updateCellText(r,i);
+          gameState.notes.get(keyFor(i,c))?.delete(n); updateCellText(i,c);
+        }
+        const br0=Math.floor(r/boxSizeR)*boxSizeR, bc0=Math.floor(c/boxSizeC)*boxSizeC;
+        for(let i=0;i<boxSizeR;i++) for(let j=0;j<boxSizeC;j++){ const rr=br0+i, cc=bc0+j; gameState.notes.get(keyFor(rr,cc))?.delete(n); updateCellText(rr,cc); }
+      }
+    }
+
+    function postPlace(r,c){
+      const n=gameState.board[r][c];
+      const size=gameState.size; let conflict=false; if(n){
+        for(let i=0;i<size;i++){
+          if(i!==c && gameState.board[r][i]===n) conflict=true;
+          if(i!==r && gameState.board[i][c]===n) conflict=true;
+        }
+        const { boxSizeR, boxSizeC } = gameState;
+        const br0=Math.floor(r/boxSizeR)*boxSizeR, bc0=Math.floor(c/boxSizeC)*boxSizeC;
+        for(let i=0;i<boxSizeR;i++) for(let j=0;j<boxSizeC;j++){ const rr=br0+i, cc=bc0+j; if((rr!==r||cc!==c) && gameState.board[rr][cc]===n) conflict=true; }
+      }
+      const cell = boardEl.querySelector(`.cell[data-r="${r}"][data-c="${c}"]`); if(cell){ cell.classList.toggle('conflict', conflict); }
+      updateHighlights();
+      checkSolved();
+    }
+
+    function checkSolved(){
+      for(let r=0;r<gameState.size;r++) for(let c=0;c<gameState.size;c++){ if(gameState.board[r][c]===0) return false; }
+      const b=cloneBoard(gameState.board);
+      for(let r=0;r<gameState.size;r++) for(let c=0;c<gameState.size;c++){ const n=b[r][c]; if(!isValid(b,r,c,n)) return false; }
+      win(); return true;
+    }
+
+    // --- Undo/Redo
+    function applyMove(m){ gameState.undo.push(m); gameState.redo.length=0; }
+    function undo(){ const m=gameState.undo.pop(); if(!m) return; gameState.redo.push(m); if(m.type==='set'){ gameState.board[m.r][m.c]=m.prev; updateCellText(m.r,m.c); postPlace(m.r,m.c); } }
+    function redo(){ const m=gameState.redo.pop(); if(!m) return; gameState.undo.push(m); if(m.type==='set'){ gameState.board[m.r][m.c]=m.next; updateCellText(m.r,m.c); postPlace(m.r,m.c); } }
+
+    // --- Timer
+    function startTimer(){ stopTimer(); gameState.startTime=Date.now(); timerEl.textContent='00:00'; gameState.timerId=setInterval(()=>{ const d=Date.now()-gameState.startTime; const m=Math.floor(d/60000), s=Math.floor((d%60000)/1000); timerEl.textContent=String(m).padStart(2,'0')+":"+String(s).padStart(2,'0'); }, 1000); }
+    function stopTimer(){ if(gameState.timerId){ clearInterval(gameState.timerId); gameState.timerId=null; } }
+
+    // --- Modal + focus trap
+    const modal = document.getElementById('modal');
+    const dialog = document.getElementById('dialog');
+    const closeModalBtn = document.getElementById('closeModal');
+    const newFromModalBtn = document.getElementById('newFromModal');
+    let lastFocused = null;
+
+    function openModal(){ lastFocused=document.activeElement; modal.classList.add('open'); modal.removeAttribute('aria-hidden'); dialog.focus(); document.addEventListener('keydown', trapTab); document.addEventListener('keydown', escClose); stopTimer(); }
+    function closeModal(){ modal.classList.remove('open'); modal.setAttribute('aria-hidden','true'); document.removeEventListener('keydown', trapTab); document.removeEventListener('keydown', escClose); lastFocused?.focus(); }
+    function trapTab(e){ if(e.key!=='Tab') return; const focusable=dialog.querySelectorAll('button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'); if(!focusable.length) return; const first=focusable[0], last=focusable[focusable.length-1]; if(e.shiftKey && document.activeElement===first){ last.focus(); e.preventDefault(); } else if(!e.shiftKey && document.activeElement===last){ first.focus(); e.preventDefault(); } }
+    function escClose(e){ if(e.key==='Escape') closeModal(); }
+    closeModalBtn.addEventListener('click', closeModal); newFromModalBtn.addEventListener('click', ()=>{ closeModal(); newGame(); });
+
+    function win(){ gameState.solved=true; boardEl.classList.add('solved'); infoEl.textContent='Solved! Great job.'; openModal(); }
+
+    // --- Events (board)
+    boardEl.addEventListener('click', (e)=>{
+      const cell=e.target.closest('.cell'); if(!cell) return; const r=+cell.dataset.r, c=+cell.dataset.c; setSelected(r,c);
+    });
+
+    boardEl.addEventListener('keydown', (e)=>{
+      if(!gameState.selected) return; const [r,c]=gameState.selected; const size=gameState.size; const key=e.key.toUpperCase();
+      const symbols=SYMBOLS(size); const idx=symbols.indexOf(key);
+      if(idx!==-1){ placeNumber(idx+1, e); e.preventDefault(); return; }
+      if(key==='BACKSPACE' || key==='DELETE'){ clearCell(); e.preventDefault(); return; }
+      if(key==='ARROWRIGHT'){ setSelected(r, Math.min(size-1, c+1)); e.preventDefault(); return; }
+      if(key==='ARROWLEFT'){ setSelected(r, Math.max(0, c-1)); e.preventDefault(); return; }
+      if(key==='ARROWDOWN'){ setSelected(Math.min(size-1, r+1), c); e.preventDefault(); return; }
+      if(key==='ARROWUP'){ setSelected(Math.max(0, r-1), c); e.preventDefault(); return; }
+      if(key==='N'){ newGame(); return; }
+      if(key==='H'){ hint(); return; }
+      if(key==='C'){ checkBoard(); return; }
+      if(key==='Z' && (e.ctrlKey||e.metaKey)){ if(e.shiftKey) redo(); else undo(); e.preventDefault(); return; }
+    });
+
+    // --- Toolbar
+    document.getElementById('newBtn').addEventListener('click', newGame);
+    document.getElementById('hintBtn').addEventListener('click', hint);
+    document.getElementById('checkBtn').addEventListener('click', checkBoard);
+    notesBtn.addEventListener('click', ()=>{ gameState.notesMode=!gameState.notesMode; notesBtn.setAttribute('aria-pressed', String(gameState.notesMode)); info(`Notes ${gameState.notesMode? 'on':'off'}.`); });
+    window.addEventListener('keydown', (e)=>{ if(e.key==='Shift') notesBtn.setAttribute('aria-pressed','true'); });
+    window.addEventListener('keyup', (e)=>{ if(e.key==='Shift') notesBtn.setAttribute('aria-pressed', String(gameState.notesMode)); });
+
+    sizeSel.addEventListener('change', ()=> newGame());
+    diffSel.addEventListener('change', ()=> newGame());
+
+    // --- Info
+    function info(msg){ infoEl.textContent=msg; }
+
+    // --- Hints & Checks
+    function hint(){
+      const b=cloneBoard(gameState.board); if(!solve(b)){ info('No solution found.'); return; }
+      for(let r=0;r<gameState.size;r++){
+        for(let c=0;c<gameState.size;c++){
+          if(gameState.board[r][c]===0){ const n=b[r][c]; applyMove({type:'set', r,c, prev:0, next:n}); setNumber(r,c,n); updateCellText(r,c); postPlace(r,c); info('Hint placed.'); return; }
+        }
+      }
+      info('Nothing to hint.');
+    }
+
+    function checkBoard(){
+      for (const el of boardEl.querySelectorAll('.cell')) el.classList.remove('conflict');
+      let mistakes=0;
+      const size=gameState.size;
+      for(let r=0;r<size;r++){
+        for(let c=0;c<size;c++){
+          const n=gameState.board[r][c];
+          if(n===0) continue;
+          const ok=isValid(gameState.board, r,c,n);
+          if(!ok){
+            boardEl.querySelector(`.cell[data-r="${r}"][data-c="${c}"]`)?.classList.add('conflict');
+            mistakes++;
+          }
+        }
+      }
+      info(mistakes? `${mistakes} mistake${mistakes>1?'s':''} highlighted.` : 'Looks good so far!');
+    }
+
+
+    // --- New Game
+    function newGame(){
+      stopTimer();
+      const size = parseInt(sizeSel.value,10); gameState.size=size; gameState.notes.clear(); gameState.undo.length=0; gameState.redo.length=0; gameState.solved=false; boardEl.classList.remove('solved');
+      info('Generating puzzle…');
+      setTimeout(() => {
+        const solved = generateSolved();
+        const puzzle = makePuzzle(solved);
+        gameState.board = puzzle;
+        gameState.given = puzzle.map(row => row.map(v => v!==0));
+        renderBoard();
+        let sel=null; for(let r=0;r<size;r++){ for(let c=0;c<size;c++){ if(!gameState.given[r][c]) { sel=[r,c]; break; } } if(sel) break; }
+        setSelected(sel? sel[0]:0, sel? sel[1]:0);
+        renderNumPad();
+        updateFooterText();
+        info('Good luck!');
+        startTimer();
+      }, 10);
+    }
+
+    // --- Layout Sizing
+    function sizeBoardToViewport(){
+      const wrap = document.querySelector('.board-wrap');
+      const board = boardEl;
+      if (!wrap || !board) return;
+      const wrapStyles = getComputedStyle(wrap);
+      const gap = parseFloat(wrapStyles.rowGap) || 0;
+      const infoH   = document.getElementById('info').offsetHeight;
+      const footerH = document.querySelector('.footer').offsetHeight;
+      const available = wrap.clientHeight - (infoH + footerH + 2*gap);
+      const size = Math.max(0, available);
+      const maxWidth = wrap.clientWidth;
+      const side = Math.min(size, maxWidth);
+      board.style.width  = side + 'px';
+      board.style.height = `board.style.height = side + 'px';`
+    }
+
+    window.addEventListener('resize', sizeBoardToViewport);
+
+    // --- Function Wrappers for Layout
+    const _oldRenderBoard = renderBoard;
+    renderBoard = function(){
+      _oldRenderBoard();
+      sizeBoardToViewport();
+    };
+
+    const _oldNewGame = newGame;
+    newGame = function(){
+      _oldNewGame();
+      setTimeout(sizeBoardToViewport, 15); // Allow DOM to update
+    };
+
+    // --- Boot
+    newGame();
+  </script>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/method-access/array-method.approved.1.txt b/src/test-llm-autocompletion/approvals/method-access/array-method.approved.1.txt
new file mode 100644
index 00000000000..9b0091ab4bf
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/method-access/array-method.approved.1.txt
@@ -0,0 +1,4 @@
+const arr = [1, 2, 3];
+arr.forEach((item) => {
+  console.log(item);
+});
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/method-access/array-method.approved.2.txt b/src/test-llm-autocompletion/approvals/method-access/array-method.approved.2.txt
new file mode 100644
index 00000000000..96cc15061b4
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/method-access/array-method.approved.2.txt
@@ -0,0 +1,2 @@
+const arr = [1, 2, 3];
+arr.push(4);
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/method-access/array-method.approved.3.txt b/src/test-llm-autocompletion/approvals/method-access/array-method.approved.3.txt
new file mode 100644
index 00000000000..54b6e33daea
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/method-access/array-method.approved.3.txt
@@ -0,0 +1,2 @@
+const arr = [1, 2, 3];
+arr.map((x) => x * 2)
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/method-access/array-method.approved.4.txt b/src/test-llm-autocompletion/approvals/method-access/array-method.approved.4.txt
new file mode 100644
index 00000000000..a005716144f
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/method-access/array-method.approved.4.txt
@@ -0,0 +1,2 @@
+const arr = [1, 2, 3];
+arr.map(x => x * 2)
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/method-access/string-method.approved.1.txt b/src/test-llm-autocompletion/approvals/method-access/string-method.approved.1.txt
new file mode 100644
index 00000000000..c512915a389
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/method-access/string-method.approved.1.txt
@@ -0,0 +1,2 @@
+const str = 'hello world';
+str.charAt(0)
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/method-access/string-method.approved.2.txt b/src/test-llm-autocompletion/approvals/method-access/string-method.approved.2.txt
new file mode 100644
index 00000000000..f419f5ca643
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/method-access/string-method.approved.2.txt
@@ -0,0 +1,2 @@
+const str = 'hello world';
+str.toUpperCase()
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.approved.10.txt b/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.approved.10.txt
new file mode 100644
index 00000000000..32d83152a0a
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.approved.10.txt
@@ -0,0 +1 @@
+const numbers = [1, 2, 3]
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.approved.9.txt b/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.approved.9.txt
new file mode 100644
index 00000000000..de853445092
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.approved.9.txt
@@ -0,0 +1 @@
+const numbers = [1, 2, 3, 4, 5]
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.rb.approved.7.txt b/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.rb.approved.7.txt
new file mode 100644
index 00000000000..0955da4e993
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.rb.approved.7.txt
@@ -0,0 +1 @@
+arr = [1, 2, 3, 4, 5];
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.rb.approved.8.txt b/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.rb.approved.8.txt
new file mode 100644
index 00000000000..f5b4a9a660c
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.rb.approved.8.txt
@@ -0,0 +1 @@
+arr = [1, 2, 3, 4, 5]
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.rb.approved.9.txt b/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.rb.approved.9.txt
new file mode 100644
index 00000000000..a0046c27326
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/variable-assignment/array-declaration.rb.approved.9.txt
@@ -0,0 +1 @@
+arr = [1, 2, 3, 4]
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/variable-assignment/object-declaration.approved.7.txt b/src/test-llm-autocompletion/approvals/variable-assignment/object-declaration.approved.7.txt
new file mode 100644
index 00000000000..5738f26030d
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/variable-assignment/object-declaration.approved.7.txt
@@ -0,0 +1,3 @@
+const config = {
+  // Your configuration properties here
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/variable-assignment/object-declaration.approved.8.txt b/src/test-llm-autocompletion/approvals/variable-assignment/object-declaration.approved.8.txt
new file mode 100644
index 00000000000..cfca448a870
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/variable-assignment/object-declaration.approved.8.txt
@@ -0,0 +1,4 @@
+const config = {
+  apiKey: process.env.OPENAI_API_KEY,
+  organization: process.env.OPENAI_ORGANIZATION,
+}
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/variable-assignment/variable-assignment.approved.7.txt b/src/test-llm-autocompletion/approvals/variable-assignment/variable-assignment.approved.7.txt
new file mode 100644
index 00000000000..822d500ad92
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/variable-assignment/variable-assignment.approved.7.txt
@@ -0,0 +1 @@
+const userName = "getUserName()";
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/approvals/variable-assignment/variable-assignment.approved.8.txt b/src/test-llm-autocompletion/approvals/variable-assignment/variable-assignment.approved.8.txt
new file mode 100644
index 00000000000..c31cb4e234f
--- /dev/null
+++ b/src/test-llm-autocompletion/approvals/variable-assignment/variable-assignment.approved.8.txt
@@ -0,0 +1 @@
+const userName = "John Doe"
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/runner.ts b/src/test-llm-autocompletion/runner.ts
index fe6b0ba25d2..6ee58744d64 100644
--- a/src/test-llm-autocompletion/runner.ts
+++ b/src/test-llm-autocompletion/runner.ts
@@ -35,16 +35,14 @@ export class TestRunner {
 	async runTest(testCase: TestCase): Promise<TestResult> {
 		try {
 			const startTime = performance.now()
-			const completion = await this.strategyTester.getCompletion(testCase.input)
+			const { prefix, completion, suffix } = await this.strategyTester.getCompletion(
+				testCase.input,
+				testCase.name,
+			)
 			const llmRequestDuration = performance.now() - startTime
+			let actualValue: string = prefix + completion + suffix
 
-			const modifiedCode = this.strategyTester.parseCompletion(testCase.input, completion)
-
-			let actualValue: string
-
-			if (modifiedCode !== null) {
-				actualValue = modifiedCode
-			} else {
+			if (completion === "") {
 				actualValue = "(no changes parsed)"
 			}
 
@@ -146,7 +144,7 @@ export class TestRunner {
 						console.log("    " + "─".repeat(76))
 
 						if (this.verbose && result.completion) {
-							console.log("    Full XML Response:")
+							console.log("    Full LLM Response:")
 							console.log(
 								result.completion
 									.split("\n")
@@ -329,23 +327,15 @@ export class TestRunner {
 		}
 
 		if (lastResult.completion) {
-			const modifiedCode = this.strategyTester.parseCompletion(lastResult.testCase.input, lastResult.completion)
-			if (modifiedCode !== null) {
-				console.log("\nModified Code:")
-				console.log("  " + "─".repeat(78))
-				console.log(
-					modifiedCode
-						.split("\n")
-						.map((l) => "  " + l)
-						.join("\n"),
-				)
-				console.log("  " + "─".repeat(78))
-			} else {
-				console.log("\nNo changes were parsed from the response")
-			}
-
-			console.log("\nFull LLM Response:")
-			console.log(lastResult.completion)
+			console.log("\nCompletion:")
+			console.log("  " + "─".repeat(78))
+			console.log(
+				lastResult.completion
+					.split("\n")
+					.map((l) => "  " + l)
+					.join("\n"),
+			)
+			console.log("  " + "─".repeat(78))
 		}
 
 		console.log("\n" + "═".repeat(80) + "\n")
diff --git a/src/test-llm-autocompletion/strategy-tester.ts b/src/test-llm-autocompletion/strategy-tester.ts
index d5dc2c2f926..0c7fae3cec5 100644
--- a/src/test-llm-autocompletion/strategy-tester.ts
+++ b/src/test-llm-autocompletion/strategy-tester.ts
@@ -1,6 +1,6 @@
 import { LLMClient } from "./llm-client.js"
 import { AutoTriggerStrategy } from "../services/ghost/classic-auto-complete/AutoTriggerStrategy.js"
-import { GhostSuggestionContext, AutocompleteInput, extractPrefixSuffix } from "../services/ghost/types.js"
+import { GhostSuggestionContext, AutocompleteInput } from "../services/ghost/types.js"
 import { MockTextDocument } from "../services/mocking/MockTextDocument.js"
 import { CURSOR_MARKER } from "../services/ghost/classic-auto-complete/ghostConstants.js"
 import { parseGhostResponse } from "../services/ghost/classic-auto-complete/GhostStreamingParser.js"
@@ -20,7 +20,7 @@ export class StrategyTester {
 	 * Converts test input to GhostSuggestionContext
 	 * Extracts cursor position from CURSOR_MARKER in the code
 	 */
-	private createContext(code: string): GhostSuggestionContext {
+	private createContext(code: string, testCaseName: string): GhostSuggestionContext {
 		const lines = code.split("\n")
 		let cursorLine = 0
 		let cursorCharacter = 0
@@ -39,8 +39,13 @@ export class StrategyTester {
 		// the code will add it back at the correct position
 		const codeWithoutMarker = code.replace(CURSOR_MARKER, "")
 
-		const uri = vscode.Uri.parse("file:///test.js")
+		// Extract language from test case name (e.g., "class-constructor.rb" -> ".rb")
+		const fileExtension = this.getFileExtensionFromTestName(testCaseName)
+		const languageId = this.getLanguageIdFromExtension(fileExtension)
+
+		const uri = vscode.Uri.parse(`file:///test${fileExtension}`)
 		const document = new MockTextDocument(uri, codeWithoutMarker)
+		document.languageId = languageId
 		const position = new vscode.Position(cursorLine, cursorCharacter)
 		const range = new vscode.Range(position, position)
 
@@ -54,8 +59,54 @@ export class StrategyTester {
 		}
 	}
 
-	async getCompletion(code: string): Promise<string> {
-		const context = this.createContext(code)
+	/**
+	 * Extract file extension from test case name
+	 * e.g., "class-constructor.rb" -> ".rb"
+	 * e.g., "class-constructor" -> ".js"
+	 */
+	private getFileExtensionFromTestName(testCaseName: string): string {
+		const match = testCaseName.match(/\.([a-z]+)$/i)
+		return match ? `.${match[1]}` : ".js"
+	}
+
+	/**
+	 * Map file extension to VSCode languageId
+	 */
+	private getLanguageIdFromExtension(extension: string): string {
+		const languageMap: Record<string, string> = {
+			".js": "javascript",
+			".ts": "typescript",
+			".jsx": "javascriptreact",
+			".tsx": "typescriptreact",
+			".py": "python",
+			".rb": "ruby",
+			".java": "java",
+			".go": "go",
+			".rs": "rust",
+			".cpp": "cpp",
+			".c": "c",
+			".cs": "csharp",
+			".php": "php",
+			".swift": "swift",
+			".kt": "kotlin",
+			".scala": "scala",
+			".html": "html",
+			".css": "css",
+			".json": "json",
+			".xml": "xml",
+			".yaml": "yaml",
+			".yml": "yaml",
+			".md": "markdown",
+			".sh": "shellscript",
+		}
+		return languageMap[extension] || "javascript"
+	}
+
+	async getCompletion(
+		code: string,
+		testCaseName: string = "test",
+	): Promise<{ prefix: string; completion: string; suffix: string }> {
+		const context = this.createContext(code, testCaseName)
 
 		// Extract prefix, suffix, and languageId
 		const position = context.range?.start ?? new vscode.Position(0, 0)
@@ -83,35 +134,18 @@ export class StrategyTester {
 		)
 
 		const response = await this.llmClient.sendPrompt(systemPrompt, userPrompt)
-		return response.content
-	}
 
-	parseCompletion(originalContent: string, xmlResponse: string): string | null {
-		try {
-			const cursorIndex = originalContent.indexOf(CURSOR_MARKER)
-			const prefix = originalContent.substring(0, cursorIndex)
-			const suffix = originalContent.substring(cursorIndex + CURSOR_MARKER.length)
+		// Parse the response to extract the completion from XML tags
+		const parseResult = parseGhostResponse(response.content, prefix, suffix)
+		const suggestion = parseResult.suggestions.getFillInAtCursor()
 
-			const result = parseGhostResponse(xmlResponse, prefix, suffix)
+		// Use parsed completion only if available
+		const completion = suggestion?.text || ""
 
-			// Check if we have any suggestions
-			if (!result.suggestions.hasSuggestions()) {
-				console.warn("No suggestions found")
-				return null
-			}
-
-			// Get the FIM suggestion
-			const fimSuggestion = result.suggestions.getFillInAtCursor()
-			if (!fimSuggestion) {
-				console.warn("No FIM suggestion found")
-				return null
-			}
-
-			// Reconstruct the complete content with the FIM text inserted
-			return fimSuggestion.prefix + fimSuggestion.text + fimSuggestion.suffix
-		} catch (error) {
-			console.warn("Failed to parse completion:", error)
-			return null
+		return {
+			prefix,
+			completion,
+			suffix,
 		}
 	}
 
diff --git a/src/test-llm-autocompletion/test-cases/comment-driven/implement-function-add-numbers.txt b/src/test-llm-autocompletion/test-cases/comment-driven/implement-function-add-numbers.txt
index 6ca030495fa..5ca095a93e7 100644
--- a/src/test-llm-autocompletion/test-cases/comment-driven/implement-function-add-numbers.txt
+++ b/src/test-llm-autocompletion/test-cases/comment-driven/implement-function-add-numbers.txt
@@ -1,2 +1,2 @@
 # Description: Should fix bug described in FIXME comment
-// Implement functino to add two numbers<<CURSOR>>
\ No newline at end of file
+// Implement functino to add two numbers<<<CURSOR>>>
\ No newline at end of file
diff --git a/src/test-llm-autocompletion/test-cases/comment-driven/implement-function-combine-functions.txt b/src/test-llm-autocompletion/test-cases/comment-driven/implement-function-combine-functions.txt
index a6ce5f54d00..d9de81157e3 100644
--- a/src/test-llm-autocompletion/test-cases/comment-driven/implement-function-combine-functions.txt
+++ b/src/test-llm-autocompletion/test-cases/comment-driven/implement-function-combine-functions.txt
@@ -8,4 +8,4 @@ function multiplyBy5(a) {
     return a * 5
 }
 
-// Implement function to combine above functions<<CURSOR>>
\ No newline at end of file
+// Implement function to combine above functions<<<CURSOR>>>
\ No newline at end of file