maxsimcli 4.7.0 → 4.7.1

package/dist/mcp-server.cjs

@@ -26771,17 +26771,12 @@ const isSummaryFile = (f) => f.endsWith("-SUMMARY.md") || f === "SUMMARY.md";
 const planId = (f) => f.replace("-PLAN.md", "").replace("PLAN.md", "");
 const summaryId = (f) => f.replace("-SUMMARY.md", "").replace("SUMMARY.md", "");
 /** List subdirectory names, optionally sorted by phase number. */
-function listSubDirs(dir, sortByPhase = false) {
-	const dirs = node_fs.default.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
-	return sortByPhase ? dirs.sort((a, b) => comparePhaseNum(a, b)) : dirs;
-}
-/** Async version of listSubDirs using fs.promises. */
-async function listSubDirsAsync(dir, sortByPhase = false) {
+async function listSubDirs(dir, sortByPhase = false) {
 	const dirs = (await node_fs.promises.readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
 	return sortByPhase ? dirs.sort((a, b) => comparePhaseNum(a, b)) : dirs;
 }
-/** Async version of safeReadFile using fs.promises. */
-async function safeReadFileAsync(filePath) {
+/** Read a file, returning null if it doesn't exist or fails. */
+async function safeReadFile(filePath) {
 	try {
 		return await node_fs.promises.readFile(filePath, "utf-8");
 	} catch {
@@ -26802,15 +26797,65 @@ function debugLog(contextOrError, error) {
 function escapePhaseNum(phase) {
 	return String(phase).replace(/\./g, "\\.");
 }
-function safeReadFile(filePath) {
+let _configCache = null;
+function normalizePhaseName(phase) {
+	const match = phase.match(/^(\d+)([A-Z])?(\.\d+)?/i);
+	if (!match) return phase;
+	const padded = match[1].padStart(2, "0");
+	const letter = match[2] ? match[2].toUpperCase() : "";
+	const decimal = match[3] || "";
+	return padded + letter + decimal;
+}
+function comparePhaseNum(a, b) {
+	const pa = String(a).match(/^(\d+)([A-Z])?(\.\d+)?/i);
+	const pb = String(b).match(/^(\d+)([A-Z])?(\.\d+)?/i);
+	if (!pa || !pb) return String(a).localeCompare(String(b));
+	const intDiff = parseInt(pa[1], 10) - parseInt(pb[1], 10);
+	if (intDiff !== 0) return intDiff;
+	const la = (pa[2] || "").toUpperCase();
+	const lb = (pb[2] || "").toUpperCase();
+	if (la !== lb) {
+		if (!la) return -1;
+		if (!lb) return 1;
+		return la < lb ? -1 : 1;
+	}
+	return (pa[3] ? parseFloat(pa[3]) : -1) - (pb[3] ? parseFloat(pb[3]) : -1);
+}
+/**
+* Returns the canonical regex for matching Phase heading lines in ROADMAP.md.
+*
+* General form (no escapedPhaseNum):
+*   Matches: ## Phase 03: Name Here
+*   Group 1: phase number string (e.g. "03", "3A", "2.1")
+*   Group 2: phase name string (e.g. "Name Here")
+*
+* Specific form (with escapedPhaseNum):
+*   Matches: ## Phase 03: Name Here
+*   Group 1: phase name string only
+*
+* @param escapedPhaseNum - regex-escaped phase number string to match a specific phase
+* @param flags - regex flags (default: 'gi')
+*/
+function getPhasePattern(escapedPhaseNum, flags = "gim") {
+	if (escapedPhaseNum) return new RegExp(`^#{2,4}\\s*Phase\\s+${escapedPhaseNum}:\\s*([^\\n]+)`, flags);
+	return new RegExp(`^#{2,4}\\s*Phase\\s+(\\d+[A-Z]?(?:\\.\\d+)?)\\s*:\\s*([^\\n]+)`, flags);
+}
+function generateSlugInternal(text) {
+	if (!text) return null;
+	return (0, import_slugify.default)(text, {
+		lower: true,
+		strict: true
+	});
+}
+async function pathExistsInternal(p) {
 	try {
-		return node_fs.default.readFileSync(filePath, "utf-8");
+		await node_fs.promises.access(p);
+		return true;
 	} catch {
-		return null;
+		return false;
 	}
 }
-let _configCache = null;
-function loadConfig(cwd) {
+async function loadConfig(cwd) {
 	if (_configCache && _configCache.cwd === cwd) return _configCache.config;
 	const cfgPath = configPath(cwd);
 	const defaults = {
@@ -26827,7 +26872,7 @@ function loadConfig(cwd) {
 		brave_search: false
 	};
 	try {
-		const raw = node_fs.default.readFileSync(cfgPath, "utf-8");
+		const raw = await node_fs.promises.readFile(cfgPath, "utf-8");
 		const parsed = JSON.parse(raw);
 		const get = (key, nested) => {
 			if (parsed[key] !== void 0) return parsed[key];
@@ -26889,7 +26934,7 @@ function loadConfig(cwd) {
 		};
 		return result;
 	} catch (e) {
-		if (node_fs.default.existsSync(cfgPath)) {
+		if (await pathExistsInternal(cfgPath)) {
 			console.warn(`[maxsim] Warning: config.json exists but could not be parsed — using defaults.`);
 			debugLog("config-load-failed", e);
 		}
@@ -26900,57 +26945,15 @@ function loadConfig(cwd) {
 		return defaults;
 	}
 }
-function normalizePhaseName(phase) {
-	const match = phase.match(/^(\d+)([A-Z])?(\.\d+)?/i);
-	if (!match) return phase;
-	const padded = match[1].padStart(2, "0");
-	const letter = match[2] ? match[2].toUpperCase() : "";
-	const decimal = match[3] || "";
-	return padded + letter + decimal;
-}
-function comparePhaseNum(a, b) {
-	const pa = String(a).match(/^(\d+)([A-Z])?(\.\d+)?/i);
-	const pb = String(b).match(/^(\d+)([A-Z])?(\.\d+)?/i);
-	if (!pa || !pb) return String(a).localeCompare(String(b));
-	const intDiff = parseInt(pa[1], 10) - parseInt(pb[1], 10);
-	if (intDiff !== 0) return intDiff;
-	const la = (pa[2] || "").toUpperCase();
-	const lb = (pb[2] || "").toUpperCase();
-	if (la !== lb) {
-		if (!la) return -1;
-		if (!lb) return 1;
-		return la < lb ? -1 : 1;
-	}
-	return (pa[3] ? parseFloat(pa[3]) : -1) - (pb[3] ? parseFloat(pb[3]) : -1);
-}
-/**
-* Returns the canonical regex for matching Phase heading lines in ROADMAP.md.
-*
-* General form (no escapedPhaseNum):
-*   Matches: ## Phase 03: Name Here
-*   Group 1: phase number string (e.g. "03", "3A", "2.1")
-*   Group 2: phase name string (e.g. "Name Here")
-*
-* Specific form (with escapedPhaseNum):
-*   Matches: ## Phase 03: Name Here
-*   Group 1: phase name string only
-*
-* @param escapedPhaseNum - regex-escaped phase number string to match a specific phase
-* @param flags - regex flags (default: 'gi')
-*/
-function getPhasePattern(escapedPhaseNum, flags = "gim") {
-	if (escapedPhaseNum) return new RegExp(`^#{2,4}\\s*Phase\\s+${escapedPhaseNum}:\\s*([^\\n]+)`, flags);
-	return new RegExp(`^#{2,4}\\s*Phase\\s+(\\d+[A-Z]?(?:\\.\\d+)?)\\s*:\\s*([^\\n]+)`, flags);
-}
-function searchPhaseInDir(baseDir, relBase, normalized) {
+async function searchPhaseInDir(baseDir, relBase, normalized) {
 	try {
-		const match = listSubDirs(baseDir, true).find((d) => d.startsWith(normalized));
+		const match = (await listSubDirs(baseDir, true)).find((d) => d.startsWith(normalized));
 		if (!match) return null;
 		const dirMatch = match.match(/^(\d+[A-Z]?(?:\.\d+)?)-?(.*)/i);
 		const phaseNumber = dirMatch ? dirMatch[1] : normalized;
 		const phaseName = dirMatch && dirMatch[2] ? dirMatch[2] : null;
 		const phaseDir = node_path.default.join(baseDir, match);
-		const phaseFiles = node_fs.default.readdirSync(phaseDir);
+		const phaseFiles = await node_fs.promises.readdir(phaseDir);
 		const plans = phaseFiles.filter(isPlanFile).sort();
 		const summaries = phaseFiles.filter(isSummaryFile).sort();
 		const hasResearch = phaseFiles.some((f) => f.endsWith("-RESEARCH.md") || f === "RESEARCH.md");
@@ -26972,7 +26975,7 @@ function searchPhaseInDir(baseDir, relBase, normalized) {
 			has_verification: hasVerification
 		};
 	} catch (e) {
-		debugLog("search-phase-in-dir-failed", {
+		debugLog("search-phase-in-dir-async-failed", {
 			dir: baseDir,
 			phase: normalized,
 			error: errorMsg(e)
@@ -26980,148 +26983,82 @@ function searchPhaseInDir(baseDir, relBase, normalized) {
 		return null;
 	}
 }
-function findPhaseInternal(cwd, phase) {
+async function findPhaseInternal(cwd, phase) {
 	if (!phase) return null;
 	const pd = phasesPath(cwd);
 	const normalized = normalizePhaseName(phase);
-	const current = searchPhaseInDir(pd, node_path.default.join(".planning", "phases"), normalized);
+	const current = await searchPhaseInDir(pd, node_path.default.join(".planning", "phases"), normalized);
 	if (current) return current;
-	const milestonesDir = planningPath(cwd, "milestones");
-	try {
-		node_fs.default.statSync(milestonesDir);
-	} catch {
-		return null;
+	const archiveDir = planningPath(cwd, "archive");
+	if (await pathExistsInternal(archiveDir)) try {
+		const versionDirs = (await node_fs.promises.readdir(archiveDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name).sort().reverse();
+		for (const versionName of versionDirs) {
+			const result = await searchPhaseInDir(node_path.default.join(archiveDir, versionName), node_path.default.join(".planning", "archive", versionName), normalized);
+			if (result) {
+				result.archived = versionName;
+				return result;
+			}
+		}
+	} catch (e) {
+		debugLog("find-phase-async-archive-search-failed", e);
 	}
+	const milestonesDir = planningPath(cwd, "milestones");
+	if (!await pathExistsInternal(milestonesDir)) return null;
 	try {
-		const archiveDirs = node_fs.default.readdirSync(milestonesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && /^v[\d.]+-phases$/.test(e.name)).map((e) => e.name).sort().reverse();
+		const archiveDirs = (await node_fs.promises.readdir(milestonesDir, { withFileTypes: true })).filter((e) => e.isDirectory() && /^v[\d.]+-phases$/.test(e.name)).map((e) => e.name).sort().reverse();
 		for (const archiveName of archiveDirs) {
 			const versionMatch = archiveName.match(/^(v[\d.]+)-phases$/);
 			if (!versionMatch) continue;
 			const version = versionMatch[1];
-			const result = searchPhaseInDir(node_path.default.join(milestonesDir, archiveName), node_path.default.join(".planning", "milestones", archiveName), normalized);
+			const result = await searchPhaseInDir(node_path.default.join(milestonesDir, archiveName), node_path.default.join(".planning", "milestones", archiveName), normalized);
 			if (result) {
 				result.archived = version;
 				return result;
 			}
 		}
 	} catch (e) {
-		debugLog("find-phase-milestone-search-failed", e);
+		debugLog("find-phase-async-milestone-search-failed", e);
 	}
 	return null;
 }
-function getArchivedPhaseDirs(cwd) {
-	const milestonesDir = planningPath(cwd, "milestones");
+async function getArchivedPhaseDirs(cwd) {
 	const results = [];
+	const archiveDir = planningPath(cwd, "archive");
 	try {
-		const phaseDirs = node_fs.default.readdirSync(milestonesDir, { withFileTypes: true }).filter((e) => e.isDirectory() && /^v[\d.]+-phases$/.test(e.name)).map((e) => e.name).sort().reverse();
-		for (const archiveName of phaseDirs) {
-			const versionMatch = archiveName.match(/^(v[\d.]+)-phases$/);
-			if (!versionMatch) continue;
-			const version = versionMatch[1];
-			const archivePath = node_path.default.join(milestonesDir, archiveName);
-			const dirs = listSubDirs(archivePath, true);
+		const versionDirs = (await node_fs.promises.readdir(archiveDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name).sort().reverse();
+		for (const versionName of versionDirs) {
+			const versionPath = node_path.default.join(archiveDir, versionName);
+			const dirs = await listSubDirs(versionPath, true);
 			for (const dir of dirs) results.push({
 				name: dir,
-				milestone: version,
-				basePath: node_path.default.join(".planning", "milestones", archiveName),
-				fullPath: node_path.default.join(archivePath, dir)
+				milestone: versionName,
+				basePath: node_path.default.join(".planning", "archive", versionName),
+				fullPath: node_path.default.join(versionPath, dir)
 			});
 		}
 	} catch (e) {
-		debugLog("get-archived-phase-dirs-failed", e);
-	}
-	return results;
-}
-function generateSlugInternal(text) {
-	if (!text) return null;
-	return (0, import_slugify.default)(text, {
-		lower: true,
-		strict: true
-	});
-}
-async function pathExistsAsync(p) {
-	try {
-		await node_fs.promises.access(p);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function searchPhaseInDirAsync(baseDir, relBase, normalized) {
-	try {
-		const match = (await listSubDirsAsync(baseDir, true)).find((d) => d.startsWith(normalized));
-		if (!match) return null;
-		const dirMatch = match.match(/^(\d+[A-Z]?(?:\.\d+)?)-?(.*)/i);
-		const phaseNumber = dirMatch ? dirMatch[1] : normalized;
-		const phaseName = dirMatch && dirMatch[2] ? dirMatch[2] : null;
-		const phaseDir = node_path.default.join(baseDir, match);
-		const phaseFiles = await node_fs.promises.readdir(phaseDir);
-		const plans = phaseFiles.filter(isPlanFile).sort();
-		const summaries = phaseFiles.filter(isSummaryFile).sort();
-		const hasResearch = phaseFiles.some((f) => f.endsWith("-RESEARCH.md") || f === "RESEARCH.md");
-		const hasContext = phaseFiles.some((f) => f.endsWith("-CONTEXT.md") || f === "CONTEXT.md");
-		const hasVerification = phaseFiles.some((f) => f.endsWith("-VERIFICATION.md") || f === "VERIFICATION.md");
-		const completedPlanIds = new Set(summaries.map(summaryId));
-		const incompletePlans = plans.filter((p) => !completedPlanIds.has(planId(p)));
-		return {
-			found: true,
-			directory: node_path.default.join(relBase, match),
-			phase_number: phaseNumber,
-			phase_name: phaseName,
-			phase_slug: phaseName ? phaseName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") : null,
-			plans,
-			summaries,
-			incomplete_plans: incompletePlans,
-			has_research: hasResearch,
-			has_context: hasContext,
-			has_verification: hasVerification
-		};
-	} catch (e) {
-		debugLog("search-phase-in-dir-async-failed", {
-			dir: baseDir,
-			phase: normalized,
-			error: errorMsg(e)
-		});
-		return null;
-	}
-}
-async function findPhaseInternalAsync(cwd, phase) {
-	if (!phase) return null;
-	const pd = phasesPath(cwd);
-	const normalized = normalizePhaseName(phase);
-	const current = await searchPhaseInDirAsync(pd, node_path.default.join(".planning", "phases"), normalized);
-	if (current) return current;
-	const archiveDir = planningPath(cwd, "archive");
-	if (await pathExistsAsync(archiveDir)) try {
-		const versionDirs = (await node_fs.promises.readdir(archiveDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name).sort().reverse();
-		for (const versionName of versionDirs) {
-			const result = await searchPhaseInDirAsync(node_path.default.join(archiveDir, versionName), node_path.default.join(".planning", "archive", versionName), normalized);
-			if (result) {
-				result.archived = versionName;
-				return result;
-			}
-		}
-	} catch (e) {
-		debugLog("find-phase-async-archive-search-failed", e);
+		debugLog("get-archived-phase-dirs-async-archive-failed", e);
 	}
 	const milestonesDir = planningPath(cwd, "milestones");
-	if (!await pathExistsAsync(milestonesDir)) return null;
 	try {
-		const archiveDirs = (await node_fs.promises.readdir(milestonesDir, { withFileTypes: true })).filter((e) => e.isDirectory() && /^v[\d.]+-phases$/.test(e.name)).map((e) => e.name).sort().reverse();
-		for (const archiveName of archiveDirs) {
+		const phaseDirs = (await node_fs.promises.readdir(milestonesDir, { withFileTypes: true })).filter((e) => e.isDirectory() && /^v[\d.]+-phases$/.test(e.name)).map((e) => e.name).sort().reverse();
+		for (const archiveName of phaseDirs) {
 			const versionMatch = archiveName.match(/^(v[\d.]+)-phases$/);
 			if (!versionMatch) continue;
 			const version = versionMatch[1];
-			const result = await searchPhaseInDirAsync(node_path.default.join(milestonesDir, archiveName), node_path.default.join(".planning", "milestones", archiveName), normalized);
-			if (result) {
-				result.archived = version;
-				return result;
-			}
+			const archiveMilestonePath = node_path.default.join(milestonesDir, archiveName);
+			const dirs = await listSubDirs(archiveMilestonePath, true);
+			for (const dir of dirs) results.push({
+				name: dir,
+				milestone: version,
+				basePath: node_path.default.join(".planning", "milestones", archiveName),
+				fullPath: node_path.default.join(archiveMilestonePath, dir)
+			});
 		}
 	} catch (e) {
-		debugLog("find-phase-async-milestone-search-failed", e);
+		debugLog("get-archived-phase-dirs-async-failed", e);
 	}
-	return null;
+	return results;
 }
 
 //#endregion
@@ -33862,7 +33799,7 @@ async function phaseInsertCore(cwd, afterPhase, description, options) {
 	const normalizedBase = normalizePhaseName(afterPhase);
 	const existingDecimals = [];
 	try {
-		const dirs = await listSubDirsAsync(phasesDirPath);
+		const dirs = await listSubDirs(phasesDirPath);
 		const decimalPattern = new RegExp(`^${normalizedBase}\\.(\\d+)`);
 		for (const dir of dirs) {
 			const dm = dir.match(decimalPattern);
@@ -33901,12 +33838,12 @@ async function phaseCompleteCore(cwd, phaseNum) {
 	const stPath = statePath(cwd);
 	const phasesDirPath = phasesPath(cwd);
 	const today = todayISO();
-	const phaseInfo = await findPhaseInternalAsync(cwd, phaseNum);
+	const phaseInfo = await findPhaseInternal(cwd, phaseNum);
 	if (!phaseInfo) throw new Error(`Phase ${phaseNum} not found`);
 	const planCount = phaseInfo.plans.length;
 	const summaryCount = phaseInfo.summaries.length;
 	let requirementsUpdated = false;
-	const rmExists = await pathExistsAsync(rmPath);
+	const rmExists = await pathExistsInternal(rmPath);
 	if (rmExists) {
 		let roadmapContent = await node_fs.promises.readFile(rmPath, "utf-8");
 		const checkboxPattern = new RegExp(`(-\\s*\\[)[ ](\\]\\s*.*Phase\\s+${escapePhaseNum(phaseNum)}[:\\s][^\\n]*)`, "i");
@@ -33920,7 +33857,7 @@ async function phaseCompleteCore(cwd, phaseNum) {
 		await node_fs.promises.writeFile(rmPath, roadmapContent, "utf-8");
 		debugLog("phase-complete-write", `ROADMAP.md updated for phase ${phaseNum}`);
 		const reqPath = planningPath(cwd, "REQUIREMENTS.md");
-		if (await pathExistsAsync(reqPath)) {
+		if (await pathExistsInternal(reqPath)) {
 			const reqMatch = roadmapContent.match(new RegExp(`Phase\\s+${escapePhaseNum(phaseNum)}[\\s\\S]*?\\*\\*Requirements:\\*\\*\\s*([^\\n]+)`, "i"));
 			if (reqMatch) {
 				const reqIds = reqMatch[1].replace(/[\[\]]/g, "").split(/[,\s]+/).map((r) => r.trim()).filter(Boolean);
@@ -33940,7 +33877,7 @@ async function phaseCompleteCore(cwd, phaseNum) {
 	let nextPhaseName = null;
 	let isLastPhase = true;
 	try {
-		const dirs = await listSubDirsAsync(phasesDirPath, true);
+		const dirs = await listSubDirs(phasesDirPath, true);
 		for (const dir of dirs) {
 			const dm = dir.match(/^(\d+[A-Z]?(?:\.\d+)?)-?(.*)/i);
 			if (dm) {
@@ -33955,7 +33892,7 @@ async function phaseCompleteCore(cwd, phaseNum) {
 	} catch (e) {
 		debugLog("phase-complete-next-phase-scan-failed", e);
 	}
-	const stExists = await pathExistsAsync(stPath);
+	const stExists = await pathExistsInternal(stPath);
 	if (stExists) {
 		let stateContent = await node_fs.promises.readFile(stPath, "utf-8");
 		stateContent = stateContent.replace(/(\*\*Current Phase:\*\*\s*).*/, `$1${nextPhaseNum || phaseNum}`);
@@ -35523,7 +35460,7 @@ function registerPhaseTools(server) {
 		try {
 			const cwd = detectProjectRoot();
 			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
-			const result = findPhaseInternal(cwd, phase);
+			const result = await findPhaseInternal(cwd, phase);
 			if (!result) return mcpError(`Phase ${phase} not found`, "Phase not found");
 			let githubTracking = null;
 			let githubTaskIssues = null;
@@ -35588,9 +35525,9 @@ function registerPhaseTools(server) {
 				limit,
 				has_more: false
 			}, "No phases directory found");
-			let dirs = listSubDirs(phasesDir);
+			let dirs = await listSubDirs(phasesDir);
 			if (include_archived) {
-				const archived = getArchivedPhaseDirs(cwd);
+				const archived = await getArchivedPhaseDirs(cwd);
 				for (const a of archived) dirs.push(`${a.name} [${a.milestone}]`);
 			}
 			dirs.sort((a, b) => comparePhaseNum(a, b));
@@ -36297,7 +36234,7 @@ function registerStateTools(server) {
 * Ported from maxsim/bin/lib/roadmap.cjs
 */
 async function cmdRoadmapAnalyze(cwd) {
-	const content = await safeReadFileAsync(roadmapPath(cwd));
+	const content = await safeReadFile(roadmapPath(cwd));
 	if (!content) return cmdOk({
 		error: "ROADMAP.md not found",
 		milestones: [],
@@ -36330,7 +36267,7 @@ async function cmdRoadmapAnalyze(cwd) {
 	}
 	let allDirs = [];
 	try {
-		allDirs = await listSubDirsAsync(phasesDir);
+		allDirs = await listSubDirs(phasesDir);
 	} catch {}
 	const phases = await Promise.all(parsedPhases.map(async (p) => {
 		let diskStatus = "no_directory";
@@ -36470,9 +36407,9 @@ function loadRoadmapContext(cwd) {
 	addIfExists(files, cwd, ".planning/ROADMAP.md", "roadmap");
 	return files;
 }
-function loadPhaseContext(cwd, phase) {
+async function loadPhaseContext(cwd, phase) {
 	const files = [];
-	const phaseInfo = findPhaseInternal(cwd, phase);
+	const phaseInfo = await findPhaseInternal(cwd, phase);
 	if (!phaseInfo?.directory) return files;
 	const phaseDir = phaseInfo.directory;
 	try {
@@ -36490,7 +36427,7 @@ function loadPhaseContext(cwd, phase) {
 	}
 	return files;
 }
-function loadArtefakteContext(cwd, phase) {
+async function loadArtefakteContext(cwd, phase) {
 	const files = [];
 	for (const filename of [
 		"DECISIONS.md",
@@ -36498,7 +36435,7 @@ function loadArtefakteContext(cwd, phase) {
 		"NO-GOS.md"
 	]) {
 		if (phase) {
-			const phaseInfo = findPhaseInternal(cwd, phase);
+			const phaseInfo = await findPhaseInternal(cwd, phase);
 			if (phaseInfo?.directory) addIfExists(files, cwd, node_path.default.join(phaseInfo.directory, filename), `artefakt-${filename.toLowerCase()}`);
 		}
 		addIfExists(files, cwd, `.planning/${filename}`, `artefakt-${filename.toLowerCase()}`);
@@ -36515,11 +36452,11 @@ function loadCodebaseContext(cwd, topic) {
 	} catch {}
 	return files;
 }
-function loadHistoryContext(cwd, currentPhase) {
+async function loadHistoryContext(cwd, currentPhase) {
 	const files = [];
 	const pd = phasesPath(cwd);
 	try {
-		const dirs = listSubDirs(pd, true);
+		const dirs = await listSubDirs(pd, true);
 		for (const dir of dirs) {
 			if (currentPhase) {
 				if (dir.match(/^(\d+[A-Z]?(?:\.\d+)?)/i)?.[1] === currentPhase) continue;
@@ -36533,15 +36470,15 @@ function loadHistoryContext(cwd, currentPhase) {
 	}
 	return files;
 }
-function cmdContextLoad(cwd, phase, topic, includeHistory) {
+async function cmdContextLoad(cwd, phase, topic, includeHistory) {
 	const allFiles = [];
 	allFiles.push(...loadProjectContext(cwd));
 	allFiles.push(...loadRoadmapContext(cwd));
-	allFiles.push(...loadArtefakteContext(cwd, phase));
+	allFiles.push(...await loadArtefakteContext(cwd, phase));
 	const selectedDocs = selectCodebaseDocs(topic);
 	allFiles.push(...loadCodebaseContext(cwd, topic));
-	if (phase) allFiles.push(...loadPhaseContext(cwd, phase));
-	if (includeHistory) allFiles.push(...loadHistoryContext(cwd, phase));
+	if (phase) allFiles.push(...await loadPhaseContext(cwd, phase));
+	if (includeHistory) allFiles.push(...await loadHistoryContext(cwd, phase));
 	const seen = /* @__PURE__ */ new Set();
 	const deduped = allFiles.filter((f) => {
 		if (seen.has(f.path)) return false;
@@ -36584,7 +36521,7 @@ function registerContextTools(server) {
 				current_phase = data.current_phase ?? null;
 				next_phase = data.next_phase ?? null;
 			}
-			const stateContent = safeReadFile(planningPath(cwd, "STATE.md"));
+			const stateContent = await safeReadFile(planningPath(cwd, "STATE.md"));
 			if (stateContent) {
 				const statePhase = stateExtractField(stateContent, "Current Phase");
 				if (statePhase) phase_name = statePhase;
@@ -36605,12 +36542,12 @@ function registerContextTools(server) {
 		try {
 			const cwd = detectProjectRoot();
 			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
-			const project_vision = safeReadFile(planningPath(cwd, "PROJECT.md"));
-			const config = loadConfig(cwd);
+			const project_vision = await safeReadFile(planningPath(cwd, "PROJECT.md"));
+			const config = await loadConfig(cwd);
 			let phase_context = null;
 			if (phase) {
-				const phaseInfo = findPhaseInternal(cwd, phase);
-				if (phaseInfo) phase_context = safeReadFile(node_path.default.join(phaseInfo.directory, `${phaseInfo.phase_number}-CONTEXT.md`));
+				const phaseInfo = await findPhaseInternal(cwd, phase);
+				if (phaseInfo) phase_context = await safeReadFile(node_path.default.join(phaseInfo.directory, `${phaseInfo.phase_number}-CONTEXT.md`));
 			}
 			return mcpSuccess({
 				project_vision,
@@ -36628,7 +36565,7 @@ function registerContextTools(server) {
 		try {
 			const cwd = detectProjectRoot();
 			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
-			const result = cmdContextLoad(cwd, phase, topic, true);
+			const result = await cmdContextLoad(cwd, phase, topic, true);
 			if (!result.ok) return mcpError(result.error, "Context load failed");
 			return mcpSuccess({ context: result.result }, `Context loaded${phase ? ` for phase ${phase}` : ""}${topic ? ` topic "${topic}"` : ""}`);
 		} catch (e) {
@@ -36640,9 +36577,9 @@ function registerContextTools(server) {
 			const cwd = detectProjectRoot();
 			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
 			return mcpSuccess({
-				project: safeReadFile(planningPath(cwd, "PROJECT.md")),
-				requirements: safeReadFile(planningPath(cwd, "REQUIREMENTS.md")),
-				state: safeReadFile(planningPath(cwd, "STATE.md"))
+				project: await safeReadFile(planningPath(cwd, "PROJECT.md")),
+				requirements: await safeReadFile(planningPath(cwd, "REQUIREMENTS.md")),
+				state: await safeReadFile(planningPath(cwd, "STATE.md"))
 			}, "Project overview loaded");
 		} catch (e) {
 			return mcpError("Failed: " + e.message, "Error occurred");
@@ -36652,7 +36589,7 @@ function registerContextTools(server) {
 		try {
 			const cwd = detectProjectRoot();
 			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
-			const phaseInfo = findPhaseInternal(cwd, phase);
+			const phaseInfo = await findPhaseInternal(cwd, phase);
 			if (!phaseInfo) return mcpError(`Phase ${phase} not found`, "Phase not found");
 			const files = [];
 			try {
@@ -36661,7 +36598,7 @@ function registerContextTools(server) {
 					const fullPath = node_path.default.join(phaseInfo.directory, entry);
 					if (node_fs.default.statSync(fullPath).isFile()) files.push({
 						name: entry,
-						content: safeReadFile(fullPath)
+						content: await safeReadFile(fullPath)
 					});
 				}
 			} catch {}
@@ -36812,7 +36749,7 @@ function registerConfigTools(server) {
 					value: result.rawValue ?? result.result
 				}, `Config value for "${key}"`);
 			}
-			return mcpSuccess({ config: loadConfig(cwd) }, "Full configuration loaded");
+			return mcpSuccess({ config: await loadConfig(cwd) }, "Full configuration loaded");
 		} catch (e) {
 			return mcpError("Failed: " + e.message, "Error occurred");
 		}