@inkeep/agents-core 0.59.3 → 0.60.0

package/dist/dolt/merge.js

@@ -1,36 +1,150 @@
+import { getLogger } from "../utils/logger.js";
+import { doltAddAndCommit } from "./commit.js";
+import { createApiError } from "../utils/error.js";
+import { managePkMap } from "./pk-map.js";
+import { ResolutionValidationError, applyResolutions } from "./resolve-conflicts.js";
 import { doltCheckout } from "./branch.js";
 import { sql } from "drizzle-orm";
 
 //#region src/dolt/merge.ts
+const logger = getLogger("dolt-merge");
+const TIMESTAMP_COLUMNS = new Set(["created_at", "updated_at"]);
+var MergeConflictError = class extends Error {
+	constructor(message, conflictCount, fromBranch, toBranch) {
+		super(message);
+		this.conflictCount = conflictCount;
+		this.fromBranch = fromBranch;
+		this.toBranch = toBranch;
+		this.name = "MergeConflictError";
+	}
+};
+function extractConflictCount(row) {
+	if (typeof row.conflicts === "number" || typeof row.conflicts === "string") return Number(row.conflicts);
+	const doltMerge$1 = row.dolt_merge;
+	if (Array.isArray(doltMerge$1)) return Number(doltMerge$1[2] ?? 0);
+	throw new Error(`Unexpected DOLT_MERGE result format: ${JSON.stringify(row)}`);
+}
+function isTimestampOnlyConflictRow(row, pkColumns) {
+	if (row.our_diff_type !== "modified" || row.their_diff_type !== "modified") return false;
+	const pkSet = new Set(pkColumns);
+	for (const key of Object.keys(row)) {
+		if (!key.startsWith("base_")) continue;
+		const col = key.slice(5);
+		if (col === "diff_type" || pkSet.has(col) || TIMESTAMP_COLUMNS.has(col)) continue;
+		if (String(row[`base_${col}`] ?? "") !== String(row[`our_${col}`] ?? "") || String(row[`base_${col}`] ?? "") !== String(row[`their_${col}`] ?? "")) return false;
+	}
+	return true;
+}
+function buildTimestampAutoResolution(tableName, row, pkColumns) {
+	const primaryKey = {};
+	for (const col of pkColumns) primaryKey[col] = String(row[`base_${col}`] ?? row[`our_${col}`] ?? row[`their_${col}`]);
+	return {
+		table: tableName,
+		primaryKey,
+		rowDefaultPick: (row.our_updated_at ? new Date(String(row.our_updated_at)) : /* @__PURE__ */ new Date(0)) >= (row.their_updated_at ? new Date(String(row.their_updated_at)) : /* @__PURE__ */ new Date(0)) ? "ours" : "theirs"
+	};
+}
 /**
-* Merge another branch into the current branch
-* Returns merge status and handles conflicts by allowing commit with conflicts
+* Merge a branch into the currently checked out branch.
+*
+* Runs inside an explicit transaction so that conflicts and
+* constraint-violations are surfaced to the caller instead of being
+* auto-rolled-back by Dolt's AUTOCOMMIT mode.
+*
+* If conflicts arise and `resolutions` are provided, they are applied
+* and the merge is committed. If conflicts arise without resolutions
+* (or with insufficient resolutions), the transaction is rolled back
+* and a `MergeConflictError` is thrown.
 */
 const doltMerge = (db) => async (params) => {
-	console.log("merging branch", params.fromBranch, "into", params.toBranch);
+	logger.info({
+		fromBranch: params.fromBranch,
+		toBranch: params.toBranch
+	}, "Merging branch");
 	await doltCheckout(db)({ branch: params.toBranch });
 	const toHead = (await db.execute(sql`SELECT HASHOF('HEAD') as hash`)).rows[0]?.hash;
-	const args = [`'${params.fromBranch}'`];
+	const args = [`'${params.fromBranch.replace(/'/g, "''")}'`];
 	if (params.noFastForward) args.push("'--no-ff'");
-	if (params.message) args.push("'-m'", `'${params.message.replace(/'/g, "''")}'`);
-	if (params.author) args.push("'--author'", `'${params.author.name} <${params.author.email}>'`);
-	const firstRow = (await db.execute(sql.raw(`SELECT DOLT_MERGE(${args.join(", ")})`))).rows[0] ?? {};
-	const mergeResult = typeof firstRow.conflicts === "number" || typeof firstRow.conflicts === "string" || firstRow.conflicts == null ? firstRow : Object.values(firstRow)[0] ?? {};
-	const conflicts = Number(mergeResult.conflicts ?? 0);
-	if (Number.isFinite(conflicts) && conflicts > 0) return {
-		status: "conflicts",
-		from: params.fromBranch,
-		to: params.toBranch,
-		toHead,
-		hasConflicts: true
-	};
-	return {
-		status: "success",
-		from: params.fromBranch,
-		to: params.toBranch,
-		toHead,
-		hasConflicts: false
-	};
+	if (params.message) {
+		const cleanedMessage = params.message.replace(/'/g, "''");
+		args.push("'-m'", `'${cleanedMessage}'`);
+	}
+	const cleanedAuthor = params.author?.name?.replace(/'/g, "''");
+	const cleanedEmail = params.author?.email?.replace(/'/g, "''");
+	if (params.author) args.push("'--author'", `'${cleanedAuthor} <${cleanedEmail}>'`);
+	await db.execute(sql.raw("START TRANSACTION"));
+	let txFinalized = false;
+	try {
+		let result;
+		try {
+			result = await db.execute(sql.raw(`SELECT DOLT_MERGE(${args.join(", ")})`));
+			logger.info({ result }, "DOLT_MERGE result");
+		} catch (error) {
+			const cause = error?.cause;
+			logger.error({
+				message: error?.message,
+				code: cause?.code,
+				severity: cause?.severity,
+				detail: cause?.detail,
+				hint: cause?.hint,
+				query: error?.query,
+				fromBranch: params.fromBranch,
+				toBranch: params.toBranch
+			}, "Error merging branch");
+			throw error;
+		}
+		const conflicts = extractConflictCount(result.rows[0] ?? {});
+		if (Number.isFinite(conflicts) && conflicts > 0) {
+			const userResolutions = params.resolutions ?? [];
+			const autoResolutions = [];
+			const conflictTables = await doltConflicts(db)();
+			let manualConflicts = 0;
+			for (const ct of conflictTables) {
+				const tableConflicts = await doltTableConflicts(db)({ tableName: ct.table });
+				const pkColumns = managePkMap[ct.table] ?? [];
+				for (const row of tableConflicts) if (isTimestampOnlyConflictRow(row, pkColumns)) autoResolutions.push(buildTimestampAutoResolution(ct.table, row, pkColumns));
+				else manualConflicts++;
+			}
+			if (manualConflicts > 0 && userResolutions.length < manualConflicts) throw new MergeConflictError(manualConflicts > 0 && userResolutions.length === 0 ? "Merge has conflicts but no resolutions were provided." : `Resolutions provided (${userResolutions.length}) do not cover all conflicts (${manualConflicts}). All conflicts must be resolved.`, manualConflicts, params.fromBranch, params.toBranch);
+			const allResolutions = [...autoResolutions, ...userResolutions];
+			try {
+				await applyResolutions(db)(allResolutions);
+			} catch (error) {
+				if (error instanceof ResolutionValidationError) throw createApiError({
+					code: "bad_request",
+					message: `Invalid resolution: ${error.message}`
+				});
+				throw error;
+			}
+			await doltAddAndCommit(db)({
+				message: params.message ? `${params.message} (with conflict resolution)` : `Merge ${params.fromBranch} into ${params.toBranch} (with conflict resolution)`,
+				author: params.author
+			});
+			txFinalized = true;
+			return {
+				status: "success",
+				from: params.fromBranch,
+				to: params.toBranch,
+				toHead,
+				hasConflicts: true
+			};
+		}
+		await db.execute(sql.raw("COMMIT"));
+		txFinalized = true;
+		return {
+			status: "success",
+			from: params.fromBranch,
+			to: params.toBranch,
+			toHead,
+			hasConflicts: false
+		};
+	} finally {
+		if (!txFinalized) try {
+			await db.execute(sql.raw("ROLLBACK"));
+		} catch (rollbackError) {
+			logger.error({ error: rollbackError }, "Failed to rollback transaction");
+		}
+	}
 };
 /**
 * Abort a merge
@@ -70,6 +184,29 @@ const doltSchemaConflicts = (db) => async () => {
 	return (await db.execute(sql`SELECT * FROM dolt_schema_conflicts`)).rows;
 };
 /**
+* Preview merge conflicts without modifying the database (dry-run).
+* Returns a summary of which tables have conflicts.
+*/
+const doltPreviewMergeConflictsSummary = (db) => async (params) => {
+	const escapedBaseBranch = params.baseBranch.replace(/'/g, "''");
+	const escapedMergeBranch = params.mergeBranch.replace(/'/g, "''");
+	return (await db.execute(sql.raw(`SELECT * FROM DOLT_PREVIEW_MERGE_CONFLICTS_SUMMARY('${escapedBaseBranch}', '${escapedMergeBranch}')`))).rows.map((row) => ({
+		table: row.table.replace("public.", ""),
+		numDataConflicts: Number(row.num_data_conflicts ?? 0),
+		numSchemaConflicts: Number(row.num_schema_conflicts ?? 0)
+	}));
+};
+/**
+* Preview detailed merge conflicts for a specific table without modifying the database (dry-run).
+* Returns the same column shape as dolt_conflicts_$table.
+*/
+const doltPreviewMergeConflicts = (db) => async (params) => {
+	const escapedBaseBranch = params.baseBranch.replace(/'/g, "''");
+	const escapedMergeBranch = params.mergeBranch.replace(/'/g, "''");
+	const escapedTableName = params.tableName.replace(/'/g, "''");
+	return (await db.execute(sql.raw(`SELECT * FROM DOLT_PREVIEW_MERGE_CONFLICTS('${escapedBaseBranch}', '${escapedMergeBranch}', '${escapedTableName}')`))).rows;
+};
+/**
 * Resolve conflicts for a table using a strategy
 */
 const doltResolveConflicts = (db) => async (params) => {
@@ -78,4 +215,4 @@ const doltResolveConflicts = (db) => async (params) => {
 };
 
 //#endregion
-export { doltAbortMerge, doltConflicts, doltMerge, doltMergeStatus, doltResolveConflicts, doltSchemaConflicts, doltTableConflicts };
+export { MergeConflictError, doltAbortMerge, doltConflicts, doltMerge, doltMergeStatus, doltPreviewMergeConflicts, doltPreviewMergeConflictsSummary, doltResolveConflicts, doltSchemaConflicts, doltTableConflicts };

package/dist/dolt/pk-map.d.ts

@@ -0,0 +1,6 @@
+//#region src/dolt/pk-map.d.ts
+type PkMap = Record<string, string[]>;
+declare const managePkMap: PkMap;
+declare const isValidManageTable: (tableName: string) => boolean;
+//#endregion
+export { PkMap, isValidManageTable, managePkMap };

package/dist/dolt/pk-map.js

@@ -0,0 +1,27 @@
+import { manage_schema_exports } from "../db/manage/manage-schema.js";
+import { getTableConfig } from "drizzle-orm/pg-core";
+
+//#region src/dolt/pk-map.ts
+function buildPkMapFromSchema() {
+	const pkMap = {};
+	for (const value of Object.values(manage_schema_exports)) {
+		if (value == null || typeof value !== "object") continue;
+		let config;
+		try {
+			config = getTableConfig(value);
+		} catch {
+			continue;
+		}
+		if (!config?.name || !config.primaryKeys?.length) continue;
+		const pkColumns = config.primaryKeys[0]?.columns.map((col) => col.name);
+		if (pkColumns && pkColumns.length > 0) pkMap[config.name] = pkColumns;
+	}
+	return pkMap;
+}
+const managePkMap = buildPkMapFromSchema();
+const isValidManageTable = (tableName) => {
+	return tableName in managePkMap;
+};
+
+//#endregion
+export { isValidManageTable, managePkMap };

package/dist/dolt/ref-middleware.d.ts

@@ -3,6 +3,7 @@ import { AgentsManageDatabaseClient } from "../db/manage/manage-client.js";
 import { Context, Next } from "hono";
 
 //#region src/dolt/ref-middleware.d.ts
+declare function isMergeRoute(path: string): boolean;
 type RefContext = {
   resolvedRef?: ResolvedRef;
 };
@@ -79,4 +80,4 @@ declare const refMiddlewareFactory: (db: AgentsManageDatabaseClient, options?: R
  */
 declare const writeProtectionMiddlewareFactory: () => (c: Context, next: Next) => Promise<void>;
 //#endregion
-export { RefContext, RefMiddlewareOptions, createRefMiddleware, createWriteProtectionMiddleware, refMiddlewareFactory, writeProtectionMiddlewareFactory };
+export { RefContext, RefMiddlewareOptions, createRefMiddleware, createWriteProtectionMiddleware, isMergeRoute, refMiddlewareFactory, writeProtectionMiddlewareFactory };

package/dist/dolt/ref-middleware.js

@@ -1,10 +1,14 @@
 import { getLogger } from "../utils/logger.js";
+import { createApiError } from "../utils/error.js";
 import { isRefWritable, resolveRef } from "./ref-helpers.js";
 import { ensureBranchExists } from "./branch.js";
-import { createApiError } from "../utils/error.js";
 
 //#region src/dolt/ref-middleware.ts
 const logger = getLogger("ref-middleware");
+const MERGE_ROUTE_PATTERN = /\/branches\/merge(\/preview)?$/;
+function isMergeRoute(path) {
+	return MERGE_ROUTE_PATTERN.test(path);
+}
 /**
 * Default tenant ID extractor - extracts from /tenants/{tenantId} path pattern
 */
@@ -43,8 +47,18 @@ const defaultExtractProjectId = (c) => {
 const createRefMiddleware = (db, options = {}) => {
 	const { extractTenantId = defaultExtractTenantId, extractProjectId = defaultExtractProjectId, allowProjectIdFromBody = true } = options;
 	return async (c, next) => {
-		const ref = c.req.query("ref");
-		const pathSplit = c.req.path.split("/");
+		let ref = c.req.query("ref");
+		const path = c.req.path;
+		const pathSplit = path.split("/");
+		if (!ref && isMergeRoute(path) && c.req.method === "POST") try {
+			const body = await c.req.json();
+			if (body && typeof body.targetBranch === "string") {
+				ref = body.targetBranch;
+				logger.debug({ ref }, "Extracted targetBranch from merge route body as ref");
+			}
+		} catch {
+			logger.debug({}, "Could not extract targetBranch from merge route body");
+		}
 		const tenantId = extractTenantId(c);
 		let projectId = extractProjectId(c);
 		if (!projectId && allowProjectIdFromBody && [
@@ -214,4 +228,4 @@ const refMiddlewareFactory = createRefMiddleware;
 const writeProtectionMiddlewareFactory = createWriteProtectionMiddleware;
 
 //#endregion
-export { createRefMiddleware, createWriteProtectionMiddleware, refMiddlewareFactory, writeProtectionMiddlewareFactory };
+export { createRefMiddleware, createWriteProtectionMiddleware, isMergeRoute, refMiddlewareFactory, writeProtectionMiddlewareFactory };

package/dist/dolt/resolve-conflicts.d.ts

@@ -0,0 +1,20 @@
+import { ConflictResolution } from "../validation/dolt-schemas.js";
+import { AgentsManageDatabaseClient } from "../db/manage/manage-client.js";
+import { FkDeps } from "./fk-map.js";
+
+//#region src/dolt/resolve-conflicts.d.ts
+declare class ResolutionValidationError extends Error {
+  constructor(message: string);
+}
+type OperationType = 'skip' | 'delete' | 'update' | 'insert';
+interface ClassifiedResolution {
+  resolution: ConflictResolution;
+  conflictRow: Record<string, unknown>;
+  pkColumns: string[];
+  operation: OperationType;
+}
+declare function computeTableInsertOrder(fkDeps: FkDeps): Map<string, number>;
+declare function sortByFkDependencyOrder(classified: ClassifiedResolution[]): ClassifiedResolution[];
+declare const applyResolutions: (db: AgentsManageDatabaseClient) => (resolutions: ConflictResolution[]) => Promise<void>;
+//#endregion
+export { ResolutionValidationError, applyResolutions, computeTableInsertOrder, sortByFkDependencyOrder };

package/dist/dolt/resolve-conflicts.js

@@ -0,0 +1,158 @@
+import { isValidManageTable, managePkMap } from "./pk-map.js";
+import { manageFkDeps } from "./fk-map.js";
+import { sql } from "drizzle-orm";
+
+//#region src/dolt/resolve-conflicts.ts
+var ResolutionValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ResolutionValidationError";
+	}
+};
+function toSqlLiteral(val) {
+	if (val === null || val === void 0) return "NULL";
+	if (typeof val === "object") return `'${JSON.stringify(val).replace(/'/g, "''")}'`;
+	return `'${String(val).replace(/'/g, "''")}'`;
+}
+function classifyOperation(conflictRow, rowDefaultPick, hasColumnOverrides) {
+	const ourDiffType = conflictRow.our_diff_type;
+	const theirDiffType = conflictRow.their_diff_type;
+	if (rowDefaultPick === "theirs" && !hasColumnOverrides) {
+		if (theirDiffType === "removed") return "delete";
+		if (ourDiffType === "removed") return "insert";
+		return "update";
+	}
+	if (theirDiffType === "removed" || ourDiffType === "removed") {
+		if (rowDefaultPick === "ours") return "skip";
+		if (theirDiffType === "removed") return "delete";
+		if (ourDiffType === "removed") return "insert";
+	}
+	return "update";
+}
+function computeTableInsertOrder(fkDeps) {
+	const order = /* @__PURE__ */ new Map();
+	const visited = /* @__PURE__ */ new Set();
+	let counter = 0;
+	function visit(table) {
+		if (visited.has(table)) return;
+		visited.add(table);
+		for (const dep of fkDeps[table] ?? []) visit(dep);
+		order.set(table, counter++);
+	}
+	for (const table of Object.keys(fkDeps)) visit(table);
+	return order;
+}
+const PHASE_ORDER = {
+	delete: 0,
+	update: 1,
+	insert: 2,
+	skip: 3
+};
+const tableOrder = computeTableInsertOrder(manageFkDeps);
+function sortByFkDependencyOrder(classified) {
+	return [...classified].sort((a, b) => {
+		const phaseA = PHASE_ORDER[a.operation];
+		const phaseB = PHASE_ORDER[b.operation];
+		if (phaseA !== phaseB) return phaseA - phaseB;
+		const orderA = tableOrder.get(a.resolution.table) ?? 0;
+		const orderB = tableOrder.get(b.resolution.table) ?? 0;
+		if (a.operation === "delete") return orderB - orderA;
+		if (a.operation === "insert") return orderA - orderB;
+		return 0;
+	});
+}
+const applyResolutions = (db) => async (resolutions) => {
+	const affectedTables = /* @__PURE__ */ new Set();
+	const classified = [];
+	for (const resolution of resolutions) {
+		if (!isValidManageTable(resolution.table)) throw new ResolutionValidationError(`Invalid table name: ${resolution.table}`);
+		affectedTables.add(resolution.table);
+		const pkColumns = managePkMap[resolution.table];
+		if (!pkColumns) throw new ResolutionValidationError(`No PK columns found for table: ${resolution.table}`);
+		const hasColumnOverrides = resolution.columns && Object.keys(resolution.columns).length > 0;
+		if (resolution.rowDefaultPick === "ours" && !hasColumnOverrides) {
+			classified.push({
+				resolution,
+				conflictRow: {},
+				pkColumns,
+				operation: "skip"
+			});
+			continue;
+		}
+		const conflictRow = await readConflictRow(db, resolution.table, resolution.primaryKey, pkColumns);
+		if (!conflictRow) throw new ResolutionValidationError(`No conflict found for table ${resolution.table} with PK ${JSON.stringify(resolution.primaryKey)}`);
+		if (hasColumnOverrides) {
+			const ourDiffType = conflictRow.our_diff_type;
+			const theirDiffType = conflictRow.their_diff_type;
+			if (Object.values(resolution.columns ?? {}).some((pick) => pick !== resolution.rowDefaultPick) && (ourDiffType === "removed" || theirDiffType === "removed")) {
+				const removedSide = ourDiffType === "removed" ? "ours" : "theirs";
+				throw new ResolutionValidationError(`Cannot apply column overrides for table ${resolution.table} (PK ${JSON.stringify(resolution.primaryKey)}): ${removedSide} side deleted the row`);
+			}
+		}
+		const operation = classifyOperation(conflictRow, resolution.rowDefaultPick, hasColumnOverrides ?? false);
+		classified.push({
+			resolution,
+			conflictRow,
+			pkColumns,
+			operation
+		});
+	}
+	const sorted = sortByFkDependencyOrder(classified);
+	for (const { resolution, conflictRow, pkColumns, operation } of sorted) {
+		if (operation === "skip") continue;
+		const pkWhere = buildPkWhere(pkColumns, resolution.primaryKey);
+		switch (operation) {
+			case "delete":
+				await db.execute(sql.raw(`DELETE FROM "${resolution.table}" WHERE ${pkWhere}`));
+				break;
+			case "insert": {
+				const columns = getColumnNames(conflictRow, pkColumns);
+				const allCols = [...pkColumns, ...columns];
+				const values = allCols.map((col) => {
+					return toSqlLiteral(pkColumns.includes(col) ? resolution.primaryKey[col] : conflictRow[`their_${col}`]);
+				});
+				await db.execute(sql.raw(`INSERT INTO "${resolution.table}" (${allCols.map((c) => `"${c}"`).join(", ")}) VALUES (${values.join(", ")})`));
+				break;
+			}
+			case "update": {
+				const setClauses = getColumnNames(conflictRow, pkColumns).map((col) => {
+					return `"${col}" = ${toSqlLiteral(conflictRow[`${(resolution.columns?.[col] ?? resolution.rowDefaultPick) === "theirs" ? "their_" : "our_"}${col}`])}`;
+				});
+				await db.execute(sql.raw(`UPDATE "${resolution.table}" SET ${setClauses.join(", ")} WHERE ${pkWhere}`));
+				break;
+			}
+		}
+	}
+	for (const table of affectedTables) await db.execute(sql.raw(`SELECT DOLT_CONFLICTS_RESOLVE('--ours', '${table}')`));
+};
+async function readConflictRow(db, table, primaryKey, pkColumns) {
+	const whereClause = pkColumns.map((col) => {
+		const val = primaryKey[col];
+		if (val === void 0) throw new ResolutionValidationError(`Missing PK column ${col} for table ${table}`);
+		const escapedVal = val.replace(/'/g, "''");
+		return `(base_${col} = '${escapedVal}' OR (base_${col} IS NULL AND (our_${col} = '${escapedVal}' OR their_${col} = '${escapedVal}')))`;
+	}).join(" AND ");
+	return (await db.execute(sql.raw(`SELECT * FROM dolt_conflicts_${table} WHERE ${whereClause} LIMIT 1`))).rows[0] ?? null;
+}
+function buildPkWhere(pkColumns, primaryKey) {
+	return pkColumns.map((col) => {
+		return `"${col}" = '${primaryKey[col]?.replace(/'/g, "''")}'`;
+	}).join(" AND ");
+}
+function getColumnNames(conflictRow, pkColumns) {
+	const theirPrefix = "their_";
+	const skipColumns = new Set([
+		"our_diff_type",
+		"their_diff_type",
+		"base_diff_type",
+		...pkColumns.map((c) => `base_${c}`),
+		...pkColumns.map((c) => `our_${c}`),
+		...pkColumns.map((c) => `their_${c}`)
+	]);
+	const columns = [];
+	for (const key of Object.keys(conflictRow)) if (key.startsWith(theirPrefix) && !skipColumns.has(key)) columns.push(key.slice(6));
+	return columns;
+}
+
+//#endregion
+export { ResolutionValidationError, applyResolutions, computeTableInsertOrder, sortByFkDependencyOrder };

package/dist/dolt/schema-sync.js

@@ -1,5 +1,5 @@
 import { doltAddAndCommit, doltStatus } from "./commit.js";
-import { doltAbortMerge, doltMerge } from "./merge.js";
+import { MergeConflictError, doltMerge } from "./merge.js";
 import { sql } from "drizzle-orm";
 import { createHash } from "node:crypto";
 
@@ -135,23 +135,26 @@ const syncSchemaFromMain = (db) => async (options = {}) => {
 			error: "Cannot sync schema: uncommitted changes exist. Commit changes first or set autoCommitPending: true"
 		};
 		const mergeSchemaMessage = `Synced schema from ${SCHEMA_SOURCE_BRANCH}`;
-		if ((await doltMerge(db)({
-			fromBranch: SCHEMA_SOURCE_BRANCH,
-			toBranch: currentBranch,
-			message: mergeSchemaMessage,
-			noFastForward: true,
-			author: {
-				name: "Schema Sync System",
-				email: "system@inkeep.com"
-			}
-		})).status === "conflicts") {
-			await doltAbortMerge(db)();
-			return {
+		const schemaSyncAuthor = {
+			name: "Schema Sync System",
+			email: "system@inkeep.com"
+		};
+		try {
+			await doltMerge(db)({
+				fromBranch: SCHEMA_SOURCE_BRANCH,
+				toBranch: currentBranch,
+				message: mergeSchemaMessage,
+				noFastForward: true,
+				author: schemaSyncAuthor
+			});
+		} catch (error) {
+			if (error instanceof MergeConflictError) return {
 				synced: false,
 				hadDifferences: true,
 				differences,
-				error: "Schema merge produced conflicts that require manual resolution. Merge has been aborted."
+				error: "Schema merge produced conflicts that require manual resolution. Merge has been rolled back."
 			};
+			throw error;
 		}
 		return {
 			synced: true,
@@ -160,9 +163,6 @@ const syncSchemaFromMain = (db) => async (options = {}) => {
 			mergeCommitHash: await getLatestCommitHash(db)()
 		};
 	} catch (error) {
-		try {
-			await doltAbortMerge(db)();
-		} catch {}
 		return {
 			synced: false,
 			hadDifferences: true,