@overdeck/desktop 0.45.21 → 0.45.23

package/server/{merge-agent-DnBsms_V.js → merge-agent-XrB80vfT.js}

@@ -1,14 +1,14 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Dr as VcsError, Gn as loadProjectsConfigSync, Or as init_errors, Rr as OVERDECK_HOME, f as loadConfigSync, t as init_config_yaml, ti as init_paths, yr as GitError, zn as init_projects } from "./config-yaml-Ciyp2mYe.js";
+import { Tn as init_projects, Vr as init_paths, ar as GitError, f as loadConfigSync, jn as loadProjectsConfigSync, mr as init_errors, pr as VcsError, t as init_config_yaml, wr as OVERDECK_HOME } from "./config-yaml-DvyMuOle.js";
 import { a as init_activity_logger, n as emitActivityEntrySync, r as emitActivityTtsSync } from "./activity-logger-DDlOIAML.js";
-import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-DN2wSxle.js";
-import { D as killSession, R as sendKeys, V as sessionExists, i as capturePane, j as listSessionNames, w as init_tmux } from "./tmux-y1blSxks.js";
-import { c as init_review_status, f as markWorkspaceStuck, s as getReviewStatusSync, y as setReviewStatusSync } from "./review-status-CCgPVK1h.js";
-import { i as resolveGitHubIssueSync, n as init_tracker_utils } from "./tracker-utils-DiceZN3a.js";
-import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-D9Z3tYSa.js";
-import { r as verifyMergedBeforeLifecycle, t as init_merge_verification } from "./merge-verification-B3meGcXF.js";
-import { i as runQualityGates, n as init_validation } from "./validation-BA4e5EGm.js";
-import { i as init_git_utils, t as cleanupStaleLocks } from "./git-utils-Bkxzr1Xf.js";
+import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-CzaSOgul.js";
+import { D as killSession, H as sessionExists, M as listSessionNames, i as capturePane, w as init_tmux, z as sendKeys } from "./tmux-ftABRAmc.js";
+import { b as setReviewStatusSync, c as getReviewStatusSync, l as init_review_status, p as markWorkspaceStuck } from "./review-status-A7quS5KJ.js";
+import { i as resolveGitHubIssueSync, n as init_tracker_utils } from "./tracker-utils-tnxxqROg.js";
+import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-B0pmAz0a.js";
+import { r as verifyMergedBeforeLifecycle, t as init_merge_verification } from "./merge-verification-CSizH3HY.js";
+import { i as init_git_utils, t as cleanupStaleLocks } from "./git-utils-BVa07a4a.js";
+import { i as runQualityGates, n as init_validation } from "./validation-B5JxoPUS.js";
 import { Data, Effect } from "effect";
 import { appendFileSync, existsSync, mkdirSync } from "fs";
 import { basename, dirname, join, relative } from "path";
@@ -19,7 +19,7 @@ import { promisify } from "util";
 //#region ../../lib/cloister/merge-agent-step0.ts
 async function shouldRestartForPostMerge(repoRoot, dependencies = {}) {
 	if ((await (dependencies.computeStaleness ?? (async () => {
-		const [{ getBuildInfo }, { computeBuildStaleness }] = await Promise.all([import("./build-info-Cv6CI7Gu.js"), import("./staleness-zGp4P1hd.js")]);
+		const [{ getBuildInfo }, { computeBuildStaleness }] = await Promise.all([import("./build-info-DgTqZkL5.js"), import("./staleness-Cbl_w4Bw.js")]);
 		return computeBuildStaleness({
 			repoRoot,
 			buildCommit: getBuildInfo().buildCommit
@@ -28,7 +28,7 @@ async function shouldRestartForPostMerge(repoRoot, dependencies = {}) {
 		(dependencies.log ?? console.log)("Running build already contains origin/main build inputs — skipping deploy restart");
 		return false;
 	}
-	const reason = await (dependencies.getBlockReason ?? (async () => (await import("./deploy-window-ClLq1RYf.js")).getDeployBlockReason()))();
+	const reason = await (dependencies.getBlockReason ?? (async () => (await import("./deploy-window-CM6W1-c6.js")).getDeployBlockReason()))();
 	if (reason) {
 		(dependencies.log ?? console.log)(`Deploy window unsafe (${reason}) — deferring deploy to the staleness patrol`);
 		return false;
@@ -37,6 +37,175 @@ async function shouldRestartForPostMerge(repoRoot, dependencies = {}) {
 }
 var init_merge_agent_step0 = __esmMin((() => {}));
 //#endregion
+//#region ../../lib/cloister/sync-main-git.ts
+function killCommandTree(child) {
+	if (!child?.pid) return;
+	try {
+		if (process.platform === "win32") child.kill("SIGKILL");
+		else process.kill(-child.pid, "SIGKILL");
+	} catch {
+		try {
+			child.kill("SIGKILL");
+		} catch {}
+	}
+}
+function runSyncGitCommand(command, options) {
+	if (options.signal?.aborted) return Promise.reject(new SyncGitCommandAbortError(command));
+	return new Promise((resolve, reject) => {
+		let child;
+		let termination;
+		const finishTermination = (kind) => {
+			if (termination) return;
+			termination = kind;
+			killCommandTree(child);
+		};
+		const timeout = setTimeout(() => finishTermination("timeout"), options.timeout);
+		const onAbort = () => finishTermination("abort");
+		options.signal?.addEventListener("abort", onAbort, { once: true });
+		child = execDetached(command, {
+			cwd: options.cwd,
+			encoding: "utf-8",
+			detached: process.platform !== "win32",
+			timeout: options.timeout
+		}, (error, stdout, stderr) => {
+			clearTimeout(timeout);
+			options.signal?.removeEventListener("abort", onAbort);
+			if (termination === "abort") reject(Object.assign(new SyncGitCommandAbortError(command), {
+				stdout,
+				stderr
+			}));
+			else if (termination === "timeout") reject(Object.assign(new SyncGitCommandTimeoutError(command, options.timeout), {
+				stdout,
+				stderr
+			}));
+			else if (error?.killed) reject(Object.assign(new SyncGitCommandTimeoutError(command, options.timeout), {
+				stdout,
+				stderr
+			}));
+			else if (error) reject(Object.assign(error, {
+				stdout,
+				stderr
+			}));
+			else resolve({
+				stdout,
+				stderr
+			});
+		});
+		if (options.signal?.aborted) finishTermination("abort");
+	});
+}
+async function probeGitOperationHeads(projectPath, timeoutMs, signal) {
+	const present = [];
+	for (const operationHead of GIT_OPERATION_HEADS) try {
+		await runSyncGitCommand(`git rev-parse -q --verify ${operationHead}`, {
+			cwd: projectPath,
+			timeout: timeoutMs,
+			signal
+		});
+		present.push(operationHead);
+	} catch (error) {
+		if (error instanceof SyncGitCommandAbortError) throw error;
+		if (error instanceof SyncGitCommandTimeoutError) return {
+			success: false,
+			present,
+			reason: `${operationHead} probe timed out after ${timeoutMs / 1e3}s`
+		};
+		if (error?.code !== 1) return {
+			success: false,
+			present,
+			reason: `${operationHead} probe failed: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+	return {
+		success: true,
+		present
+	};
+}
+async function ensureSyncGitQuiescent(projectPath, abortMerge, timeoutMs = 3e4) {
+	const controller = new AbortController();
+	const deadline = Date.now() + timeoutMs;
+	const timeout = setTimeout(() => controller.abort(), timeoutMs);
+	const remaining = (stage) => {
+		const budget = deadline - Date.now();
+		if (controller.signal.aborted || budget <= 0) throw new UnsafeSyncMainStateError(`Git cleanup timed out after ${timeoutMs / 1e3}s while ${stage}`);
+		return budget;
+	};
+	try {
+		let lockCleanup;
+		try {
+			lockCleanup = await Effect.runPromise(cleanupStaleLocks(projectPath, {
+				signal: controller.signal,
+				processProbeTimeoutMs: remaining("checking Git lock owners")
+			}));
+		} catch (error) {
+			throw new UnsafeSyncMainStateError(`Could not verify Git lock state after cancellation: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (lockCleanup.errors.length > 0) throw new UnsafeSyncMainStateError(`Could not establish Git quiescence: ${lockCleanup.errors.map(({ file, error }) => `${file}: ${error}`).join("; ")}`);
+		let before;
+		try {
+			before = await probeGitOperationHeads(projectPath, remaining("checking Git operation state"), controller.signal);
+		} catch (error) {
+			throw new UnsafeSyncMainStateError(`Could not verify Git operation state: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (!before.success) throw new UnsafeSyncMainStateError(`Could not verify Git operation state: ${before.reason}`);
+		if (before.present.filter((head) => head !== "MERGE_HEAD").length > 0 || before.present.includes("MERGE_HEAD") && !abortMerge) throw new UnsafeSyncMainStateError(`Git operation remains active after cancellation: ${before.present.join(", ")}`);
+		if (before.present.includes("MERGE_HEAD")) try {
+			await runSyncGitCommand("git merge --abort", {
+				cwd: projectPath,
+				timeout: remaining("aborting the timed-out merge"),
+				signal: controller.signal
+			});
+		} catch (error) {
+			throw new UnsafeSyncMainStateError(`Could not abort timed-out sync merge: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		let after;
+		try {
+			after = await probeGitOperationHeads(projectPath, remaining("verifying Git cleanup"), controller.signal);
+		} catch (error) {
+			throw new UnsafeSyncMainStateError(`Could not verify Git operation state after cleanup: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (!after.success) throw new UnsafeSyncMainStateError(`Could not verify Git operation state after cleanup: ${after.reason}`);
+		if (after.present.length > 0) throw new UnsafeSyncMainStateError(`Git operation remains active after cleanup: ${after.present.join(", ")}`);
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+var GIT_OPERATION_HEADS, SyncGitCommandTimeoutError, SyncGitCommandAbortError, UnsafeSyncMainStateError, execDetached;
+var init_sync_main_git = __esmMin((() => {
+	init_git_utils();
+	GIT_OPERATION_HEADS = [
+		"MERGE_HEAD",
+		"REBASE_HEAD",
+		"CHERRY_PICK_HEAD",
+		"REVERT_HEAD"
+	];
+	SyncGitCommandTimeoutError = class extends Error {
+		killed = true;
+		constructor(command, budgetMs) {
+			super(`${command} timed out after ${budgetMs / 1e3}s`);
+			this.command = command;
+			this.budgetMs = budgetMs;
+			this.name = "SyncGitCommandTimeoutError";
+		}
+	};
+	SyncGitCommandAbortError = class extends Error {
+		code = "ABORT_ERR";
+		killed = true;
+		constructor(command) {
+			super(`${command} was cancelled`);
+			this.command = command;
+			this.name = "SyncGitCommandAbortError";
+		}
+	};
+	UnsafeSyncMainStateError = class extends Error {
+		constructor(message) {
+			super(message);
+			this.name = "UnsafeSyncMainStateError";
+		}
+	};
+	execDetached = exec;
+}));
+//#endregion
 //#region ../../lib/overdeck/git-activity.ts
 function overdeckDb() {
 	return getOverdeckDatabaseSync();
@@ -331,29 +500,26 @@ function parseStatusPath(line) {
 * Respects .gitignore (no -f), unstages excluded paths, and leaves excluded
 * paths dirty so the sync can proceed. Returns success=false on git errors.
 */
-async function autoCommitWorkspaceChangesBeforeSync(projectPath, issueId) {
+async function autoCommitWorkspaceChangesBeforeSync(projectPath, issueId, signal) {
+	const run = (command, timeout = SYNC_GIT_STATUS_TIMEOUT_MS) => runSyncGitCommand(command, {
+		cwd: projectPath,
+		timeout,
+		signal
+	});
 	try {
-		for (const operationHead of [
-			"MERGE_HEAD",
-			"REBASE_HEAD",
-			"CHERRY_PICK_HEAD",
-			"REVERT_HEAD"
-		]) try {
-			await execAsync(`git rev-parse -q --verify ${operationHead}`, {
-				cwd: projectPath,
-				encoding: "utf-8"
-			});
-			return {
-				success: false,
-				committed: false,
-				reason: `Refusing to auto-commit while ${operationHead} exists; finish or abort the in-progress Git operation first`
-			};
-		} catch {}
+		const operationHeads = await probeGitOperationHeads(projectPath, SYNC_GIT_STATUS_TIMEOUT_MS, signal);
+		if (!operationHeads.success) return {
+			success: false,
+			committed: false,
+			reason: operationHeads.reason
+		};
+		if (operationHeads.present.length > 0) return {
+			success: false,
+			committed: false,
+			reason: `Refusing to auto-commit while ${operationHeads.present[0]} exists; finish or abort the in-progress Git operation first`
+		};
 		try {
-			const { stdout: conflictMarkers } = await execAsync("git grep -n -I -E '^(<<<<<<<( |$)|=======$|>>>>>>>( |$))' -- .", {
-				cwd: projectPath,
-				encoding: "utf-8"
-			});
+			const { stdout: conflictMarkers } = await run("git grep -n -I -E '^(<<<<<<<( |$)|=======$|>>>>>>>( |$))' -- .");
 			if (conflictMarkers.trim()) return {
 				success: false,
 				committed: false,
@@ -366,45 +532,31 @@ async function autoCommitWorkspaceChangesBeforeSync(projectPath, issueId) {
 				reason: `Failed to scan for conflict markers: ${error.message}`
 			};
 		}
-		const { stdout: statusOut } = await execAsync("git status --porcelain", {
-			cwd: projectPath,
-			encoding: "utf-8"
-		});
+		const { stdout: statusOut } = await run("git status --porcelain");
 		if (!statusOut.trim()) return {
 			success: true,
 			committed: false,
 			reason: "no uncommitted changes"
 		};
-		await execAsync("git add -A", {
-			cwd: projectPath,
-			encoding: "utf-8"
-		});
-		await execAsync(`git reset HEAD -- ${AUTO_COMMIT_EXCLUDED_PATHS.map((p) => p.endsWith("/") ? p.slice(0, -1) : p).join(" ")}`, {
-			cwd: projectPath,
-			encoding: "utf-8"
-		});
-		const { stdout: diffStat } = await execAsync("git diff --cached --stat", {
-			cwd: projectPath,
-			encoding: "utf-8"
-		});
+		await run("git add -A");
+		await run(`git reset HEAD -- ${AUTO_COMMIT_EXCLUDED_PATHS.map((p) => p.endsWith("/") ? p.slice(0, -1) : p).join(" ")}`);
+		const { stdout: diffStat } = await run("git diff --cached --stat");
 		if (!diffStat.trim()) return {
 			success: true,
 			committed: false,
 			reason: "only excluded/ignored changes remain"
 		};
-		await execAsync(`git commit -m "${issueId ? `chore: auto-commit before sync with main (${issueId})` : "chore: auto-commit before sync with main"}"`, {
-			cwd: projectPath,
-			encoding: "utf-8"
-		});
+		await run(`git commit -m "${issueId ? `chore: auto-commit before sync with main (${issueId})` : "chore: auto-commit before sync with main"}"`, SYNC_GIT_COMMIT_TIMEOUT_MS);
 		return {
 			success: true,
 			committed: true
 		};
 	} catch (error) {
+		if (error instanceof SyncGitCommandAbortError || error instanceof SyncGitCommandTimeoutError) await ensureSyncGitQuiescent(projectPath, false);
 		return {
 			success: false,
 			committed: false,
-			reason: `Failed to auto-commit: ${error.message}`
+			reason: error instanceof SyncGitCommandTimeoutError && error.command.startsWith("git commit ") ? `Auto-commit git commit timed out after ${SYNC_GIT_COMMIT_TIMEOUT_MS / 1e3}s` : `Failed to auto-commit: ${error.message}`
 		};
 	}
 }
@@ -447,7 +599,7 @@ async function notifyTldrDaemon(projectPath, _sourceBranch) {
 			return;
 		}
 		console.log(`[merge-agent] Found ${changedFiles.length} changed source files to reindex`);
-		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-BJA7TkqS.js");
+		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-DL566HbH.js");
 		const tldrService = getTldrDaemonServiceSync(projectPath, venvPath);
 		if (!(await tldrService.getStatus()).running) {
 			console.log(`[merge-agent] TLDR daemon not running, skipping notification`);
@@ -477,7 +629,7 @@ async function postMergeLifecycle(issueId, projectPath, sourceBranch, options) {
 	}
 	const run = (async () => {
 		try {
-			const { findSpecByIssue } = await import("./specs-BsNcum0h.js");
+			const { findSpecByIssue } = await import("./specs-nN45DG2X.js");
 			const spec = await Effect.runPromise(findSpecByIssue(projectPath, issueId));
 			if (spec && (spec.status === "completed" || spec.status === "cancelled")) {
 				console.log(`[merge-agent] ${issueId} is closed out (spec ${spec.status}) — skipping post-merge lifecycle`);
@@ -539,7 +691,7 @@ async function postMergeLifecycle(issueId, projectPath, sourceBranch, options) {
 		}
 		console.log(`[merge-agent] Running post-merge verify handoff for ${issueId}`);
 		try {
-			const { cleanupMergedLabels } = await import("./label-cleanup-CJ4m8iRU.js");
+			const { cleanupMergedLabels } = await import("./label-cleanup-BKPJm4Hv.js");
 			const ghResolved = resolveGitHubIssueSync(issueId);
 			const labelCtx = ghResolved.isGitHub ? {
 				issueId,
@@ -588,8 +740,8 @@ async function postMergeLifecycle(issueId, projectPath, sourceBranch, options) {
 			console.warn(`[merge-agent] Async post-merge release trigger failed for ${issueId}: ${err instanceof Error ? err.message : String(err)}`);
 		});
 		try {
-			const { setAgentPaused, getAgentState } = await import("./agents-Czz6R57Z.js");
-			const { killSession, sessionExists } = await import("./tmux-HQLgwo_C.js");
+			const { setAgentPaused, getAgentState } = await import("./agents-FlIgQ3ql.js");
+			const { killSession, sessionExists } = await import("./tmux-DoThH6aj.js");
 			const issueLower = issueId.toLowerCase();
 			const reason = "awaiting close-out (verify on main)";
 			for (const agentId of [`agent-${issueLower}`, `planning-${issueLower}`]) {
@@ -614,8 +766,8 @@ async function postMergeLifecycle(issueId, projectPath, sourceBranch, options) {
 			console.warn(`[merge-agent] Could not pause or kill agent sessions: ${err}`);
 		}
 		try {
-			const { killAllReviewerSessions } = await import("./review-agent-CSswH985.js");
-			const { resolveProjectFromIssueSync } = await import("./projects-IRHJIPYC.js");
+			const { killAllReviewerSessions } = await import("./review-agent-DJRO8EG8.js");
+			const { resolveProjectFromIssueSync } = await import("./projects-9SkRpES9.js");
 			const projectKey = resolveProjectFromIssueSync(issueId)?.projectKey;
 			if (projectKey) {
 				const { killed } = await Effect.runPromise(killAllReviewerSessions(projectKey, issueId));
@@ -629,7 +781,7 @@ async function postMergeLifecycle(issueId, projectPath, sourceBranch, options) {
 		}
 		await killPostMergeRoleSessions(issueId);
 		try {
-			const { createResetMarker } = await import("./cli-ChErG518.js");
+			const { createResetMarker } = await import("./cli-BsVIHwzC.js");
 			const timestamp = (/* @__PURE__ */ new Date()).toISOString();
 			const marker = await createResetMarker({
 				projectId: basename(projectPath),
@@ -644,8 +796,8 @@ async function postMergeLifecycle(issueId, projectPath, sourceBranch, options) {
 			console.warn(`[merge-agent] Memory reset marker creation failed (non-fatal): ${err}`);
 		}
 		try {
-			const { findWorkspacePath } = await import("./archive-planning-MPpvQJL4.js");
-			const { stopWorkspaceDocker } = await import("./workspace-manager-CcujONCR.js");
+			const { findWorkspacePath } = await import("./archive-planning-zkJb3BeM.js");
+			const { stopWorkspaceDocker } = await import("./workspace-manager-ZTdJAy9M.js");
 			const issueLower = issueId.toLowerCase();
 			const workspacePath = findWorkspacePath(projectPath, issueLower);
 			if (workspacePath) {
@@ -676,7 +828,7 @@ async function triggerPostMergeReleaseIfConfigured(issueId, projectPath) {
 		console.log(`[merge-agent] Release already started or completed for ${issueId} (${currentStatus}), skipping`);
 		return;
 	}
-	const { resolveProjectFromIssueSync, getProjectSync } = await import("./projects-IRHJIPYC.js");
+	const { resolveProjectFromIssueSync, getProjectSync } = await import("./projects-9SkRpES9.js");
 	const resolved = resolveProjectFromIssueSync(issueId);
 	if (!(resolved ? getProjectSync(resolved.projectKey) : null)?.release) {
 		setReviewStatusSync(issueId, {
@@ -686,7 +838,7 @@ async function triggerPostMergeReleaseIfConfigured(issueId, projectPath) {
 		console.log(`[merge-agent] No release config for ${issueId}; marked release skipped`);
 		return;
 	}
-	const { runRelease } = await import("./release-engine-CSI4K6Oj.js");
+	const { runRelease } = await import("./release-engine-DZpmGGzb.js");
 	try {
 		await runRelease(issueId, projectPath);
 	} catch (err) {
@@ -705,10 +857,10 @@ async function triggerPostMergeReleaseIfConfigured(issueId, projectPath) {
 async function transitionIssueToVerifyingOnMain(issueId, projectPath) {
 	const [effectModule, issueLifecycleModule, githubModule, linearModule, rallyModule, errorsModule] = await Promise.all([
 		import("effect"),
-		import("./issue-lifecycle-ytsEdDlK.js"),
-		import("./github-client-4A6FgA8O.js"),
-		import("./linear-client-Bj1l4FOA.js"),
-		import("./rally-client-Cqf6EX_r.js"),
+		import("./issue-lifecycle-Dy4vd0Oa.js"),
+		import("./github-client-B4QsdE-X.js"),
+		import("./linear-client-DqhDQO9k.js"),
+		import("./rally-client-CULK2XAY.js"),
 		import("./typed-errors-BHhE85Ul.js")
 	]);
 	const { Effect, Layer } = effectModule;
@@ -922,49 +1074,50 @@ function parseAgentOutput(output) {
 /**
 * Get conflict files from git status (async)
 */
-async function getConflictFiles(projectPath) {
+function isSyncGitTermination(error) {
+	return error instanceof SyncGitCommandAbortError || error instanceof SyncGitCommandTimeoutError;
+}
+async function getConflictFiles(projectPath, signal) {
 	try {
-		const { stdout: status } = await execAsync("git diff --name-only --diff-filter=U", {
+		const { stdout: status } = await runSyncGitCommand("git diff --name-only --diff-filter=U", {
 			cwd: projectPath,
-			encoding: "utf-8"
+			timeout: SYNC_GIT_STATUS_TIMEOUT_MS,
+			signal
 		});
-		return status.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+		return status.split("\n").map((line) => line.trim()).filter(Boolean);
 	} catch (error) {
+		if (isSyncGitTermination(error)) throw error;
 		console.error("Failed to get conflict files:", error);
 		return [];
 	}
 }
-async function resolveMainPreferredSyncConflicts(projectPath, conflictFiles) {
+async function resolveMainPreferredSyncConflicts(projectPath, conflictFiles, signal) {
 	if (conflictFiles.length === 0 || !conflictFiles.every(isSyncMainMainPreferredPath)) return {
 		success: false,
 		reason: "conflicts include non-pipeline-owned files"
 	};
+	const run = (command, timeout = SYNC_GIT_STATUS_TIMEOUT_MS) => runSyncGitCommand(command, {
+		cwd: projectPath,
+		timeout,
+		signal
+	});
 	try {
 		for (const path of SYNC_MAIN_MAIN_PREFERRED_PATHS) {
-			await execAsync(`git rm -r --quiet --ignore-unmatch -- ${path}`, {
-				cwd: projectPath,
-				encoding: "utf-8"
-			});
-			await execAsync(`git checkout origin/main -- ${path}`, {
-				cwd: projectPath,
-				encoding: "utf-8"
-			}).catch(() => {});
-			await execAsync(`git add -A -- ${path}`, {
-				cwd: projectPath,
-				encoding: "utf-8"
+			await run(`git rm -r --quiet --ignore-unmatch -- ${path}`);
+			await run(`git checkout origin/main -- ${path}`).catch((error) => {
+				if (isSyncGitTermination(error)) throw error;
 			});
+			await run(`git add -A -- ${path}`);
 		}
-		const remainingConflicts = await getConflictFiles(projectPath);
+		const remainingConflicts = await getConflictFiles(projectPath, signal);
 		if (remainingConflicts.length > 0) return {
 			success: false,
 			reason: `Unresolved conflicts remain: ${remainingConflicts.join(", ")}`
 		};
-		await execAsync("git commit --no-edit", {
-			cwd: projectPath,
-			encoding: "utf-8"
-		});
+		await run("git commit --no-edit", SYNC_GIT_COMMIT_TIMEOUT_MS);
 		return { success: true };
 	} catch (error) {
+		if (isSyncGitTermination(error)) throw error;
 		return {
 			success: false,
 			reason: `Failed to auto-resolve pipeline-owned conflicts: ${error.message}`
@@ -1156,6 +1309,31 @@ async function scanForConflictMarkers(projectPath) {
 		return [];
 	}
 }
+async function collectSyncMergeStats(projectPath, signal) {
+	const run = (command) => runSyncGitCommand(command, {
+		cwd: projectPath,
+		timeout: SYNC_GIT_STATUS_TIMEOUT_MS,
+		signal
+	});
+	let changedFiles = [];
+	let commitCount = 0;
+	try {
+		const { stdout } = await run("git diff --name-only ORIG_HEAD HEAD 2>/dev/null || git diff --name-only HEAD~1 HEAD");
+		changedFiles = stdout.trim().split("\n").filter(Boolean);
+	} catch (error) {
+		if (isSyncGitTermination(error)) throw error;
+	}
+	try {
+		const { stdout } = await run("git log ORIG_HEAD..HEAD --oneline 2>/dev/null || echo \"\"");
+		commitCount = stdout.trim().split("\n").filter(Boolean).length;
+	} catch (error) {
+		if (isSyncGitTermination(error)) throw error;
+	}
+	return {
+		changedFiles,
+		commitCount
+	};
+}
 /**
 * Sync the latest main branch into a workspace's feature branch.
 *
@@ -1166,27 +1344,30 @@ async function scanForConflictMarkers(projectPath) {
 *
 * Auto-commits any uncommitted changes before merging (with safety verification).
 */
-async function syncMainIntoWorkspace(projectPath, issueId) {
+async function syncMainIntoWorkspace(projectPath, issueId, signal) {
 	console.log(`[sync-main] Starting sync of main into workspace for ${issueId}`);
 	logActivity("sync_main_start", `Starting sync for ${issueId}`);
-	console.log(`[sync-main] Checking for uncommitted changes...`);
-	logActivity("sync_main_auto_commit", `Auto-committing uncommitted changes before sync`);
-	const autoCommit = await autoCommitWorkspaceChangesBeforeSync(projectPath, issueId);
-	if (!autoCommit.success) {
-		const message = autoCommit.reason || "Failed to auto-commit uncommitted changes";
-		console.error(`[sync-main] ${message}`);
-		logActivity("sync_main_blocked", message);
-		return {
-			success: false,
-			reason: message
-		};
-	}
-	if (autoCommit.committed) console.log(`[sync-main] Auto-commit successful`);
+	const run = (command, timeout = SYNC_GIT_STATUS_TIMEOUT_MS) => runSyncGitCommand(command, {
+		cwd: projectPath,
+		timeout,
+		signal
+	});
+	let mergeStarted = false;
 	try {
-		const { stdout: postCommitStatus } = await execAsync("git status --porcelain", {
-			cwd: projectPath,
-			encoding: "utf-8"
-		});
+		console.log(`[sync-main] Checking for uncommitted changes...`);
+		logActivity("sync_main_auto_commit", `Auto-committing uncommitted changes before sync`);
+		const autoCommit = await autoCommitWorkspaceChangesBeforeSync(projectPath, issueId, signal);
+		if (!autoCommit.success) {
+			const message = autoCommit.reason || "Failed to auto-commit uncommitted changes";
+			console.error(`[sync-main] ${message}`);
+			logActivity("sync_main_blocked", message);
+			return {
+				success: false,
+				reason: message
+			};
+		}
+		if (autoCommit.committed) console.log(`[sync-main] Auto-commit successful`);
+		const { stdout: postCommitStatus } = await run("git status --porcelain");
 		if (postCommitStatus.trim()) {
 			if (postCommitStatus.trim().split("\n").filter((line) => !isAutoCommitExcludedPath(parseStatusPath(line))).length > 0) {
 				const message = "Uncommitted changes remain after auto-commit — aborting sync";
@@ -1198,22 +1379,18 @@ async function syncMainIntoWorkspace(projectPath, issueId) {
 				};
 			}
 		}
-	} catch (error) {
-		return {
-			success: false,
-			reason: `Failed to check git status: ${error.message}`
-		};
-	}
-	try {
-		const lockCleanup = await Effect.runPromise(cleanupStaleLocks(projectPath));
-		if (lockCleanup.found.length > 0) {
-			console.log(`[sync-main] Found ${lockCleanup.found.length} lock file(s)`);
+		try {
+			const lockCleanup = await Effect.runPromise(cleanupStaleLocks(projectPath, {
+				signal,
+				processProbeTimeoutMs: SYNC_GIT_STATUS_TIMEOUT_MS
+			}));
+			if (lockCleanup.found.length > 0) console.log(`[sync-main] Found ${lockCleanup.found.length} lock file(s)`);
 			if (lockCleanup.removed.length > 0) {
 				console.log(`[sync-main] Cleaned up ${lockCleanup.removed.length} stale lock file(s)`);
 				logActivity("git_lock_cleanup", `Removed ${lockCleanup.removed.length} stale lock file(s)`);
 			}
-			if (lockCleanup.errors.some((e) => e.error.includes("Git processes are running"))) {
-				const message = "Git processes are still running — cannot safely start sync";
+			if (lockCleanup.errors.length > 0) {
+				const message = `Cannot safely start sync: ${lockCleanup.errors.map(({ file, error }) => `${file}: ${error}`).join("; ")}`;
 				console.error(`[sync-main] ${message}`);
 				logActivity("sync_main_blocked", message);
 				return {
@@ -1221,106 +1398,80 @@ async function syncMainIntoWorkspace(projectPath, issueId) {
 					reason: message
 				};
 			}
+		} catch (lockError) {
+			const message = `Cannot verify Git lock state: ${lockError instanceof Error ? lockError.message : String(lockError)}`;
+			console.error(`[sync-main] ${message}`);
+			logActivity("sync_main_blocked", message);
+			return {
+				success: false,
+				reason: message
+			};
 		}
-	} catch (lockErr) {
-		console.warn(`[sync-main] Lock cleanup warning: ${lockErr.message} (continuing)`);
-	}
-	try {
 		console.log(`[sync-main] Fetching origin/main...`);
-		await execAsync("git fetch origin main", {
-			cwd: projectPath,
-			encoding: "utf-8"
-		});
-	} catch (error) {
-		return {
-			success: false,
-			reason: `Failed to fetch origin/main: ${error.message}`
-		};
-	}
-	let mergeOutput = "";
-	let hasConflicts = false;
-	try {
-		const result = await execAsync("git merge origin/main", {
-			cwd: projectPath,
-			encoding: "utf-8"
-		});
-		mergeOutput = (result.stdout || "") + (result.stderr || "");
-	} catch (error) {
-		mergeOutput = (error.stdout || "") + (error.stderr || "");
-		hasConflicts = true;
-	}
-	if (mergeOutput.includes("Already up to date") || mergeOutput.includes("Already up-to-date")) {
-		console.log(`[sync-main] Already up to date`);
-		logActivity("sync_main_noop", `${issueId} already up to date with main`);
-		return {
-			success: true,
-			alreadyUpToDate: true
-		};
-	}
-	if (!hasConflicts) {
-		console.log(`[sync-main] Clean merge completed`);
-		logActivity("sync_main_success", `Clean merge of main into ${issueId}`);
-		let changedFiles = [];
-		let commitCount = 0;
 		try {
-			const { stdout: diffFiles } = await execAsync("git diff --name-only ORIG_HEAD HEAD 2>/dev/null || git diff --name-only HEAD~1 HEAD", {
-				cwd: projectPath,
-				encoding: "utf-8"
-			});
-			changedFiles = diffFiles.trim().split("\n").filter((f) => f.length > 0);
-		} catch {}
+			await run("git fetch origin main", SYNC_GIT_FETCH_TIMEOUT_MS);
+		} catch (error) {
+			if (isSyncGitTermination(error)) throw error;
+			return {
+				success: false,
+				reason: `Failed to fetch origin/main: ${error.message}`
+			};
+		}
+		let mergeOutput = "";
+		let hasConflicts = false;
 		try {
-			const { stdout: logOut } = await execAsync("git log ORIG_HEAD..HEAD --oneline 2>/dev/null || echo \"\"", {
-				cwd: projectPath,
-				encoding: "utf-8"
-			});
-			commitCount = logOut.trim().split("\n").filter((l) => l.length > 0).length;
-		} catch {}
+			mergeStarted = true;
+			const result = await run("git merge origin/main", SYNC_GIT_MERGE_TIMEOUT_MS);
+			mergeStarted = false;
+			mergeOutput = (result.stdout || "") + (result.stderr || "");
+		} catch (error) {
+			if (isSyncGitTermination(error)) throw error;
+			mergeOutput = (error.stdout || "") + (error.stderr || "");
+			hasConflicts = true;
+		}
+		if (mergeOutput.includes("Already up to date") || mergeOutput.includes("Already up-to-date")) {
+			console.log(`[sync-main] Already up to date`);
+			logActivity("sync_main_noop", `${issueId} already up to date with main`);
+			return {
+				success: true,
+				alreadyUpToDate: true
+			};
+		}
+		if (!hasConflicts) {
+			console.log(`[sync-main] Clean merge completed`);
+			logActivity("sync_main_success", `Clean merge of main into ${issueId}`);
+			return {
+				success: true,
+				...await collectSyncMergeStats(projectPath, signal)
+			};
+		}
+		const conflictFiles = await getConflictFiles(projectPath, signal);
+		if ((await resolveMainPreferredSyncConflicts(projectPath, conflictFiles, signal)).success) {
+			mergeStarted = false;
+			console.log(`[sync-main] Auto-resolved ${conflictFiles.length} pipeline-owned conflict(s) with origin/main`);
+			logActivity("sync_main_auto_resolved_conflicts", `Auto-resolved ${conflictFiles.length} pipeline-owned conflict(s) in ${issueId} with origin/main`);
+			return {
+				success: true,
+				...await collectSyncMergeStats(projectPath, signal)
+			};
+		}
+		console.log(`[sync-main] ${conflictFiles.length} conflict(s); aborting merge for manual resolution`);
+		logActivity("sync_main_conflicts", `${conflictFiles.length} conflict(s) in ${issueId}: ${conflictFiles.join(", ")}`);
+		await ensureSyncGitQuiescent(projectPath, true);
+		mergeStarted = false;
 		return {
-			success: true,
-			commitCount,
-			changedFiles
+			success: false,
+			conflictFiles,
+			reason: `Sync-main produced ${conflictFiles.length} conflict(s) in ${issueId}: ${conflictFiles.join(", ")}. Resolve manually in the workspace, then re-run sync-main.`
 		};
-	}
-	const conflictFiles = await getConflictFiles(projectPath);
-	if ((await resolveMainPreferredSyncConflicts(projectPath, conflictFiles)).success) {
-		console.log(`[sync-main] Auto-resolved ${conflictFiles.length} pipeline-owned conflict(s) with origin/main`);
-		logActivity("sync_main_auto_resolved_conflicts", `Auto-resolved ${conflictFiles.length} pipeline-owned conflict(s) in ${issueId} with origin/main`);
-		let changedFiles = [];
-		let commitCount = 0;
-		try {
-			const { stdout: diffFiles } = await execAsync("git diff --name-only ORIG_HEAD HEAD 2>/dev/null || git diff --name-only HEAD~1 HEAD", {
-				cwd: projectPath,
-				encoding: "utf-8"
-			});
-			changedFiles = diffFiles.trim().split("\n").filter((f) => f.length > 0);
-		} catch {}
-		try {
-			const { stdout: logOut } = await execAsync("git log ORIG_HEAD..HEAD --oneline 2>/dev/null || echo \"\"", {
-				cwd: projectPath,
-				encoding: "utf-8"
-			});
-			commitCount = logOut.trim().split("\n").filter((l) => l.length > 0).length;
-		} catch {}
+	} catch (error) {
+		if (!isSyncGitTermination(error)) throw error;
+		await ensureSyncGitQuiescent(projectPath, mergeStarted);
 		return {
-			success: true,
-			commitCount,
-			changedFiles
+			success: false,
+			reason: error instanceof SyncGitCommandTimeoutError ? error.message : "Sync-main cancelled after reaching its preparation deadline"
 		};
 	}
-	console.log(`[sync-main] ${conflictFiles.length} conflict(s); aborting merge for manual resolution`);
-	logActivity("sync_main_conflicts", `${conflictFiles.length} conflict(s) in ${issueId}: ${conflictFiles.join(", ")}`);
-	try {
-		await execAsync("git merge --abort", {
-			cwd: projectPath,
-			encoding: "utf-8"
-		});
-	} catch {}
-	return {
-		success: false,
-		conflictFiles,
-		reason: `Sync-main produced ${conflictFiles.length} conflict(s) in ${issueId}: ${conflictFiles.join(", ")}. Resolve manually in the workspace, then re-run sync-main.`
-	};
 }
 /**
 * Look up and run quality gates for the project at projectPath.
@@ -1358,12 +1509,13 @@ async function runProjectQualityGates(projectPath, phase) {
 		return [];
 	}
 }
-var execAsync, AUTO_COMMIT_EXCLUDED_PATHS, SYNC_MAIN_MAIN_PREFERRED_PATHS, __dirname, MERGE_HISTORY_DIR, MERGE_HISTORY_FILE, _completedPostMerge, _postMergeInFlight, GIT_PATTERNS;
+var execAsync, SYNC_GIT_FETCH_TIMEOUT_MS, SYNC_GIT_MERGE_TIMEOUT_MS, SYNC_GIT_COMMIT_TIMEOUT_MS, SYNC_GIT_STATUS_TIMEOUT_MS, AUTO_COMMIT_EXCLUDED_PATHS, SYNC_MAIN_MAIN_PREFERRED_PATHS, __dirname, MERGE_HISTORY_DIR, MERGE_HISTORY_FILE, _completedPostMerge, _postMergeInFlight, GIT_PATTERNS;
 var init_merge_agent = __esmMin((() => {
 	init_tmux();
 	init_activity_logger();
 	init_config_yaml();
 	init_merge_agent_step0();
+	init_sync_main_git();
 	init_paths();
 	init_tracker_utils();
 	init_validation();
@@ -1375,6 +1527,10 @@ var init_merge_agent = __esmMin((() => {
 	init_feature_registry_population();
 	init_merge_verification();
 	execAsync = promisify(exec);
+	SYNC_GIT_FETCH_TIMEOUT_MS = 6e4;
+	SYNC_GIT_MERGE_TIMEOUT_MS = 12e4;
+	SYNC_GIT_COMMIT_TIMEOUT_MS = 6e4;
+	SYNC_GIT_STATUS_TIMEOUT_MS = 3e4;
 	AUTO_COMMIT_EXCLUDED_PATHS = [
 		".pan/kickoff.md",
 		".pan/continue.json",
@@ -1436,4 +1592,4 @@ var init_merge_agent = __esmMin((() => {
 //#endregion
 export { init_operations as C, gitPush as S, listGitOperationsSync as T, scanGitPatterns as _, init_merge_agent as a, triggerPostMergeReleaseIfConfigured as b, isSyncMainMainPreferredPath as c, parseAgentOutput as d, postMergeLifecycle as f, scanForConflictMarkers as g, salvageStrandedMerge as h, captureTmuxOutput as i, logMergeHistory as l, runProjectQualityGates as m, GIT_PATTERNS as n, isAutoCommitExcludedPath as o, resetPostMergeState as p, autoCommitWorkspaceChangesBeforeSync as r, isMergeAgentRunning as s, AUTO_COMMIT_EXCLUDED_PATHS as t, notifyTldrDaemon as u, sendMessageToAgent as v, init_git_activity as w, MainDivergedError as x, syncMainIntoWorkspace as y };
 
-//# sourceMappingURL=merge-agent-DnBsms_V.js.map
+//# sourceMappingURL=merge-agent-XrB80vfT.js.map