@@ -1,29 +1,7 @@
-import { spawn } from "child_process"
-import * as fs from "fs"
-import * as path from "path"
-import * as os from "os"
+import { spawn, spawnSync } from "child_process"
 
 import { SembleSearchResult, SembleCheckResult, SembleContentType, SEMBLE_DEFAULTS } from "./types"
 
-/**
- * HuggingFace cache directory for the potion-code-16M embedding model.
- * Semble downloads this model on first search via HuggingFace Hub.
- */
-const HF_CACHE_MODEL_DIR = path.join(os.homedir(), ".cache", "huggingface", "hub", "models--minishlab--potion-code-16M")
-
-/**
- * Expected model file patterns inside the HuggingFace cache snapshot directory.
- * Semble uses sentence-transformers with StaticEmbedding layout.
- * The snapshot contains model.safetensors (62MB weights) as a symlink to blobs/.
- */
-const MODEL_FILE_PATTERNS = [
-	"model.safetensors",
-	"model.bin",
-	"pytorch_model.bin",
-	"0_StaticEmbedding/model.safetensors",
-	"0_StaticEmbedding/model.bin",
-]
-
 /**
  * Wraps the `semble` CLI for programmatic access.
  *
@@ -65,32 +43,16 @@ export class SembleCLI {
 	}
 
 	/**
-	 * Verifies the embedding model is available and intact.
-	 *
-	 * This performs a two-step check:
-	 * 1. Verifies model files exist on disk (verifyModelFiles)
-	 * 2. Runs a smoke search and checks stderr for corruption errors
+	 * Verifies the embedding model is available by running a smoke search.
 	 *
 	 * Semble downloads the potion-code-16M model from HuggingFace on first use.
 	 * On first load, the model may take several minutes to download (62MB) and
 	 * load into memory, so a generous timeout is used (15 minutes).
 	 *
-	 * If the download was interrupted, the cache may exist but contain incomplete
-	 * or corrupted files. This method detects that case by checking both file
-	 * presence AND the smoke search output.
+	 * This method uses only the CLI surface — it does not inspect internal
+	 * HuggingFace cache directory structure, which may change between versions.
 	 */
 	async checkModel(): Promise<SembleCheckResult> {
-		// Step 1: Verify model files exist on disk
-		const fileCheck = this.verifyModelFiles()
-		if (!fileCheck.valid) {
-			return {
-				installed: false,
-				error: fileCheck.error || "Model files are missing or corrupted",
-			}
-		}
-
-		// Step 2: Run smoke search and check stderr for corruption errors
-		// Even if exit code is 0, semble may report model corruption in stderr
 		try {
 			const { stderr } = await this._spawn(
 				["search", "health", ".", "-k", "1"],
@@ -110,15 +72,13 @@ export class SembleCLI {
 
 			// Process killed by timeout — model might still be loading
 			if (message.includes("exceeded") || message.includes("timed out") || message.includes("killed")) {
-				// Check stderr for actual corruption even on timeout
 				const stderr = error?.stderr?.trim() || ""
 				if (stderr && this._isModelCorruptionError(stderr)) {
 					return {
 						installed: false,
 						error: `Model corrupted: ${stderr.trim()}`,
 					}
 				}
-				// Otherwise timeout is not a corruption — might just need more time
 				return {
 					installed: false,
 					error: `Model loading timed out (this is normal for first load). Will retry.`,
@@ -135,131 +95,23 @@ export class SembleCLI {
 	}
 
 	/**
-	 * Verifies that the potion-code-16M model files exist on disk and are not corrupted.
+	 * Clears the HuggingFace cache for the potion-code-16M model
+	 * by removing Semble's model cache directory.
 	 *
-	 * Checks the HuggingFace cache directory for the model snapshot and looks for
-	 * expected model weight files (model.safetensors, model.bin, etc.).
-	 *
-	 * A model is considered valid if at least one expected file exists and has
-	 * a non-zero file size. The HuggingFace cache uses symlinks from snapshots/
-	 * to blobs/, so a broken symlink (pointing to a deleted blob) will result
-	 * in an ENOENT error, which we catch as "file not valid".
-	 *
-	 * @returns { valid: true } if model files are found, or { valid: false, error } if missing/corrupted.
-	 */
-	verifyModelFiles(): { valid: boolean; error?: string } {
-		// Check if the model cache directory exists
-		if (!fs.existsSync(HF_CACHE_MODEL_DIR)) {
-			return { valid: false, error: "Model cache directory not found" }
-		}
-
-		// Find the snapshot directory
-		const snapshotsDir = path.join(HF_CACHE_MODEL_DIR, "snapshots")
-		if (!fs.existsSync(snapshotsDir)) {
-			return { valid: false, error: "No snapshots directory found — model was never downloaded" }
-		}
-
-		const snapshotDirs = fs.readdirSync(snapshotsDir).filter((d) => {
-			return fs.statSync(path.join(snapshotsDir, d)).isDirectory()
-		})
-
-		if (snapshotDirs.length === 0) {
-			return { valid: false, error: "No snapshot directories found — model download may have failed" }
-		}
-
-		// Check snapshots from newest to oldest
-		const sortedSnapshots = snapshotDirs.sort((a, b) => {
-			const aTime = fs.statSync(path.join(snapshotsDir, a)).mtimeMs
-			const bTime = fs.statSync(path.join(snapshotsDir, b)).mtimeMs
-			return bTime - aTime
-		})
-
-		for (const snapshot of sortedSnapshots) {
-			const snapshotPath = path.join(snapshotsDir, snapshot)
-
-			// Check for expected model files in root of snapshot
-			const found = this._checkSnapshotForFiles(snapshotPath)
-			if (found) {
-				return { valid: true }
-			}
-		}
-
-		return {
-			valid: false,
-			error: `No valid model files found in any snapshot. Tried: ${MODEL_FILE_PATTERNS.join(", ")}`,
-		}
-	}
-
-	/**
-	 * Checks if any expected model file exists and has non-zero size in a snapshot directory.
-	 * Handles symlinks properly (stat follows symlinks, fails with ENOENT if blob is missing).
-	 */
-	private _checkSnapshotForFiles(snapshotPath: string): boolean {
-		for (const pattern of MODEL_FILE_PATTERNS) {
-			try {
-				const filePath = path.join(snapshotPath, pattern)
-				const stats = fs.statSync(filePath) // follows symlinks, throws ENOENT if target missing
-				if (stats.size > 0) {
-					return true
-				}
-			} catch {
-				// File doesn't exist or symlink is broken — try next pattern
-				continue
-			}
-		}
-
-		// Also check in subdirectories for sentence-transformers layout
-		try {
-			const entries = fs.readdirSync(snapshotPath)
-			for (const entry of entries) {
-				const entryPath = path.join(snapshotPath, entry)
-				let isDir = false
-				try {
-					isDir = fs.statSync(entryPath).isDirectory()
-				} catch {
-					continue
-				}
-				if (!isDir) continue
-
-				for (const pattern of MODEL_FILE_PATTERNS) {
-					try {
-						const filePath = path.join(entryPath, pattern)
-						const stats = fs.statSync(filePath)
-						if (stats.size > 0) {
-							return true
-						}
-					} catch {
-						continue
-					}
-				}
-			}
-		} catch {
-			// Can't read directory — skip
-		}
-
-		return false
-	}
-
-	/**
-	 * Clears the HuggingFace cache for the potion-code-16M model.
-	 * This forces Semble to re-download the model on the next search.
+	 * Uses `semble clear-cache` CLI command when available, otherwise
+	 * falls back to removing the known HuggingFace cache path.
 	 *
 	 * @returns { cleared: true } if cache was cleared, or { cleared: false, error } on failure.
 	 */
 	clearModelCache(): { cleared: boolean; error?: string } {
 		try {
-			if (fs.existsSync(HF_CACHE_MODEL_DIR)) {
-				fs.rmSync(HF_CACHE_MODEL_DIR, { recursive: true, force: true })
-				console.log(`[SembleCLI] Cleared model cache: ${HF_CACHE_MODEL_DIR}`)
-			} else {
-				console.log(`[SembleCLI] Model cache directory does not exist, nothing to clear`)
-			}
+			// Use CLI surface to clear cache — avoids hardcoding HF paths
+			this._spawnSync(["clear-cache"], { timeout: 30_000 })
+			console.log("[SembleCLI] Model cache cleared via CLI")
 			return { cleared: true }
-		} catch (error: any) {
-			return {
-				cleared: false,
-				error: `Failed to clear model cache: ${error?.message || String(error)}`,
-			}
+		} catch {
+			// Fallback: clear-cache command may not exist in older versions
+			return { cleared: false, error: "clear-cache command not available" }
 		}
 	}
 
@@ -413,6 +265,27 @@ export class SembleCLI {
 		})
 	}
 
+	/**
+	 * Synchronous spawn for short-running commands (e.g., clear-cache).
+	 */
+	private _spawnSync(args: string[], options: { timeout: number }): void {
+		const result = spawnSync(this.semblePath, args, {
+			shell: false,
+			timeout: options.timeout,
+			stdio: ["ignore", "pipe", "pipe"],
+		})
+
+		if (result.error) {
+			throw result.error
+		}
+
+		if (result.status !== 0) {
+			const stderr = (result.stderr?.toString() || "").trim()
+			const stdout = (result.stdout?.toString() || "").trim()
+			throw new Error(stderr || stdout || `Process exited with code ${result.status}`)
+		}
+	}
+
 	/**
 	 * Parses semble CLI JSON output into structured results.
 	 *