maxsimcli 4.7.1 → 4.9.0

package/dist/cli.cjs

@@ -69,7 +69,15 @@ const PLANNING_CONFIG_DEFAULTS = {
 		verifier: true
 	},
 	parallelization: true,
-	brave_search: false
+	brave_search: false,
+	worktree_mode: "auto",
+	max_parallel_agents: 10,
+	review: {
+		spec_review: true,
+		code_review: true,
+		simplify_review: true,
+		retry_limit: 3
+	}
 };
 
 //#endregion
@@ -4655,73 +4663,25 @@ var require_slugify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 */
 var import_slugify = /* @__PURE__ */ __toESM(require_slugify());
 const MODEL_PROFILES = {
-	"maxsim-planner": {
-		quality: "opus",
-		balanced: "opus",
-		budget: "sonnet",
-		tokenburner: "opus"
-	},
-	"maxsim-roadmapper": {
+	"executor": {
 		quality: "opus",
 		balanced: "sonnet",
 		budget: "sonnet",
 		tokenburner: "opus"
 	},
-	"maxsim-executor": {
+	"planner": {
 		quality: "opus",
-		balanced: "sonnet",
+		balanced: "opus",
 		budget: "sonnet",
 		tokenburner: "opus"
 	},
-	"maxsim-phase-researcher": {
+	"researcher": {
 		quality: "opus",
 		balanced: "sonnet",
 		budget: "haiku",
 		tokenburner: "opus"
 	},
-	"maxsim-project-researcher": {
-		quality: "opus",
-		balanced: "sonnet",
-		budget: "haiku",
-		tokenburner: "opus"
-	},
-	"maxsim-research-synthesizer": {
-		quality: "sonnet",
-		balanced: "sonnet",
-		budget: "haiku",
-		tokenburner: "opus"
-	},
-	"maxsim-debugger": {
-		quality: "opus",
-		balanced: "sonnet",
-		budget: "sonnet",
-		tokenburner: "opus"
-	},
-	"maxsim-codebase-mapper": {
-		quality: "sonnet",
-		balanced: "haiku",
-		budget: "haiku",
-		tokenburner: "opus"
-	},
-	"maxsim-verifier": {
-		quality: "sonnet",
-		balanced: "sonnet",
-		budget: "haiku",
-		tokenburner: "opus"
-	},
-	"maxsim-plan-checker": {
-		quality: "sonnet",
-		balanced: "sonnet",
-		budget: "haiku",
-		tokenburner: "opus"
-	},
-	"maxsim-integration-checker": {
-		quality: "sonnet",
-		balanced: "sonnet",
-		budget: "haiku",
-		tokenburner: "opus"
-	},
-	"maxsim-drift-checker": {
+	"verifier": {
 		quality: "sonnet",
 		balanced: "sonnet",
 		budget: "haiku",
@@ -4921,6 +4881,12 @@ async function pathExistsInternal(p) {
 async function loadConfig(cwd) {
 	if (_configCache && _configCache.cwd === cwd) return _configCache.config;
 	const cfgPath = configPath(cwd);
+	const reviewDefaults = {
+		spec_review: true,
+		code_review: true,
+		simplify_review: true,
+		retry_limit: 3
+	};
 	const defaults = {
 		model_profile: "balanced",
 		commit_docs: true,
@@ -4932,7 +4898,10 @@ async function loadConfig(cwd) {
 		plan_checker: true,
 		verifier: true,
 		parallelization: true,
-		brave_search: false
+		brave_search: false,
+		worktree_mode: "auto",
+		max_parallel_agents: 10,
+		review: reviewDefaults
 	};
 	try {
 		const raw = await node_fs.promises.readFile(cfgPath, "utf-8");
@@ -4989,7 +4958,17 @@ async function loadConfig(cwd) {
 			}) ?? defaults.verifier,
 			parallelization,
 			brave_search: get("brave_search") ?? defaults.brave_search,
-			model_overrides: parsed["model_overrides"]
+			model_overrides: parsed["model_overrides"],
+			worktree_mode: get("worktree_mode") ?? defaults.worktree_mode,
+			max_parallel_agents: get("max_parallel_agents") ?? defaults.max_parallel_agents,
+			review: (() => {
+				const userReview = get("review");
+				if (!userReview || typeof userReview !== "object") return reviewDefaults;
+				return {
+					...reviewDefaults,
+					...userReview
+				};
+			})()
 		};
 		_configCache = {
 			cwd,
@@ -12041,6 +12020,10 @@ function cmdConfigEnsureSection(cwd, raw) {
 		workflow: {
 			...hardcoded.workflow,
 			...userDefaults.workflow || {}
+		},
+		review: {
+			...hardcoded.review,
+			...userDefaults.review || {}
 		}
 	};
 	try {
@@ -14177,6 +14160,122 @@ async function cmdVerifyKeyLinks(cwd, planFilePath) {
 		links: results
 	}, verified === results.length ? "valid" : "invalid");
 }
+/**
+* Gate G1: Validate that all requirement IDs from a plan's frontmatter exist in REQUIREMENTS.md.
+* Parses REQUIREMENTS.md for **{ID}**: patterns and checks each reqId is present.
+*/
+async function validateRequirementExistence(cwd, reqIds) {
+	const content = await safeReadFile(planningPath(cwd, "REQUIREMENTS.md"));
+	if (!content) return {
+		valid: false,
+		missing: reqIds,
+		found: []
+	};
+	const idPattern = /\*\*([A-Z]+-\d+)\*\*/g;
+	const existingIds = /* @__PURE__ */ new Set();
+	let m;
+	while ((m = idPattern.exec(content)) !== null) existingIds.add(m[1]);
+	const found = [];
+	const missing = [];
+	for (const id of reqIds) {
+		const trimmed = id.trim();
+		if (!trimmed) continue;
+		if (existingIds.has(trimmed)) found.push(trimmed);
+		else missing.push(trimmed);
+	}
+	return {
+		valid: missing.length === 0,
+		missing,
+		found
+	};
+}
+async function cmdValidateRequirementExistence(cwd, reqIds) {
+	if (!reqIds || reqIds.length === 0) return cmdErr("At least one requirement ID required");
+	const result = await validateRequirementExistence(cwd, reqIds);
+	return cmdOk(result, result.valid ? "valid" : "invalid");
+}
+/**
+* Gate G2: Validate that requirement IDs are not already marked Complete in REQUIREMENTS.md.
+* Checks checkbox status: [x] = complete, [ ] = pending.
+*/
+async function validateRequirementStatus(cwd, reqIds) {
+	const content = await safeReadFile(planningPath(cwd, "REQUIREMENTS.md"));
+	if (!content) return {
+		valid: true,
+		already_complete: [],
+		pending: reqIds
+	};
+	const lines = content.split("\n");
+	const statusMap = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		const match = line.match(/^-\s*\[([ xX])\]\s*\*\*([A-Z]+-\d+)\*\*/);
+		if (match) {
+			const isComplete = match[1].toLowerCase() === "x";
+			statusMap.set(match[2], isComplete);
+		}
+	}
+	const already_complete = [];
+	const pending = [];
+	for (const id of reqIds) {
+		const trimmed = id.trim();
+		if (!trimmed) continue;
+		if (statusMap.get(trimmed) === true) already_complete.push(trimmed);
+		else pending.push(trimmed);
+	}
+	return {
+		valid: already_complete.length === 0,
+		already_complete,
+		pending
+	};
+}
+async function cmdValidateRequirementStatus(cwd, reqIds) {
+	if (!reqIds || reqIds.length === 0) return cmdErr("At least one requirement ID required");
+	const result = await validateRequirementStatus(cwd, reqIds);
+	return cmdOk(result, result.valid ? "valid" : "invalid");
+}
+/**
+* Gate G6: Validate that SUMMARY.md has evidence for each requirement ID.
+* Parses the ## Requirement Evidence section table rows and checks Status != UNMET.
+*/
+async function validateEvidenceCompleteness(summaryPath, reqIds) {
+	const content = await safeReadFile(summaryPath);
+	if (!content) return {
+		valid: false,
+		missing_evidence: reqIds,
+		has_evidence: []
+	};
+	const sectionMatch = content.match(/##\s*Requirement Evidence[\s\S]*?(?=\n##\s|\n---\s*\n|$)/);
+	if (!sectionMatch) return {
+		valid: false,
+		missing_evidence: reqIds,
+		has_evidence: []
+	};
+	const section = sectionMatch[0];
+	const evidenceIds = /* @__PURE__ */ new Map();
+	const rowPattern = /\|\s*([A-Z]+-\d+)\s*\|[^|]*\|\s*(\w+)\s*\|/g;
+	let rm;
+	while ((rm = rowPattern.exec(section)) !== null) evidenceIds.set(rm[1], rm[2].toUpperCase());
+	const has_evidence = [];
+	const missing_evidence = [];
+	for (const id of reqIds) {
+		const trimmed = id.trim();
+		if (!trimmed) continue;
+		const status = evidenceIds.get(trimmed);
+		if (status && status !== "UNMET") has_evidence.push(trimmed);
+		else missing_evidence.push(trimmed);
+	}
+	return {
+		valid: missing_evidence.length === 0,
+		missing_evidence,
+		has_evidence
+	};
+}
+async function cmdValidateEvidenceCompleteness(cwd, summaryFilePath, reqIds) {
+	if (!summaryFilePath) return cmdErr("summary file path required");
+	if (!reqIds || reqIds.length === 0) return cmdErr("At least one requirement ID required");
+	const result = await validateEvidenceCompleteness(node_path.default.isAbsolute(summaryFilePath) ? summaryFilePath : node_path.default.join(cwd, summaryFilePath), reqIds);
+	return cmdOk(result, result.valid ? "valid" : "invalid");
+}
 async function cmdValidateConsistency(cwd) {
 	const rmPath = roadmapPath(cwd);
 	const phasesDir = phasesPath(cwd);
@@ -16044,8 +16143,8 @@ async function cmdInitExecutePhase(cwd, phase) {
 	const milestone = await getMilestoneInfo(cwd);
 	const phase_req_ids = await extractReqIds(cwd, phase);
 	return cmdOk({
-		executor_model: await resolveModelInternal(cwd, "maxsim-executor"),
-		verifier_model: await resolveModelInternal(cwd, "maxsim-verifier"),
+		executor_model: await resolveModelInternal(cwd, "executor"),
+		verifier_model: await resolveModelInternal(cwd, "verifier"),
 		commit_docs: config.commit_docs,
 		parallelization: config.parallelization,
 		branching_strategy: config.branching_strategy,
@@ -16072,7 +16171,15 @@ async function cmdInitExecutePhase(cwd, phase) {
 		config_exists: await pathExistsInternal(planningPath(cwd, "config.json")),
 		state_path: ".planning/STATE.md",
 		roadmap_path: ".planning/ROADMAP.md",
-		config_path: ".planning/config.json"
+		config_path: ".planning/config.json",
+		worktree_mode: config.worktree_mode ?? "auto",
+		max_parallel_agents: config.max_parallel_agents ?? 10,
+		review_config: config.review ?? {
+			spec_review: true,
+			code_review: true,
+			simplify_review: true,
+			retry_limit: 3
+		}
 	});
 }
 async function cmdInitPlanPhase(cwd, phase) {
@@ -16081,9 +16188,9 @@ async function cmdInitPlanPhase(cwd, phase) {
 	const phaseInfo = await findPhaseInternal(cwd, phase);
 	const phase_req_ids = await extractReqIds(cwd, phase);
 	const result = {
-		researcher_model: await resolveModelInternal(cwd, "maxsim-phase-researcher"),
-		planner_model: await resolveModelInternal(cwd, "maxsim-planner"),
-		checker_model: await resolveModelInternal(cwd, "maxsim-plan-checker"),
+		researcher_model: await resolveModelInternal(cwd, "researcher"),
+		planner_model: await resolveModelInternal(cwd, "planner"),
+		checker_model: await resolveModelInternal(cwd, "planner"),
 		research_enabled: config.research,
 		plan_checker_enabled: config.plan_checker,
 		commit_docs: config.commit_docs,
@@ -16123,9 +16230,9 @@ async function cmdInitNewProject(cwd) {
 	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: await resolveModelInternal(cwd, "maxsim-project-researcher"),
-		synthesizer_model: await resolveModelInternal(cwd, "maxsim-research-synthesizer"),
-		roadmapper_model: await resolveModelInternal(cwd, "maxsim-roadmapper"),
+		researcher_model: await resolveModelInternal(cwd, "researcher"),
+		synthesizer_model: await resolveModelInternal(cwd, "researcher"),
+		roadmapper_model: await resolveModelInternal(cwd, "planner"),
 		commit_docs: config.commit_docs,
 		project_exists: await pathExistsInternal(planningPath(cwd, "PROJECT.md")),
 		has_codebase_map: hasCodebaseMap,
@@ -16143,9 +16250,9 @@ async function cmdInitNewMilestone(cwd) {
 	const config = await loadConfig(cwd);
 	const milestone = await getMilestoneInfo(cwd);
 	return cmdOk({
-		researcher_model: await resolveModelInternal(cwd, "maxsim-project-researcher"),
-		synthesizer_model: await resolveModelInternal(cwd, "maxsim-research-synthesizer"),
-		roadmapper_model: await resolveModelInternal(cwd, "maxsim-roadmapper"),
+		researcher_model: await resolveModelInternal(cwd, "researcher"),
+		synthesizer_model: await resolveModelInternal(cwd, "researcher"),
+		roadmapper_model: await resolveModelInternal(cwd, "planner"),
 		commit_docs: config.commit_docs,
 		research_enabled: config.research,
 		current_milestone: milestone.version,
@@ -16171,10 +16278,10 @@ async function cmdInitQuick(cwd, description) {
 		debugLog(e);
 	}
 	return cmdOk({
-		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"),
+		planner_model: await resolveModelInternal(cwd, "planner"),
+		executor_model: await resolveModelInternal(cwd, "executor"),
+		checker_model: await resolveModelInternal(cwd, "planner"),
+		verifier_model: await resolveModelInternal(cwd, "verifier"),
 		commit_docs: config.commit_docs,
 		next_num: nextNum,
 		slug,
@@ -16213,8 +16320,8 @@ async function cmdInitVerifyWork(cwd, phase) {
 	const config = await loadConfig(cwd);
 	const phaseInfo = await findPhaseInternal(cwd, phase);
 	return cmdOk({
-		planner_model: await resolveModelInternal(cwd, "maxsim-planner"),
-		checker_model: await resolveModelInternal(cwd, "maxsim-plan-checker"),
+		planner_model: await resolveModelInternal(cwd, "planner"),
+		checker_model: await resolveModelInternal(cwd, "planner"),
 		commit_docs: config.commit_docs,
 		phase_found: !!phaseInfo,
 		phase_dir: phaseInfo?.directory ?? null,
@@ -16369,7 +16476,7 @@ async function cmdInitMapCodebase(cwd) {
 		debugLog(e);
 	}
 	return cmdOk({
-		mapper_model: await resolveModelInternal(cwd, "maxsim-codebase-mapper"),
+		mapper_model: await resolveModelInternal(cwd, "researcher"),
 		commit_docs: config.commit_docs,
 		search_gitignored: config.search_gitignored,
 		parallelization: config.parallelization,
@@ -16395,10 +16502,10 @@ async function cmdInitExisting(cwd) {
 		debugLog(e);
 	}
 	return cmdOk({
-		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"),
+		researcher_model: await resolveModelInternal(cwd, "researcher"),
+		synthesizer_model: await resolveModelInternal(cwd, "researcher"),
+		roadmapper_model: await resolveModelInternal(cwd, "planner"),
+		mapper_model: await resolveModelInternal(cwd, "researcher"),
 		commit_docs: config.commit_docs,
 		project_exists: await pathExistsInternal(planningPath(cwd, "PROJECT.md")),
 		planning_exists: await pathExistsInternal(planningPath(cwd)),
@@ -16459,8 +16566,8 @@ async function cmdInitProgress(cwd) {
 		debugLog(e);
 	}
 	return cmdOk({
-		executor_model: await resolveModelInternal(cwd, "maxsim-executor"),
-		planner_model: await resolveModelInternal(cwd, "maxsim-planner"),
+		executor_model: await resolveModelInternal(cwd, "executor"),
+		planner_model: await resolveModelInternal(cwd, "planner"),
 		commit_docs: config.commit_docs,
 		milestone_version: milestone.version,
 		milestone_name: milestone.name,
@@ -16499,8 +16606,8 @@ async function cmdInitExecutor(cwd, phase) {
 	const phaseInfo = await findPhaseInternal(cwd, phase);
 	const codebaseDocs = listCodebaseDocs(cwd);
 	const result = {
-		executor_model: await resolveModelInternal(cwd, "maxsim-executor"),
-		verifier_model: await resolveModelInternal(cwd, "maxsim-verifier"),
+		executor_model: await resolveModelInternal(cwd, "executor"),
+		verifier_model: await resolveModelInternal(cwd, "verifier"),
 		commit_docs: config.commit_docs,
 		parallelization: config.parallelization,
 		branching_strategy: config.branching_strategy,
@@ -16523,8 +16630,8 @@ async function cmdInitPlanner(cwd, phase) {
 	const phase_req_ids = await extractReqIds(cwd, phase);
 	const codebaseDocs = listCodebaseDocs(cwd);
 	const result = {
-		planner_model: await resolveModelInternal(cwd, "maxsim-planner"),
-		checker_model: await resolveModelInternal(cwd, "maxsim-plan-checker"),
+		planner_model: await resolveModelInternal(cwd, "planner"),
+		checker_model: await resolveModelInternal(cwd, "planner"),
 		commit_docs: config.commit_docs,
 		research_enabled: config.research,
 		plan_checker_enabled: config.plan_checker,
@@ -16557,7 +16664,7 @@ async function cmdInitResearcher(cwd, phase) {
 	const phase_req_ids = await extractReqIds(cwd, phase);
 	const codebaseDocs = listCodebaseDocs(cwd);
 	const result = {
-		researcher_model: await resolveModelInternal(cwd, "maxsim-phase-researcher"),
+		researcher_model: await resolveModelInternal(cwd, "researcher"),
 		commit_docs: config.commit_docs,
 		brave_search: config.brave_search,
 		phase_found: !!phaseInfo,
@@ -16587,7 +16694,7 @@ async function cmdInitVerifier(cwd, phase) {
 	const phase_req_ids = await extractReqIds(cwd, phase);
 	const codebaseDocs = listCodebaseDocs(cwd);
 	return cmdOk({
-		verifier_model: await resolveModelInternal(cwd, "maxsim-verifier"),
+		verifier_model: await resolveModelInternal(cwd, "verifier"),
 		commit_docs: config.commit_docs,
 		phase_found: !!phaseInfo,
 		phase_dir: phaseInfo?.directory ?? null,
@@ -16605,7 +16712,7 @@ async function cmdInitDebugger(cwd, phase) {
 	const phaseInfo = phase ? await findPhaseInternal(cwd, phase) : null;
 	const codebaseDocs = listCodebaseDocs(cwd);
 	const result = {
-		debugger_model: await resolveModelInternal(cwd, "maxsim-debugger"),
+		debugger_model: await resolveModelInternal(cwd, "verifier"),
 		commit_docs: config.commit_docs,
 		phase_found: !!phaseInfo,
 		phase_dir: phaseInfo?.directory ?? null,
@@ -16619,7 +16726,7 @@ async function cmdInitDebugger(cwd, phase) {
 }
 async function cmdInitCheckDrift(cwd) {
 	const config = await loadConfig(cwd);
-	const driftModel = await resolveModelInternal(cwd, "maxsim-drift-checker");
+	const driftModel = await resolveModelInternal(cwd, "verifier");
 	const hasPlanning = await pathExistsInternal(planningPath(cwd));
 	const hasRequirements = await pathExistsInternal(planningPath(cwd, "REQUIREMENTS.md"));
 	const hasRoadmap = await pathExistsInternal(planningPath(cwd, "ROADMAP.md"));
@@ -16686,6 +16793,285 @@ async function cmdInitRealign(cwd, direction) {
 	});
 }
 
+//#endregion
+//#region src/core/worktree.ts
+/**
+* Worktree — Git worktree lifecycle management for parallel execution
+*
+* Provides functions to create, list, cleanup worktrees and to assign
+* plans to worktree slots for batch execution.
+*/
+const WORKTREE_DIR = ".maxsim-worktrees";
+const WORKTREE_BRANCH_PREFIX = "maxsim/worktree";
+/** Ensure .maxsim-worktrees/ directory exists */
+function ensureWorktreeDir(cwd) {
+	const dir = node_path.default.join(cwd, WORKTREE_DIR);
+	if (!node_fs.default.existsSync(dir)) node_fs.default.mkdirSync(dir, { recursive: true });
+	return dir;
+}
+/** Add .maxsim-worktrees/ to .gitignore if not already present */
+function ensureGitignoreEntry(cwd) {
+	const gitignorePath = node_path.default.join(cwd, ".gitignore");
+	const entry = WORKTREE_DIR + "/";
+	try {
+		if (node_fs.default.existsSync(gitignorePath)) {
+			if (node_fs.default.readFileSync(gitignorePath, "utf-8").includes(WORKTREE_DIR)) return;
+			node_fs.default.appendFileSync(gitignorePath, "\n" + entry + "\n", "utf-8");
+		} else node_fs.default.writeFileSync(gitignorePath, entry + "\n", "utf-8");
+	} catch (e) {
+		debugLog("worktree-gitignore-failed", errorMsg(e));
+	}
+}
+/**
+* Create a new git worktree for a plan.
+* Branch: maxsim/worktree-{phaseNum}-{planId}
+* Path: {cwd}/.maxsim-worktrees/{planId}
+*/
+async function createWorktree(cwd, phaseNum, planId, wave) {
+	ensureWorktreeDir(cwd);
+	ensureGitignoreEntry(cwd);
+	const branch = `${WORKTREE_BRANCH_PREFIX}-${phaseNum}-${planId}`;
+	const worktreePath = node_path.default.join(cwd, WORKTREE_DIR, planId);
+	const git = simpleGit(cwd);
+	try {
+		await git.raw([
+			"worktree",
+			"add",
+			"-b",
+			branch,
+			worktreePath
+		]);
+	} catch (e) {
+		const msg = errorMsg(e);
+		if (msg.includes("already exists")) try {
+			await git.raw([
+				"worktree",
+				"add",
+				worktreePath,
+				branch
+			]);
+		} catch (e2) {
+			throw new Error(`Failed to create worktree: ${errorMsg(e2)}`);
+		}
+		else throw new Error(`Failed to create worktree: ${msg}`);
+	}
+	return {
+		id: planId,
+		path: worktreePath,
+		branch,
+		wave,
+		plan_id: planId,
+		status: "active",
+		created_at: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+/**
+* List all MAXSIM-managed worktrees.
+* Parses `git worktree list --porcelain` and filters to .maxsim-worktrees/.
+*/
+async function listWorktrees(cwd) {
+	const git = simpleGit(cwd);
+	const worktrees = [];
+	try {
+		const blocks = (await git.raw([
+			"worktree",
+			"list",
+			"--porcelain"
+		])).split("\n\n").filter((b) => b.trim());
+		for (const block of blocks) {
+			const lines = block.split("\n");
+			let wtPath = "";
+			let branch = "";
+			for (const line of lines) if (line.startsWith("worktree ")) wtPath = line.slice(9).trim();
+			else if (line.startsWith("branch ")) branch = line.slice(7).trim().replace("refs/heads/", "");
+			if (!wtPath || !wtPath.includes(WORKTREE_DIR)) continue;
+			const planId = node_path.default.basename(wtPath);
+			worktrees.push({
+				id: planId,
+				path: wtPath,
+				branch,
+				wave: 0,
+				plan_id: planId,
+				status: "active",
+				created_at: ""
+			});
+		}
+	} catch (e) {
+		debugLog("worktree-list-failed", errorMsg(e));
+	}
+	return worktrees;
+}
+/**
+* Remove a single worktree by its ID (directory name under .maxsim-worktrees/).
+* Removes the worktree and deletes the branch.
+*/
+async function cleanupWorktree(cwd, worktreeId) {
+	const git = simpleGit(cwd);
+	const worktreePath = node_path.default.join(cwd, WORKTREE_DIR, worktreeId);
+	try {
+		await git.raw([
+			"worktree",
+			"remove",
+			worktreePath
+		]);
+	} catch (e) {
+		debugLog("worktree-remove-failed", errorMsg(e));
+		try {
+			await git.raw([
+				"worktree",
+				"remove",
+				"--force",
+				worktreePath
+			]);
+		} catch (e2) {
+			debugLog("worktree-force-remove-failed", errorMsg(e2));
+			try {
+				if (node_fs.default.existsSync(worktreePath)) node_fs.default.rmSync(worktreePath, {
+					recursive: true,
+					force: true
+				});
+				await git.raw(["worktree", "prune"]);
+			} catch (e3) {
+				throw new Error(`Failed to cleanup worktree ${worktreeId}: ${errorMsg(e3)}`);
+			}
+		}
+	}
+	try {
+		const branchName = (await git.raw([
+			"branch",
+			"--list",
+			`${WORKTREE_BRANCH_PREFIX}-*${worktreeId}*`
+		])).trim().replace(/^\*?\s*/, "").split("\n")[0]?.trim();
+		if (branchName) await git.raw([
+			"branch",
+			"-D",
+			branchName
+		]);
+	} catch (e) {
+		debugLog("worktree-branch-delete-failed", errorMsg(e));
+	}
+}
+/**
+* Remove all MAXSIM-managed worktrees.
+* Returns the count of worktrees removed.
+*/
+async function cleanupAllWorktrees(cwd) {
+	const worktrees = await listWorktrees(cwd);
+	let removed = 0;
+	for (const wt of worktrees) try {
+		await cleanupWorktree(cwd, wt.id);
+		removed++;
+	} catch (e) {
+		debugLog("worktree-cleanup-failed", {
+			id: wt.id,
+			error: errorMsg(e)
+		});
+	}
+	const worktreeDir = node_path.default.join(cwd, WORKTREE_DIR);
+	try {
+		if (node_fs.default.existsSync(worktreeDir)) {
+			if (node_fs.default.readdirSync(worktreeDir).length === 0) node_fs.default.rmSync(worktreeDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	} catch (e) {
+		debugLog("worktree-dir-cleanup-failed", errorMsg(e));
+	}
+	return removed;
+}
+/**
+* Pure function: decide whether to use batch (worktree) or standard execution mode.
+*
+* Returns 'batch' if:
+* - flagOverride is 'worktrees', OR
+* - worktree_mode is 'always', OR
+* - worktree_mode is 'auto' AND waveCount === 1 AND planCount > 2
+*
+* Returns 'standard' if:
+* - flagOverride is 'no-worktrees', OR
+* - worktree_mode is 'never', OR
+* - auto-detect doesn't trigger
+*/
+function decideExecutionMode(planCount, waveCount, config) {
+	if (config.flagOverride === "worktrees") return "batch";
+	if (config.flagOverride === "no-worktrees") return "standard";
+	if (config.worktree_mode === "always") return "batch";
+	if (config.worktree_mode === "never") return "standard";
+	if (config.worktree_mode === "auto" && waveCount === 1 && planCount > 2) return "batch";
+	return "standard";
+}
+/**
+* Pure function: validate that plans are independent (no file overlaps).
+* Returns conflicts if any file appears in multiple plans.
+*/
+function validatePlanIndependence(plans) {
+	const fileMap = /* @__PURE__ */ new Map();
+	for (const plan of plans) for (const file of plan.files_modified) {
+		const normalized = file.replace(/\\/g, "/");
+		const existing = fileMap.get(normalized) || [];
+		existing.push(plan.id);
+		fileMap.set(normalized, existing);
+	}
+	const conflicts = [];
+	for (const [file, planIds] of fileMap) if (planIds.length > 1) conflicts.push({
+		file,
+		plans: planIds
+	});
+	return {
+		valid: conflicts.length === 0,
+		conflicts
+	};
+}
+async function cmdWorktreeCreate(cwd, phaseNum, planId, wave) {
+	if (!phaseNum) return cmdErr("phaseNum required for worktree-create");
+	if (!planId) return cmdErr("planId required for worktree-create");
+	const waveNum = wave ? parseInt(wave, 10) : 1;
+	try {
+		return cmdOk(await createWorktree(cwd, phaseNum, planId, waveNum));
+	} catch (e) {
+		return cmdErr(`worktree-create failed: ${errorMsg(e)}`);
+	}
+}
+async function cmdWorktreeList(cwd) {
+	try {
+		return cmdOk(await listWorktrees(cwd));
+	} catch (e) {
+		return cmdErr(`worktree-list failed: ${errorMsg(e)}`);
+	}
+}
+async function cmdWorktreeCleanup(cwd, worktreeId, all) {
+	try {
+		if (all) return cmdOk({
+			removed: await cleanupAllWorktrees(cwd),
+			all: true
+		});
+		if (!worktreeId) return cmdErr("worktreeId required for worktree-cleanup (or use --all)");
+		await cleanupWorktree(cwd, worktreeId);
+		return cmdOk({
+			removed: 1,
+			worktree_id: worktreeId
+		});
+	} catch (e) {
+		return cmdErr(`worktree-cleanup failed: ${errorMsg(e)}`);
+	}
+}
+function cmdDecideExecutionMode(planCount, waveCount, worktreeMode, flagOverride) {
+	if (!planCount || !waveCount) return cmdErr("planCount and waveCount required");
+	return cmdOk({ mode: decideExecutionMode(parseInt(planCount, 10), parseInt(waveCount, 10), {
+		worktree_mode: worktreeMode || "auto",
+		flagOverride
+	}) });
+}
+function cmdValidatePlanIndependence(plansJson) {
+	if (!plansJson) return cmdErr("plans JSON required");
+	try {
+		return cmdOk(validatePlanIndependence(JSON.parse(plansJson)));
+	} catch (e) {
+		return cmdErr(`validate-plan-independence failed: ${errorMsg(e)}`);
+	}
+}
+
 //#endregion
 //#region src/cli.ts
 /**
@@ -16806,10 +17192,13 @@ const handleVerify = async (args, cwd, raw) => {
 		"references": async () => handleResult(await cmdVerifyReferences(cwd, args[2]), raw),
 		"commits": async () => handleResult(await cmdVerifyCommits(cwd, args.slice(2)), raw),
 		"artifacts": async () => handleResult(await cmdVerifyArtifacts(cwd, args[2]), raw),
-		"key-links": async () => handleResult(await cmdVerifyKeyLinks(cwd, args[2]), raw)
+		"key-links": async () => handleResult(await cmdVerifyKeyLinks(cwd, args[2]), raw),
+		"requirement-existence": async () => handleResult(await cmdValidateRequirementExistence(cwd, args.slice(2)), raw),
+		"requirement-status": async () => handleResult(await cmdValidateRequirementStatus(cwd, args.slice(2)), raw),
+		"evidence-completeness": async () => handleResult(await cmdValidateEvidenceCompleteness(cwd, args[2], args.slice(3)), raw)
 	}[sub] : void 0;
 	if (handler) return handler();
-	error("Unknown verify subcommand. Available: plan-structure, phase-completeness, references, commits, artifacts, key-links");
+	error("Unknown verify subcommand. Available: plan-structure, phase-completeness, references, commits, artifacts, key-links, requirement-existence, requirement-status, evidence-completeness");
 };
 const handlePhases = async (args, cwd, raw) => {
 	if (args[1] === "list") {
@@ -16887,6 +17276,16 @@ const handleDrift = async (args, cwd, 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 handleWorktree = async (args, cwd, raw) => {
+	const sub = args[1];
+	const handler = sub ? {
+		"create": () => cmdWorktreeCreate(cwd, args[2], args[3], args[4]),
+		"list": () => cmdWorktreeList(cwd),
+		"cleanup": () => cmdWorktreeCleanup(cwd, args[2], hasFlag(args, "all"))
+	}[sub] : void 0;
+	if (handler) return handleResult(await handler(), raw);
+	error("Unknown worktree subcommand. Available: create, list, cleanup");
+};
 const handleInit = async (args, cwd, raw) => {
 	const workflow = args[1];
 	const handler = workflow ? {
@@ -16948,6 +17347,12 @@ const COMMANDS = {
 	"milestone": handleMilestone,
 	"validate": handleValidate,
 	"drift": handleDrift,
+	"worktree": handleWorktree,
+	"decide-execution-mode": (args, _cwd, raw) => {
+		const f = getFlags(args, "worktree-mode", "flag-override");
+		handleResult(cmdDecideExecutionMode(args[1], args[2], f["worktree-mode"] ?? void 0, f["flag-override"] ?? void 0), raw);
+	},
+	"validate-plan-independence": (args, _cwd, raw) => handleResult(cmdValidatePlanIndependence(args[1]), 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);