maxsimcli 4.7.0 → 4.8.0

package/dist/cli.cjs

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp$1 = Object.defineProperty;
@@ -42,7 +41,6 @@ let node_process = require("node:process");
 node_process = __toESM(node_process);
 let node_tty = require("node:tty");
 node_tty = __toESM(node_tty);
-let node_module = require("node:module");
 
 //#region src/core/types.ts
 function cmdOk(result, rawValue) {
@@ -607,7 +605,7 @@ var require_has_flag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/supports-color/index.js
 var require_supports_color = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const os$6 = require("os");
+	const os$5 = require("os");
 	const tty$2 = require("tty");
 	const hasFlag = require_has_flag();
 	const { env } = process;
@@ -634,7 +632,7 @@ var require_supports_color = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 		const min = forceColor || 0;
 		if (env.TERM === "dumb") return min;
 		if (process.platform === "win32") {
-			const osRelease = os$6.release().split(".");
+			const osRelease = os$5.release().split(".");
 			if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
 			return 1;
 		}
@@ -4799,17 +4797,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 {
@@ -4830,104 +4823,7 @@ function debugLog(contextOrError, error) {
 function escapePhaseNum(phase) {
 	return String(phase).replace(/\./g, "\\.");
 }
-function safeReadFile(filePath) {
-	try {
-		return node_fs.default.readFileSync(filePath, "utf-8");
-	} catch {
-		return null;
-	}
-}
 let _configCache = null;
-function loadConfig(cwd) {
-	if (_configCache && _configCache.cwd === cwd) return _configCache.config;
-	const cfgPath = configPath(cwd);
-	const defaults = {
-		model_profile: "balanced",
-		commit_docs: true,
-		search_gitignored: false,
-		branching_strategy: "none",
-		phase_branch_template: "maxsim/phase-{phase}-{slug}",
-		milestone_branch_template: "maxsim/{milestone}-{slug}",
-		research: true,
-		plan_checker: true,
-		verifier: true,
-		parallelization: true,
-		brave_search: false
-	};
-	try {
-		const raw = node_fs.default.readFileSync(cfgPath, "utf-8");
-		const parsed = JSON.parse(raw);
-		const get = (key, nested) => {
-			if (parsed[key] !== void 0) return parsed[key];
-			if (nested) {
-				const section = parsed[nested.section];
-				if (section && typeof section === "object" && section !== null && nested.field in section) return section[nested.field];
-			}
-		};
-		const parallelization = (() => {
-			const val = get("parallelization");
-			if (typeof val === "boolean") return val;
-			if (typeof val === "object" && val !== null && "enabled" in val) return val.enabled;
-			return defaults.parallelization;
-		})();
-		const result = {
-			model_profile: get("model_profile") ?? defaults.model_profile,
-			commit_docs: get("commit_docs", {
-				section: "planning",
-				field: "commit_docs"
-			}) ?? defaults.commit_docs,
-			search_gitignored: get("search_gitignored", {
-				section: "planning",
-				field: "search_gitignored"
-			}) ?? defaults.search_gitignored,
-			branching_strategy: get("branching_strategy", {
-				section: "git",
-				field: "branching_strategy"
-			}) ?? defaults.branching_strategy,
-			phase_branch_template: get("phase_branch_template", {
-				section: "git",
-				field: "phase_branch_template"
-			}) ?? defaults.phase_branch_template,
-			milestone_branch_template: get("milestone_branch_template", {
-				section: "git",
-				field: "milestone_branch_template"
-			}) ?? defaults.milestone_branch_template,
-			research: get("research", {
-				section: "workflow",
-				field: "research"
-			}) ?? defaults.research,
-			plan_checker: get("plan_checker", {
-				section: "workflow",
-				field: "plan_checker"
-			}) ?? get("plan_checker", {
-				section: "workflow",
-				field: "plan_check"
-			}) ?? defaults.plan_checker,
-			verifier: get("verifier", {
-				section: "workflow",
-				field: "verifier"
-			}) ?? defaults.verifier,
-			parallelization,
-			brave_search: get("brave_search") ?? defaults.brave_search,
-			model_overrides: parsed["model_overrides"]
-		};
-		_configCache = {
-			cwd,
-			config: result
-		};
-		return result;
-	} catch (e) {
-		if (node_fs.default.existsSync(cfgPath)) {
-			console.warn(`[maxsim] Warning: config.json exists but could not be parsed — using defaults.`);
-			debugLog("config-load-failed", e);
-		}
-		_configCache = {
-			cwd,
-			config: defaults
-		};
-		return defaults;
-	}
-}
 async function isGitIgnored(cwd, targetPath) {
 	try {
 		return (await simpleGit(cwd).checkIgnore(targetPath)).length > 0;
@@ -4997,128 +4893,8 @@ 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) {
-	try {
-		const match = 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 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-failed", {
-			dir: baseDir,
-			phase: normalized,
-			error: errorMsg(e)
-		});
-		return null;
-	}
-}
-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);
-	if (current) return current;
-	const milestonesDir = planningPath(cwd, "milestones");
-	try {
-		node_fs.default.statSync(milestonesDir);
-	} catch {
-		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();
-		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);
-			if (result) {
-				result.archived = version;
-				return result;
-			}
-		}
-	} catch (e) {
-		debugLog("find-phase-milestone-search-failed", e);
-	}
-	return null;
-}
-function getArchivedPhaseDirs(cwd) {
-	const milestonesDir = planningPath(cwd, "milestones");
-	const results = [];
-	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);
-			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)
-			});
-		}
-	} catch (e) {
-		debugLog("get-archived-phase-dirs-failed", e);
-	}
-	return results;
-}
-function getRoadmapPhaseInternal(cwd, phaseNum) {
-	if (!phaseNum) return null;
-	const rp = roadmapPath(cwd);
-	try {
-		const content = node_fs.default.readFileSync(rp, "utf-8");
-		const phasePattern = getPhasePattern(escapePhaseNum(phaseNum), "i");
-		const headerMatch = content.match(phasePattern);
-		if (!headerMatch) return null;
-		const phaseName = headerMatch[1].trim();
-		const headerIndex = headerMatch.index;
-		const nextHeaderMatch = content.slice(headerIndex).match(/\n#{2,4}\s+Phase\s+\d/i);
-		const sectionEnd = nextHeaderMatch ? headerIndex + nextHeaderMatch.index : content.length;
-		const section = content.slice(headerIndex, sectionEnd).trim();
-		const goalMatch = section.match(/\*\*Goal(?::\*\*|\*\*:)\s*([^\n]+)/i);
-		const goal = goalMatch ? goalMatch[1].trim() : null;
-		return {
-			found: true,
-			phase_number: phaseNum.toString(),
-			phase_name: phaseName,
-			goal,
-			section
-		};
-	} catch (e) {
-		debugLog("get-roadmap-phase-failed", {
-			phase: phaseNum,
-			error: errorMsg(e)
-		});
-		return null;
-	}
-}
-function resolveModelInternal(cwd, agentType, config) {
-	config = config ?? loadConfig(cwd);
+async function resolveModelInternal(cwd, agentType, config) {
+	config = config ?? await loadConfig(cwd);
 	const override = config.model_overrides?.[agentType];
 	if (override) return override === "opus" ? "inherit" : override;
 	const profile = config.model_profile || "balanced";
@@ -5127,15 +4903,6 @@ function resolveModelInternal(cwd, agentType, config) {
 	const resolved = agentModels[profile] || agentModels["balanced"] || "sonnet";
 	return resolved === "opus" ? "inherit" : resolved;
 }
-function pathExistsInternal(cwd, targetPath) {
-	const fullPath = node_path.default.isAbsolute(targetPath) ? targetPath : node_path.default.join(cwd, targetPath);
-	try {
-		node_fs.default.statSync(fullPath);
-		return true;
-	} catch {
-		return false;
-	}
-}
 function generateSlugInternal(text) {
 	if (!text) return null;
 	return (0, import_slugify.default)(text, {
@@ -5143,23 +4910,7 @@ function generateSlugInternal(text) {
 		strict: true
 	});
 }
-function getMilestoneInfo(cwd) {
-	try {
-		const roadmap = node_fs.default.readFileSync(roadmapPath(cwd), "utf-8");
-		const versionMatch = roadmap.match(/v(\d+\.\d+)/);
-		const nameMatch = roadmap.match(/## .*v\d+\.\d+[:\s]+([^\n(]+)/);
-		return {
-			version: versionMatch ? versionMatch[0] : "v1.0",
-			name: nameMatch ? nameMatch[1].trim() : "milestone"
-		};
-	} catch {
-		return {
-			version: "v1.0",
-			name: "milestone"
-		};
-	}
-}
-async function pathExistsAsync(p) {
+async function pathExistsInternal(p) {
 	try {
 		await node_fs.promises.access(p);
 		return true;
@@ -5167,9 +4918,99 @@ async function pathExistsAsync(p) {
 		return false;
 	}
 }
-async function searchPhaseInDirAsync(baseDir, relBase, normalized) {
+async function loadConfig(cwd) {
+	if (_configCache && _configCache.cwd === cwd) return _configCache.config;
+	const cfgPath = configPath(cwd);
+	const defaults = {
+		model_profile: "balanced",
+		commit_docs: true,
+		search_gitignored: false,
+		branching_strategy: "none",
+		phase_branch_template: "maxsim/phase-{phase}-{slug}",
+		milestone_branch_template: "maxsim/{milestone}-{slug}",
+		research: true,
+		plan_checker: true,
+		verifier: true,
+		parallelization: true,
+		brave_search: false
+	};
+	try {
+		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];
+			if (nested) {
+				const section = parsed[nested.section];
+				if (section && typeof section === "object" && section !== null && nested.field in section) return section[nested.field];
+			}
+		};
+		const parallelization = (() => {
+			const val = get("parallelization");
+			if (typeof val === "boolean") return val;
+			if (typeof val === "object" && val !== null && "enabled" in val) return val.enabled;
+			return defaults.parallelization;
+		})();
+		const result = {
+			model_profile: get("model_profile") ?? defaults.model_profile,
+			commit_docs: get("commit_docs", {
+				section: "planning",
+				field: "commit_docs"
+			}) ?? defaults.commit_docs,
+			search_gitignored: get("search_gitignored", {
+				section: "planning",
+				field: "search_gitignored"
+			}) ?? defaults.search_gitignored,
+			branching_strategy: get("branching_strategy", {
+				section: "git",
+				field: "branching_strategy"
+			}) ?? defaults.branching_strategy,
+			phase_branch_template: get("phase_branch_template", {
+				section: "git",
+				field: "phase_branch_template"
+			}) ?? defaults.phase_branch_template,
+			milestone_branch_template: get("milestone_branch_template", {
+				section: "git",
+				field: "milestone_branch_template"
+			}) ?? defaults.milestone_branch_template,
+			research: get("research", {
+				section: "workflow",
+				field: "research"
+			}) ?? defaults.research,
+			plan_checker: get("plan_checker", {
+				section: "workflow",
+				field: "plan_checker"
+			}) ?? get("plan_checker", {
+				section: "workflow",
+				field: "plan_check"
+			}) ?? defaults.plan_checker,
+			verifier: get("verifier", {
+				section: "workflow",
+				field: "verifier"
+			}) ?? defaults.verifier,
+			parallelization,
+			brave_search: get("brave_search") ?? defaults.brave_search,
+			model_overrides: parsed["model_overrides"]
+		};
+		_configCache = {
+			cwd,
+			config: result
+		};
+		return result;
+	} catch (e) {
+		if (await pathExistsInternal(cfgPath)) {
+			console.warn(`[maxsim] Warning: config.json exists but could not be parsed — using defaults.`);
+			debugLog("config-load-failed", e);
+		}
+		_configCache = {
+			cwd,
+			config: defaults
+		};
+		return defaults;
+	}
+}
+async function searchPhaseInDir(baseDir, relBase, normalized) {
 	try {
-		const match = (await listSubDirsAsync(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;
@@ -5205,17 +5046,17 @@ async function searchPhaseInDirAsync(baseDir, relBase, normalized) {
 		return null;
 	}
 }
-async function findPhaseInternalAsync(cwd, phase) {
+async function findPhaseInternal(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);
+	const current = await searchPhaseInDir(pd, node_path.default.join(".planning", "phases"), normalized);
 	if (current) return current;
 	const archiveDir = planningPath(cwd, "archive");
-	if (await pathExistsAsync(archiveDir)) try {
+	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 searchPhaseInDirAsync(node_path.default.join(archiveDir, versionName), node_path.default.join(".planning", "archive", versionName), normalized);
+			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;
@@ -5225,14 +5066,14 @@ async function findPhaseInternalAsync(cwd, phase) {
 		debugLog("find-phase-async-archive-search-failed", e);
 	}
 	const milestonesDir = planningPath(cwd, "milestones");
-	if (!await pathExistsAsync(milestonesDir)) return null;
+	if (!await pathExistsInternal(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 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);
+			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;
@@ -5243,14 +5084,14 @@ async function findPhaseInternalAsync(cwd, phase) {
 	}
 	return null;
 }
-async function getArchivedPhaseDirsAsync(cwd) {
+async function getArchivedPhaseDirs(cwd) {
 	const results = [];
 	const archiveDir = planningPath(cwd, "archive");
 	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 versionPath = node_path.default.join(archiveDir, versionName);
-			const dirs = await listSubDirsAsync(versionPath, true);
+			const dirs = await listSubDirs(versionPath, true);
 			for (const dir of dirs) results.push({
 				name: dir,
 				milestone: versionName,
@@ -5269,7 +5110,7 @@ async function getArchivedPhaseDirsAsync(cwd) {
 			if (!versionMatch) continue;
 			const version = versionMatch[1];
 			const archiveMilestonePath = node_path.default.join(milestonesDir, archiveName);
-			const dirs = await listSubDirsAsync(archiveMilestonePath, true);
+			const dirs = await listSubDirs(archiveMilestonePath, true);
 			for (const dir of dirs) results.push({
 				name: dir,
 				milestone: version,
@@ -5282,15 +5123,43 @@ async function getArchivedPhaseDirsAsync(cwd) {
 	}
 	return results;
 }
-function archivePath(cwd, milestone) {
-	return planningPath(cwd, "archive", milestone ?? getMilestoneInfo(cwd).version);
+async function getRoadmapPhaseInternal(cwd, phaseNum) {
+	if (!phaseNum) return null;
+	const rp = roadmapPath(cwd);
+	try {
+		const content = await safeReadFile(rp);
+		if (!content) return null;
+		const phasePattern = getPhasePattern(escapePhaseNum(phaseNum), "i");
+		const headerMatch = content.match(phasePattern);
+		if (!headerMatch) return null;
+		const phaseName = headerMatch[1].trim();
+		const headerIndex = headerMatch.index;
+		const nextHeaderMatch = content.slice(headerIndex).match(/\n#{2,4}\s+Phase\s+\d/i);
+		const sectionEnd = nextHeaderMatch ? headerIndex + nextHeaderMatch.index : content.length;
+		const section = content.slice(headerIndex, sectionEnd).trim();
+		const goalMatch = section.match(/\*\*Goal(?::\*\*|\*\*:)\s*([^\n]+)/i);
+		const goal = goalMatch ? goalMatch[1].trim() : null;
+		return {
+			found: true,
+			phase_number: phaseNum.toString(),
+			phase_name: phaseName,
+			goal,
+			section
+		};
+	} catch (e) {
+		debugLog("get-roadmap-phase-async-failed", {
+			phase: phaseNum,
+			error: errorMsg(e)
+		});
+		return null;
+	}
 }
-async function archivePathAsync(cwd, milestone) {
-	return planningPath(cwd, "archive", milestone ?? (await getMilestoneInfoAsync(cwd)).version);
+async function archivePath(cwd, milestone) {
+	return planningPath(cwd, "archive", milestone ?? (await getMilestoneInfo(cwd)).version);
 }
-async function getMilestoneInfoAsync(cwd) {
+async function getMilestoneInfo(cwd) {
 	try {
-		const roadmap = await safeReadFileAsync(roadmapPath(cwd));
+		const roadmap = await safeReadFile(roadmapPath(cwd));
 		if (!roadmap) return {
 			version: "v1.0",
 			name: "milestone"
@@ -12051,9 +11920,9 @@ const FRONTMATTER_SCHEMAS = {
 		"info_count"
 	] }
 };
-function cmdFrontmatterGet(cwd, filePath, field) {
+async function cmdFrontmatterGet(cwd, filePath, field) {
 	if (!filePath) return cmdErr("file path required");
-	const content = safeReadFile(node_path.default.isAbsolute(filePath) ? filePath : node_path.default.join(cwd, filePath));
+	const content = await safeReadFile(node_path.default.isAbsolute(filePath) ? filePath : node_path.default.join(cwd, filePath));
 	if (!content) return cmdOk({
 		error: "File not found",
 		path: filePath
@@ -12115,11 +11984,11 @@ function cmdFrontmatterMerge(cwd, filePath, data) {
 		fields: Object.keys(mergeData)
 	}, "true");
 }
-function cmdFrontmatterValidate(cwd, filePath, schemaName) {
+async function cmdFrontmatterValidate(cwd, filePath, schemaName) {
 	if (!filePath || !schemaName) return cmdErr("file and schema required");
 	const schema = FRONTMATTER_SCHEMAS[schemaName];
 	if (!schema) return cmdErr(`Unknown schema: ${schemaName}. Available: ${Object.keys(FRONTMATTER_SCHEMAS).join(", ")}`);
-	const content = safeReadFile(node_path.default.isAbsolute(filePath) ? filePath : node_path.default.join(cwd, filePath));
+	const content = await safeReadFile(node_path.default.isAbsolute(filePath) ? filePath : node_path.default.join(cwd, filePath));
 	if (!content) return cmdOk({
 		error: "File not found",
 		path: filePath
@@ -12302,11 +12171,11 @@ function appendToStateSection(content, sectionPattern, entry, placeholderPattern
 	return content.replace(sectionPattern, (_m, header) => `${header}${sectionBody}`);
 }
 async function cmdStateLoad(cwd, raw) {
-	const config = loadConfig(cwd);
+	const config = await loadConfig(cwd);
 	const [stateContent, configExists, roadmapExists] = await Promise.all([
-		safeReadFileAsync(statePath(cwd)),
-		pathExistsAsync(configPath(cwd)),
-		pathExistsAsync(roadmapPath(cwd))
+		safeReadFile(statePath(cwd)),
+		pathExistsInternal(configPath(cwd)),
+		pathExistsInternal(roadmapPath(cwd))
 	]);
 	const stateRaw = stateContent ?? "";
 	const stateExists = stateRaw.length > 0;
@@ -12397,7 +12266,7 @@ async function cmdStateUpdate(cwd, field, value) {
 }
 async function cmdStateAdvancePlan(cwd, raw) {
 	const statePath$5 = statePath(cwd);
-	if (!await pathExistsAsync(statePath$5)) return cmdOk({ error: "STATE.md not found" });
+	if (!await pathExistsInternal(statePath$5)) return cmdOk({ error: "STATE.md not found" });
 	let content = await node_fs.promises.readFile(statePath$5, "utf-8");
 	const currentPlan = parseInt(stateExtractField(content, "Current Plan") ?? "", 10);
 	const totalPlans = parseInt(stateExtractField(content, "Total Plans in Phase") ?? "", 10);
@@ -12430,7 +12299,7 @@ async function cmdStateAdvancePlan(cwd, raw) {
 }
 async function cmdStateRecordMetric(cwd, options, raw) {
 	const statePath$6 = statePath(cwd);
-	if (!await pathExistsAsync(statePath$6)) return cmdOk({ error: "STATE.md not found" });
+	if (!await pathExistsInternal(statePath$6)) return cmdOk({ error: "STATE.md not found" });
 	let content = await node_fs.promises.readFile(statePath$6, "utf-8");
 	const { phase, plan, duration, tasks, files } = options;
 	if (!phase || !plan || !duration) return cmdOk({ error: "phase, plan, and duration required" });
@@ -12456,12 +12325,12 @@ async function cmdStateRecordMetric(cwd, options, raw) {
 }
 async function cmdStateUpdateProgress(cwd, raw) {
 	const statePath$7 = statePath(cwd);
-	if (!await pathExistsAsync(statePath$7)) return cmdOk({ error: "STATE.md not found" });
+	if (!await pathExistsInternal(statePath$7)) return cmdOk({ error: "STATE.md not found" });
 	let content = await node_fs.promises.readFile(statePath$7, "utf-8");
 	const phasesDir = phasesPath(cwd);
 	let totalPlans = 0;
 	let totalSummaries = 0;
-	if (await pathExistsAsync(phasesDir)) {
+	if (await pathExistsInternal(phasesDir)) {
 		const phaseDirs = (await node_fs.promises.readdir(phasesDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
 		const counts = await Promise.all(phaseDirs.map(async (dir) => {
 			const files = await node_fs.promises.readdir(node_path.default.join(phasesDir, dir));
@@ -12496,7 +12365,7 @@ async function cmdStateUpdateProgress(cwd, raw) {
 }
 async function cmdStateAddDecision(cwd, options, raw) {
 	const statePath$8 = statePath(cwd);
-	if (!await pathExistsAsync(statePath$8)) return cmdOk({ error: "STATE.md not found" });
+	if (!await pathExistsInternal(statePath$8)) return cmdOk({ error: "STATE.md not found" });
 	const { phase, summary, summary_file, rationale, rationale_file } = options;
 	let summaryText;
 	let rationaleText = "";
@@ -12526,7 +12395,7 @@ async function cmdStateAddDecision(cwd, options, raw) {
 }
 async function cmdStateAddBlocker(cwd, text, raw) {
 	const statePath$9 = statePath(cwd);
-	if (!await pathExistsAsync(statePath$9)) return cmdOk({ error: "STATE.md not found" });
+	if (!await pathExistsInternal(statePath$9)) return cmdOk({ error: "STATE.md not found" });
 	const blockerOptions = typeof text === "object" && text !== null ? text : { text };
 	let blockerText;
 	try {
@@ -12552,7 +12421,7 @@ async function cmdStateAddBlocker(cwd, text, raw) {
 }
 async function cmdStateResolveBlocker(cwd, text, raw) {
 	const statePath$10 = statePath(cwd);
-	if (!await pathExistsAsync(statePath$10)) return cmdOk({ error: "STATE.md not found" });
+	if (!await pathExistsInternal(statePath$10)) return cmdOk({ error: "STATE.md not found" });
 	if (!text) return cmdOk({ error: "text required" });
 	let content = await node_fs.promises.readFile(statePath$10, "utf-8");
 	const sectionPattern = /(#{2,3}\s*(?:Blockers|Blockers\/Concerns|Concerns)\s*\n\s*\n?)([\s\S]*?)(?=\n#{2,3}\s|$)/i;
@@ -12576,7 +12445,7 @@ async function cmdStateResolveBlocker(cwd, text, raw) {
 }
 async function cmdStateRecordSession(cwd, options, raw) {
 	const statePath$11 = statePath(cwd);
-	if (!await pathExistsAsync(statePath$11)) return cmdOk({ error: "STATE.md not found" });
+	if (!await pathExistsInternal(statePath$11)) return cmdOk({ error: "STATE.md not found" });
 	let content = await node_fs.promises.readFile(statePath$11, "utf-8");
 	const now = (/* @__PURE__ */ new Date()).toISOString();
 	const updated = [];
@@ -12618,7 +12487,7 @@ async function cmdStateRecordSession(cwd, options, raw) {
 }
 async function cmdStateSnapshot(cwd, raw) {
 	const statePath$12 = statePath(cwd);
-	if (!await pathExistsAsync(statePath$12)) return cmdOk({ error: "STATE.md not found" });
+	if (!await pathExistsInternal(statePath$12)) return cmdOk({ error: "STATE.md not found" });
 	const content = await node_fs.promises.readFile(statePath$12, "utf-8");
 	const extractField = (fieldName) => stateExtractField(content, fieldName);
 	const currentPhase = extractField("Current Phase");
@@ -12685,7 +12554,7 @@ async function cmdStateSnapshot(cwd, raw) {
 async function cmdDetectStaleContext(cwd) {
 	const rmPath = roadmapPath(cwd);
 	const stPath = statePath(cwd);
-	const [roadmapContent, stateContent] = await Promise.all([safeReadFileAsync(rmPath), safeReadFileAsync(stPath)]);
+	const [roadmapContent, stateContent] = await Promise.all([safeReadFile(rmPath), safeReadFile(stPath)]);
 	if (!roadmapContent) return cmdErr("ROADMAP.md not found");
 	if (!stateContent) return cmdErr("STATE.md not found");
 	const completedPhases = [];
@@ -12740,7 +12609,7 @@ async function cmdDetectStaleContext(cwd) {
 * Ported from maxsim/bin/lib/roadmap.cjs
 */
 async function cmdRoadmapGetPhase(cwd, phaseNum) {
-	const content = await safeReadFileAsync(roadmapPath(cwd));
+	const content = await safeReadFile(roadmapPath(cwd));
 	if (!content) return cmdOk({
 		found: false,
 		error: "ROADMAP.md not found"
@@ -12785,7 +12654,7 @@ async function cmdRoadmapGetPhase(cwd, phaseNum) {
 	}
 }
 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: [],
@@ -12818,7 +12687,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";
@@ -12893,7 +12762,7 @@ async function cmdRoadmapAnalyze(cwd) {
 async function cmdRoadmapUpdatePlanProgress(cwd, phaseNum) {
 	if (!phaseNum) return cmdErr("phase number required for roadmap update-plan-progress");
 	const rmPath = roadmapPath(cwd);
-	const phaseInfo = await findPhaseInternalAsync(cwd, phaseNum);
+	const phaseInfo = await findPhaseInternal(cwd, phaseNum);
 	if (!phaseInfo) return cmdErr(`Phase ${phaseNum} not found`);
 	const planCount = phaseInfo.plans.length;
 	const summaryCount = phaseInfo.summaries.length;
@@ -12906,7 +12775,7 @@ async function cmdRoadmapUpdatePlanProgress(cwd, phaseNum) {
 	const isComplete = summaryCount >= planCount;
 	const status = isComplete ? "Complete" : summaryCount > 0 ? "In Progress" : "Planned";
 	const today = todayISO();
-	const rawContent = await safeReadFileAsync(rmPath);
+	const rawContent = await safeReadFile(rmPath);
 	if (!rawContent) return cmdOk({
 		updated: false,
 		reason: "ROADMAP.md not found",
@@ -12979,7 +12848,7 @@ async function cmdMilestoneComplete(cwd, version, options) {
 	const reqPath = planningPath(cwd, "REQUIREMENTS.md");
 	const statePath$1 = statePath(cwd);
 	const milestonesPath = planningPath(cwd, "MILESTONES.md");
-	const archiveDir = archivePath(cwd, version);
+	const archiveDir = await archivePath(cwd, version);
 	const phasesDir = phasesPath(cwd);
 	const today = todayISO();
 	const milestoneName = options.name || version;
@@ -12989,7 +12858,7 @@ async function cmdMilestoneComplete(cwd, version, options) {
 	let totalTasks = 0;
 	const accomplishments = [];
 	try {
-		const dirs = await listSubDirsAsync(phasesDir, true);
+		const dirs = await listSubDirs(phasesDir, true);
 		for (const dir of dirs) {
 			phaseCount++;
 			const phaseFiles = await node_fs.promises.readdir(node_path.default.join(phasesDir, dir));
@@ -13009,12 +12878,12 @@ async function cmdMilestoneComplete(cwd, version, options) {
 	} catch (e) {
 		debugLog(e);
 	}
-	const stateExists = await pathExistsAsync(statePath$1);
+	const stateExists = await pathExistsInternal(statePath$1);
 	if (stateExists) {
 		const stateContent = await node_fs.promises.readFile(statePath$1, "utf-8");
 		await node_fs.promises.writeFile(node_path.default.join(archiveDir, "STATE.md"), stateContent, "utf-8");
 	}
-	const roadmapExists = await pathExistsAsync(roadmapPath$1);
+	const roadmapExists = await pathExistsInternal(roadmapPath$1);
 	if (roadmapExists) {
 		const roadmapContent = await node_fs.promises.readFile(roadmapPath$1, "utf-8");
 		await node_fs.promises.writeFile(node_path.default.join(archiveDir, "ROADMAP.md"), roadmapContent, "utf-8");
@@ -13023,16 +12892,16 @@ async function cmdMilestoneComplete(cwd, version, options) {
 		const roadmapContent = await node_fs.promises.readFile(roadmapPath$1, "utf-8");
 		await node_fs.promises.writeFile(node_path.default.join(archiveDir, `${version}-ROADMAP.md`), roadmapContent, "utf-8");
 	}
-	if (await pathExistsAsync(reqPath)) {
+	if (await pathExistsInternal(reqPath)) {
 		const reqContent = await node_fs.promises.readFile(reqPath, "utf-8");
 		const archiveHeader = `# Requirements Archive: ${version} ${milestoneName}\n\n**Archived:** ${today}\n**Status:** SHIPPED\n\nFor current requirements, see \`.planning/REQUIREMENTS.md\`.\n\n---\n\n`;
 		await node_fs.promises.writeFile(node_path.default.join(archiveDir, `${version}-REQUIREMENTS.md`), archiveHeader + reqContent, "utf-8");
 	}
 	const auditFile = node_path.default.join(cwd, ".planning", `${version}-MILESTONE-AUDIT.md`);
-	if (await pathExistsAsync(auditFile)) await node_fs.promises.rename(auditFile, node_path.default.join(archiveDir, `${version}-MILESTONE-AUDIT.md`));
+	if (await pathExistsInternal(auditFile)) await node_fs.promises.rename(auditFile, node_path.default.join(archiveDir, `${version}-MILESTONE-AUDIT.md`));
 	const accomplishmentsList = accomplishments.map((a) => `- ${a}`).join("\n");
 	const milestoneEntry = `## ${version} ${milestoneName} (Shipped: ${today})\n\n**Phases completed:** ${phaseCount} phases, ${totalPlans} plans, ${totalTasks} tasks\n\n**Key accomplishments:**\n${accomplishmentsList || "- (none recorded)"}\n\n---\n\n`;
-	if (await pathExistsAsync(milestonesPath)) {
+	if (await pathExistsInternal(milestonesPath)) {
 		const existing = await node_fs.promises.readFile(milestonesPath, "utf-8");
 		await node_fs.promises.writeFile(milestonesPath, existing + "\n" + milestoneEntry, "utf-8");
 	} else await node_fs.promises.writeFile(milestonesPath, `# Milestones\n\n${milestoneEntry}`, "utf-8");
@@ -13078,7 +12947,7 @@ Last session: ${today}
 	if (options.archivePhases) try {
 		const phaseArchiveDir = node_path.default.join(archiveDir, "phases");
 		await node_fs.promises.mkdir(phaseArchiveDir, { recursive: true });
-		const phaseDirNames = await listSubDirsAsync(phasesDir);
+		const phaseDirNames = await listSubDirs(phasesDir);
 		for (const dir of phaseDirNames) await node_fs.promises.rename(node_path.default.join(phasesDir, dir), node_path.default.join(phaseArchiveDir, dir));
 		phasesArchived = phaseDirNames.length > 0;
 	} catch (e) {
@@ -13093,12 +12962,12 @@ Last session: ${today}
 		tasks: totalTasks,
 		accomplishments,
 		archived: {
-			roadmap: await pathExistsAsync(node_path.default.join(archiveDir, `${version}-ROADMAP.md`)),
-			requirements: await pathExistsAsync(node_path.default.join(archiveDir, `${version}-REQUIREMENTS.md`)),
-			audit: await pathExistsAsync(node_path.default.join(archiveDir, `${version}-MILESTONE-AUDIT.md`)),
+			roadmap: await pathExistsInternal(node_path.default.join(archiveDir, `${version}-ROADMAP.md`)),
+			requirements: await pathExistsInternal(node_path.default.join(archiveDir, `${version}-REQUIREMENTS.md`)),
+			audit: await pathExistsInternal(node_path.default.join(archiveDir, `${version}-MILESTONE-AUDIT.md`)),
 			phases: phasesArchived,
-			state_snapshot: await pathExistsAsync(node_path.default.join(archiveDir, "STATE.md")),
-			roadmap_snapshot: await pathExistsAsync(node_path.default.join(archiveDir, "ROADMAP.md"))
+			state_snapshot: await pathExistsInternal(node_path.default.join(archiveDir, "STATE.md")),
+			roadmap_snapshot: await pathExistsInternal(node_path.default.join(archiveDir, "ROADMAP.md"))
 		},
 		milestones_updated: true,
 		state_updated: stateExists,
@@ -13600,7 +13469,7 @@ function cmdVerifyPathExists(cwd, targetPath, raw) {
 		}, raw ? "false" : void 0);
 	}
 }
-function cmdHistoryDigest(cwd, raw) {
+async function cmdHistoryDigest(cwd, raw) {
 	const phasesDir = phasesPath(cwd);
 	const digest = {
 		phases: {},
@@ -13608,14 +13477,14 @@ function cmdHistoryDigest(cwd, raw) {
 		tech_stack: /* @__PURE__ */ new Set()
 	};
 	const allPhaseDirs = [];
-	const archived = getArchivedPhaseDirs(cwd);
+	const archived = await getArchivedPhaseDirs(cwd);
 	for (const a of archived) allPhaseDirs.push({
 		name: a.name,
 		fullPath: a.fullPath,
 		milestone: a.milestone
 	});
 	if (node_fs.default.existsSync(phasesDir)) try {
-		const currentDirs = listSubDirs(phasesDir, true);
+		const currentDirs = await listSubDirs(phasesDir, true);
 		for (const dir of currentDirs) allPhaseDirs.push({
 			name: dir,
 			fullPath: node_path.default.join(phasesDir, dir),
@@ -13675,9 +13544,9 @@ function cmdHistoryDigest(cwd, raw) {
 		return cmdErr("Failed to generate history digest: " + e.message);
 	}
 }
-function cmdResolveModel(cwd, agentType, raw) {
+async function cmdResolveModel(cwd, agentType, raw) {
 	if (!agentType) return cmdErr("agent-type required");
-	const profile = loadConfig(cwd).model_profile || "balanced";
+	const profile = (await loadConfig(cwd)).model_profile || "balanced";
 	const agentModels = MODEL_PROFILES[agentType];
 	if (!agentModels) return cmdOk({
 		model: "sonnet",
@@ -13693,7 +13562,7 @@ function cmdResolveModel(cwd, agentType, raw) {
 }
 async function cmdCommit(cwd, message, files, raw, amend) {
 	if (!message && !amend) return cmdErr("commit message required");
-	if (!loadConfig(cwd).commit_docs) return cmdOk({
+	if (!(await loadConfig(cwd)).commit_docs) return cmdOk({
 		committed: false,
 		hash: null,
 		reason: "skipped_commit_docs_false"
@@ -13825,9 +13694,9 @@ async function cmdWebsearch(query, options, raw) {
 		}, raw ? "" : void 0);
 	}
 }
-function cmdProgressRender(cwd, format, raw) {
+async function cmdProgressRender(cwd, format, raw) {
 	const phasesDir = phasesPath(cwd);
-	const milestone = getMilestoneInfo(cwd);
+	const milestone = await getMilestoneInfo(cwd);
 	const phases = [];
 	let totalPlans = 0;
 	let totalSummaries = 0;
@@ -13934,11 +13803,11 @@ function cmdTodoComplete(cwd, filename, raw) {
 		date: today
 	}, raw ? "completed" : void 0);
 }
-function cmdScaffold(cwd, type, options, raw) {
+async function cmdScaffold(cwd, type, options, raw) {
 	const { phase, name } = options;
 	const padded = phase ? normalizePhaseName(phase) : "00";
 	const today = todayISO();
-	const phaseInfo = phase ? findPhaseInternal(cwd, phase) : null;
+	const phaseInfo = phase ? await findPhaseInternal(cwd, phase) : null;
 	const phaseDir = phaseInfo ? node_path.default.join(cwd, phaseInfo.directory) : null;
 	if (phase && !phaseDir && type !== "phase-dir") return cmdErr(`Phase ${phase} directory not found`);
 	let filePath;
@@ -14064,9 +13933,9 @@ async function cmdVerifySummary(cwd, summaryPath, checkFileCount) {
 		errors
 	}, passed ? "passed" : "failed");
 }
-function cmdVerifyPlanStructure(cwd, filePath) {
+async function cmdVerifyPlanStructure(cwd, filePath) {
 	if (!filePath) return cmdErr("file path required");
-	const content = safeReadFile(node_path.default.isAbsolute(filePath) ? filePath : node_path.default.join(cwd, filePath));
+	const content = await safeReadFile(node_path.default.isAbsolute(filePath) ? filePath : node_path.default.join(cwd, filePath));
 	if (!content) return cmdOk({
 		error: "File not found",
 		path: filePath
@@ -14120,9 +13989,9 @@ function cmdVerifyPlanStructure(cwd, filePath) {
 		frontmatter_fields: Object.keys(fm)
 	}, errors.length === 0 ? "valid" : "invalid");
 }
-function cmdVerifyPhaseCompleteness(cwd, phase) {
+async function cmdVerifyPhaseCompleteness(cwd, phase) {
 	if (!phase) return cmdErr("phase required");
-	const phaseInfo = findPhaseInternal(cwd, phase);
+	const phaseInfo = await findPhaseInternal(cwd, phase);
 	if (!phaseInfo) return cmdOk({
 		error: "Phase not found",
 		phase
@@ -14155,9 +14024,9 @@ function cmdVerifyPhaseCompleteness(cwd, phase) {
 		warnings
 	}, errors.length === 0 ? "complete" : "incomplete");
 }
-function cmdVerifyReferences(cwd, filePath) {
+async function cmdVerifyReferences(cwd, filePath) {
 	if (!filePath) return cmdErr("file path required");
-	const content = safeReadFile(node_path.default.isAbsolute(filePath) ? filePath : node_path.default.join(cwd, filePath));
+	const content = await safeReadFile(node_path.default.isAbsolute(filePath) ? filePath : node_path.default.join(cwd, filePath));
 	if (!content) return cmdOk({
 		error: "File not found",
 		path: filePath
@@ -14207,9 +14076,9 @@ async function cmdVerifyCommits(cwd, hashes) {
 		total: hashes.length
 	}, invalid.length === 0 ? "valid" : "invalid");
 }
-function cmdVerifyArtifacts(cwd, planFilePath) {
+async function cmdVerifyArtifacts(cwd, planFilePath) {
 	if (!planFilePath) return cmdErr("plan file path required");
-	const content = safeReadFile(node_path.default.isAbsolute(planFilePath) ? planFilePath : node_path.default.join(cwd, planFilePath));
+	const content = await safeReadFile(node_path.default.isAbsolute(planFilePath) ? planFilePath : node_path.default.join(cwd, planFilePath));
 	if (!content) return cmdOk({
 		error: "File not found",
 		path: planFilePath
@@ -14234,7 +14103,7 @@ function cmdVerifyArtifacts(cwd, planFilePath) {
 			passed: false
 		};
 		if (exists) {
-			const fileContent = safeReadFile(artFullPath) || "";
+			const fileContent = await safeReadFile(artFullPath) || "";
 			const lineCount = fileContent.split("\n").length;
 			if (artObj.min_lines && lineCount < artObj.min_lines) check.issues.push(`Only ${lineCount} lines, need ${artObj.min_lines}`);
 			if (artObj.contains && !fileContent.includes(artObj.contains)) check.issues.push(`Missing pattern: ${artObj.contains}`);
@@ -14254,9 +14123,9 @@ function cmdVerifyArtifacts(cwd, planFilePath) {
 		artifacts: results
 	}, passed === results.length ? "valid" : "invalid");
 }
-function cmdVerifyKeyLinks(cwd, planFilePath) {
+async function cmdVerifyKeyLinks(cwd, planFilePath) {
 	if (!planFilePath) return cmdErr("plan file path required");
-	const content = safeReadFile(node_path.default.isAbsolute(planFilePath) ? planFilePath : node_path.default.join(cwd, planFilePath));
+	const content = await safeReadFile(node_path.default.isAbsolute(planFilePath) ? planFilePath : node_path.default.join(cwd, planFilePath));
 	if (!content) return cmdOk({
 		error: "File not found",
 		path: planFilePath
@@ -14277,7 +14146,7 @@ function cmdVerifyKeyLinks(cwd, planFilePath) {
 			verified: false,
 			detail: ""
 		};
-		const sourceContent = safeReadFile(node_path.default.join(cwd, linkObj.from || ""));
+		const sourceContent = await safeReadFile(node_path.default.join(cwd, linkObj.from || ""));
 		if (!sourceContent) check.detail = "Source file not found";
 		else if (linkObj.pattern) try {
 			const regex = new RegExp(linkObj.pattern);
@@ -14285,7 +14154,7 @@ function cmdVerifyKeyLinks(cwd, planFilePath) {
 				check.verified = true;
 				check.detail = "Pattern found in source";
 			} else {
-				const targetContent = safeReadFile(node_path.default.join(cwd, linkObj.to || ""));
+				const targetContent = await safeReadFile(node_path.default.join(cwd, linkObj.to || ""));
 				if (targetContent && regex.test(targetContent)) {
 					check.verified = true;
 					check.detail = "Pattern found in target";
@@ -14308,7 +14177,7 @@ function cmdVerifyKeyLinks(cwd, planFilePath) {
 		links: results
 	}, verified === results.length ? "valid" : "invalid");
 }
-function cmdValidateConsistency(cwd) {
+async function cmdValidateConsistency(cwd) {
 	const rmPath = roadmapPath(cwd);
 	const phasesDir = phasesPath(cwd);
 	const errors = [];
@@ -14328,7 +14197,7 @@ function cmdValidateConsistency(cwd) {
 	while ((m = phasePattern.exec(roadmapContent)) !== null) roadmapPhases.add(m[1]);
 	const diskPhases = /* @__PURE__ */ new Set();
 	try {
-		const dirs = listSubDirs(phasesDir);
+		const dirs = await listSubDirs(phasesDir);
 		for (const dir of dirs) {
 			const dm = dir.match(/^(\d+[A-Z]?(?:\.\d+)?)/i);
 			if (dm) diskPhases.add(dm[1]);
@@ -14344,7 +14213,7 @@ function cmdValidateConsistency(cwd) {
 	const integerPhases = [...diskPhases].filter((p) => !p.includes(".")).map((p) => parseInt(p, 10)).sort((a, b) => a - b);
 	for (let i = 1; i < integerPhases.length; i++) if (integerPhases[i] !== integerPhases[i - 1] + 1) warnings.push(`Gap in phase numbering: ${integerPhases[i - 1]} → ${integerPhases[i]}`);
 	try {
-		const dirs = listSubDirs(phasesDir, true);
+		const dirs = await listSubDirs(phasesDir, true);
 		for (const dir of dirs) {
 			const phaseFiles = node_fs.default.readdirSync(node_path.default.join(phasesDir, dir));
 			const plans = phaseFiles.filter((f) => isPlanFile(f)).sort();
@@ -14362,7 +14231,7 @@ function cmdValidateConsistency(cwd) {
 		debugLog(e);
 	}
 	try {
-		const dirs = listSubDirs(phasesDir);
+		const dirs = await listSubDirs(phasesDir);
 		for (const dir of dirs) {
 			const plans = node_fs.default.readdirSync(node_path.default.join(phasesDir, dir)).filter((f) => isPlanFile(f));
 			for (const plan of plans) if (!extractFrontmatter(node_fs.default.readFileSync(node_path.default.join(phasesDir, dir, plan), "utf-8")).wave) warnings.push(`${dir}/${plan}: missing 'wave' in frontmatter`);
@@ -14378,7 +14247,7 @@ function cmdValidateConsistency(cwd) {
 		warning_count: warnings.length
 	}, passed ? "passed" : "failed");
 }
-function cmdValidateHealth(cwd, options) {
+async function cmdValidateHealth(cwd, options) {
 	const planningDir = planningPath(cwd);
 	const projectPath = planningPath(cwd, "PROJECT.md");
 	const rmPath = roadmapPath(cwd);
@@ -14427,7 +14296,7 @@ function cmdValidateHealth(cwd, options) {
 		const phaseRefs = [...node_fs.default.readFileSync(stPath, "utf-8").matchAll(/[Pp]hase\s+(\d+(?:\.\d+)?)/g)].map((m) => m[1]);
 		const diskPhases = /* @__PURE__ */ new Set();
 		try {
-			for (const dir of listSubDirs(phasesDir)) {
+			for (const dir of await listSubDirs(phasesDir)) {
 				const dm = dir.match(/^(\d+(?:\.\d+)?)/);
 				if (dm) diskPhases.add(dm[1]);
 			}
@@ -14462,12 +14331,12 @@ function cmdValidateHealth(cwd, options) {
 		repairs.push("resetConfig");
 	}
 	try {
-		for (const dirName of listSubDirs(phasesDir)) if (!dirName.match(/^\d{2}(?:\.\d+)?-[\w-]+$/)) addIssue("warning", "W005", `Phase directory "${dirName}" doesn't follow NN-name format`, "Rename to match pattern (e.g., 01-setup)");
+		for (const dirName of await listSubDirs(phasesDir)) if (!dirName.match(/^\d{2}(?:\.\d+)?-[\w-]+$/)) addIssue("warning", "W005", `Phase directory "${dirName}" doesn't follow NN-name format`, "Rename to match pattern (e.g., 01-setup)");
 	} catch (e) {
 		debugLog(e);
 	}
 	try {
-		const orphanDirs = listSubDirs(phasesDir);
+		const orphanDirs = await listSubDirs(phasesDir);
 		for (const dirName of orphanDirs) {
 			const phaseFiles = node_fs.default.readdirSync(node_path.default.join(phasesDir, dirName));
 			const plans = phaseFiles.filter((f) => isPlanFile(f));
@@ -14489,7 +14358,7 @@ function cmdValidateHealth(cwd, options) {
 		while ((m = phasePattern.exec(roadmapContent)) !== null) roadmapPhases.add(m[1]);
 		const diskPhases = /* @__PURE__ */ new Set();
 		try {
-			for (const dir of listSubDirs(phasesDir)) {
+			for (const dir of await listSubDirs(phasesDir)) {
 				const dm = dir.match(/^(\d+[A-Z]?(?:\.\d+)?)/i);
 				if (dm) diskPhases.add(dm[1]);
 			}
@@ -14536,7 +14405,7 @@ function cmdValidateHealth(cwd, options) {
 						path: backupPath
 					});
 				}
-				const milestone = getMilestoneInfo(cwd);
+				const milestone = await getMilestoneInfo(cwd);
 				let stateContent = `# Session State\n\n`;
 				stateContent += `## Project Reference\n\n`;
 				stateContent += `See: .planning/PROJECT.md\n\n`;
@@ -14590,8 +14459,8 @@ const DRIFT_REPORT_NAME = "DRIFT-REPORT.md";
 * Read the drift report from .planning/DRIFT-REPORT.md.
 * Returns parsed frontmatter and body content, or structured error if not found.
 */
-function cmdDriftReadReport(cwd) {
-	const content = safeReadFile(planningPath(cwd, DRIFT_REPORT_NAME));
+async function cmdDriftReadReport(cwd) {
+	const content = await safeReadFile(planningPath(cwd, DRIFT_REPORT_NAME));
 	if (!content) return cmdOk({
 		found: false,
 		path: `.planning/${DRIFT_REPORT_NAME}`,
@@ -14611,10 +14480,10 @@ function cmdDriftReadReport(cwd) {
 * Write content to .planning/DRIFT-REPORT.md.
 * Supports direct content or reading from a file (tmpfile pattern for large reports).
 */
-function cmdDriftWriteReport(cwd, content, contentFile) {
+async function cmdDriftWriteReport(cwd, content, contentFile) {
 	let reportContent;
 	if (contentFile) {
-		const fileContent = safeReadFile(node_path.default.isAbsolute(contentFile) ? contentFile : node_path.default.join(cwd, contentFile));
+		const fileContent = await safeReadFile(node_path.default.isAbsolute(contentFile) ? contentFile : node_path.default.join(cwd, contentFile));
 		if (!fileContent) return cmdErr(`Content file not found: ${contentFile}`);
 		reportContent = fileContent;
 	} else if (content) reportContent = content;
@@ -14637,8 +14506,8 @@ function cmdDriftWriteReport(cwd, content, contentFile) {
 * Extract all requirements from .planning/REQUIREMENTS.md.
 * Parses requirement lines matching `- [ ] **ID**: description` or `- [x] **ID**: description`.
 */
-function cmdDriftExtractRequirements(cwd) {
-	const content = safeReadFile(planningPath(cwd, "REQUIREMENTS.md"));
+async function cmdDriftExtractRequirements(cwd) {
+	const content = await safeReadFile(planningPath(cwd, "REQUIREMENTS.md"));
 	if (!content) return cmdOk({
 		found: false,
 		path: ".planning/REQUIREMENTS.md",
@@ -14666,8 +14535,8 @@ function cmdDriftExtractRequirements(cwd) {
 * Extract no-go rules from .planning/NO-GOS.md.
 * Returns array of no-go items with section context, or empty if file missing.
 */
-function cmdDriftExtractNoGos(cwd) {
-	const content = safeReadFile(planningPath(cwd, "NO-GOS.md"));
+async function cmdDriftExtractNoGos(cwd) {
+	const content = await safeReadFile(planningPath(cwd, "NO-GOS.md"));
 	if (!content) return cmdOk({
 		found: false,
 		path: ".planning/NO-GOS.md",
@@ -14704,8 +14573,8 @@ function cmdDriftExtractNoGos(cwd) {
 * Read .planning/CONVENTIONS.md and return its full content.
 * Returns the raw content for agent analysis, or null if missing.
 */
-function cmdDriftExtractConventions(cwd) {
-	const content = safeReadFile(planningPath(cwd, "CONVENTIONS.md"));
+async function cmdDriftExtractConventions(cwd) {
+	const content = await safeReadFile(planningPath(cwd, "CONVENTIONS.md"));
 	if (!content) return cmdOk({
 		found: false,
 		path: ".planning/CONVENTIONS.md",
@@ -14721,8 +14590,8 @@ function cmdDriftExtractConventions(cwd) {
 * Read existing DRIFT-REPORT.md frontmatter for diff tracking.
 * Returns previous_hash and checked date, or null if no report exists.
 */
-function cmdDriftPreviousHash(cwd) {
-	const content = safeReadFile(planningPath(cwd, DRIFT_REPORT_NAME));
+async function cmdDriftPreviousHash(cwd) {
+	const content = await safeReadFile(planningPath(cwd, DRIFT_REPORT_NAME));
 	if (!content) return cmdOk({
 		found: false,
 		hash: null,
@@ -14799,7 +14668,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);
@@ -14838,12 +14707,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");
@@ -14857,7 +14726,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);
@@ -14877,7 +14746,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) {
@@ -14892,7 +14761,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}`);
@@ -14921,7 +14790,7 @@ async function phaseCompleteCore(cwd, phaseNum) {
 async function cmdPhasesList(cwd, options) {
 	const phasesDirPath = phasesPath(cwd);
 	const { type, phase, includeArchived, offset, limit } = options;
-	if (!await pathExistsAsync(phasesDirPath)) if (type) return cmdOk({
+	if (!await pathExistsInternal(phasesDirPath)) if (type) return cmdOk({
 		files: [],
 		count: 0,
 		total: 0
@@ -14932,9 +14801,9 @@ async function cmdPhasesList(cwd, options) {
 		total: 0
 	}, "");
 	try {
-		let dirs = await listSubDirsAsync(phasesDirPath);
+		let dirs = await listSubDirs(phasesDirPath);
 		if (includeArchived) {
-			const archived = await getArchivedPhaseDirsAsync(cwd);
+			const archived = await getArchivedPhaseDirs(cwd);
 			for (const a of archived) dirs.push(`${a.name} [${a.milestone}]`);
 		}
 		dirs.sort((a, b) => comparePhaseNum(a, b));
@@ -14982,14 +14851,14 @@ async function cmdPhasesList(cwd, options) {
 async function cmdPhaseNextDecimal(cwd, basePhase) {
 	const phasesDirPath = phasesPath(cwd);
 	const normalized = normalizePhaseName(basePhase);
-	if (!await pathExistsAsync(phasesDirPath)) return cmdOk({
+	if (!await pathExistsInternal(phasesDirPath)) return cmdOk({
 		found: false,
 		base_phase: normalized,
 		next: `${normalized}.1`,
 		existing: []
 	}, `${normalized}.1`);
 	try {
-		const dirs = await listSubDirsAsync(phasesDirPath);
+		const dirs = await listSubDirs(phasesDirPath);
 		const baseExists = dirs.some((d) => d.startsWith(normalized + "-") || d === normalized);
 		const decimalPattern = new RegExp(`^${normalized}\\.(\\d+)`);
 		const existingDecimals = [];
@@ -15029,7 +14898,7 @@ async function cmdFindPhase(cwd, phase) {
 		summaries: []
 	};
 	try {
-		const match = (await listSubDirsAsync(phasesDirPath, true)).find((d) => d.startsWith(normalized));
+		const match = (await listSubDirs(phasesDirPath, true)).find((d) => d.startsWith(normalized));
 		if (!match) return cmdOk(notFound, "");
 		const dirMatch = match.match(/^(\d+[A-Z]?(?:\.\d+)?)-?(.*)/i);
 		const phaseNumber = dirMatch ? dirMatch[1] : normalized;
@@ -15057,7 +14926,7 @@ async function cmdPhasePlanIndex(cwd, phase) {
 	const normalized = normalizePhaseName(phase);
 	let phaseDir = null;
 	try {
-		const match = (await listSubDirsAsync(phasesDirPath, true)).find((d) => d.startsWith(normalized));
+		const match = (await listSubDirs(phasesDirPath, true)).find((d) => d.startsWith(normalized));
 		if (match) phaseDir = node_path.default.join(phasesDirPath, match);
 	} catch (e) {
 		debugLog("phase-plan-index-failed", e);
@@ -15150,12 +15019,12 @@ async function cmdPhaseRemove(cwd, targetPhase, options) {
 	const rmPath = roadmapPath(cwd);
 	const phasesDirPath = phasesPath(cwd);
 	const force = options.force || false;
-	if (!await pathExistsAsync(rmPath)) return cmdErr("ROADMAP.md not found");
+	if (!await pathExistsInternal(rmPath)) return cmdErr("ROADMAP.md not found");
 	const normalized = normalizePhaseName(targetPhase);
 	const isDecimal = targetPhase.includes(".");
 	let targetDir = null;
 	try {
-		targetDir = (await listSubDirsAsync(phasesDirPath, true)).find((d) => d.startsWith(normalized + "-") || d === normalized) || null;
+		targetDir = (await listSubDirs(phasesDirPath, true)).find((d) => d.startsWith(normalized + "-") || d === normalized) || null;
 	} catch (e) {
 		debugLog("phase-remove-find-target-failed", e);
 	}
@@ -15175,7 +15044,7 @@ async function cmdPhaseRemove(cwd, targetPhase, options) {
 		const baseInt = baseParts[0];
 		const removedDecimal = parseInt(baseParts[1], 10);
 		try {
-			const dirs = await listSubDirsAsync(phasesDirPath, true);
+			const dirs = await listSubDirs(phasesDirPath, true);
 			const decPattern = new RegExp(`^${baseInt}\\.(\\d+)-(.+)$`);
 			const toRename = [];
 			for (const dir of dirs) {
@@ -15216,7 +15085,7 @@ async function cmdPhaseRemove(cwd, targetPhase, options) {
 	} else {
 		const removedInt = parseInt(normalized, 10);
 		try {
-			const dirs = await listSubDirsAsync(phasesDirPath, true);
+			const dirs = await listSubDirs(phasesDirPath, true);
 			const toRename = [];
 			for (const dir of dirs) {
 				const dm = dir.match(/^(\d+)([A-Z])?(?:\.(\d+))?-(.+)$/i);
@@ -15290,7 +15159,7 @@ async function cmdPhaseRemove(cwd, targetPhase, options) {
 	}
 	await node_fs.promises.writeFile(rmPath, roadmapContent, "utf-8");
 	const stPath = statePath(cwd);
-	const stExists = await pathExistsAsync(stPath);
+	const stExists = await pathExistsInternal(stPath);
 	if (stExists) {
 		let stateContent = await node_fs.promises.readFile(stPath, "utf-8");
 		const totalPattern = /(\*\*Total Phases:\*\*\s*)(\d+)/;
@@ -15348,15 +15217,15 @@ function findPhaseTaggedLines(content, sectionPattern, phaseNum) {
 const DECISIONS_SECTION_PATTERN = /(#{2,3}\s*(?:Decisions|Decisions Made|Accumulated.*Decisions)\s*\n)([\s\S]*?)(?=\n#{2,3}\s|\n##[^#]|$)/i;
 const BLOCKERS_SECTION_PATTERN = /(#{2,3}\s*(?:Blockers|Blockers\/Concerns|Concerns)\s*\n\s*\n?)([\s\S]*?)(?=\n#{2,3}\s|$)/i;
 async function archivePhasePreview(cwd, phaseNum, outcomeSummary) {
-	const phaseInfo = await findPhaseInternalAsync(cwd, phaseNum);
+	const phaseInfo = await findPhaseInternal(cwd, phaseNum);
 	if (!phaseInfo) return cmdErr(`Phase ${phaseNum} not found`);
-	const archiveDir = await archivePathAsync(cwd);
+	const archiveDir = await archivePath(cwd);
 	const phaseDirName = node_path.default.basename(phaseInfo.directory);
 	const archiveDest = node_path.default.join(archiveDir, phaseDirName);
-	const stContent = await safeReadFileAsync(statePath(cwd)) ?? "";
+	const stContent = await safeReadFile(statePath(cwd)) ?? "";
 	const decisionsToRemove = findPhaseTaggedLines(stContent, DECISIONS_SECTION_PATTERN, phaseNum);
 	const blockersToRemove = findPhaseTaggedLines(stContent, BLOCKERS_SECTION_PATTERN, phaseNum);
-	const rmContent = await safeReadFileAsync(roadmapPath(cwd)) ?? "";
+	const rmContent = await safeReadFile(roadmapPath(cwd)) ?? "";
 	const escaped = escapePhaseNum(phaseNum);
 	const sectionPattern = new RegExp(`#{2,4}\\s*Phase\\s+${escaped}\\s*:[\\s\\S]*?(?=\\n#{2,4}\\s+Phase\\s+\\d|\\n## |$)`, "i");
 	const sectionMatch = rmContent.match(sectionPattern);
@@ -15384,9 +15253,9 @@ function pruneSection(content, sectionPattern, phaseNum) {
 	return content.replace(sectionPattern, (_m, header) => `${header}${newBody}`);
 }
 async function archivePhaseExecute(cwd, phaseNum, outcomeSummary) {
-	const phaseInfo = await findPhaseInternalAsync(cwd, phaseNum);
+	const phaseInfo = await findPhaseInternal(cwd, phaseNum);
 	if (!phaseInfo) return cmdErr(`Phase ${phaseNum} not found`);
-	const archiveDir = await archivePathAsync(cwd);
+	const archiveDir = await archivePath(cwd);
 	const phaseDirName = node_path.default.basename(phaseInfo.directory);
 	const archiveDest = node_path.default.join(archiveDir, phaseDirName);
 	const phaseDirFull = node_path.default.join(cwd, phaseInfo.directory);
@@ -15404,14 +15273,14 @@ async function archivePhaseExecute(cwd, phaseNum, outcomeSummary) {
 		} else throw e;
 	}
 	const stPath = statePath(cwd);
-	let stContent = await safeReadFileAsync(stPath);
+	let stContent = await safeReadFile(stPath);
 	if (stContent) {
 		stContent = pruneSection(stContent, DECISIONS_SECTION_PATTERN, phaseNum);
 		stContent = pruneSection(stContent, BLOCKERS_SECTION_PATTERN, phaseNum);
 		await node_fs.promises.writeFile(stPath, stContent, "utf-8");
 	}
 	const rmPath = roadmapPath(cwd);
-	let rmContent = await safeReadFileAsync(rmPath);
+	let rmContent = await safeReadFile(rmPath);
 	if (rmContent) {
 		const escaped = escapePhaseNum(phaseNum);
 		const sectionPattern = new RegExp(`\\n?#{2,4}\\s*Phase\\s+${escaped}\\s*:[\\s\\S]*?(?=\\n#{2,4}\\s+Phase\\s+\\d|\\n## |$)`, "i");
@@ -15436,7 +15305,7 @@ async function archivePhaseExecute(cwd, phaseNum, outcomeSummary) {
 		archived: true,
 		phase: phaseNum,
 		archive_path: node_path.default.relative(cwd, archiveDest).replace(/\\/g, "/"),
-		decisions_pruned: findPhaseTaggedLines(await safeReadFileAsync(statePath(cwd)) ?? "", DECISIONS_SECTION_PATTERN, phaseNum).length === 0,
+		decisions_pruned: findPhaseTaggedLines(await safeReadFile(statePath(cwd)) ?? "", DECISIONS_SECTION_PATTERN, phaseNum).length === 0,
 		blockers_pruned: true,
 		roadmap_collapsed: true
 	});
@@ -15447,7 +15316,7 @@ async function cmdGetArchivedPhase(cwd, phaseNum) {
 	const found = await searchArchiveLocations(planningPath(cwd, "archive"), normalized);
 	if (found) return cmdOk(found);
 	const milestonesDir = planningPath(cwd, "milestones");
-	if (await pathExistsAsync(milestonesDir)) try {
+	if (await pathExistsInternal(milestonesDir)) try {
 		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 result = await searchForPhaseInDir(node_path.default.join(milestonesDir, archiveName), normalized, archiveName);
@@ -15459,7 +15328,7 @@ async function cmdGetArchivedPhase(cwd, phaseNum) {
 	return cmdErr(`Phase ${phaseNum} not found in archive`);
 }
 async function searchArchiveLocations(archiveDir, normalized) {
-	if (!await pathExistsAsync(archiveDir)) return null;
+	if (!await pathExistsInternal(archiveDir)) return null;
 	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) {
@@ -15473,7 +15342,7 @@ async function searchArchiveLocations(archiveDir, normalized) {
 }
 async function searchForPhaseInDir(baseDir, normalized, milestone) {
 	try {
-		const match = (await listSubDirsAsync(baseDir, true)).find((d) => d.startsWith(normalized));
+		const match = (await listSubDirs(baseDir, true)).find((d) => d.startsWith(normalized));
 		if (!match) return null;
 		const phaseDir = node_path.default.join(baseDir, match);
 		const mdFiles = (await node_fs.promises.readdir(phaseDir)).filter((f) => f.endsWith(".md"));
@@ -15535,10 +15404,10 @@ function cmdTemplateSelect(cwd, planPath) {
 		}, "templates/summary-standard.md");
 	}
 }
-function cmdTemplateFill(cwd, templateType, options) {
+async function cmdTemplateFill(cwd, templateType, options) {
 	if (!templateType) return cmdErr("template type required: summary, plan, or verification");
 	if (!options.phase) return cmdErr("--phase required");
-	const phaseInfo = findPhaseInternal(cwd, options.phase);
+	const phaseInfo = await findPhaseInternal(cwd, options.phase);
 	if (!phaseInfo) return cmdOk({
 		error: "Phase not found",
 		phase: options.phase
@@ -15721,10 +15590,10 @@ const ARTEFAKT_FILES = {
 function isValidType(type) {
 	return !!type && type in ARTEFAKT_FILES;
 }
-function resolveArtefaktPath(cwd, type, phase) {
+async function resolveArtefaktPath(cwd, type, phase) {
 	const filename = ARTEFAKT_FILES[type];
 	if (phase) {
-		const phaseInfo = findPhaseInternal(cwd, phase);
+		const phaseInfo = await findPhaseInternal(cwd, phase);
 		if (!phaseInfo?.directory) return null;
 		return node_path.default.join(cwd, phaseInfo.directory, filename);
 	}
@@ -15735,8 +15604,8 @@ const TEMPLATE_FILES = {
 	"acceptance-criteria": "acceptance-criteria.md",
 	"no-gos": "no-gos.md"
 };
-function getTemplate(type) {
-	const content = safeReadFile(node_path.default.join(node_os.default.homedir(), ".claude", "maxsim", "templates", TEMPLATE_FILES[type]));
+async function getTemplate(type) {
+	const content = await safeReadFile(node_path.default.join(node_os.default.homedir(), ".claude", "maxsim", "templates", TEMPLATE_FILES[type]));
 	if (content) return content.replace(/\{\{date\}\}/g, todayISO());
 	return getHardcodedTemplate(type);
 }
@@ -15748,11 +15617,11 @@ function getHardcodedTemplate(type) {
 		case "no-gos": return `# No-Gos\n\n> Things explicitly out of scope or forbidden.\n\n**Created:** ${today}\n\n## Boundaries\n\n- _No entries yet._\n`;
 	}
 }
-function cmdArtefakteRead(cwd, type, phase, raw) {
+async function cmdArtefakteRead(cwd, type, phase, raw) {
 	if (!isValidType(type)) return cmdErr(`Invalid artefakt type: ${type}. Available: ${Object.keys(ARTEFAKT_FILES).join(", ")}`);
-	const filePath = resolveArtefaktPath(cwd, type, phase);
+	const filePath = await resolveArtefaktPath(cwd, type, phase);
 	if (!filePath) return cmdErr(`Phase ${phase} not found`);
-	const content = safeReadFile(filePath);
+	const content = await safeReadFile(filePath);
 	if (content === null) return cmdOk({
 		exists: false,
 		type,
@@ -15766,10 +15635,10 @@ function cmdArtefakteRead(cwd, type, phase, raw) {
 		content
 	}, raw ? content : void 0);
 }
-function cmdArtefakteWrite(cwd, type, content, phase, raw) {
+async function cmdArtefakteWrite(cwd, type, content, phase, raw) {
 	if (!isValidType(type)) return cmdErr(`Invalid artefakt type: ${type}. Available: ${Object.keys(ARTEFAKT_FILES).join(", ")}`);
-	const fileContent = content ?? getTemplate(type);
-	const filePath = resolveArtefaktPath(cwd, type, phase);
+	const fileContent = content ?? await getTemplate(type);
+	const filePath = await resolveArtefaktPath(cwd, type, phase);
 	if (!filePath) return cmdErr(`Phase ${phase} not found`);
 	node_fs.default.mkdirSync(node_path.default.dirname(filePath), { recursive: true });
 	node_fs.default.writeFileSync(filePath, fileContent, "utf-8");
@@ -15781,13 +15650,13 @@ function cmdArtefakteWrite(cwd, type, content, phase, raw) {
 		path: relPath
 	}, raw ? relPath : void 0);
 }
-function cmdArtefakteAppend(cwd, type, entry, phase, raw) {
+async function cmdArtefakteAppend(cwd, type, entry, phase, raw) {
 	if (!entry) return cmdErr("entry required for artefakte append");
 	if (!isValidType(type)) return cmdErr(`Invalid artefakt type: ${type}. Available: ${Object.keys(ARTEFAKT_FILES).join(", ")}`);
-	const filePath = resolveArtefaktPath(cwd, type, phase);
+	const filePath = await resolveArtefaktPath(cwd, type, phase);
 	if (!filePath) return cmdErr(`Phase ${phase} not found`);
-	let fileContent = safeReadFile(filePath);
-	if (fileContent === null) fileContent = getTemplate(type);
+	let fileContent = await safeReadFile(filePath);
+	if (fileContent === null) fileContent = await getTemplate(type);
 	fileContent = fileContent.replace(/^-\s*_No entries yet\._\s*$/m, "");
 	const today = todayISO();
 	let appendLine;
@@ -15805,12 +15674,12 @@ function cmdArtefakteAppend(cwd, type, entry, phase, raw) {
 		path: relPath
 	}, raw ? "true" : void 0);
 }
-function cmdArtefakteList(cwd, phase, raw) {
+async function cmdArtefakteList(cwd, phase, raw) {
 	const results = [];
 	for (const [type, filename] of Object.entries(ARTEFAKT_FILES)) {
 		let filePath;
 		if (phase) {
-			const phaseInfo = findPhaseInternal(cwd, phase);
+			const phaseInfo = await findPhaseInternal(cwd, phase);
 			if (!phaseInfo?.directory) return cmdOk({ error: `Phase ${phase} not found` });
 			filePath = node_path.default.join(cwd, phaseInfo.directory, filename);
 		} else filePath = planningPath(cwd, filename);
@@ -15893,9 +15762,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 {
@@ -15913,7 +15782,7 @@ function loadPhaseContext(cwd, phase) {
 	}
 	return files;
 }
-function loadArtefakteContext(cwd, phase) {
+async function loadArtefakteContext(cwd, phase) {
 	const files = [];
 	for (const filename of [
 		"DECISIONS.md",
@@ -15921,7 +15790,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()}`);
@@ -15938,11 +15807,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;
@@ -15956,15 +15825,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;
@@ -16005,8 +15874,8 @@ function skillsTemplateDir() {
 /**
 * Read a single skill's metadata from its SKILL.md frontmatter.
 */
-function readSkillInfo(skillDir, dirName) {
-	const content = safeReadFile(node_path.default.join(skillDir, "SKILL.md"));
+async function readSkillInfo(skillDir, dirName) {
+	const content = await safeReadFile(node_path.default.join(skillDir, "SKILL.md"));
 	if (!content) return null;
 	const fm = extractFrontmatter(content);
 	return {
@@ -16018,7 +15887,7 @@ function readSkillInfo(skillDir, dirName) {
 /**
 * List all installed skills from `.claude/skills/`.
 */
-function cmdSkillList(cwd) {
+async function cmdSkillList(cwd) {
 	const dir = skillsDir(cwd);
 	if (!node_fs.default.existsSync(dir)) return cmdOk({
 		skills: [],
@@ -16028,7 +15897,7 @@ function cmdSkillList(cwd) {
 	const skills = [];
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
-		const info = readSkillInfo(node_path.default.join(dir, entry.name), entry.name);
+		const info = await readSkillInfo(node_path.default.join(dir, entry.name), entry.name);
 		if (info) skills.push(info);
 	}
 	return cmdOk({
@@ -16104,268 +15973,6 @@ function listAvailableTemplates() {
 	return node_fs.default.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
 }
 
-//#endregion
-//#region src/core/dashboard-launcher.ts
-/**
-* Dashboard Launcher — Shared dashboard lifecycle utilities
-*
-* Used by both cli.ts (tool-router) and install.ts (npx entry point).
-*/
-const DEFAULT_PORT = 3333;
-const PORT_RANGE_END = 3343;
-const HEALTH_TIMEOUT_MS = 1e4;
-/**
-* Check if a dashboard health endpoint is responding on the given port.
-*/
-async function checkHealth(port, timeoutMs = HEALTH_TIMEOUT_MS) {
-	try {
-		const controller = new AbortController();
-		const timer = setTimeout(() => controller.abort(), timeoutMs);
-		const res = await fetch(`http://localhost:${port}/api/health`, { signal: controller.signal });
-		clearTimeout(timer);
-		if (res.ok) return (await res.json()).status === "ok";
-		return false;
-	} catch (e) {
-		debugLog("health-check-failed", {
-			port,
-			error: errorMsg(e)
-		});
-		return false;
-	}
-}
-/**
-* Scan the port range for a running dashboard instance.
-* Returns the port number if found, null otherwise.
-*/
-async function findRunningDashboard(timeoutMs = HEALTH_TIMEOUT_MS) {
-	for (let port = DEFAULT_PORT; port <= PORT_RANGE_END; port++) if (await checkHealth(port, timeoutMs)) return port;
-	return null;
-}
-/**
-* Kill processes listening on the given port. Cross-platform.
-*/
-function killProcessOnPort(port) {
-	if (process.platform === "win32") try {
-		const lines = (0, node_child_process.execSync)(`netstat -ano | findstr :${port} | findstr LISTENING`, { encoding: "utf-8" }).trim().split("\n");
-		const pids = /* @__PURE__ */ new Set();
-		for (const line of lines) {
-			const parts = line.trim().split(/\s+/);
-			const pid = parts[parts.length - 1];
-			if (pid && pid !== "0") pids.add(pid);
-		}
-		for (const pid of pids) try {
-			(0, node_child_process.execSync)(`taskkill /PID ${pid} /F`, { stdio: "ignore" });
-		} catch (e) {
-			debugLog("kill-process-on-port-taskkill-failed", {
-				port,
-				pid,
-				error: errorMsg(e)
-			});
-		}
-	} catch (e) {
-		debugLog("kill-process-on-port-netstat-failed", {
-			port,
-			platform: "win32",
-			error: errorMsg(e)
-		});
-	}
-	else try {
-		(0, node_child_process.execSync)(`lsof -i :${port} -t | xargs kill -SIGTERM 2>/dev/null`, { stdio: "ignore" });
-	} catch (e) {
-		debugLog("kill-process-on-port-lsof-failed", {
-			port,
-			platform: process.platform,
-			error: errorMsg(e)
-		});
-	}
-}
-/**
-* Resolve the dashboard server entry point path.
-* Tries: local project install, global install, @maxsim/dashboard package, monorepo walk.
-*/
-function resolveDashboardServer() {
-	const localDashboard = node_path.default.join(process.cwd(), ".claude", "dashboard", "server.js");
-	if (node_fs.default.existsSync(localDashboard)) return localDashboard;
-	const globalDashboard = node_path.default.join(node_os.default.homedir(), ".claude", "dashboard", "server.js");
-	if (node_fs.default.existsSync(globalDashboard)) return globalDashboard;
-	try {
-		const pkgPath = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href).resolve("@maxsim/dashboard/package.json");
-		const pkgDir = node_path.default.dirname(pkgPath);
-		const serverJs = node_path.default.join(pkgDir, "server.js");
-		if (node_fs.default.existsSync(serverJs)) return serverJs;
-		const serverTs = node_path.default.join(pkgDir, "server.ts");
-		if (node_fs.default.existsSync(serverTs)) return serverTs;
-	} catch (e) {
-		debugLog("resolve-dashboard-strategy1-failed", {
-			strategy: "@maxsim/dashboard package",
-			error: errorMsg(e)
-		});
-	}
-	try {
-		let dir = node_path.default.dirname(new URL(require("url").pathToFileURL(__filename).href).pathname);
-		if (process.platform === "win32" && dir.startsWith("/")) dir = dir.slice(1);
-		for (let i = 0; i < 5; i++) {
-			const candidate = node_path.default.join(dir, "packages", "dashboard", "server.ts");
-			if (node_fs.default.existsSync(candidate)) return candidate;
-			const candidateJs = node_path.default.join(dir, "packages", "dashboard", "server.js");
-			if (node_fs.default.existsSync(candidateJs)) return candidateJs;
-			dir = node_path.default.dirname(dir);
-		}
-	} catch (e) {
-		debugLog("resolve-dashboard-strategy2-failed", {
-			strategy: "monorepo walk",
-			error: errorMsg(e)
-		});
-	}
-	return null;
-}
-/**
-* Ensure node-pty is installed in the dashboard directory.
-* Returns true if node-pty is available after this call.
-*/
-function ensureNodePty(serverDir) {
-	const ptyModulePath = node_path.default.join(serverDir, "node_modules", "node-pty");
-	if (node_fs.default.existsSync(ptyModulePath)) return true;
-	const dashPkgPath = node_path.default.join(serverDir, "package.json");
-	if (!node_fs.default.existsSync(dashPkgPath)) node_fs.default.writeFileSync(dashPkgPath, "{\"private\":true}\n");
-	try {
-		(0, node_child_process.execSync)("npm install node-pty --save-optional --no-audit --no-fund --loglevel=error", {
-			cwd: serverDir,
-			stdio: "inherit",
-			timeout: 12e4
-		});
-		return true;
-	} catch (e) {
-		debugLog("ensure-node-pty-install-failed", {
-			serverDir,
-			error: errorMsg(e)
-		});
-		return false;
-	}
-}
-/**
-* Read dashboard.json config from the parent directory of the dashboard dir.
-*/
-function readDashboardConfig(serverPath) {
-	const dashboardDir = node_path.default.dirname(serverPath);
-	const dashboardConfigPath = node_path.default.join(node_path.default.dirname(dashboardDir), "dashboard.json");
-	let projectCwd = process.cwd();
-	let networkMode = false;
-	if (node_fs.default.existsSync(dashboardConfigPath)) try {
-		const config = JSON.parse(node_fs.default.readFileSync(dashboardConfigPath, "utf8"));
-		if (config.projectCwd) projectCwd = config.projectCwd;
-		networkMode = config.networkMode ?? false;
-	} catch (e) {
-		debugLog("read-dashboard-config-failed", {
-			path: dashboardConfigPath,
-			error: errorMsg(e)
-		});
-	}
-	return {
-		projectCwd,
-		networkMode
-	};
-}
-/**
-* Spawn the dashboard server as a detached background process.
-* Returns the child process PID, or null if spawn failed.
-*/
-function spawnDashboard(options) {
-	const { serverPath, projectCwd, networkMode = false, nodeEnv = "production" } = options;
-	const serverDir = node_path.default.dirname(serverPath);
-	const isTsFile = serverPath.endsWith(".ts");
-	const child = (0, node_child_process.spawn)("node", isTsFile ? [
-		"--import",
-		"tsx",
-		serverPath
-	] : [serverPath], {
-		cwd: serverDir,
-		detached: true,
-		stdio: "ignore",
-		env: {
-			...process.env,
-			MAXSIM_PROJECT_CWD: projectCwd,
-			MAXSIM_NETWORK_MODE: networkMode ? "1" : "0",
-			NODE_ENV: isTsFile ? "development" : nodeEnv
-		},
-		...process.platform === "win32" ? { shell: true } : {}
-	});
-	child.unref();
-	return child.pid ?? null;
-}
-/**
-* Poll the port range until a dashboard health endpoint responds.
-* Returns the URL if found within the timeout, null otherwise.
-*/
-async function waitForDashboard(pollIntervalMs = 500, pollTimeoutMs = 2e4, healthTimeoutMs = 1e3) {
-	const deadline = Date.now() + pollTimeoutMs;
-	while (Date.now() < deadline) {
-		await new Promise((r) => setTimeout(r, pollIntervalMs));
-		for (let p = DEFAULT_PORT; p <= PORT_RANGE_END; p++) if (await checkHealth(p, healthTimeoutMs)) return `http://localhost:${p}`;
-	}
-	return null;
-}
-
-//#endregion
-//#region src/core/start.ts
-/**
-* Start — Orchestrates Dashboard launch + browser open
-*
-* Provides a unified `maxsimcli start` entry point that:
-* 1. Checks for a running dashboard
-* 2. Starts the dashboard if needed
-* 3. Opens the browser
-* 4. Reports status
-*/
-function openBrowser(url) {
-	(0, node_child_process.exec)(process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`, (err) => {
-		if (err) debugLog("open-browser-failed", err);
-	});
-}
-async function cmdStart(cwd, options) {
-	const existingPort = await findRunningDashboard();
-	if (existingPort) {
-		const url = `http://localhost:${existingPort}`;
-		if (!options.noBrowser) openBrowser(url);
-		return cmdOk({
-			started: true,
-			url,
-			already_running: true,
-			port: existingPort
-		}, url);
-	}
-	const serverPath = resolveDashboardServer();
-	if (!serverPath) return cmdErr("Dashboard server not found. Run `npx maxsimcli` to install first.");
-	const serverDir = node_path.default.dirname(serverPath);
-	const dashConfig = readDashboardConfig(serverPath);
-	ensureNodePty(serverDir);
-	const pid = spawnDashboard({
-		serverPath,
-		projectCwd: dashConfig.projectCwd,
-		networkMode: options.networkMode
-	});
-	if (!pid) return cmdErr("Failed to spawn dashboard process.");
-	const url = await waitForDashboard();
-	if (url) {
-		if (!options.noBrowser) openBrowser(url);
-		return cmdOk({
-			started: true,
-			url,
-			already_running: false,
-			pid
-		}, url);
-	} else {
-		const fallbackUrl = `http://localhost:${DEFAULT_PORT}`;
-		return cmdOk({
-			started: true,
-			url: fallbackUrl,
-			already_running: false,
-			pid,
-			warning: "Dashboard spawned but health check timed out. It may still be starting."
-		}, fallbackUrl);
-	}
-}
-
 //#endregion
 //#region src/core/init.ts
 /**
@@ -16373,8 +15980,8 @@ async function cmdStart(cwd, options) {
 *
 * Ported from maxsim/bin/lib/init.cjs
 */
-function extractReqIds(cwd, phase) {
-	const reqMatch = getRoadmapPhaseInternal(cwd, phase)?.section?.match(/^\*\*Requirements\*\*:[^\S\n]*([^\n]*)$/m);
+async function extractReqIds(cwd, phase) {
+	const reqMatch = (await getRoadmapPhaseInternal(cwd, phase))?.section?.match(/^\*\*Requirements\*\*:[^\S\n]*([^\n]*)$/m);
 	const reqExtracted = reqMatch ? reqMatch[1].replace(/[\[\]]/g, "").split(",").map((s) => s.trim()).filter(Boolean).join(", ") : null;
 	return reqExtracted && reqExtracted !== "TBD" ? reqExtracted : null;
 }
@@ -16430,15 +16037,15 @@ function findCodeFiles(dir, maxDepth = 3, limit = 5) {
 	walk(dir, 1);
 	return results;
 }
-function cmdInitExecutePhase(cwd, phase) {
+async function cmdInitExecutePhase(cwd, phase) {
 	if (!phase) return cmdErr("phase required for init execute-phase");
-	const config = loadConfig(cwd);
-	const phaseInfo = findPhaseInternal(cwd, phase);
-	const milestone = getMilestoneInfo(cwd);
-	const phase_req_ids = extractReqIds(cwd, phase);
+	const config = await loadConfig(cwd);
+	const phaseInfo = await findPhaseInternal(cwd, phase);
+	const milestone = await getMilestoneInfo(cwd);
+	const phase_req_ids = await extractReqIds(cwd, phase);
 	return cmdOk({
-		executor_model: resolveModelInternal(cwd, "maxsim-executor"),
-		verifier_model: resolveModelInternal(cwd, "maxsim-verifier"),
+		executor_model: await resolveModelInternal(cwd, "maxsim-executor"),
+		verifier_model: await resolveModelInternal(cwd, "maxsim-verifier"),
 		commit_docs: config.commit_docs,
 		parallelization: config.parallelization,
 		branching_strategy: config.branching_strategy,
@@ -16460,23 +16067,23 @@ function cmdInitExecutePhase(cwd, phase) {
 		milestone_version: milestone.version,
 		milestone_name: milestone.name,
 		milestone_slug: generateSlugInternal(milestone.name),
-		state_exists: pathExistsInternal(cwd, ".planning/STATE.md"),
-		roadmap_exists: pathExistsInternal(cwd, ".planning/ROADMAP.md"),
-		config_exists: pathExistsInternal(cwd, ".planning/config.json"),
+		state_exists: await pathExistsInternal(planningPath(cwd, "STATE.md")),
+		roadmap_exists: await pathExistsInternal(planningPath(cwd, "ROADMAP.md")),
+		config_exists: await pathExistsInternal(planningPath(cwd, "config.json")),
 		state_path: ".planning/STATE.md",
 		roadmap_path: ".planning/ROADMAP.md",
 		config_path: ".planning/config.json"
 	});
 }
-function cmdInitPlanPhase(cwd, phase) {
+async function cmdInitPlanPhase(cwd, phase) {
 	if (!phase) return cmdErr("phase required for init plan-phase");
-	const config = loadConfig(cwd);
-	const phaseInfo = findPhaseInternal(cwd, phase);
-	const phase_req_ids = extractReqIds(cwd, phase);
+	const config = await loadConfig(cwd);
+	const phaseInfo = await findPhaseInternal(cwd, phase);
+	const phase_req_ids = await extractReqIds(cwd, phase);
 	const result = {
-		researcher_model: resolveModelInternal(cwd, "maxsim-phase-researcher"),
-		planner_model: resolveModelInternal(cwd, "maxsim-planner"),
-		checker_model: resolveModelInternal(cwd, "maxsim-plan-checker"),
+		researcher_model: await resolveModelInternal(cwd, "maxsim-phase-researcher"),
+		planner_model: await resolveModelInternal(cwd, "maxsim-planner"),
+		checker_model: await resolveModelInternal(cwd, "maxsim-plan-checker"),
 		research_enabled: config.research,
 		plan_checker_enabled: config.plan_checker,
 		commit_docs: config.commit_docs,
@@ -16491,13 +16098,13 @@ function cmdInitPlanPhase(cwd, phase) {
 		has_context: phaseInfo?.has_context ?? false,
 		has_plans: (phaseInfo?.plans?.length ?? 0) > 0,
 		plan_count: phaseInfo?.plans?.length ?? 0,
-		planning_exists: pathExistsInternal(cwd, ".planning"),
-		roadmap_exists: pathExistsInternal(cwd, ".planning/ROADMAP.md"),
+		planning_exists: await pathExistsInternal(planningPath(cwd)),
+		roadmap_exists: await pathExistsInternal(planningPath(cwd, "ROADMAP.md")),
 		state_path: ".planning/STATE.md",
 		roadmap_path: ".planning/ROADMAP.md",
 		requirements_path: ".planning/REQUIREMENTS.md"
 	};
-	if (pathExistsInternal(cwd, ".planning/CONVENTIONS.md")) result.conventions_path = ".planning/CONVENTIONS.md";
+	if (await pathExistsInternal(planningPath(cwd, "CONVENTIONS.md"))) result.conventions_path = ".planning/CONVENTIONS.md";
 	if (phaseInfo?.directory) {
 		const artifacts = scanPhaseArtifacts(cwd, phaseInfo.directory);
 		if (artifacts.context_path) result.context_path = artifacts.context_path;
@@ -16507,51 +16114,52 @@ function cmdInitPlanPhase(cwd, phase) {
 	}
 	return cmdOk(result);
 }
-function cmdInitNewProject(cwd) {
-	const config = loadConfig(cwd);
+async function cmdInitNewProject(cwd) {
+	const config = await loadConfig(cwd);
 	const homedir = node_os.default.homedir();
 	const braveKeyFile = node_path.default.join(homedir, ".maxsim", "brave_api_key");
 	const hasBraveSearch = !!(process.env.BRAVE_API_KEY || node_fs.default.existsSync(braveKeyFile));
 	const hasCode = findCodeFiles(cwd).length > 0;
-	const hasPackageFile = pathExistsInternal(cwd, "package.json") || pathExistsInternal(cwd, "requirements.txt") || pathExistsInternal(cwd, "Cargo.toml") || pathExistsInternal(cwd, "go.mod") || pathExistsInternal(cwd, "Package.swift");
+	const hasPackageFile = await pathExistsInternal(node_path.default.join(cwd, "package.json")) || await pathExistsInternal(node_path.default.join(cwd, "requirements.txt")) || await pathExistsInternal(node_path.default.join(cwd, "Cargo.toml")) || await pathExistsInternal(node_path.default.join(cwd, "go.mod")) || await pathExistsInternal(node_path.default.join(cwd, "Package.swift"));
+	const hasCodebaseMap = await pathExistsInternal(planningPath(cwd, "codebase"));
 	return cmdOk({
-		researcher_model: resolveModelInternal(cwd, "maxsim-project-researcher"),
-		synthesizer_model: resolveModelInternal(cwd, "maxsim-research-synthesizer"),
-		roadmapper_model: resolveModelInternal(cwd, "maxsim-roadmapper"),
+		researcher_model: await resolveModelInternal(cwd, "maxsim-project-researcher"),
+		synthesizer_model: await resolveModelInternal(cwd, "maxsim-research-synthesizer"),
+		roadmapper_model: await resolveModelInternal(cwd, "maxsim-roadmapper"),
 		commit_docs: config.commit_docs,
-		project_exists: pathExistsInternal(cwd, ".planning/PROJECT.md"),
-		has_codebase_map: pathExistsInternal(cwd, ".planning/codebase"),
-		planning_exists: pathExistsInternal(cwd, ".planning"),
+		project_exists: await pathExistsInternal(planningPath(cwd, "PROJECT.md")),
+		has_codebase_map: hasCodebaseMap,
+		planning_exists: await pathExistsInternal(planningPath(cwd)),
 		has_existing_code: hasCode,
 		has_package_file: hasPackageFile,
 		is_brownfield: hasCode || hasPackageFile,
-		needs_codebase_map: (hasCode || hasPackageFile) && !pathExistsInternal(cwd, ".planning/codebase"),
-		has_git: pathExistsInternal(cwd, ".git"),
+		needs_codebase_map: (hasCode || hasPackageFile) && !hasCodebaseMap,
+		has_git: await pathExistsInternal(node_path.default.join(cwd, ".git")),
 		brave_search_available: hasBraveSearch,
 		project_path: ".planning/PROJECT.md"
 	});
 }
-function cmdInitNewMilestone(cwd) {
-	const config = loadConfig(cwd);
-	const milestone = getMilestoneInfo(cwd);
+async function cmdInitNewMilestone(cwd) {
+	const config = await loadConfig(cwd);
+	const milestone = await getMilestoneInfo(cwd);
 	return cmdOk({
-		researcher_model: resolveModelInternal(cwd, "maxsim-project-researcher"),
-		synthesizer_model: resolveModelInternal(cwd, "maxsim-research-synthesizer"),
-		roadmapper_model: resolveModelInternal(cwd, "maxsim-roadmapper"),
+		researcher_model: await resolveModelInternal(cwd, "maxsim-project-researcher"),
+		synthesizer_model: await resolveModelInternal(cwd, "maxsim-research-synthesizer"),
+		roadmapper_model: await resolveModelInternal(cwd, "maxsim-roadmapper"),
 		commit_docs: config.commit_docs,
 		research_enabled: config.research,
 		current_milestone: milestone.version,
 		current_milestone_name: milestone.name,
-		project_exists: pathExistsInternal(cwd, ".planning/PROJECT.md"),
-		roadmap_exists: pathExistsInternal(cwd, ".planning/ROADMAP.md"),
-		state_exists: pathExistsInternal(cwd, ".planning/STATE.md"),
+		project_exists: await pathExistsInternal(planningPath(cwd, "PROJECT.md")),
+		roadmap_exists: await pathExistsInternal(planningPath(cwd, "ROADMAP.md")),
+		state_exists: await pathExistsInternal(planningPath(cwd, "STATE.md")),
 		project_path: ".planning/PROJECT.md",
 		roadmap_path: ".planning/ROADMAP.md",
 		state_path: ".planning/STATE.md"
 	});
 }
-function cmdInitQuick(cwd, description) {
-	const config = loadConfig(cwd);
+async function cmdInitQuick(cwd, description) {
+	const config = await loadConfig(cwd);
 	const now = /* @__PURE__ */ new Date();
 	const slug = description ? generateSlugInternal(description)?.substring(0, 40) ?? null : null;
 	const quickDir = planningPath(cwd, "quick");
@@ -16563,10 +16171,10 @@ function cmdInitQuick(cwd, description) {
 		debugLog(e);
 	}
 	return cmdOk({
-		planner_model: resolveModelInternal(cwd, "maxsim-planner"),
-		executor_model: resolveModelInternal(cwd, "maxsim-executor"),
-		checker_model: resolveModelInternal(cwd, "maxsim-plan-checker"),
-		verifier_model: resolveModelInternal(cwd, "maxsim-verifier"),
+		planner_model: await resolveModelInternal(cwd, "maxsim-planner"),
+		executor_model: await resolveModelInternal(cwd, "maxsim-executor"),
+		checker_model: await resolveModelInternal(cwd, "maxsim-plan-checker"),
+		verifier_model: await resolveModelInternal(cwd, "maxsim-verifier"),
 		commit_docs: config.commit_docs,
 		next_num: nextNum,
 		slug,
@@ -16575,12 +16183,12 @@ function cmdInitQuick(cwd, description) {
 		timestamp: now.toISOString(),
 		quick_dir: ".planning/quick",
 		task_dir: slug ? `.planning/quick/${nextNum}-${slug}` : null,
-		roadmap_exists: pathExistsInternal(cwd, ".planning/ROADMAP.md"),
-		planning_exists: pathExistsInternal(cwd, ".planning")
+		roadmap_exists: await pathExistsInternal(planningPath(cwd, "ROADMAP.md")),
+		planning_exists: await pathExistsInternal(planningPath(cwd))
 	});
 }
-function cmdInitResume(cwd) {
-	const config = loadConfig(cwd);
+async function cmdInitResume(cwd) {
+	const config = await loadConfig(cwd);
 	let interruptedAgentId = null;
 	try {
 		interruptedAgentId = node_fs.default.readFileSync(planningPath(cwd, "current-agent-id.txt"), "utf-8").trim();
@@ -16588,10 +16196,10 @@ function cmdInitResume(cwd) {
 		debugLog(e);
 	}
 	return cmdOk({
-		state_exists: pathExistsInternal(cwd, ".planning/STATE.md"),
-		roadmap_exists: pathExistsInternal(cwd, ".planning/ROADMAP.md"),
-		project_exists: pathExistsInternal(cwd, ".planning/PROJECT.md"),
-		planning_exists: pathExistsInternal(cwd, ".planning"),
+		state_exists: await pathExistsInternal(planningPath(cwd, "STATE.md")),
+		roadmap_exists: await pathExistsInternal(planningPath(cwd, "ROADMAP.md")),
+		project_exists: await pathExistsInternal(planningPath(cwd, "PROJECT.md")),
+		planning_exists: await pathExistsInternal(planningPath(cwd)),
 		state_path: ".planning/STATE.md",
 		roadmap_path: ".planning/ROADMAP.md",
 		project_path: ".planning/PROJECT.md",
@@ -16600,13 +16208,13 @@ function cmdInitResume(cwd) {
 		commit_docs: config.commit_docs
 	});
 }
-function cmdInitVerifyWork(cwd, phase) {
+async function cmdInitVerifyWork(cwd, phase) {
 	if (!phase) return cmdErr("phase required for init verify-work");
-	const config = loadConfig(cwd);
-	const phaseInfo = findPhaseInternal(cwd, phase);
+	const config = await loadConfig(cwd);
+	const phaseInfo = await findPhaseInternal(cwd, phase);
 	return cmdOk({
-		planner_model: resolveModelInternal(cwd, "maxsim-planner"),
-		checker_model: resolveModelInternal(cwd, "maxsim-plan-checker"),
+		planner_model: await resolveModelInternal(cwd, "maxsim-planner"),
+		checker_model: await resolveModelInternal(cwd, "maxsim-plan-checker"),
 		commit_docs: config.commit_docs,
 		phase_found: !!phaseInfo,
 		phase_dir: phaseInfo?.directory ?? null,
@@ -16615,11 +16223,11 @@ function cmdInitVerifyWork(cwd, phase) {
 		has_verification: phaseInfo?.has_verification ?? false
 	});
 }
-function cmdInitPhaseOp(cwd, phase) {
-	const config = loadConfig(cwd);
-	let phaseInfo = findPhaseInternal(cwd, phase ?? "");
+async function cmdInitPhaseOp(cwd, phase) {
+	const config = await loadConfig(cwd);
+	let phaseInfo = await findPhaseInternal(cwd, phase ?? "");
 	if (!phaseInfo) {
-		const roadmapPhase = getRoadmapPhaseInternal(cwd, phase ?? "");
+		const roadmapPhase = await getRoadmapPhaseInternal(cwd, phase ?? "");
 		if (roadmapPhase?.found) {
 			const phaseName = roadmapPhase.phase_name;
 			phaseInfo = {
@@ -16651,13 +16259,13 @@ function cmdInitPhaseOp(cwd, phase) {
 		has_plans: (phaseInfo?.plans?.length ?? 0) > 0,
 		has_verification: phaseInfo?.has_verification ?? false,
 		plan_count: phaseInfo?.plans?.length ?? 0,
-		roadmap_exists: pathExistsInternal(cwd, ".planning/ROADMAP.md"),
-		planning_exists: pathExistsInternal(cwd, ".planning"),
+		roadmap_exists: await pathExistsInternal(planningPath(cwd, "ROADMAP.md")),
+		planning_exists: await pathExistsInternal(planningPath(cwd)),
 		state_path: ".planning/STATE.md",
 		roadmap_path: ".planning/ROADMAP.md",
 		requirements_path: ".planning/REQUIREMENTS.md"
 	};
-	if (pathExistsInternal(cwd, ".planning/CONVENTIONS.md")) result.conventions_path = ".planning/CONVENTIONS.md";
+	if (await pathExistsInternal(planningPath(cwd, "CONVENTIONS.md"))) result.conventions_path = ".planning/CONVENTIONS.md";
 	if (phaseInfo?.directory) {
 		const artifacts = scanPhaseArtifacts(cwd, phaseInfo.directory);
 		if (artifacts.context_path) result.context_path = artifacts.context_path;
@@ -16667,8 +16275,8 @@ function cmdInitPhaseOp(cwd, phase) {
 	}
 	return cmdOk(result);
 }
-function cmdInitTodos(cwd, area) {
-	const config = loadConfig(cwd);
+async function cmdInitTodos(cwd, area) {
+	const config = await loadConfig(cwd);
 	const now = /* @__PURE__ */ new Date();
 	const pendingDir = planningPath(cwd, "todos", "pending");
 	let count = 0;
@@ -16705,19 +16313,19 @@ function cmdInitTodos(cwd, area) {
 		area_filter: area ?? null,
 		pending_dir: ".planning/todos/pending",
 		completed_dir: ".planning/todos/completed",
-		planning_exists: pathExistsInternal(cwd, ".planning"),
-		todos_dir_exists: pathExistsInternal(cwd, ".planning/todos"),
-		pending_dir_exists: pathExistsInternal(cwd, ".planning/todos/pending")
+		planning_exists: await pathExistsInternal(planningPath(cwd)),
+		todos_dir_exists: await pathExistsInternal(planningPath(cwd, "todos")),
+		pending_dir_exists: await pathExistsInternal(planningPath(cwd, "todos", "pending"))
 	});
 }
-function cmdInitMilestoneOp(cwd) {
-	const config = loadConfig(cwd);
-	const milestone = getMilestoneInfo(cwd);
+async function cmdInitMilestoneOp(cwd) {
+	const config = await loadConfig(cwd);
+	const milestone = await getMilestoneInfo(cwd);
 	let phaseCount = 0;
 	let completedPhases = 0;
 	const phasesDir = phasesPath(cwd);
 	try {
-		const dirs = listSubDirs(phasesDir);
+		const dirs = await listSubDirs(phasesDir);
 		phaseCount = dirs.length;
 		for (const dir of dirs) try {
 			if (node_fs.default.readdirSync(node_path.default.join(phasesDir, dir)).some((f) => isSummaryFile(f))) completedPhases++;
@@ -16730,7 +16338,7 @@ function cmdInitMilestoneOp(cwd) {
 	const archiveDir = planningPath(cwd, "archive");
 	let archivedMilestones = [];
 	try {
-		archivedMilestones = listSubDirs(archiveDir);
+		archivedMilestones = await listSubDirs(archiveDir);
 	} catch (e) {
 		debugLog(e);
 	}
@@ -16744,15 +16352,15 @@ function cmdInitMilestoneOp(cwd) {
 		all_phases_complete: phaseCount > 0 && phaseCount === completedPhases,
 		archived_milestones: archivedMilestones,
 		archive_count: archivedMilestones.length,
-		project_exists: pathExistsInternal(cwd, ".planning/PROJECT.md"),
-		roadmap_exists: pathExistsInternal(cwd, ".planning/ROADMAP.md"),
-		state_exists: pathExistsInternal(cwd, ".planning/STATE.md"),
-		archive_exists: pathExistsInternal(cwd, ".planning/archive"),
-		phases_dir_exists: pathExistsInternal(cwd, ".planning/phases")
+		project_exists: await pathExistsInternal(planningPath(cwd, "PROJECT.md")),
+		roadmap_exists: await pathExistsInternal(planningPath(cwd, "ROADMAP.md")),
+		state_exists: await pathExistsInternal(planningPath(cwd, "STATE.md")),
+		archive_exists: await pathExistsInternal(planningPath(cwd, "archive")),
+		phases_dir_exists: await pathExistsInternal(planningPath(cwd, "phases"))
 	});
 }
-function cmdInitMapCodebase(cwd) {
-	const config = loadConfig(cwd);
+async function cmdInitMapCodebase(cwd) {
+	const config = await loadConfig(cwd);
 	const codebaseDir = planningPath(cwd, "codebase");
 	let existingMaps = [];
 	try {
@@ -16761,24 +16369,24 @@ function cmdInitMapCodebase(cwd) {
 		debugLog(e);
 	}
 	return cmdOk({
-		mapper_model: resolveModelInternal(cwd, "maxsim-codebase-mapper"),
+		mapper_model: await resolveModelInternal(cwd, "maxsim-codebase-mapper"),
 		commit_docs: config.commit_docs,
 		search_gitignored: config.search_gitignored,
 		parallelization: config.parallelization,
 		codebase_dir: ".planning/codebase",
 		existing_maps: existingMaps,
 		has_maps: existingMaps.length > 0,
-		planning_exists: pathExistsInternal(cwd, ".planning"),
-		codebase_dir_exists: pathExistsInternal(cwd, ".planning/codebase")
+		planning_exists: await pathExistsInternal(planningPath(cwd)),
+		codebase_dir_exists: await pathExistsInternal(planningPath(cwd, "codebase"))
 	});
 }
-function cmdInitExisting(cwd) {
-	const config = loadConfig(cwd);
+async function cmdInitExisting(cwd) {
+	const config = await loadConfig(cwd);
 	const homedir = node_os.default.homedir();
 	const braveKeyFile = node_path.default.join(homedir, ".maxsim", "brave_api_key");
 	const hasBraveSearch = !!(process.env.BRAVE_API_KEY || node_fs.default.existsSync(braveKeyFile));
 	const hasCode = findCodeFiles(cwd).length > 0;
-	const hasPackageFile = pathExistsInternal(cwd, "package.json") || pathExistsInternal(cwd, "requirements.txt") || pathExistsInternal(cwd, "Cargo.toml") || pathExistsInternal(cwd, "go.mod") || pathExistsInternal(cwd, "Package.swift");
+	const hasPackageFile = await pathExistsInternal(node_path.default.join(cwd, "package.json")) || await pathExistsInternal(node_path.default.join(cwd, "requirements.txt")) || await pathExistsInternal(node_path.default.join(cwd, "Cargo.toml")) || await pathExistsInternal(node_path.default.join(cwd, "go.mod")) || await pathExistsInternal(node_path.default.join(cwd, "Package.swift"));
 	let planningFiles = [];
 	try {
 		const planDir = planningPath(cwd);
@@ -16787,19 +16395,19 @@ function cmdInitExisting(cwd) {
 		debugLog(e);
 	}
 	return cmdOk({
-		researcher_model: resolveModelInternal(cwd, "maxsim-project-researcher"),
-		synthesizer_model: resolveModelInternal(cwd, "maxsim-research-synthesizer"),
-		roadmapper_model: resolveModelInternal(cwd, "maxsim-roadmapper"),
-		mapper_model: resolveModelInternal(cwd, "maxsim-codebase-mapper"),
+		researcher_model: await resolveModelInternal(cwd, "maxsim-project-researcher"),
+		synthesizer_model: await resolveModelInternal(cwd, "maxsim-research-synthesizer"),
+		roadmapper_model: await resolveModelInternal(cwd, "maxsim-roadmapper"),
+		mapper_model: await resolveModelInternal(cwd, "maxsim-codebase-mapper"),
 		commit_docs: config.commit_docs,
-		project_exists: pathExistsInternal(cwd, ".planning/PROJECT.md"),
-		planning_exists: pathExistsInternal(cwd, ".planning"),
+		project_exists: await pathExistsInternal(planningPath(cwd, "PROJECT.md")),
+		planning_exists: await pathExistsInternal(planningPath(cwd)),
 		planning_files: planningFiles,
-		has_codebase_map: pathExistsInternal(cwd, ".planning/codebase"),
+		has_codebase_map: await pathExistsInternal(planningPath(cwd, "codebase")),
 		has_existing_code: hasCode,
 		has_package_file: hasPackageFile,
-		has_git: pathExistsInternal(cwd, ".git"),
-		has_readme: pathExistsInternal(cwd, "README.md"),
+		has_git: await pathExistsInternal(node_path.default.join(cwd, ".git")),
+		has_readme: await pathExistsInternal(node_path.default.join(cwd, "README.md")),
 		conflict_detected: planningFiles.length > 0,
 		existing_file_count: planningFiles.length,
 		brave_search_available: hasBraveSearch,
@@ -16808,15 +16416,15 @@ function cmdInitExisting(cwd) {
 		codebase_dir: ".planning/codebase"
 	});
 }
-function cmdInitProgress(cwd) {
-	const config = loadConfig(cwd);
-	const milestone = getMilestoneInfo(cwd);
+async function cmdInitProgress(cwd) {
+	const config = await loadConfig(cwd);
+	const milestone = await getMilestoneInfo(cwd);
 	const progressPhasesDir = phasesPath(cwd);
 	const phases = [];
 	let currentPhase = null;
 	let nextPhase = null;
 	try {
-		const dirs = listSubDirs(progressPhasesDir, true);
+		const dirs = await listSubDirs(progressPhasesDir, true);
 		for (const dir of dirs) {
 			const match = dir.match(/^(\d+(?:\.\d+)?)-?(.*)/);
 			const phaseNumber = match ? match[1] : dir;
@@ -16851,8 +16459,8 @@ function cmdInitProgress(cwd) {
 		debugLog(e);
 	}
 	return cmdOk({
-		executor_model: resolveModelInternal(cwd, "maxsim-executor"),
-		planner_model: resolveModelInternal(cwd, "maxsim-planner"),
+		executor_model: await resolveModelInternal(cwd, "maxsim-executor"),
+		planner_model: await resolveModelInternal(cwd, "maxsim-planner"),
 		commit_docs: config.commit_docs,
 		milestone_version: milestone.version,
 		milestone_name: milestone.name,
@@ -16864,9 +16472,9 @@ function cmdInitProgress(cwd) {
 		next_phase: nextPhase,
 		paused_at: pausedAt,
 		has_work_in_progress: !!currentPhase,
-		project_exists: pathExistsInternal(cwd, ".planning/PROJECT.md"),
-		roadmap_exists: pathExistsInternal(cwd, ".planning/ROADMAP.md"),
-		state_exists: pathExistsInternal(cwd, ".planning/STATE.md"),
+		project_exists: await pathExistsInternal(planningPath(cwd, "PROJECT.md")),
+		roadmap_exists: await pathExistsInternal(planningPath(cwd, "ROADMAP.md")),
+		state_exists: await pathExistsInternal(planningPath(cwd, "STATE.md")),
 		state_path: ".planning/STATE.md",
 		roadmap_path: ".planning/ROADMAP.md",
 		project_path: ".planning/PROJECT.md",
@@ -16885,14 +16493,14 @@ function listCodebaseDocs(cwd) {
 		return [];
 	}
 }
-function cmdInitExecutor(cwd, phase) {
+async function cmdInitExecutor(cwd, phase) {
 	if (!phase) return cmdErr("phase required for init executor");
-	const config = loadConfig(cwd);
-	const phaseInfo = findPhaseInternal(cwd, phase);
+	const config = await loadConfig(cwd);
+	const phaseInfo = await findPhaseInternal(cwd, phase);
 	const codebaseDocs = listCodebaseDocs(cwd);
 	const result = {
-		executor_model: resolveModelInternal(cwd, "maxsim-executor"),
-		verifier_model: resolveModelInternal(cwd, "maxsim-verifier"),
+		executor_model: await resolveModelInternal(cwd, "maxsim-executor"),
+		verifier_model: await resolveModelInternal(cwd, "maxsim-verifier"),
 		commit_docs: config.commit_docs,
 		parallelization: config.parallelization,
 		branching_strategy: config.branching_strategy,
@@ -16905,18 +16513,18 @@ function cmdInitExecutor(cwd, phase) {
 		state_path: ".planning/STATE.md",
 		codebase_docs: codebaseDocs
 	};
-	if (pathExistsInternal(cwd, ".planning/CONVENTIONS.md")) result.conventions_path = ".planning/CONVENTIONS.md";
+	if (await pathExistsInternal(planningPath(cwd, "CONVENTIONS.md"))) result.conventions_path = ".planning/CONVENTIONS.md";
 	return cmdOk(result);
 }
-function cmdInitPlanner(cwd, phase) {
+async function cmdInitPlanner(cwd, phase) {
 	if (!phase) return cmdErr("phase required for init planner");
-	const config = loadConfig(cwd);
-	const phaseInfo = findPhaseInternal(cwd, phase);
-	const phase_req_ids = extractReqIds(cwd, phase);
+	const config = await loadConfig(cwd);
+	const phaseInfo = await findPhaseInternal(cwd, phase);
+	const phase_req_ids = await extractReqIds(cwd, phase);
 	const codebaseDocs = listCodebaseDocs(cwd);
 	const result = {
-		planner_model: resolveModelInternal(cwd, "maxsim-planner"),
-		checker_model: resolveModelInternal(cwd, "maxsim-plan-checker"),
+		planner_model: await resolveModelInternal(cwd, "maxsim-planner"),
+		checker_model: await resolveModelInternal(cwd, "maxsim-plan-checker"),
 		commit_docs: config.commit_docs,
 		research_enabled: config.research,
 		plan_checker_enabled: config.plan_checker,
@@ -16934,7 +16542,7 @@ function cmdInitPlanner(cwd, phase) {
 		requirements_path: ".planning/REQUIREMENTS.md",
 		codebase_docs: codebaseDocs
 	};
-	if (pathExistsInternal(cwd, ".planning/CONVENTIONS.md")) result.conventions_path = ".planning/CONVENTIONS.md";
+	if (await pathExistsInternal(planningPath(cwd, "CONVENTIONS.md"))) result.conventions_path = ".planning/CONVENTIONS.md";
 	if (phaseInfo?.directory) {
 		const artifacts = scanPhaseArtifacts(cwd, phaseInfo.directory);
 		if (artifacts.context_path) result.context_path = artifacts.context_path;
@@ -16942,14 +16550,14 @@ function cmdInitPlanner(cwd, phase) {
 	}
 	return cmdOk(result);
 }
-function cmdInitResearcher(cwd, phase) {
+async function cmdInitResearcher(cwd, phase) {
 	if (!phase) return cmdErr("phase required for init researcher");
-	const config = loadConfig(cwd);
-	const phaseInfo = findPhaseInternal(cwd, phase);
-	const phase_req_ids = extractReqIds(cwd, phase);
+	const config = await loadConfig(cwd);
+	const phaseInfo = await findPhaseInternal(cwd, phase);
+	const phase_req_ids = await extractReqIds(cwd, phase);
 	const codebaseDocs = listCodebaseDocs(cwd);
 	const result = {
-		researcher_model: resolveModelInternal(cwd, "maxsim-phase-researcher"),
+		researcher_model: await resolveModelInternal(cwd, "maxsim-phase-researcher"),
 		commit_docs: config.commit_docs,
 		brave_search: config.brave_search,
 		phase_found: !!phaseInfo,
@@ -16965,21 +16573,21 @@ function cmdInitResearcher(cwd, phase) {
 		requirements_path: ".planning/REQUIREMENTS.md",
 		codebase_docs: codebaseDocs
 	};
-	if (pathExistsInternal(cwd, ".planning/CONVENTIONS.md")) result.conventions_path = ".planning/CONVENTIONS.md";
+	if (await pathExistsInternal(planningPath(cwd, "CONVENTIONS.md"))) result.conventions_path = ".planning/CONVENTIONS.md";
 	if (phaseInfo?.directory) {
 		const artifacts = scanPhaseArtifacts(cwd, phaseInfo.directory);
 		if (artifacts.context_path) result.context_path = artifacts.context_path;
 	}
 	return cmdOk(result);
 }
-function cmdInitVerifier(cwd, phase) {
+async function cmdInitVerifier(cwd, phase) {
 	if (!phase) return cmdErr("phase required for init verifier");
-	const config = loadConfig(cwd);
-	const phaseInfo = findPhaseInternal(cwd, phase);
-	const phase_req_ids = extractReqIds(cwd, phase);
+	const config = await loadConfig(cwd);
+	const phaseInfo = await findPhaseInternal(cwd, phase);
+	const phase_req_ids = await extractReqIds(cwd, phase);
 	const codebaseDocs = listCodebaseDocs(cwd);
 	return cmdOk({
-		verifier_model: resolveModelInternal(cwd, "maxsim-verifier"),
+		verifier_model: await resolveModelInternal(cwd, "maxsim-verifier"),
 		commit_docs: config.commit_docs,
 		phase_found: !!phaseInfo,
 		phase_dir: phaseInfo?.directory ?? null,
@@ -16992,12 +16600,12 @@ function cmdInitVerifier(cwd, phase) {
 		codebase_docs: codebaseDocs
 	});
 }
-function cmdInitDebugger(cwd, phase) {
-	const config = loadConfig(cwd);
-	const phaseInfo = phase ? findPhaseInternal(cwd, phase) : null;
+async function cmdInitDebugger(cwd, phase) {
+	const config = await loadConfig(cwd);
+	const phaseInfo = phase ? await findPhaseInternal(cwd, phase) : null;
 	const codebaseDocs = listCodebaseDocs(cwd);
 	const result = {
-		debugger_model: resolveModelInternal(cwd, "maxsim-debugger"),
+		debugger_model: await resolveModelInternal(cwd, "maxsim-debugger"),
 		commit_docs: config.commit_docs,
 		phase_found: !!phaseInfo,
 		phase_dir: phaseInfo?.directory ?? null,
@@ -17006,31 +16614,31 @@ function cmdInitDebugger(cwd, phase) {
 		state_path: ".planning/STATE.md",
 		codebase_docs: codebaseDocs
 	};
-	if (pathExistsInternal(cwd, ".planning/CONVENTIONS.md")) result.conventions_path = ".planning/CONVENTIONS.md";
+	if (await pathExistsInternal(planningPath(cwd, "CONVENTIONS.md"))) result.conventions_path = ".planning/CONVENTIONS.md";
 	return cmdOk(result);
 }
-function cmdInitCheckDrift(cwd) {
-	const config = loadConfig(cwd);
-	const driftModel = resolveModelInternal(cwd, "maxsim-drift-checker");
-	const hasPlanning = pathExistsInternal(cwd, ".planning");
-	const hasRequirements = pathExistsInternal(cwd, ".planning/REQUIREMENTS.md");
-	const hasRoadmap = pathExistsInternal(cwd, ".planning/ROADMAP.md");
-	const hasNogos = pathExistsInternal(cwd, ".planning/NO-GOS.md");
-	const hasConventions = pathExistsInternal(cwd, ".planning/CONVENTIONS.md");
-	const hasPreviousReport = pathExistsInternal(cwd, ".planning/DRIFT-REPORT.md");
+async function cmdInitCheckDrift(cwd) {
+	const config = await loadConfig(cwd);
+	const driftModel = await resolveModelInternal(cwd, "maxsim-drift-checker");
+	const hasPlanning = await pathExistsInternal(planningPath(cwd));
+	const hasRequirements = await pathExistsInternal(planningPath(cwd, "REQUIREMENTS.md"));
+	const hasRoadmap = await pathExistsInternal(planningPath(cwd, "ROADMAP.md"));
+	const hasNogos = await pathExistsInternal(planningPath(cwd, "NO-GOS.md"));
+	const hasConventions = await pathExistsInternal(planningPath(cwd, "CONVENTIONS.md"));
+	const hasPreviousReport = await pathExistsInternal(planningPath(cwd, "DRIFT-REPORT.md"));
 	const specFiles = [];
 	if (hasRequirements) specFiles.push(".planning/REQUIREMENTS.md");
 	if (hasRoadmap) specFiles.push(".planning/ROADMAP.md");
-	if (pathExistsInternal(cwd, ".planning/STATE.md")) specFiles.push(".planning/STATE.md");
+	if (await pathExistsInternal(planningPath(cwd, "STATE.md"))) specFiles.push(".planning/STATE.md");
 	if (hasNogos) specFiles.push(".planning/NO-GOS.md");
 	if (hasConventions) specFiles.push(".planning/CONVENTIONS.md");
 	let phaseDirs = [];
 	try {
-		phaseDirs = listSubDirs(phasesPath(cwd), true).map((d) => `.planning/phases/${d}`);
+		phaseDirs = (await listSubDirs(phasesPath(cwd), true)).map((d) => `.planning/phases/${d}`);
 	} catch {}
 	let archivedMilestoneDirs = [];
 	try {
-		archivedMilestoneDirs = getArchivedPhaseDirs(cwd).map((a) => a.basePath);
+		archivedMilestoneDirs = (await getArchivedPhaseDirs(cwd)).map((a) => a.basePath);
 		archivedMilestoneDirs = [...new Set(archivedMilestoneDirs)];
 	} catch {}
 	const codebaseDocs = listCodebaseDocs(cwd);
@@ -17055,13 +16663,13 @@ function cmdInitCheckDrift(cwd) {
 		codebase_docs: codebaseDocs
 	});
 }
-function cmdInitRealign(cwd, direction) {
-	const config = loadConfig(cwd);
-	const hasReport = pathExistsInternal(cwd, ".planning/DRIFT-REPORT.md");
-	const hasPlanning = pathExistsInternal(cwd, ".planning");
+async function cmdInitRealign(cwd, direction) {
+	const config = await loadConfig(cwd);
+	const hasReport = await pathExistsInternal(planningPath(cwd, "DRIFT-REPORT.md"));
+	const hasPlanning = await pathExistsInternal(planningPath(cwd));
 	let phaseDirs = [];
 	try {
-		phaseDirs = listSubDirs(phasesPath(cwd), true).map((d) => `.planning/phases/${d}`);
+		phaseDirs = (await listSubDirs(phasesPath(cwd), true)).map((d) => `.planning/phases/${d}`);
 	} catch {}
 	const codebaseDocs = listCodebaseDocs(cwd);
 	return cmdOk({
@@ -17163,12 +16771,12 @@ const handleState = async (args, cwd, raw) => {
 	if (handler) return handleResult(await handler(), raw);
 	return handleResult(await cmdStateLoad(cwd, raw), raw);
 };
-const handleTemplate = (args, cwd, raw) => {
+const handleTemplate = async (args, cwd, raw) => {
 	const sub = args[1];
 	if (sub === "select") handleResult(cmdTemplateSelect(cwd, args[2]), raw);
 	else if (sub === "fill") {
 		const f = getFlags(args, "phase", "plan", "name", "type", "wave", "fields");
-		handleResult(cmdTemplateFill(cwd, args[2], {
+		handleResult(await cmdTemplateFill(cwd, args[2], {
 			phase: f.phase ?? "",
 			plan: f.plan ?? void 0,
 			name: f.name ?? void 0,
@@ -17178,14 +16786,14 @@ const handleTemplate = (args, cwd, raw) => {
 		}), raw);
 	} else error("Unknown template subcommand. Available: select, fill");
 };
-const handleFrontmatter = (args, cwd, raw) => {
+const handleFrontmatter = async (args, cwd, raw) => {
 	const sub = args[1];
 	const file = args[2];
 	const handler = sub ? {
-		"get": () => handleResult(cmdFrontmatterGet(cwd, file, getFlag(args, "--field")), raw),
+		"get": async () => handleResult(await cmdFrontmatterGet(cwd, file, getFlag(args, "--field")), raw),
 		"set": () => handleResult(cmdFrontmatterSet(cwd, file, getFlag(args, "--field"), getFlag(args, "--value") ?? void 0), raw),
 		"merge": () => handleResult(cmdFrontmatterMerge(cwd, file, getFlag(args, "--data")), raw),
-		"validate": () => handleResult(cmdFrontmatterValidate(cwd, file, getFlag(args, "--schema")), raw)
+		"validate": async () => handleResult(await cmdFrontmatterValidate(cwd, file, getFlag(args, "--schema")), raw)
 	}[sub] : void 0;
 	if (handler) return handler();
 	error("Unknown frontmatter subcommand. Available: get, set, merge, validate");
@@ -17193,12 +16801,12 @@ const handleFrontmatter = (args, cwd, raw) => {
 const handleVerify = async (args, cwd, raw) => {
 	const sub = args[1];
 	const handler = sub ? {
-		"plan-structure": () => handleResult(cmdVerifyPlanStructure(cwd, args[2]), raw),
-		"phase-completeness": () => handleResult(cmdVerifyPhaseCompleteness(cwd, args[2]), raw),
-		"references": () => handleResult(cmdVerifyReferences(cwd, args[2]), raw),
+		"plan-structure": async () => handleResult(await cmdVerifyPlanStructure(cwd, args[2]), raw),
+		"phase-completeness": async () => handleResult(await cmdVerifyPhaseCompleteness(cwd, args[2]), raw),
+		"references": async () => handleResult(await cmdVerifyReferences(cwd, args[2]), raw),
 		"commits": async () => handleResult(await cmdVerifyCommits(cwd, args.slice(2)), raw),
-		"artifacts": () => handleResult(cmdVerifyArtifacts(cwd, args[2]), raw),
-		"key-links": () => handleResult(cmdVerifyKeyLinks(cwd, args[2]), raw)
+		"artifacts": async () => handleResult(await cmdVerifyArtifacts(cwd, args[2]), raw),
+		"key-links": async () => handleResult(await cmdVerifyKeyLinks(cwd, args[2]), raw)
 	}[sub] : void 0;
 	if (handler) return handler();
 	error("Unknown verify subcommand. Available: plan-structure, phase-completeness, references, commits, artifacts, key-links");
@@ -17257,16 +16865,16 @@ const handleMilestone = async (args, cwd, raw) => {
 		}), raw);
 	} else error("Unknown milestone subcommand. Available: complete");
 };
-const handleValidate = (args, cwd, raw) => {
+const handleValidate = async (args, cwd, raw) => {
 	const sub = args[1];
 	const handler = sub ? {
-		"consistency": () => handleResult(cmdValidateConsistency(cwd), raw),
-		"health": () => handleResult(cmdValidateHealth(cwd, { repair: hasFlag(args, "repair") }), raw)
+		"consistency": async () => handleResult(await cmdValidateConsistency(cwd), raw),
+		"health": async () => handleResult(await cmdValidateHealth(cwd, { repair: hasFlag(args, "repair") }), raw)
 	}[sub] : void 0;
 	if (handler) return handler();
 	error("Unknown validate subcommand. Available: consistency, health");
 };
-const handleDrift = (args, cwd, raw) => {
+const handleDrift = async (args, cwd, raw) => {
 	const sub = args[1];
 	const handler = sub ? {
 		"read-report": () => cmdDriftReadReport(cwd),
@@ -17276,10 +16884,10 @@ const handleDrift = (args, cwd, raw) => {
 		"write-report": () => cmdDriftWriteReport(cwd, getFlag(args, "--content"), getFlag(args, "--content-file")),
 		"previous-hash": () => cmdDriftPreviousHash(cwd)
 	}[sub] : void 0;
-	if (handler) return handleResult(handler(), raw);
+	if (handler) return handleResult(await handler(), raw);
 	error("Unknown drift subcommand. Available: read-report, extract-requirements, extract-nogos, extract-conventions, write-report, previous-hash");
 };
-const handleInit = (args, cwd, raw) => {
+const handleInit = async (args, cwd, raw) => {
 	const workflow = args[1];
 	const handler = workflow ? {
 		"execute-phase": () => cmdInitExecutePhase(cwd, args[2]),
@@ -17303,12 +16911,12 @@ const handleInit = (args, cwd, raw) => {
 		"check-drift": () => cmdInitCheckDrift(cwd),
 		"realign": () => cmdInitRealign(cwd, args[2])
 	}[workflow] : void 0;
-	if (handler) return handleResult(handler(), raw);
+	if (handler) return handleResult(await handler(), raw);
 	error(`Unknown init workflow: ${workflow}\nAvailable: execute-phase, plan-phase, new-project, new-milestone, quick, resume, verify-work, phase-op, todos, milestone-op, map-codebase, init-existing, progress, executor, planner, researcher, verifier, debugger, check-drift, realign`);
 };
 const COMMANDS = {
 	"state": handleState,
-	"resolve-model": (args, cwd, raw) => handleResult(cmdResolveModel(cwd, args[1], raw), raw),
+	"resolve-model": async (args, cwd, raw) => handleResult(await cmdResolveModel(cwd, args[1], raw), raw),
 	"find-phase": async (args, cwd, raw) => handleResult(await cmdFindPhase(cwd, args[1]), raw),
 	"commit": async (args, cwd, raw) => {
 		const files = args.indexOf("--files") !== -1 ? args.slice(args.indexOf("--files") + 1).filter((a) => !a.startsWith("--")) : [];
@@ -17329,7 +16937,7 @@ const COMMANDS = {
 	"config-ensure-section": (_args, cwd, raw) => handleResult(cmdConfigEnsureSection(cwd, raw), raw),
 	"config-set": (args, cwd, raw) => handleResult(cmdConfigSet(cwd, args[1], args[2], raw), raw),
 	"config-get": (args, cwd, raw) => handleResult(cmdConfigGet(cwd, args[1], raw), raw),
-	"history-digest": (_args, cwd, raw) => handleResult(cmdHistoryDigest(cwd, raw), raw),
+	"history-digest": async (_args, cwd, raw) => handleResult(await cmdHistoryDigest(cwd, raw), raw),
 	"phases": handlePhases,
 	"roadmap": handleRoadmap,
 	"requirements": (args, cwd, raw) => {
@@ -17340,14 +16948,14 @@ const COMMANDS = {
 	"milestone": handleMilestone,
 	"validate": handleValidate,
 	"drift": handleDrift,
-	"progress": (args, cwd, raw) => handleResult(cmdProgressRender(cwd, args[1] || "json", raw), raw),
+	"progress": async (args, cwd, raw) => handleResult(await cmdProgressRender(cwd, args[1] || "json", raw), raw),
 	"todo": (args, cwd, raw) => {
 		if (args[1] === "complete") handleResult(cmdTodoComplete(cwd, args[2], raw), raw);
 		else error("Unknown todo subcommand. Available: complete");
 	},
-	"scaffold": (args, cwd, raw) => {
+	"scaffold": async (args, cwd, raw) => {
 		const f = getFlags(args, "phase", "name");
-		handleResult(cmdScaffold(cwd, args[1], {
+		handleResult(await cmdScaffold(cwd, args[1], {
 			phase: f.phase,
 			name: f.name ? args.slice(args.indexOf("--name") + 1).join(" ") : null
 		}, raw), raw);
@@ -17369,39 +16977,17 @@ const COMMANDS = {
 			freshness: f.freshness ?? void 0
 		}, raw), raw);
 	},
-	"artefakte-read": (args, cwd, raw) => handleResult(cmdArtefakteRead(cwd, args[1], getFlag(args, "--phase") ?? void 0, raw), raw),
-	"artefakte-write": (args, cwd, raw) => handleResult(cmdArtefakteWrite(cwd, args[1], getFlag(args, "--content") ?? void 0, getFlag(args, "--phase") ?? void 0, raw), raw),
-	"artefakte-append": (args, cwd, raw) => handleResult(cmdArtefakteAppend(cwd, args[1], getFlag(args, "--entry") ?? void 0, getFlag(args, "--phase") ?? void 0, raw), raw),
-	"artefakte-list": (args, cwd, raw) => handleResult(cmdArtefakteList(cwd, getFlag(args, "--phase") ?? void 0, raw), raw),
-	"context-load": (args, cwd, raw) => handleResult(cmdContextLoad(cwd, getFlag(args, "--phase") ?? void 0, getFlag(args, "--topic") ?? void 0, hasFlag(args, "include-history")), raw),
-	"skill-list": (_args, cwd, raw) => handleResult(cmdSkillList(cwd), raw),
+	"artefakte-read": async (args, cwd, raw) => handleResult(await cmdArtefakteRead(cwd, args[1], getFlag(args, "--phase") ?? void 0, raw), raw),
+	"artefakte-write": async (args, cwd, raw) => handleResult(await cmdArtefakteWrite(cwd, args[1], getFlag(args, "--content") ?? void 0, getFlag(args, "--phase") ?? void 0, raw), raw),
+	"artefakte-append": async (args, cwd, raw) => handleResult(await cmdArtefakteAppend(cwd, args[1], getFlag(args, "--entry") ?? void 0, getFlag(args, "--phase") ?? void 0, raw), raw),
+	"artefakte-list": async (args, cwd, raw) => handleResult(await cmdArtefakteList(cwd, getFlag(args, "--phase") ?? void 0, raw), raw),
+	"context-load": async (args, cwd, raw) => handleResult(await cmdContextLoad(cwd, getFlag(args, "--phase") ?? void 0, getFlag(args, "--topic") ?? void 0, hasFlag(args, "include-history")), raw),
+	"skill-list": async (_args, cwd, raw) => handleResult(await cmdSkillList(cwd), raw),
 	"skill-install": (args, cwd, raw) => handleResult(cmdSkillInstall(cwd, args[1]), raw),
 	"skill-update": (args, cwd, raw) => handleResult(cmdSkillUpdate(cwd, args[1]), raw),
-	"start": async (args, cwd, raw) => handleResult(await cmdStart(cwd, {
-		noBrowser: hasFlag(args, "no-browser"),
-		networkMode: hasFlag(args, "network")
-	}), raw),
-	"dashboard": (args) => handleDashboard(args.slice(1)),
 	"start-server": async () => {
 		const serverPath = node_path.join(__dirname, "mcp-server.cjs");
 		(0, node_child_process.spawn)(process.execPath, [serverPath], { stdio: "inherit" }).on("exit", (code) => process.exit(code ?? 0));
-	},
-	"backend-start": async (args, cwd, raw) => {
-		const { startBackend } = await Promise.resolve().then(() => require("./lifecycle-D8mcsEjy.cjs"));
-		const portFlag = args.find((a) => a.startsWith("--port="))?.split("=")[1];
-		const background = !args.includes("--foreground");
-		output(await startBackend(cwd, {
-			port: portFlag ? parseInt(portFlag, 10) : void 0,
-			background
-		}), raw);
-	},
-	"backend-stop": async (_args, cwd, raw) => {
-		const { stopBackend } = await Promise.resolve().then(() => require("./lifecycle-D8mcsEjy.cjs"));
-		output({ stopped: await stopBackend(cwd) }, raw);
-	},
-	"backend-status": async (_args, cwd, raw) => {
-		const { getBackendStatus } = await Promise.resolve().then(() => require("./lifecycle-D8mcsEjy.cjs"));
-		output(await getBackendStatus(cwd) || { running: false }, raw);
 	}
 };
 async function main() {
@@ -17442,84 +17028,7 @@ async function main() {
 		throw thrown;
 	}
 }
-/**
-* Dashboard launch command.
-*
-* Spawns the dashboard as a detached subprocess with MAXSIM_PROJECT_CWD set.
-* If the dashboard is already running (detected via /api/health), prints the URL.
-* Supports --stop to kill a running instance.
-*/
-async function handleDashboard(args) {
-	const networkMode = args.includes("--network");
-	if (args.includes("--stop")) {
-		for (let port = DEFAULT_PORT; port <= PORT_RANGE_END; port++) if (await checkHealth(port)) {
-			console.log(`Dashboard found on port ${port} — stopping...`);
-			killProcessOnPort(port);
-			console.log("Dashboard stopped.");
-			return;
-		}
-		console.log("No running dashboard found.");
-		return;
-	}
-	const runningPort = await findRunningDashboard();
-	if (runningPort) {
-		console.log(`Dashboard already running at http://localhost:${runningPort}`);
-		return;
-	}
-	const serverPath = resolveDashboardServer();
-	if (!serverPath) {
-		console.error("Could not find @maxsim/dashboard server entry point.");
-		console.error("Ensure @maxsim/dashboard is installed and built.");
-		process.exit(1);
-	}
-	const serverDir = node_path.dirname(serverPath);
-	const dashConfig = readDashboardConfig(serverPath);
-	console.log("Installing node-pty for terminal support...");
-	if (!ensureNodePty(serverDir)) console.warn("node-pty installation failed — terminal will be unavailable.");
-	console.log("Dashboard starting...");
-	const pid = spawnDashboard({
-		serverPath,
-		projectCwd: dashConfig.projectCwd,
-		networkMode
-	});
-	await new Promise((resolve) => setTimeout(resolve, 3e3));
-	const readyPort = await findRunningDashboard();
-	if (readyPort) {
-		console.log(`Dashboard ready at http://localhost:${readyPort}`);
-		return;
-	}
-	console.log(`Dashboard spawned (PID ${pid}). It may take a moment to start.`);
-	console.log(`Check http://localhost:${DEFAULT_PORT} once ready.`);
-}
 main();
 
 //#endregion
-exports.__commonJSMin = __commonJSMin;
-exports.__toESM = __toESM;
-exports.appendToStateSection = appendToStateSection;
-exports.cmdConfigGet = cmdConfigGet;
-exports.cmdConfigSet = cmdConfigSet;
-exports.cmdContextLoad = cmdContextLoad;
-exports.cmdRoadmapAnalyze = cmdRoadmapAnalyze;
-exports.comparePhaseNum = comparePhaseNum;
-exports.escapeStringRegexp = escapeStringRegexp;
-exports.extractFrontmatter = extractFrontmatter;
-exports.findPhaseInternal = findPhaseInternal;
-exports.generateSlugInternal = generateSlugInternal;
-exports.getArchivedPhaseDirs = getArchivedPhaseDirs;
-exports.getPhasePattern = getPhasePattern;
-exports.listSubDirs = listSubDirs;
-exports.loadConfig = loadConfig;
-exports.normalizePhaseName = normalizePhaseName;
-exports.parseTodoFrontmatter = parseTodoFrontmatter;
-exports.phaseAddCore = phaseAddCore;
-exports.phaseCompleteCore = phaseCompleteCore;
-exports.phaseInsertCore = phaseInsertCore;
-exports.phasesPath = phasesPath;
-exports.planningPath = planningPath;
-exports.safeReadFile = safeReadFile;
-exports.stateExtractField = stateExtractField;
-exports.statePath = statePath;
-exports.stateReplaceField = stateReplaceField;
-exports.todayISO = todayISO;
 //# sourceMappingURL=cli.cjs.map