contentrain 0.4.4 → 0.5.0

package/dist/{server-DTdmutjb.mjs → server-B1PSjXbu.mjs}

@@ -1,16 +1,90 @@
-import { simpleGit } from "simple-git";
-import { CONTENTRAIN_BRANCH } from "@contentrain/types";
-import { tmpdir } from "node:os";
-import { randomUUID } from "node:crypto";
 import { join } from "node:path";
-import { readFile, unlink, writeFile } from "node:fs/promises";
-import { existsSync, readFileSync } from "node:fs";
+import { readConfig } from "@contentrain/mcp/core/config";
 import { createServer } from "@contentrain/mcp/server";
-import { createApp, createError, createRouter, defineEventHandler, getQuery, getRouterParam, readBody, toNodeListener } from "h3";
-import { WebSocketServer } from "ws";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { simpleGit } from "simple-git";
+import { CONTENTRAIN_BRANCH, LOCAL_CAPABILITIES } from "@contentrain/types";
+import { mergeBranch } from "@contentrain/mcp/git/transaction";
+import { branchDiff, checkBranchHealth } from "@contentrain/mcp/git/branch-lifecycle";
+import { existsSync, readFileSync } from "node:fs";
+import { readFile, unlink, writeFile } from "node:fs/promises";
+import { createApp, createError, createRouter, defineEventHandler, getQuery, getRouterParam, readBody, toNodeListener } from "h3";
+import { WebSocketServer } from "ws";
 import { watch as watch$1 } from "chokidar";
+import { z } from "zod";
+//#region src/serve/schemas.ts
+/**
+* Zod schemas for `contentrain serve` HTTP write routes.
+*
+* Each schema validates the request body BEFORE it reaches the MCP
+* tool layer. Catches malformed payloads (wrong types, extra fields,
+* path-traversal candidates) with structured 400 errors instead of
+* propagating them into git operations where they would be much
+* harder to diagnose.
+*
+* Schemas are intentionally conservative — they match the loosest
+* shape the underlying MCP tool accepts. A request that passes the
+* schema is guaranteed to at least REACH the MCP tool; whether the
+* tool accepts it (e.g. for domain-specific validation) is a separate
+* concern surfaced as an MCP-level error.
+*/
+const branchNameRegex = /^cr\/[a-z0-9-_/]+(?:\/[a-z0-9-]+)*\/\d+-[a-z0-9]+$/u;
+/** `cr/*` feature branch name. Legacy `contentrain/*` is explicitly rejected — old branches are auto-migrated on init. */
+const BranchNameSchema = z.string().min(1, "Branch name is required").regex(/^cr\//u, "Branch must start with \"cr/\"").refine((n) => branchNameRegex.test(n) || n.startsWith("cr/"), { message: "Invalid branch name format" });
+/** Body for `/api/content/:modelId/:entryId/fix`. */
+const ContentFixBodySchema = z.object({
+	locale: z.string().min(1).optional(),
+	data: z.record(z.string(), z.unknown())
+});
+/** Body for `/api/branches/approve` and `/api/branches/reject` and `/api/normalize/approve`. */
+const BranchActionBodySchema = z.object({ branch: BranchNameSchema });
+/** Body for `/api/normalize/apply` — mirrors contentrain_apply tool input, slimmed. */
+const NormalizeApplyBodySchema = z.object({
+	mode: z.enum(["extract", "reuse"]),
+	dry_run: z.boolean().optional().default(true),
+	extractions: z.array(z.unknown()).optional(),
+	scope: z.object({
+		model: z.string().optional(),
+		domain: z.string().optional()
+	}).optional(),
+	patches: z.array(z.unknown()).optional()
+}).passthrough();
+/** Body for `/api/normalize/plan/approve`. */
+const NormalizePlanApproveBodySchema = z.object({ models: z.array(z.string()).optional() });
+/**
+* Body for `/api/normalize/plan/reject`. Currently the route only
+* deletes the plan file, but we validate the body shape anyway so
+* any future caller that wants to record a rejection reason has a
+* well-defined contract. Both an empty body and `{ reason? }` pass.
+*/
+const NormalizePlanRejectBodySchema = z.object({ reason: z.string().max(500).optional() }).optional();
+/** Query params for `/api/normalize/file-context`. */
+const FileContextQuerySchema = z.object({
+	file: z.string().min(1).refine((p) => !p.includes(".."), { message: "Path traversal segments (\"..\") are not allowed" }).refine((p) => !p.startsWith("/") && !/^[a-zA-Z]:/u.test(p), { message: "Absolute paths are not allowed" }),
+	line: z.coerce.number().int().min(1).optional(),
+	range: z.coerce.number().int().min(0).max(50).optional()
+});
+/**
+* Parse a body with a schema and either return the typed value or
+* throw an h3-compatible 400 error. Keeps route handlers readable.
+*
+* Generic constraint is `z.ZodTypeAny` so the inferred type propagates
+* as `z.infer<T>` rather than the looser `T` that `z.ZodType<T>`
+* infers to at call sites.
+*/
+function parseOrThrow(schema, value, kind = "body") {
+	const result = schema.safeParse(value);
+	if (!result.success) {
+		const details = result.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+		const err = /* @__PURE__ */ new Error(`Invalid ${kind}: ${details}`);
+		err.statusCode = 400;
+		err.data = { issues: result.error.issues };
+		throw err;
+	}
+	return result.data;
+}
+//#endregion
 //#region src/serve/server.ts
 function apiError(error) {
 	if (error && typeof error === "object" && "statusCode" in error) {
@@ -36,6 +110,8 @@ async function createServeApp(options) {
 		} catch {}
 		return "main";
 	}
+	const syncWarnings = /* @__PURE__ */ new Map();
+	const SYNC_WARNING_TTL_MS = 3600 * 1e3;
 	const mcpServer = createServer(projectRoot);
 	const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
 	const mcpClient = new Client({
@@ -137,21 +213,79 @@ async function createServeApp(options) {
 					modelId: parts[1],
 					locale: parts[2]?.replace(".json", "")
 				};
+			} else if (rel.startsWith("meta/") && rel.endsWith(".json")) {
+				const parts = rel.replace("meta/", "").split("/");
+				const locale = parts[parts.length - 1]?.replace(".json", "");
+				const modelId = parts[0];
+				const entryId = parts.length === 3 ? parts[1] : void 0;
+				event = entryId ? {
+					type: "meta:changed",
+					modelId,
+					entryId,
+					locale
+				} : {
+					type: "meta:changed",
+					modelId,
+					locale
+				};
 			} else return;
 			pendingEvents.push(event);
 			if (debounceTimer) clearTimeout(debounceTimer);
 			debounceTimer = setTimeout(flush, 300);
 		});
+		watcher.on("error", (err) => {
+			broadcast({
+				type: "file-watch:error",
+				message: err instanceof Error ? err.message : String(err),
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		});
 	}
 	router.add("/api/status", defineEventHandler(async () => {
 		return await callTool("contentrain_status");
 	}));
+	router.add("/api/capabilities", defineEventHandler(async () => {
+		const config = await readConfig(projectRoot).catch(() => null);
+		const health = await checkBranchHealth(projectRoot).catch(() => null);
+		return {
+			version: 1,
+			provider: {
+				type: "local",
+				repo: config?.repository ?? null
+			},
+			transport: "stdio",
+			capabilities: LOCAL_CAPABILITIES,
+			contentBranch: CONTENTRAIN_BRANCH,
+			defaultBranch: getDefaultBranch(),
+			branchHealth: health
+		};
+	}));
+	router.add("/api/branches/:name/sync-status", defineEventHandler(async (event) => {
+		const name = getRouterParam(event, "name");
+		if (!name) throw createError({
+			statusCode: 400,
+			message: "Missing branch name"
+		});
+		const warning = syncWarnings.get(name);
+		if (warning && Date.now() - warning.recordedAt > SYNC_WARNING_TTL_MS) {
+			syncWarnings.delete(name);
+			return { warning: null };
+		}
+		return { warning: warning ?? null };
+	}));
 	router.add("/api/describe/:modelId", defineEventHandler(async (event) => {
 		return await callTool("contentrain_describe", {
 			model: getRouterParam(event, "modelId"),
 			include_sample: true
 		});
 	}));
+	router.add("/api/describe-format", defineEventHandler(async () => {
+		return await callTool("contentrain_describe_format");
+	}));
+	router.add("/api/doctor", defineEventHandler(async (event) => {
+		const query = getQuery(event);
+		return await callTool("contentrain_doctor", { usage: query["usage"] === "true" || query["usage"] === "1" });
+	}));
 	router.add("/api/content/:modelId", defineEventHandler(async (event) => {
 		const modelId = getRouterParam(event, "modelId");
 		const query = getQuery(event);
@@ -179,7 +313,7 @@ async function createServeApp(options) {
 		});
 		const modelId = getRouterParam(event, "modelId");
 		const entryId = getRouterParam(event, "entryId");
-		const body = await readBody(event);
+		const body = parseOrThrow(ContentFixBodySchema, await readBody(event));
 		const result = await callTool("contentrain_content_save", {
 			model: modelId,
 			entries: [{
@@ -221,13 +355,86 @@ async function createServeApp(options) {
 			statusCode: 400,
 			message: "Invalid branch name"
 		});
+		const result = await branchDiff(projectRoot, { branch: branchName });
+		return {
+			branch: result.branch,
+			base: result.base,
+			stat: result.stat,
+			diff: result.patch,
+			filesChanged: result.filesChanged
+		};
+	}));
+	router.add("/api/preview/merge", defineEventHandler(async (event) => {
+		const branchName = getQuery(event)["branch"];
+		if (!branchName || !branchName.startsWith("cr/")) throw createError({
+			statusCode: 400,
+			message: "Missing or invalid `branch` query (must start with \"cr/\")"
+		});
 		const git = simpleGit(projectRoot);
-		const defaultBranch = getDefaultBranch();
+		if (!(await git.branchLocal()).all.includes(branchName)) throw createError({
+			statusCode: 404,
+			message: `Branch "${branchName}" does not exist locally`
+		});
+		let alreadyMerged = false;
+		let canFastForward = false;
+		try {
+			await git.raw([
+				"merge-base",
+				"--is-ancestor",
+				branchName,
+				CONTENTRAIN_BRANCH
+			]);
+			alreadyMerged = true;
+		} catch {}
+		if (!alreadyMerged) try {
+			await git.raw([
+				"merge-base",
+				"--is-ancestor",
+				CONTENTRAIN_BRANCH,
+				branchName
+			]);
+			canFastForward = true;
+		} catch {}
+		let conflicts = null;
+		try {
+			const mergeBase = (await git.raw([
+				"merge-base",
+				CONTENTRAIN_BRANCH,
+				branchName
+			])).trim();
+			if (mergeBase) {
+				const out = await git.raw([
+					"merge-tree",
+					mergeBase,
+					CONTENTRAIN_BRANCH,
+					branchName
+				]);
+				const paths = /* @__PURE__ */ new Set();
+				const conflictBlockRegex = /^(?:changed in both|added in both|removed in (?:local|remote))\b[^\n]*\n((?:[ \t][^\n]*\n)+)/gmu;
+				let match;
+				while ((match = conflictBlockRegex.exec(out)) !== null) {
+					const block = match[1] ?? "";
+					const pathMatch = /\b100644\s+[0-9a-f]{4,}\s+(\S+)/u.exec(block);
+					if (pathMatch?.[1]) paths.add(pathMatch[1]);
+				}
+				conflicts = [...paths];
+			}
+		} catch {}
+		let stat = "";
+		let filesChanged = 0;
+		if (!alreadyMerged) try {
+			const diff = await branchDiff(projectRoot, { branch: branchName });
+			stat = diff.stat;
+			filesChanged = diff.filesChanged;
+		} catch {}
 		return {
 			branch: branchName,
-			base: defaultBranch,
-			stat: await git.diff([`${defaultBranch}...${branchName}`, "--stat"]),
-			diff: await git.diff([`${defaultBranch}...${branchName}`])
+			base: CONTENTRAIN_BRANCH,
+			alreadyMerged,
+			canFastForward,
+			conflicts,
+			filesChanged,
+			stat
 		};
 	}));
 	router.add("/api/branches/approve", defineEventHandler(async (event) => {
@@ -235,37 +442,22 @@ async function createServeApp(options) {
 			statusCode: 405,
 			message: "Method not allowed"
 		});
-		const branchName = (await readBody(event)).branch;
-		if (!branchName?.startsWith("cr/")) throw createError({
-			statusCode: 400,
-			message: "Invalid branch name"
-		});
-		const git = simpleGit(projectRoot);
-		const baseBranch = getDefaultBranch();
-		if (!(await git.branchLocal()).all.includes(CONTENTRAIN_BRANCH)) await git.branch([CONTENTRAIN_BRANCH, baseBranch]);
-		const mergePath = join(tmpdir(), `cr-merge-${randomUUID()}`);
-		await git.raw([
-			"worktree",
-			"add",
-			mergePath,
-			CONTENTRAIN_BRANCH
-		]);
-		const mergeGit = simpleGit(mergePath);
+		const { branch: branchName } = parseOrThrow(BranchActionBodySchema, await readBody(event));
 		try {
-			await mergeGit.merge([baseBranch, "--no-edit"]).catch(() => {});
-			await mergeGit.merge([branchName, "--no-edit"]);
-			const tip = (await mergeGit.raw(["rev-parse", "HEAD"])).trim();
-			await git.raw([
-				"update-ref",
-				`refs/heads/${baseBranch}`,
-				tip
-			]);
-			if ((await git.raw(["branch", "--show-current"])).trim() === baseBranch) await git.checkout([
-				tip,
-				"--",
-				".contentrain/"
-			]);
-			await git.deleteLocalBranch(branchName, true);
+			const result = await mergeBranch(projectRoot, branchName);
+			if (result.sync?.skipped?.length) {
+				syncWarnings.set(branchName, {
+					branch: branchName,
+					skipped: result.sync.skipped,
+					synced: result.sync.synced,
+					recordedAt: Date.now()
+				});
+				broadcast({
+					type: "sync:warning",
+					branch: branchName,
+					skippedCount: result.sync.skipped.length
+				});
+			}
 			broadcast({
 				type: "branch:merged",
 				branch: branchName
@@ -273,15 +465,21 @@ async function createServeApp(options) {
 			return {
 				status: "merged",
 				branch: branchName,
-				into: baseBranch
+				commit: result.commit,
+				action: result.action,
+				sync: result.sync
 			};
-		} finally {
-			await git.raw([
-				"worktree",
-				"remove",
-				mergePath,
-				"--force"
-			]).catch(() => {});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			broadcast({
+				type: "branch:merge-conflict",
+				branch: branchName,
+				message
+			});
+			throw createError({
+				statusCode: 409,
+				message: `Merge failed: ${message}`
+			});
 		}
 	}));
 	router.add("/api/branches/reject", defineEventHandler(async (event) => {
@@ -289,12 +487,13 @@ async function createServeApp(options) {
 			statusCode: 405,
 			message: "Method not allowed"
 		});
-		const branchName = (await readBody(event)).branch;
-		if (!branchName?.startsWith("cr/")) throw createError({
-			statusCode: 400,
-			message: "Invalid branch name"
-		});
+		const { branch: branchName } = parseOrThrow(BranchActionBodySchema, await readBody(event));
 		await simpleGit(projectRoot).deleteLocalBranch(branchName, true);
+		syncWarnings.delete(branchName);
+		broadcast({
+			type: "branch:rejected",
+			branch: branchName
+		});
 		return {
 			status: "deleted",
 			branch: branchName
@@ -303,7 +502,7 @@ async function createServeApp(options) {
 	router.add("/api/history", defineEventHandler(async (event) => {
 		const query = getQuery(event);
 		const limit = Number(query["limit"]) || 50;
-		const entries = (await simpleGit(projectRoot).log({
+		const log = await simpleGit(projectRoot).log({
 			maxCount: limit * 2,
 			format: {
 				hash: "%h",
@@ -314,9 +513,11 @@ async function createServeApp(options) {
 				date: "%aI",
 				relativeDate: "%ar"
 			}
-		})).all.filter((c) => {
+		});
+		const mergeBranchPattern = /^Merge branch '(cr\/|contentrain\/)/u;
+		const entries = log.all.filter((c) => {
 			const msg = c.message ?? "";
-			return msg.startsWith("[contentrain]") || msg.startsWith("Merge branch 'contentrain/") || msg.includes("contentrain");
+			return msg.startsWith("[contentrain]") || mergeBranchPattern.test(msg);
 		}).slice(0, limit).map((c) => {
 			const msg = c.message ?? "";
 			let type = "other";
@@ -330,13 +531,13 @@ async function createServeApp(options) {
 			} else if (msg.startsWith("[contentrain] content:")) {
 				type = "content_save";
 				target = msg.replace("[contentrain] content: ", "");
-			} else if (msg.startsWith("[contentrain] deleted:")) {
+			} else if (msg.startsWith("[contentrain] deleted:") || msg.startsWith("[contentrain] delete")) {
 				type = "delete";
-				target = msg.replace("[contentrain] deleted: ", "");
+				target = msg.replace(/^\[contentrain\] delete(?:d)?:?\s*/u, "");
 			} else if (msg.startsWith("[contentrain] update context")) type = "context_update";
-			else if (msg.startsWith("Merge branch 'contentrain/")) {
+			else if (mergeBranchPattern.test(msg)) {
 				type = "merge";
-				target = msg.replace("Merge branch '", "").replace("'", "");
+				target = msg.replace(/^Merge branch '/u, "").replace(/'$/u, "");
 			} else if (msg.startsWith("[contentrain]")) {
 				type = "operation";
 				target = msg.replace("[contentrain] ", "");
@@ -466,6 +667,10 @@ async function createServeApp(options) {
 			statusCode: 405,
 			message: "Method not allowed"
 		});
+		if (event.method === "POST") {
+			const raw = await readBody(event).catch(() => void 0);
+			if (raw !== void 0) parseOrThrow(NormalizePlanRejectBodySchema, raw);
+		}
 		const planPath = join(crDir, "normalize-plan.json");
 		if (existsSync(planPath)) await unlink(planPath);
 		broadcast({ type: "normalize:plan-updated" });
@@ -481,9 +686,9 @@ async function createServeApp(options) {
 			statusCode: 404,
 			message: "No normalize plan found"
 		});
-		const raw = await readFile(planPath, "utf-8");
-		const plan = JSON.parse(raw);
-		const selectedModels = (await readBody(event))?.models;
+		const rawPlan = await readFile(planPath, "utf-8");
+		const plan = JSON.parse(rawPlan);
+		const selectedModels = parseOrThrow(NormalizePlanApproveBodySchema, await readBody(event)).models;
 		plan.status = "approved";
 		plan.approved_at = (/* @__PURE__ */ new Date()).toISOString();
 		if (selectedModels) plan.approved_models = selectedModels;
@@ -523,6 +728,11 @@ async function createServeApp(options) {
 			extractions: applyExtractions
 		});
 		if (existsSync(planPath)) await unlink(planPath);
+		const git = result?.["git"];
+		if (git?.["branch"] && git?.["action"] === "pending-review") broadcast({
+			type: "branch:created",
+			branch: String(git["branch"])
+		});
 		broadcast({ type: "normalize:plan-updated" });
 		return result;
 	}));
@@ -531,44 +741,29 @@ async function createServeApp(options) {
 			statusCode: 405,
 			message: "Method not allowed"
 		});
-		return await callTool("contentrain_apply", await readBody(event));
+		return await callTool("contentrain_apply", parseOrThrow(NormalizeApplyBodySchema, await readBody(event)));
 	}));
 	router.add("/api/normalize/approve", defineEventHandler(async (event) => {
 		if (event.method !== "POST") throw createError({
 			statusCode: 405,
 			message: "Method not allowed"
 		});
-		const branchName = (await readBody(event)).branch;
-		if (!branchName?.startsWith("cr/")) throw createError({
-			statusCode: 400,
-			message: "Invalid branch name"
-		});
-		const git = simpleGit(projectRoot);
-		const baseBranch = getDefaultBranch();
-		if (!(await git.branchLocal()).all.includes(CONTENTRAIN_BRANCH)) await git.branch([CONTENTRAIN_BRANCH, baseBranch]);
-		const mergePath = join(tmpdir(), `cr-merge-${randomUUID()}`);
-		await git.raw([
-			"worktree",
-			"add",
-			mergePath,
-			CONTENTRAIN_BRANCH
-		]);
-		const mergeGit = simpleGit(mergePath);
+		const { branch: branchName } = parseOrThrow(BranchActionBodySchema, await readBody(event));
 		try {
-			await mergeGit.merge([baseBranch, "--no-edit"]).catch(() => {});
-			await mergeGit.merge([branchName, "--no-edit"]);
-			const tip = (await mergeGit.raw(["rev-parse", "HEAD"])).trim();
-			await git.raw([
-				"update-ref",
-				`refs/heads/${baseBranch}`,
-				tip
-			]);
-			if ((await git.raw(["branch", "--show-current"])).trim() === baseBranch) await git.checkout([
-				tip,
-				"--",
-				".contentrain/"
-			]);
-			await git.deleteLocalBranch(branchName, true);
+			const result = await mergeBranch(projectRoot, branchName);
+			if (result.sync?.skipped?.length) {
+				syncWarnings.set(branchName, {
+					branch: branchName,
+					skipped: result.sync.skipped,
+					synced: result.sync.synced,
+					recordedAt: Date.now()
+				});
+				broadcast({
+					type: "sync:warning",
+					branch: branchName,
+					skippedCount: result.sync.skipped.length
+				});
+			}
 			broadcast({
 				type: "branch:merged",
 				branch: branchName
@@ -576,15 +771,21 @@ async function createServeApp(options) {
 			return {
 				status: "merged",
 				branch: branchName,
-				into: baseBranch
+				commit: result.commit,
+				action: result.action,
+				sync: result.sync
 			};
-		} finally {
-			await git.raw([
-				"worktree",
-				"remove",
-				mergePath,
-				"--force"
-			]).catch(() => {});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			broadcast({
+				type: "branch:merge-conflict",
+				branch: branchName,
+				message
+			});
+			throw createError({
+				statusCode: 409,
+				message: `Merge failed: ${message}`
+			});
 		}
 	}));
 	router.add("/api/normalize/sources", defineEventHandler(async () => {
@@ -598,15 +799,15 @@ async function createServeApp(options) {
 		}
 	}));
 	router.add("/api/normalize/file-context", defineEventHandler(async (event) => {
-		const query = getQuery(event);
-		const filePath = query["file"];
-		const line = Number(query["line"]) || 1;
-		const range = Number(query["range"]) || 5;
-		if (!filePath || filePath.includes("..") || filePath.startsWith("/")) throw createError({
+		const { file: filePath, line = 1, range = 5 } = parseOrThrow(FileContextQuerySchema, getQuery(event), "query");
+		const fullPath = join(projectRoot, filePath);
+		const { resolve: resolvePath, sep } = await import("node:path");
+		const resolvedRoot = resolvePath(projectRoot);
+		const resolvedFull = resolvePath(fullPath);
+		if (!resolvedFull.startsWith(resolvedRoot + sep) && resolvedFull !== resolvedRoot) throw createError({
 			statusCode: 400,
-			message: "Invalid file path"
+			message: "Path escapes project root"
 		});
-		const fullPath = join(projectRoot, filePath);
 		if (!existsSync(fullPath)) throw createError({
 			statusCode: 404,
 			message: "File not found"

package/dist/{setup-Y1LFQ9rZ.mjs → setup-BMqKibZt.mjs}

@@ -1,6 +1,6 @@
-import { r as resolveProjectRoot, t as loadProjectContext } from "./context-An3xrvcP.mjs";
-import { i as pc } from "./ui-B5mXontH.mjs";
-import { a as createPackageResolver, c as writeMcpConfig, n as IDE_CONFIGS, o as detectIdes, r as MCP_CONFIGS, s as installIdeRulesAndSkills } from "./ide-_C2gUPbQ.mjs";
+import { i as pc } from "./ui-B8l_LC36.mjs";
+import { r as resolveProjectRoot, t as loadProjectContext } from "./context-OskMGy8y.mjs";
+import { a as createPackageResolver, c as writeMcpConfig, n as IDE_CONFIGS, o as detectIdes, r as MCP_CONFIGS, s as installIdeRulesAndSkills } from "./ide-DPDVYiaq.mjs";
 import { defineCommand } from "citty";
 import { intro, log, outro, spinner } from "@clack/prompts";
 //#region src/commands/setup.ts

package/dist/{skills-Cp8KF1af.mjs → skills-CZ54F-97.mjs}

@@ -1,6 +1,6 @@
-import { r as resolveProjectRoot } from "./context-An3xrvcP.mjs";
-import { i as pc } from "./ui-B5mXontH.mjs";
-import { a as createPackageResolver, n as IDE_CONFIGS, o as detectIdes, s as installIdeRulesAndSkills, t as AGENT_SKILL_NAMES } from "./ide-_C2gUPbQ.mjs";
+import { i as pc } from "./ui-B8l_LC36.mjs";
+import { r as resolveProjectRoot } from "./context-OskMGy8y.mjs";
+import { a as createPackageResolver, n as IDE_CONFIGS, o as detectIdes, s as installIdeRulesAndSkills, t as AGENT_SKILL_NAMES } from "./ide-DPDVYiaq.mjs";
 import { defineCommand } from "citty";
 import { intro, log, outro, spinner } from "@clack/prompts";
 import { join } from "node:path";

package/dist/{status-Cyv-jo1y.mjs → status-BJ6Lu3J4.mjs}

@@ -1,6 +1,6 @@
-import { i as pc, r as formatTable, t as formatCount } from "./ui-B5mXontH.mjs";
-import { n as resolveStudioClient } from "./client-C400qHcL.mjs";
-import { t as resolveStudioContext } from "./resolve-context-Cg6JoVZt.mjs";
+import { i as pc, r as formatTable, t as formatCount } from "./ui-B8l_LC36.mjs";
+import { n as resolveStudioClient } from "./client-C9E9D4mb.mjs";
+import { t as resolveStudioContext } from "./resolve-context-hKVYPniC.mjs";
 import { defineCommand } from "citty";
 import { intro, log, outro, spinner } from "@clack/prompts";
 //#region src/studio/commands/status.ts

package/dist/{status-CoHgz6HN.mjs → status-Bmjfrk-B.mjs}

@@ -1,10 +1,11 @@
-import { n as requireInitialized, r as resolveProjectRoot, t as loadProjectContext } from "./context-An3xrvcP.mjs";
-import { i as pc, n as formatPercent, r as formatTable, t as formatCount } from "./ui-B5mXontH.mjs";
+import { i as pc, n as formatPercent, r as formatTable, t as formatCount } from "./ui-B8l_LC36.mjs";
+import { n as requireInitialized, r as resolveProjectRoot, t as loadProjectContext } from "./context-OskMGy8y.mjs";
 import { defineCommand } from "citty";
 import { intro, log, outro } from "@clack/prompts";
+import { countEntries, readModel } from "@contentrain/mcp/core/model-manager";
 import { simpleGit } from "simple-git";
 import { CONTENTRAIN_BRANCH } from "@contentrain/types";
-import { countEntries, readModel } from "@contentrain/mcp/core/model-manager";
+import { checkBranchHealth } from "@contentrain/mcp/git/branch-lifecycle";
 import { validateProject } from "@contentrain/mcp/core/validator";
 //#region src/commands/status.ts
 var status_default = defineCommand({
@@ -48,6 +49,17 @@ var status_default = defineCommand({
 					const branches = await git.branch(["--list", "cr/*"]);
 					const allLocal = await git.branchLocal();
 					jsonResult["pending_branches"] = branches.all.filter((b) => b !== CONTENTRAIN_BRANCH);
+					try {
+						const health = await checkBranchHealth(projectRoot);
+						jsonResult["branch_health"] = {
+							total: health.total,
+							merged: health.merged,
+							unmerged: health.unmerged,
+							warning: health.warning,
+							blocked: health.blocked,
+							message: health.message ?? null
+						};
+					} catch {}
 					const contentBranchExists = allLocal.all.includes(CONTENTRAIN_BRANCH);
 					const contentBranchInfo = { exists: contentBranchExists };
 					if (contentBranchExists) try {
@@ -126,14 +138,15 @@ var status_default = defineCommand({
 			} catch {}
 			const featureBranches = (await git.branch(["--list", "cr/*"])).all.filter((b) => b !== CONTENTRAIN_BRANCH);
 			if (featureBranches.length > 0) {
-				const count = featureBranches.length;
-				if (count >= 80) {
-					log.error(pc.bold(`\nBLOCKED: ${count} active contentrain branches (limit: 80)`));
-					log.message(`  New writes are blocked. Merge or delete old branches with ${pc.cyan("contentrain diff")}.`);
-				} else if (count >= 50) {
-					log.warning(pc.bold(`\nWARNING: ${count} active contentrain branches (limit: 50)`));
-					log.message(`  Consider merging or deleting old branches with ${pc.cyan("contentrain diff")}.`);
-				} else log.info(pc.bold(`\nPending branches (${count})`));
+				const health = await checkBranchHealth(projectRoot).catch(() => null);
+				const headerLabel = health ? `\nPending branches (${health.unmerged} unmerged / ${health.total} total)` : `\nPending branches (${featureBranches.length})`;
+				if (health?.blocked) {
+					log.error(pc.bold(headerLabel));
+					log.message(`  ${health.message}`);
+				} else if (health?.warning) {
+					log.warning(pc.bold(headerLabel));
+					log.message(`  ${health.message}`);
+				} else log.info(pc.bold(headerLabel));
 				for (const branch of featureBranches) log.message(`  ${pc.yellow("●")} ${branch}`);
 				log.message(`  Run ${pc.cyan("contentrain diff")} to review.`);
 			}