maxsimcli 4.0.2 → 4.2.0

package/dist/mcp-server.cjs

@@ -23028,7 +23028,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$1 = require("os");
+	const os$2 = require("os");
 	const tty$1 = require("tty");
 	const hasFlag = require_has_flag();
 	const { env } = process;
@@ -23055,7 +23055,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$1.release().split(".");
+			const osRelease = os$2.release().split(".");
 			if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
 			return 1;
 		}
@@ -26756,6 +26756,9 @@ function statePath(cwd) {
 function roadmapPath(cwd) {
 	return planningPath(cwd, "ROADMAP.md");
 }
+function configPath(cwd) {
+	return planningPath(cwd, "config.json");
+}
 function phasesPath(cwd) {
 	return planningPath(cwd, "phases");
 }
@@ -26770,6 +26773,19 @@ 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) {
+	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) {
+	try {
+		return await node_fs.promises.readFile(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
 /** Extract a human-readable message from an unknown thrown value. */
 function errorMsg(e) {
 	return e instanceof Error ? e.message : String(e);
@@ -26784,6 +26800,104 @@ 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;
+	}
+}
 function normalizePhaseName(phase) {
 	const match = phase.match(/^(\d+)([A-Z])?(\.\d+)?/i);
 	if (!match) return phase;
@@ -26923,6 +27037,77 @@ function generateSlugInternal(text) {
 		strict: true
 	});
 }
+async function pathExistsAsync(p) {
+	try {
+		await node_fs.promises.access(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function searchPhaseInDirAsync(baseDir, relBase, normalized) {
+	try {
+		const match = (await listSubDirsAsync(baseDir, true)).find((d) => d.startsWith(normalized));
+		if (!match) return null;
+		const dirMatch = match.match(/^(\d+[A-Z]?(?:\.\d+)?)-?(.*)/i);
+		const phaseNumber = dirMatch ? dirMatch[1] : normalized;
+		const phaseName = dirMatch && dirMatch[2] ? dirMatch[2] : null;
+		const phaseDir = node_path.default.join(baseDir, match);
+		const phaseFiles = await node_fs.promises.readdir(phaseDir);
+		const plans = phaseFiles.filter(isPlanFile).sort();
+		const summaries = phaseFiles.filter(isSummaryFile).sort();
+		const hasResearch = phaseFiles.some((f) => f.endsWith("-RESEARCH.md") || f === "RESEARCH.md");
+		const hasContext = phaseFiles.some((f) => f.endsWith("-CONTEXT.md") || f === "CONTEXT.md");
+		const hasVerification = phaseFiles.some((f) => f.endsWith("-VERIFICATION.md") || f === "VERIFICATION.md");
+		const completedPlanIds = new Set(summaries.map(summaryId));
+		const incompletePlans = plans.filter((p) => !completedPlanIds.has(planId(p)));
+		return {
+			found: true,
+			directory: node_path.default.join(relBase, match),
+			phase_number: phaseNumber,
+			phase_name: phaseName,
+			phase_slug: phaseName ? phaseName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") : null,
+			plans,
+			summaries,
+			incomplete_plans: incompletePlans,
+			has_research: hasResearch,
+			has_context: hasContext,
+			has_verification: hasVerification
+		};
+	} catch (e) {
+		debugLog("search-phase-in-dir-async-failed", {
+			dir: baseDir,
+			phase: normalized,
+			error: errorMsg(e)
+		});
+		return null;
+	}
+}
+async function findPhaseInternalAsync(cwd, phase) {
+	if (!phase) return null;
+	const pd = phasesPath(cwd);
+	const normalized = normalizePhaseName(phase);
+	const current = await searchPhaseInDirAsync(pd, node_path.default.join(".planning", "phases"), normalized);
+	if (current) return current;
+	const milestonesDir = planningPath(cwd, "milestones");
+	if (!await pathExistsAsync(milestonesDir)) return null;
+	try {
+		const archiveDirs = (await node_fs.promises.readdir(milestonesDir, { withFileTypes: true })).filter((e) => e.isDirectory() && /^v[\d.]+-phases$/.test(e.name)).map((e) => e.name).sort().reverse();
+		for (const archiveName of archiveDirs) {
+			const versionMatch = archiveName.match(/^(v[\d.]+)-phases$/);
+			if (!versionMatch) continue;
+			const version = versionMatch[1];
+			const result = await searchPhaseInDirAsync(node_path.default.join(milestonesDir, archiveName), node_path.default.join(".planning", "milestones", archiveName), normalized);
+			if (result) {
+				result.archived = version;
+				return result;
+			}
+		}
+	} catch (e) {
+		debugLog("find-phase-async-milestone-search-failed", e);
+	}
+	return null;
+}
 
 //#endregion
 //#region ../../node_modules/yaml/dist/nodes/identity.js
@@ -33574,6 +33759,23 @@ var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.visitAsync = visit.visitAsync;
 }));
 
+//#endregion
+//#region src/core/types.ts
+var import_dist = /* @__PURE__ */ __toESM(require_dist());
+function cmdOk(result, rawValue) {
+	return {
+		ok: true,
+		result,
+		rawValue
+	};
+}
+function cmdErr(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+
 //#endregion
 //#region src/core/frontmatter.ts
 /**
@@ -33581,7 +33783,6 @@ var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
 *
 * Uses the `yaml` npm package instead of a hand-rolled parser.
 */
-var import_dist = /* @__PURE__ */ __toESM(require_dist());
 
 //#endregion
 //#region src/core/phase.ts
@@ -33590,15 +33791,18 @@ var import_dist = /* @__PURE__ */ __toESM(require_dist());
 *
 * Ported from maxsim/bin/lib/phase.cjs
 */
-function scaffoldPhaseStubs(dirPath, phaseId, name) {
+async function scaffoldPhaseStubs(dirPath, phaseId, name) {
 	const today = todayISO();
-	node_fs.default.writeFileSync(node_path.default.join(dirPath, `${phaseId}-CONTEXT.md`), `# Phase ${phaseId} Context: ${name}\n\n**Created:** ${today}\n**Phase goal:** [To be defined during /maxsim:discuss-phase]\n\n---\n\n_Context will be populated by /maxsim:discuss-phase_\n`);
-	node_fs.default.writeFileSync(node_path.default.join(dirPath, `${phaseId}-RESEARCH.md`), `# Phase ${phaseId}: ${name} - Research\n\n**Researched:** Not yet\n**Domain:** TBD\n**Confidence:** TBD\n\n---\n\n_Research will be populated by /maxsim:research-phase_\n`);
+	await Promise.all([node_fs.promises.writeFile(node_path.default.join(dirPath, `${phaseId}-CONTEXT.md`), `# Phase ${phaseId} Context: ${name}\n\n**Created:** ${today}\n**Phase goal:** [To be defined during /maxsim:discuss-phase]\n\n---\n\n_Context will be populated by /maxsim:discuss-phase_\n`), node_fs.promises.writeFile(node_path.default.join(dirPath, `${phaseId}-RESEARCH.md`), `# Phase ${phaseId}: ${name} - Research\n\n**Researched:** Not yet\n**Domain:** TBD\n**Confidence:** TBD\n\n---\n\n_Research will be populated by /maxsim:research-phase_\n`)]);
 }
-function phaseAddCore(cwd, description, options) {
+async function phaseAddCore(cwd, description, options) {
 	const rmPath = roadmapPath(cwd);
-	if (!node_fs.default.existsSync(rmPath)) throw new Error("ROADMAP.md not found");
-	const content = node_fs.default.readFileSync(rmPath, "utf-8");
+	let content;
+	try {
+		content = await node_fs.promises.readFile(rmPath, "utf-8");
+	} catch {
+		throw new Error("ROADMAP.md not found");
+	}
 	const slug = generateSlugInternal(description);
 	const phasePattern = getPhasePattern();
 	let maxPhase = 0;
@@ -33611,15 +33815,15 @@ function phaseAddCore(cwd, description, options) {
 	const paddedNum = String(newPhaseNum).padStart(2, "0");
 	const dirName = `${paddedNum}-${slug}`;
 	const dirPath = planningPath(cwd, "phases", dirName);
-	node_fs.default.mkdirSync(dirPath, { recursive: true });
-	node_fs.default.writeFileSync(node_path.default.join(dirPath, ".gitkeep"), "");
-	if (options?.includeStubs) scaffoldPhaseStubs(dirPath, paddedNum, description);
+	await node_fs.promises.mkdir(dirPath, { recursive: true });
+	await node_fs.promises.writeFile(node_path.default.join(dirPath, ".gitkeep"), "");
+	if (options?.includeStubs) await scaffoldPhaseStubs(dirPath, paddedNum, description);
 	const phaseEntry = `\n### Phase ${newPhaseNum}: ${description}\n\n**Goal:** [To be planned]\n**Requirements**: TBD\n**Depends on:** Phase ${maxPhase}\n**Plans:** 0 plans\n\nPlans:\n- [ ] TBD (run /maxsim:plan-phase ${newPhaseNum} to break down)\n`;
 	let updatedContent;
 	const lastSeparator = content.lastIndexOf("\n---");
 	if (lastSeparator > 0) updatedContent = content.slice(0, lastSeparator) + phaseEntry + content.slice(lastSeparator);
 	else updatedContent = content + phaseEntry;
-	node_fs.default.writeFileSync(rmPath, updatedContent, "utf-8");
+	await node_fs.promises.writeFile(rmPath, updatedContent, "utf-8");
 	return {
 		phase_number: newPhaseNum,
 		padded: paddedNum,
@@ -33628,10 +33832,14 @@ function phaseAddCore(cwd, description, options) {
 		description
 	};
 }
-function phaseInsertCore(cwd, afterPhase, description, options) {
+async function phaseInsertCore(cwd, afterPhase, description, options) {
 	const rmPath = roadmapPath(cwd);
-	if (!node_fs.default.existsSync(rmPath)) throw new Error("ROADMAP.md not found");
-	const content = node_fs.default.readFileSync(rmPath, "utf-8");
+	let content;
+	try {
+		content = await node_fs.promises.readFile(rmPath, "utf-8");
+	} catch {
+		throw new Error("ROADMAP.md not found");
+	}
 	const slug = generateSlugInternal(description);
 	const afterPhaseEscaped = "0*" + normalizePhaseName(afterPhase).replace(/^0+/, "").replace(/\./g, "\\.");
 	if (!getPhasePattern(afterPhaseEscaped, "i").test(content)) throw new Error(`Phase ${afterPhase} not found in ROADMAP.md`);
@@ -33639,7 +33847,7 @@ function phaseInsertCore(cwd, afterPhase, description, options) {
 	const normalizedBase = normalizePhaseName(afterPhase);
 	const existingDecimals = [];
 	try {
-		const dirs = listSubDirs(phasesDirPath);
+		const dirs = await listSubDirsAsync(phasesDirPath);
 		const decimalPattern = new RegExp(`^${normalizedBase}\\.(\\d+)`);
 		for (const dir of dirs) {
 			const dm = dir.match(decimalPattern);
@@ -33651,9 +33859,9 @@ function phaseInsertCore(cwd, afterPhase, description, options) {
 	const decimalPhase = `${normalizedBase}.${existingDecimals.length === 0 ? 1 : Math.max(...existingDecimals) + 1}`;
 	const dirName = `${decimalPhase}-${slug}`;
 	const dirPath = planningPath(cwd, "phases", dirName);
-	node_fs.default.mkdirSync(dirPath, { recursive: true });
-	node_fs.default.writeFileSync(node_path.default.join(dirPath, ".gitkeep"), "");
-	if (options?.includeStubs) scaffoldPhaseStubs(dirPath, decimalPhase, description);
+	await node_fs.promises.mkdir(dirPath, { recursive: true });
+	await node_fs.promises.writeFile(node_path.default.join(dirPath, ".gitkeep"), "");
+	if (options?.includeStubs) await scaffoldPhaseStubs(dirPath, decimalPhase, description);
 	const phaseEntry = `\n### Phase ${decimalPhase}: ${description} (INSERTED)\n\n**Goal:** [Urgent work - to be planned]\n**Requirements**: TBD\n**Depends on:** Phase ${afterPhase}\n**Plans:** 0 plans\n\nPlans:\n- [ ] TBD (run /maxsim:plan-phase ${decimalPhase} to break down)\n`;
 	const headerPattern = new RegExp(`(#{2,4}\\s*Phase\\s+0*${afterPhaseEscaped}:[^\\n]*\\n)`, "i");
 	const headerMatch = content.match(headerPattern);
@@ -33664,7 +33872,7 @@ function phaseInsertCore(cwd, afterPhase, description, options) {
 	if (nextPhaseMatch) insertIdx = headerIdx + headerMatch[0].length + nextPhaseMatch.index;
 	else insertIdx = content.length;
 	const updatedContent = content.slice(0, insertIdx) + phaseEntry + content.slice(insertIdx);
-	node_fs.default.writeFileSync(rmPath, updatedContent, "utf-8");
+	await node_fs.promises.writeFile(rmPath, updatedContent, "utf-8");
 	return {
 		phase_number: decimalPhase,
 		after_phase: afterPhase,
@@ -33673,18 +33881,19 @@ function phaseInsertCore(cwd, afterPhase, description, options) {
 		description
 	};
 }
-function phaseCompleteCore(cwd, phaseNum) {
+async function phaseCompleteCore(cwd, phaseNum) {
 	const rmPath = roadmapPath(cwd);
 	const stPath = statePath(cwd);
 	const phasesDirPath = phasesPath(cwd);
 	const today = todayISO();
-	const phaseInfo = findPhaseInternal(cwd, phaseNum);
+	const phaseInfo = await findPhaseInternalAsync(cwd, phaseNum);
 	if (!phaseInfo) throw new Error(`Phase ${phaseNum} not found`);
 	const planCount = phaseInfo.plans.length;
 	const summaryCount = phaseInfo.summaries.length;
 	let requirementsUpdated = false;
-	if (node_fs.default.existsSync(rmPath)) {
-		let roadmapContent = node_fs.default.readFileSync(rmPath, "utf-8");
+	const rmExists = await pathExistsAsync(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");
 		roadmapContent = roadmapContent.replace(checkboxPattern, `$1x$2 (completed ${today})`);
 		const phaseEscaped = escapePhaseNum(phaseNum);
@@ -33693,20 +33902,20 @@ function phaseCompleteCore(cwd, phaseNum) {
 		const planCountPattern = new RegExp(`(#{2,4}\\s*Phase\\s+${phaseEscaped}[\\s\\S]*?\\*\\*Plans:\\*\\*\\s*)[^\\n]+`, "i");
 		roadmapContent = roadmapContent.replace(planCountPattern, `$1${summaryCount}/${planCount} plans complete`);
 		debugLog("phase-complete-write", `writing ROADMAP.md for phase ${phaseNum}`);
-		node_fs.default.writeFileSync(rmPath, roadmapContent, "utf-8");
+		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 (node_fs.default.existsSync(reqPath)) {
+		if (await pathExistsAsync(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);
-				let reqContent = node_fs.default.readFileSync(reqPath, "utf-8");
+				let reqContent = await node_fs.promises.readFile(reqPath, "utf-8");
 				for (const reqId of reqIds) {
 					reqContent = reqContent.replace(new RegExp(`(-\\s*\\[)[ ](\\]\\s*\\*\\*${reqId}\\*\\*)`, "gi"), "$1x$2");
 					reqContent = reqContent.replace(new RegExp(`(\\|\\s*${reqId}\\s*\\|[^|]+\\|)\\s*Pending\\s*(\\|)`, "gi"), "$1 Complete $2");
 				}
 				debugLog("phase-complete-write", `writing REQUIREMENTS.md for phase ${phaseNum}`);
-				node_fs.default.writeFileSync(reqPath, reqContent, "utf-8");
+				await node_fs.promises.writeFile(reqPath, reqContent, "utf-8");
 				debugLog("phase-complete-write", `REQUIREMENTS.md updated for phase ${phaseNum}`);
 				requirementsUpdated = true;
 			}
@@ -33716,7 +33925,7 @@ function phaseCompleteCore(cwd, phaseNum) {
 	let nextPhaseName = null;
 	let isLastPhase = true;
 	try {
-		const dirs = listSubDirs(phasesDirPath, true);
+		const dirs = await listSubDirsAsync(phasesDirPath, true);
 		for (const dir of dirs) {
 			const dm = dir.match(/^(\d+[A-Z]?(?:\.\d+)?)-?(.*)/i);
 			if (dm) {
@@ -33731,8 +33940,9 @@ function phaseCompleteCore(cwd, phaseNum) {
 	} catch (e) {
 		debugLog("phase-complete-next-phase-scan-failed", e);
 	}
-	if (node_fs.default.existsSync(stPath)) {
-		let stateContent = node_fs.default.readFileSync(stPath, "utf-8");
+	const stExists = await pathExistsAsync(stPath);
+	if (stExists) {
+		let stateContent = await node_fs.promises.readFile(stPath, "utf-8");
 		stateContent = stateContent.replace(/(\*\*Current Phase:\*\*\s*).*/, `$1${nextPhaseNum || phaseNum}`);
 		if (nextPhaseName) stateContent = stateContent.replace(/(\*\*Current Phase Name:\*\*\s*).*/, `$1${nextPhaseName.replace(/-/g, " ")}`);
 		stateContent = stateContent.replace(/(\*\*Status:\*\*\s*).*/, `$1${isLastPhase ? "Milestone complete" : "Ready to plan"}`);
@@ -33740,7 +33950,7 @@ function phaseCompleteCore(cwd, phaseNum) {
 		stateContent = stateContent.replace(/(\*\*Last Activity:\*\*\s*).*/, `$1${today}`);
 		stateContent = stateContent.replace(/(\*\*Last Activity Description:\*\*\s*).*/, `$1Phase ${phaseNum} complete${nextPhaseNum ? `, transitioned to Phase ${nextPhaseNum}` : ""}`);
 		debugLog("phase-complete-write", `writing STATE.md for phase ${phaseNum}`);
-		node_fs.default.writeFileSync(stPath, stateContent, "utf-8");
+		await node_fs.promises.writeFile(stPath, stateContent, "utf-8");
 		debugLog("phase-complete-write", `STATE.md updated for phase ${phaseNum}`);
 	}
 	return {
@@ -33751,8 +33961,8 @@ function phaseCompleteCore(cwd, phaseNum) {
 		next_phase_name: nextPhaseName,
 		is_last_phase: isLastPhase,
 		date: today,
-		roadmap_updated: node_fs.default.existsSync(rmPath),
-		state_updated: node_fs.default.existsSync(stPath),
+		roadmap_updated: rmExists,
+		state_updated: stExists,
 		requirements_updated: requirementsUpdated
 	};
 }
@@ -33886,7 +34096,7 @@ function registerPhaseTools(server) {
 			const cwd = detectProjectRoot();
 			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
 			if (!name || !name.trim()) return mcpError("Phase name must not be empty", "Validation failed");
-			const result = phaseAddCore(cwd, name, { includeStubs: true });
+			const result = await phaseAddCore(cwd, name, { includeStubs: true });
 			return mcpSuccess({
 				phase_number: result.phase_number,
 				padded: result.padded,
@@ -33906,7 +34116,7 @@ function registerPhaseTools(server) {
 			const cwd = detectProjectRoot();
 			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
 			if (!name || !name.trim()) return mcpError("Phase name must not be empty", "Validation failed");
-			const result = phaseInsertCore(cwd, after, name, { includeStubs: true });
+			const result = await phaseInsertCore(cwd, after, name, { includeStubs: true });
 			return mcpSuccess({
 				phase_number: result.phase_number,
 				after_phase: result.after_phase,
@@ -33922,7 +34132,7 @@ function registerPhaseTools(server) {
 		try {
 			const cwd = detectProjectRoot();
 			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
-			const result = phaseCompleteCore(cwd, phase);
+			const result = await phaseCompleteCore(cwd, phase);
 			return mcpSuccess({
 				completed_phase: result.completed_phase,
 				phase_name: result.phase_name,
@@ -34245,6 +34455,554 @@ function registerStateTools(server) {
 	});
 }
 
+//#endregion
+//#region src/core/roadmap.ts
+/**
+* Roadmap — Roadmap parsing and update operations
+*
+* Ported from maxsim/bin/lib/roadmap.cjs
+*/
+async function cmdRoadmapAnalyze(cwd) {
+	const content = await safeReadFileAsync(roadmapPath(cwd));
+	if (!content) return cmdOk({
+		error: "ROADMAP.md not found",
+		milestones: [],
+		phases: [],
+		current_phase: null
+	});
+	const phasesDir = phasesPath(cwd);
+	const phasePattern = getPhasePattern();
+	const parsedPhases = [];
+	let match;
+	while ((match = phasePattern.exec(content)) !== null) {
+		const phaseNum = match[1];
+		const phaseName = match[2].replace(/\(INSERTED\)/i, "").trim();
+		const sectionStart = match.index;
+		const nextHeader = content.slice(sectionStart).match(/\n#{2,4}\s+Phase\s+\d/i);
+		const sectionEnd = nextHeader ? sectionStart + nextHeader.index : content.length;
+		const section = content.slice(sectionStart, sectionEnd);
+		const goalMatch = section.match(/\*\*Goal(?::\*\*|\*\*:)\s*([^\n]+)/i);
+		const goal = goalMatch ? goalMatch[1].trim() : null;
+		const dependsMatch = section.match(/\*\*Depends on:\*\*\s*([^\n]+)/i);
+		const depends_on = dependsMatch ? dependsMatch[1].trim() : null;
+		parsedPhases.push({
+			phaseNum,
+			phaseName,
+			goal,
+			depends_on,
+			normalized: normalizePhaseName(phaseNum),
+			checkboxPattern: new RegExp(`-\\s*\\[(x| )\\]\\s*.*Phase\\s+${phaseNum.replace(".", "\\.")}`, "i")
+		});
+	}
+	let allDirs = [];
+	try {
+		allDirs = await listSubDirsAsync(phasesDir);
+	} catch {}
+	const phases = await Promise.all(parsedPhases.map(async (p) => {
+		let diskStatus = "no_directory";
+		let planCount = 0;
+		let summaryCount = 0;
+		let hasContext = false;
+		let hasResearch = false;
+		try {
+			const dirMatch = allDirs.find((d) => d.startsWith(p.normalized + "-") || d === p.normalized);
+			if (dirMatch) {
+				const phaseFiles = await node_fs.promises.readdir(node_path.default.join(phasesDir, dirMatch));
+				planCount = phaseFiles.filter((f) => isPlanFile(f)).length;
+				summaryCount = phaseFiles.filter((f) => isSummaryFile(f)).length;
+				hasContext = phaseFiles.some((f) => f.endsWith("-CONTEXT.md") || f === "CONTEXT.md");
+				hasResearch = phaseFiles.some((f) => f.endsWith("-RESEARCH.md") || f === "RESEARCH.md");
+				if (summaryCount >= planCount && planCount > 0) diskStatus = "complete";
+				else if (summaryCount > 0) diskStatus = "partial";
+				else if (planCount > 0) diskStatus = "planned";
+				else if (hasResearch) diskStatus = "researched";
+				else if (hasContext) diskStatus = "discussed";
+				else diskStatus = "empty";
+			}
+		} catch (e) {
+			debugLog(e);
+		}
+		const checkboxMatch = content.match(p.checkboxPattern);
+		const roadmapComplete = checkboxMatch ? checkboxMatch[1] === "x" : false;
+		return {
+			number: p.phaseNum,
+			name: p.phaseName,
+			goal: p.goal,
+			depends_on: p.depends_on,
+			plan_count: planCount,
+			summary_count: summaryCount,
+			has_context: hasContext,
+			has_research: hasResearch,
+			disk_status: diskStatus,
+			roadmap_complete: roadmapComplete
+		};
+	}));
+	const milestones = [];
+	const milestonePattern = /##\s*(.*v(\d+\.\d+)[^(\n]*)/gi;
+	let mMatch;
+	while ((mMatch = milestonePattern.exec(content)) !== null) milestones.push({
+		heading: mMatch[1].trim(),
+		version: "v" + mMatch[2]
+	});
+	const currentPhase = phases.find((p) => p.disk_status === "planned" || p.disk_status === "partial") || null;
+	const nextPhase = phases.find((p) => p.disk_status === "empty" || p.disk_status === "no_directory" || p.disk_status === "discussed" || p.disk_status === "researched") || null;
+	const totalPlans = phases.reduce((sum, p) => sum + p.plan_count, 0);
+	const totalSummaries = phases.reduce((sum, p) => sum + p.summary_count, 0);
+	const completedPhases = phases.filter((p) => p.disk_status === "complete").length;
+	const checklistPattern = /-\s*\[[ x]\]\s*\*\*Phase\s+(\d+[A-Z]?(?:\.\d+)?)/gi;
+	const checklistPhases = /* @__PURE__ */ new Set();
+	let checklistMatch;
+	while ((checklistMatch = checklistPattern.exec(content)) !== null) checklistPhases.add(checklistMatch[1]);
+	const detailPhases = new Set(phases.map((p) => p.number));
+	const missingDetails = [...checklistPhases].filter((p) => !detailPhases.has(p));
+	return cmdOk({
+		milestones,
+		phases,
+		phase_count: phases.length,
+		completed_phases: completedPhases,
+		total_plans: totalPlans,
+		total_summaries: totalSummaries,
+		progress_percent: totalPlans > 0 ? Math.min(100, Math.round(totalSummaries / totalPlans * 100)) : 0,
+		current_phase: currentPhase ? currentPhase.number : null,
+		next_phase: nextPhase ? nextPhase.number : null,
+		missing_phase_details: missingDetails.length > 0 ? missingDetails : null
+	});
+}
+
+//#endregion
+//#region src/core/context-loader.ts
+/**
+* Context Loader — Intelligent file selection for workflow context assembly
+*
+* Selects relevant planning files based on the current task/phase domain,
+* preventing context overload by loading only what matters.
+*/
+function fileEntry(cwd, relPath, role) {
+	const fullPath = node_path.default.join(cwd, relPath);
+	try {
+		return {
+			path: relPath,
+			role,
+			size: node_fs.default.statSync(fullPath).size
+		};
+	} catch {
+		return null;
+	}
+}
+function addIfExists(files, cwd, relPath, role) {
+	const entry = fileEntry(cwd, relPath, role);
+	if (entry) files.push(entry);
+}
+const TOPIC_TO_CODEBASE_DOCS = {
+	ui: ["CONVENTIONS.md", "STRUCTURE.md"],
+	frontend: ["CONVENTIONS.md", "STRUCTURE.md"],
+	component: ["CONVENTIONS.md", "STRUCTURE.md"],
+	api: ["ARCHITECTURE.md", "CONVENTIONS.md"],
+	backend: ["ARCHITECTURE.md", "CONVENTIONS.md"],
+	server: ["ARCHITECTURE.md", "CONVENTIONS.md"],
+	database: ["ARCHITECTURE.md", "STACK.md"],
+	schema: ["ARCHITECTURE.md", "STACK.md"],
+	data: ["ARCHITECTURE.md", "STACK.md"],
+	testing: ["TESTING.md", "CONVENTIONS.md"],
+	test: ["TESTING.md", "CONVENTIONS.md"],
+	integration: ["INTEGRATIONS.md", "STACK.md"],
+	deploy: ["INTEGRATIONS.md", "STACK.md"],
+	refactor: ["CONCERNS.md", "ARCHITECTURE.md"],
+	cleanup: ["CONCERNS.md", "ARCHITECTURE.md"],
+	setup: ["STACK.md", "STRUCTURE.md"],
+	config: ["STACK.md", "STRUCTURE.md"],
+	auth: ["ARCHITECTURE.md", "INTEGRATIONS.md"],
+	performance: ["ARCHITECTURE.md", "STACK.md"],
+	install: ["STACK.md", "STRUCTURE.md"]
+};
+const DEFAULT_CODEBASE_DOCS = ["STACK.md", "ARCHITECTURE.md"];
+function selectCodebaseDocs(topic) {
+	if (!topic) return DEFAULT_CODEBASE_DOCS;
+	const topicLower = topic.toLowerCase();
+	const matched = /* @__PURE__ */ new Set();
+	for (const [keyword, docs] of Object.entries(TOPIC_TO_CODEBASE_DOCS)) if (topicLower.includes(keyword)) for (const doc of docs) matched.add(doc);
+	return matched.size > 0 ? Array.from(matched) : DEFAULT_CODEBASE_DOCS;
+}
+function loadProjectContext(cwd) {
+	const files = [];
+	addIfExists(files, cwd, ".planning/PROJECT.md", "project-vision");
+	addIfExists(files, cwd, ".planning/REQUIREMENTS.md", "requirements");
+	addIfExists(files, cwd, ".planning/STATE.md", "state");
+	addIfExists(files, cwd, ".planning/config.json", "config");
+	return files;
+}
+function loadRoadmapContext(cwd) {
+	const files = [];
+	addIfExists(files, cwd, ".planning/ROADMAP.md", "roadmap");
+	return files;
+}
+function loadPhaseContext(cwd, phase) {
+	const files = [];
+	const phaseInfo = findPhaseInternal(cwd, phase);
+	if (!phaseInfo?.directory) return files;
+	const phaseDir = phaseInfo.directory;
+	try {
+		const phaseFiles = node_fs.default.readdirSync(node_path.default.join(cwd, phaseDir));
+		for (const f of phaseFiles) {
+			const relPath = node_path.default.join(phaseDir, f);
+			if (f.endsWith("-CONTEXT.md") || f === "CONTEXT.md") addIfExists(files, cwd, relPath, "phase-context");
+			else if (f.endsWith("-RESEARCH.md") || f === "RESEARCH.md") addIfExists(files, cwd, relPath, "phase-research");
+			else if (f.endsWith("-PLAN.md")) addIfExists(files, cwd, relPath, "phase-plan");
+			else if (f.endsWith("-SUMMARY.md")) addIfExists(files, cwd, relPath, "phase-summary");
+			else if (f.endsWith("-VERIFICATION.md") || f === "VERIFICATION.md") addIfExists(files, cwd, relPath, "phase-verification");
+		}
+	} catch (e) {
+		debugLog("context-loader-phase-files-failed", e);
+	}
+	return files;
+}
+function loadArtefakteContext(cwd, phase) {
+	const files = [];
+	for (const filename of [
+		"DECISIONS.md",
+		"ACCEPTANCE-CRITERIA.md",
+		"NO-GOS.md"
+	]) {
+		if (phase) {
+			const phaseInfo = 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()}`);
+	}
+	return files;
+}
+function loadCodebaseContext(cwd, topic) {
+	const files = [];
+	const codebaseDir = planningPath(cwd, "codebase");
+	try {
+		const existing = node_fs.default.readdirSync(codebaseDir).filter((f) => f.endsWith(".md"));
+		const selected = selectCodebaseDocs(topic);
+		for (const filename of selected) if (existing.includes(filename)) addIfExists(files, cwd, `.planning/codebase/${filename}`, `codebase-${filename.replace(".md", "").toLowerCase()}`);
+	} catch {}
+	return files;
+}
+function loadHistoryContext(cwd, currentPhase) {
+	const files = [];
+	const pd = phasesPath(cwd);
+	try {
+		const dirs = listSubDirs(pd, true);
+		for (const dir of dirs) {
+			if (currentPhase) {
+				if (dir.match(/^(\d+[A-Z]?(?:\.\d+)?)/i)?.[1] === currentPhase) continue;
+			}
+			const dirPath = node_path.default.join(pd, dir);
+			const summaries = node_fs.default.readdirSync(dirPath).filter((f) => isSummaryFile(f));
+			for (const s of summaries) addIfExists(files, cwd, node_path.default.join(".planning", "phases", dir, s), "history-summary");
+		}
+	} catch (e) {
+		debugLog("context-loader-history-failed", e);
+	}
+	return files;
+}
+function cmdContextLoad(cwd, phase, topic, includeHistory) {
+	const allFiles = [];
+	allFiles.push(...loadProjectContext(cwd));
+	allFiles.push(...loadRoadmapContext(cwd));
+	allFiles.push(...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));
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = allFiles.filter((f) => {
+		if (seen.has(f.path)) return false;
+		seen.add(f.path);
+		return true;
+	});
+	return cmdOk({
+		files: deduped,
+		total_size: deduped.reduce((sum, f) => sum + f.size, 0),
+		phase: phase ?? null,
+		topic: topic ?? null,
+		codebase_docs_selected: selectedDocs
+	});
+}
+
+//#endregion
+//#region src/mcp/context-tools.ts
+/**
+* Context Query MCP Tools — Project context exposed as MCP tools
+*
+* CRITICAL: Never import output() or error() from core — they call process.exit().
+* CRITICAL: Never write to stdout — it is reserved for MCP JSON-RPC protocol.
+* CRITICAL: Never call process.exit() — the server must stay alive after every tool call.
+*/
+/**
+* Register all context query tools on the MCP server.
+*/
+function registerContextTools(server) {
+	server.tool("mcp_get_active_phase", "Get the currently active phase and next phase from roadmap analysis and STATE.md.", {}, async () => {
+		try {
+			const cwd = detectProjectRoot();
+			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
+			const roadmapResult = await cmdRoadmapAnalyze(cwd);
+			let current_phase = null;
+			let next_phase = null;
+			let phase_name = null;
+			let status = null;
+			if (roadmapResult.ok) {
+				const data = roadmapResult.result;
+				current_phase = data.current_phase ?? null;
+				next_phase = data.next_phase ?? null;
+			}
+			const stateContent = safeReadFile(planningPath(cwd, "STATE.md"));
+			if (stateContent) {
+				const statePhase = stateExtractField(stateContent, "Current Phase");
+				if (statePhase) phase_name = statePhase;
+				const stateStatus = stateExtractField(stateContent, "Status");
+				if (stateStatus) status = stateStatus;
+			}
+			return mcpSuccess({
+				current_phase,
+				next_phase,
+				phase_name,
+				status
+			}, `Active phase: ${phase_name ?? current_phase ?? "unknown"}`);
+		} catch (e) {
+			return mcpError("Failed: " + e.message, "Error occurred");
+		}
+	});
+	server.tool("mcp_get_guidelines", "Get project guidelines: PROJECT.md vision, config, and optionally phase-specific context.", { phase: stringType().optional().describe("Optional phase number to include phase-specific context") }, async ({ phase }) => {
+		try {
+			const cwd = detectProjectRoot();
+			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
+			const project_vision = safeReadFile(planningPath(cwd, "PROJECT.md"));
+			const config = loadConfig(cwd);
+			let phase_context = null;
+			if (phase) {
+				const phaseInfo = findPhaseInternal(cwd, phase);
+				if (phaseInfo) phase_context = safeReadFile(node_path.default.join(phaseInfo.directory, `${phaseInfo.phase_number}-CONTEXT.md`));
+			}
+			return mcpSuccess({
+				project_vision,
+				config,
+				phase_context
+			}, `Guidelines loaded${phase ? ` with phase ${phase} context` : ""}`);
+		} catch (e) {
+			return mcpError("Failed: " + e.message, "Error occurred");
+		}
+	});
+	server.tool("mcp_get_context_for_task", "Load context files for a task. Includes project context, roadmap, artefakte, and codebase docs filtered by topic. Topic keywords select relevant codebase docs: \"ui/frontend\" loads CONVENTIONS+STRUCTURE, \"api/backend\" loads ARCHITECTURE+CONVENTIONS, \"testing\" loads TESTING+CONVENTIONS, \"database\" loads ARCHITECTURE+STACK, \"refactor\" loads CONCERNS+ARCHITECTURE. Without topic, defaults to STACK+ARCHITECTURE.", {
+		phase: stringType().optional().describe("Phase number to scope context to"),
+		topic: stringType().optional().describe("Topic keywords to filter codebase docs (e.g. \"frontend\", \"api\", \"testing\", \"database\", \"refactor\")")
+	}, async ({ phase, topic }) => {
+		try {
+			const cwd = detectProjectRoot();
+			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
+			const result = cmdContextLoad(cwd, phase, topic, true);
+			if (!result.ok) return mcpError(result.error, "Context load failed");
+			return mcpSuccess({ context: result.result }, `Context loaded${phase ? ` for phase ${phase}` : ""}${topic ? ` topic "${topic}"` : ""}`);
+		} catch (e) {
+			return mcpError("Failed: " + e.message, "Error occurred");
+		}
+	});
+	server.tool("mcp_get_project_overview", "Get a high-level project overview: PROJECT.md, REQUIREMENTS.md, and STATE.md contents.", {}, async () => {
+		try {
+			const cwd = detectProjectRoot();
+			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
+			return mcpSuccess({
+				project: safeReadFile(planningPath(cwd, "PROJECT.md")),
+				requirements: safeReadFile(planningPath(cwd, "REQUIREMENTS.md")),
+				state: safeReadFile(planningPath(cwd, "STATE.md"))
+			}, "Project overview loaded");
+		} catch (e) {
+			return mcpError("Failed: " + e.message, "Error occurred");
+		}
+	});
+	server.tool("mcp_get_phase_detail", "Get detailed information about a specific phase including all its files (plans, summaries, context, research, verification).", { phase: stringType().describe("Phase number or name (e.g. \"01\", \"1\", \"01A\")") }, async ({ phase }) => {
+		try {
+			const cwd = detectProjectRoot();
+			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
+			const phaseInfo = findPhaseInternal(cwd, phase);
+			if (!phaseInfo) return mcpError(`Phase ${phase} not found`, "Phase not found");
+			const files = [];
+			try {
+				const entries = node_fs.default.readdirSync(phaseInfo.directory);
+				for (const entry of entries) {
+					const fullPath = node_path.default.join(phaseInfo.directory, entry);
+					if (node_fs.default.statSync(fullPath).isFile()) files.push({
+						name: entry,
+						content: safeReadFile(fullPath)
+					});
+				}
+			} catch {}
+			return mcpSuccess({
+				phase_number: phaseInfo.phase_number,
+				phase_name: phaseInfo.phase_name,
+				directory: phaseInfo.directory,
+				files
+			}, `Phase ${phaseInfo.phase_number} detail: ${files.length} file(s)`);
+		} catch (e) {
+			return mcpError("Failed: " + e.message, "Error occurred");
+		}
+	});
+}
+
+//#endregion
+//#region src/mcp/roadmap-tools.ts
+/**
+* Register all roadmap query tools on the MCP server.
+*/
+function registerRoadmapTools(server) {
+	server.tool("mcp_get_roadmap", "Get the full roadmap analysis including all phases, their status, and progress.", {}, async () => {
+		try {
+			const cwd = detectProjectRoot();
+			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
+			const result = await cmdRoadmapAnalyze(cwd);
+			if (!result.ok) return mcpError(result.error, "Roadmap analysis failed");
+			return mcpSuccess({ roadmap: result.result }, "Roadmap analysis complete");
+		} catch (e) {
+			return mcpError("Failed: " + e.message, "Error occurred");
+		}
+	});
+	server.tool("mcp_get_roadmap_progress", "Get a focused progress summary: total phases, completed, in-progress, not started, and progress percentage.", {}, async () => {
+		try {
+			const cwd = detectProjectRoot();
+			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
+			const result = await cmdRoadmapAnalyze(cwd);
+			if (!result.ok) return mcpError(result.error, "Roadmap analysis failed");
+			const data = result.result;
+			const phases = data.phases ?? [];
+			const total_phases = phases.length;
+			let completed = 0;
+			let in_progress = 0;
+			let not_started = 0;
+			for (const p of phases) {
+				const status = String(p.status ?? "").toLowerCase();
+				if (status === "completed" || status === "done") completed++;
+				else if (status === "in-progress" || status === "in_progress" || status === "active") in_progress++;
+				else not_started++;
+			}
+			const progress_percent = total_phases > 0 ? Math.round(completed / total_phases * 100) : 0;
+			return mcpSuccess({
+				total_phases,
+				completed,
+				in_progress,
+				not_started,
+				progress_percent,
+				current_phase: data.current_phase ?? null,
+				next_phase: data.next_phase ?? null
+			}, `Progress: ${completed}/${total_phases} phases complete (${progress_percent}%)`);
+		} catch (e) {
+			return mcpError("Failed: " + e.message, "Error occurred");
+		}
+	});
+}
+
+//#endregion
+//#region src/core/config.ts
+/**
+* Config — Planning config CRUD operations
+*
+* Ported from maxsim/bin/lib/config.cjs
+*/
+function cmdConfigSet(cwd, keyPath, value, raw) {
+	const configPath = node_path.default.join(cwd, ".planning", "config.json");
+	if (!keyPath) return cmdErr("Usage: config-set <key.path> <value>");
+	let parsedValue = value;
+	if (value === "true") parsedValue = true;
+	else if (value === "false") parsedValue = false;
+	else if (value !== void 0 && !isNaN(Number(value)) && value !== "") parsedValue = Number(value);
+	let config = {};
+	try {
+		if (node_fs.default.existsSync(configPath)) config = JSON.parse(node_fs.default.readFileSync(configPath, "utf-8"));
+	} catch (err) {
+		return cmdErr("Failed to read config.json: " + err.message);
+	}
+	const keys = keyPath.split(".");
+	let current = config;
+	for (let i = 0; i < keys.length - 1; i++) {
+		const key = keys[i];
+		if (current[key] === void 0 || typeof current[key] !== "object") current[key] = {};
+		current = current[key];
+	}
+	current[keys[keys.length - 1]] = parsedValue;
+	try {
+		node_fs.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+		return cmdOk({
+			updated: true,
+			key: keyPath,
+			value: parsedValue
+		}, raw ? `${keyPath}=${parsedValue}` : void 0);
+	} catch (err) {
+		return cmdErr("Failed to write config.json: " + err.message);
+	}
+}
+function cmdConfigGet(cwd, keyPath, raw) {
+	const configPath = node_path.default.join(cwd, ".planning", "config.json");
+	if (!keyPath) return cmdErr("Usage: config-get <key.path>");
+	let config = {};
+	try {
+		if (node_fs.default.existsSync(configPath)) config = JSON.parse(node_fs.default.readFileSync(configPath, "utf-8"));
+		else return cmdErr("No config.json found at " + configPath);
+	} catch (err) {
+		return cmdErr("Failed to read config.json: " + err.message);
+	}
+	const keys = keyPath.split(".");
+	let current = config;
+	for (const key of keys) {
+		if (current === void 0 || current === null || typeof current !== "object") return cmdErr(`Key not found: ${keyPath}`);
+		current = current[key];
+	}
+	if (current === void 0) return cmdErr(`Key not found: ${keyPath}`);
+	return cmdOk(current, raw ? String(current) : void 0);
+}
+
+//#endregion
+//#region src/mcp/config-tools.ts
+/**
+* Config Query MCP Tools — Project configuration exposed as MCP tools
+*
+* CRITICAL: Never import output() or error() from core — they call process.exit().
+* CRITICAL: Never write to stdout — it is reserved for MCP JSON-RPC protocol.
+* CRITICAL: Never call process.exit() — the server must stay alive after every tool call.
+*/
+/**
+* Register all config query tools on the MCP server.
+*/
+function registerConfigTools(server) {
+	server.tool("mcp_get_config", "Get project configuration. Optionally provide a key path to get a specific value.", { key: stringType().optional().describe("Optional dot-separated key path (e.g. \"model_profile\", \"branching.strategy\")") }, async ({ key }) => {
+		try {
+			const cwd = detectProjectRoot();
+			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
+			if (key) {
+				const result = cmdConfigGet(cwd, key, true);
+				if (!result.ok) return mcpError(result.error, "Config get failed");
+				return mcpSuccess({
+					key,
+					value: result.rawValue ?? result.result
+				}, `Config value for "${key}"`);
+			}
+			return mcpSuccess({ config: loadConfig(cwd) }, "Full configuration loaded");
+		} catch (e) {
+			return mcpError("Failed: " + e.message, "Error occurred");
+		}
+	});
+	server.tool("mcp_update_config", "Update a project configuration value by key path.", {
+		key: stringType().describe("Dot-separated key path (e.g. \"model_profile\", \"branching.strategy\")"),
+		value: stringType().describe("New value to set")
+	}, async ({ key, value }) => {
+		try {
+			const cwd = detectProjectRoot();
+			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
+			const result = cmdConfigSet(cwd, key, value, true);
+			if (!result.ok) return mcpError(result.error, "Config update failed");
+			return mcpSuccess({
+				updated: true,
+				key,
+				value
+			}, `Config "${key}" updated to "${value}"`);
+		} catch (e) {
+			return mcpError("Failed: " + e.message, "Error occurred");
+		}
+	});
+}
+
 //#endregion
 //#region src/mcp/index.ts
 /**
@@ -34254,6 +35012,9 @@ function registerAllTools(server) {
 	registerPhaseTools(server);
 	registerTodoTools(server);
 	registerStateTools(server);
+	registerContextTools(server);
+	registerRoadmapTools(server);
+	registerConfigTools(server);
 }
 
 //#endregion