vde-worktree 0.0.15 → 0.0.17

package/dist/index.mjs

@@ -617,7 +617,8 @@ const hasStateDirectory = async (repoRoot) => {
 const parseLifecycle = (content) => {
 	try {
 		const parsed = JSON.parse(content);
-		if (parsed.schemaVersion !== 1 || typeof parsed.branch !== "string" || typeof parsed.worktreeId !== "string" || typeof parsed.baseBranch !== "string" || typeof parsed.createdHead !== "string" || parsed.createdHead.length === 0 || typeof parsed.createdAt !== "string" || typeof parsed.updatedAt !== "string") return {
+		const isLastDivergedHeadValid = parsed.lastDivergedHead === null || typeof parsed.lastDivergedHead === "string" && parsed.lastDivergedHead.length > 0;
+		if (parsed.schemaVersion !== 2 || typeof parsed.branch !== "string" || typeof parsed.worktreeId !== "string" || typeof parsed.baseBranch !== "string" || typeof parsed.everDiverged !== "boolean" || isLastDivergedHeadValid !== true || typeof parsed.createdAt !== "string" || typeof parsed.updatedAt !== "string") return {
 			valid: false,
 			record: null
 		};
@@ -665,15 +666,17 @@ const readWorktreeMergeLifecycle = async ({ repoRoot, branch }) => {
 		};
 	}
 };
-const upsertWorktreeMergeLifecycle = async ({ repoRoot, branch, baseBranch, createdHead }) => {
+const upsertWorktreeMergeLifecycle = async ({ repoRoot, branch, baseBranch, observedDivergedHead }) => {
+	const normalizedObservedHead = typeof observedDivergedHead === "string" && observedDivergedHead.length > 0 ? observedDivergedHead : null;
 	if (await hasStateDirectory(repoRoot) !== true) {
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		return {
-			schemaVersion: 1,
+			schemaVersion: 2,
 			branch,
 			worktreeId: branchToWorktreeId(branch),
 			baseBranch,
-			createdHead,
+			everDiverged: normalizedObservedHead !== null,
+			lastDivergedHead: normalizedObservedHead,
 			createdAt: now,
 			updatedAt: now
 		};
@@ -682,14 +685,17 @@ const upsertWorktreeMergeLifecycle = async ({ repoRoot, branch, baseBranch, crea
 		repoRoot,
 		branch
 	});
-	if (current.valid && current.record !== null && current.record.baseBranch === baseBranch) return current.record;
+	if (current.valid && current.record !== null && current.record.baseBranch === baseBranch && normalizedObservedHead === null) return current.record;
 	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const everDiverged = current.record?.everDiverged === true || normalizedObservedHead !== null;
+	const lastDivergedHead = normalizedObservedHead ?? current.record?.lastDivergedHead ?? null;
 	const next = {
-		schemaVersion: 1,
+		schemaVersion: 2,
 		branch,
 		worktreeId: branchToWorktreeId(branch),
 		baseBranch,
-		createdHead: current.record?.createdHead ?? createdHead,
+		everDiverged,
+		lastDivergedHead,
 		createdAt: current.record?.createdAt ?? now,
 		updatedAt: now
 	};
@@ -699,15 +705,17 @@ const upsertWorktreeMergeLifecycle = async ({ repoRoot, branch, baseBranch, crea
 	});
 	return next;
 };
-const moveWorktreeMergeLifecycle = async ({ repoRoot, fromBranch, toBranch, baseBranch, createdHead }) => {
+const moveWorktreeMergeLifecycle = async ({ repoRoot, fromBranch, toBranch, baseBranch, observedDivergedHead }) => {
+	const normalizedObservedHead = typeof observedDivergedHead === "string" && observedDivergedHead.length > 0 ? observedDivergedHead : null;
 	if (await hasStateDirectory(repoRoot) !== true) {
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		return {
-			schemaVersion: 1,
+			schemaVersion: 2,
 			branch: toBranch,
 			worktreeId: branchToWorktreeId(toBranch),
 			baseBranch,
-			createdHead,
+			everDiverged: normalizedObservedHead !== null,
+			lastDivergedHead: normalizedObservedHead,
 			createdAt: now,
 			updatedAt: now
 		};
@@ -718,12 +726,15 @@ const moveWorktreeMergeLifecycle = async ({ repoRoot, fromBranch, toBranch, base
 	});
 	const targetPath = lifecycleFilePath(repoRoot, toBranch);
 	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const everDiverged = source.record?.everDiverged === true || normalizedObservedHead !== null;
+	const lastDivergedHead = normalizedObservedHead ?? source.record?.lastDivergedHead ?? null;
 	const next = {
-		schemaVersion: 1,
+		schemaVersion: 2,
 		branch: toBranch,
 		worktreeId: branchToWorktreeId(toBranch),
 		baseBranch,
-		createdHead: source.record?.createdHead ?? createdHead,
+		everDiverged,
+		lastDivergedHead,
 		createdAt: source.record?.createdAt ?? now,
 		updatedAt: now
 	};
@@ -842,43 +853,68 @@ const toTargetBranches = ({ branches, baseBranch }) => {
 	}
 	return [...uniqueBranches];
 };
-const buildUnknownBranchMap = (branches) => {
-	return new Map(branches.map((branch) => [branch, null]));
+const buildUnknownPrStatusMap = (branches) => {
+	return new Map(branches.map((branch) => [branch, "unknown"]));
+};
+const parseUpdatedAtMillis = (value) => {
+	if (typeof value !== "string" || value.length === 0) return Number.NEGATIVE_INFINITY;
+	const parsed = Date.parse(value);
+	if (Number.isNaN(parsed)) return Number.NEGATIVE_INFINITY;
+	return parsed;
 };
-const parseMergedBranches = ({ raw, targetBranches }) => {
+const toPrStatus = (record) => {
+	if (typeof record.mergedAt === "string" && record.mergedAt.length > 0) return "merged";
+	const state = typeof record.state === "string" ? record.state.toUpperCase() : "";
+	if (state === "MERGED") return "merged";
+	if (state === "OPEN") return "open";
+	if (state === "CLOSED") return "closed_unmerged";
+	return "unknown";
+};
+const parsePrStatusByBranch = ({ raw, targetBranches }) => {
 	try {
 		const parsed = JSON.parse(raw);
 		if (Array.isArray(parsed) !== true) return null;
+		const targetBranchSet = new Set(targetBranches);
 		const records = parsed;
-		const mergedBranches = /* @__PURE__ */ new Set();
-		for (const record of records) {
+		const latestByBranch = /* @__PURE__ */ new Map();
+		for (const [index, record] of records.entries()) {
 			if (typeof record?.headRefName !== "string" || record.headRefName.length === 0) continue;
-			if (targetBranches.has(record.headRefName) !== true) continue;
-			if (typeof record.mergedAt !== "string" || record.mergedAt.length === 0) continue;
-			mergedBranches.add(record.headRefName);
+			if (targetBranchSet.has(record.headRefName) !== true) continue;
+			const updatedAtMillis = parseUpdatedAtMillis(record.updatedAt);
+			const status = toPrStatus(record);
+			const current = latestByBranch.get(record.headRefName);
+			if (current === void 0 || updatedAtMillis > current.updatedAtMillis || updatedAtMillis === current.updatedAtMillis && index > current.index) latestByBranch.set(record.headRefName, {
+				updatedAtMillis,
+				index,
+				status
+			});
+		}
+		const result = /* @__PURE__ */ new Map();
+		for (const branch of targetBranches) {
+			const latest = latestByBranch.get(branch);
+			result.set(branch, latest?.status ?? "none");
 		}
-		return mergedBranches;
+		return result;
 	} catch {
 		return null;
 	}
 };
-const resolveMergedByPrBatch = async ({ repoRoot, baseBranch, branches, enabled = true, runGh = defaultRunGh }) => {
-	if (enabled !== true) return /* @__PURE__ */ new Map();
+const resolvePrStatusByBranchBatch = async ({ repoRoot, baseBranch, branches, enabled = true, runGh = defaultRunGh }) => {
 	if (baseBranch === null) return /* @__PURE__ */ new Map();
 	const targetBranches = toTargetBranches({
 		branches,
 		baseBranch
 	});
 	if (targetBranches.length === 0) return /* @__PURE__ */ new Map();
+	if (enabled !== true) return buildUnknownPrStatusMap(targetBranches);
 	try {
-		const targetBranchSet = new Set(targetBranches);
 		const result = await runGh({
 			cwd: repoRoot,
 			args: [
 				"pr",
 				"list",
 				"--state",
-				"merged",
+				"all",
 				"--base",
 				baseBranch,
 				"--search",
@@ -886,21 +922,19 @@ const resolveMergedByPrBatch = async ({ repoRoot, baseBranch, branches, enabled
 				"--limit",
 				"1000",
 				"--json",
-				"headRefName,mergedAt"
+				"headRefName,state,mergedAt,updatedAt"
 			]
 		});
-		if (result.exitCode !== 0) return buildUnknownBranchMap(targetBranches);
-		const mergedBranches = parseMergedBranches({
+		if (result.exitCode !== 0) return buildUnknownPrStatusMap(targetBranches);
+		const prStatusByBranch = parsePrStatusByBranch({
 			raw: result.stdout,
-			targetBranches: targetBranchSet
+			targetBranches
 		});
-		if (mergedBranches === null) return buildUnknownBranchMap(targetBranches);
-		return new Map(targetBranches.map((branch) => {
-			return [branch, mergedBranches.has(branch)];
-		}));
+		if (prStatusByBranch === null) return buildUnknownPrStatusMap(targetBranches);
+		return prStatusByBranch;
 	} catch (error) {
-		if (error.code === "ENOENT") return buildUnknownBranchMap(targetBranches);
-		return buildUnknownBranchMap(targetBranches);
+		if (error.code === "ENOENT") return buildUnknownPrStatusMap(targetBranches);
+		return buildUnknownPrStatusMap(targetBranches);
 	}
 };
 
@@ -1049,7 +1083,57 @@ const resolveLockState = async ({ repoRoot, branch }) => {
 		};
 	}
 };
-const resolveMergedState = async ({ repoRoot, branch, head, baseBranch, mergedByPrByBranch }) => {
+const WORK_REFLOG_MESSAGE_PATTERN = /^(commit(?: \([^)]*\))?|cherry-pick|revert|rebase \(pick\)|merge):/;
+const resolveLifecycleFromReflog = async ({ repoRoot, branch, baseBranch }) => {
+	const reflog = await runGitCommand({
+		cwd: repoRoot,
+		args: [
+			"reflog",
+			"show",
+			"--format=%H%x09%gs",
+			branch
+		],
+		reject: false
+	});
+	if (reflog.exitCode !== 0) return {
+		merged: null,
+		divergedHead: null
+	};
+	let latestWorkHead = null;
+	for (const line of reflog.stdout.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.length === 0) continue;
+		const separatorIndex = trimmed.indexOf("	");
+		if (separatorIndex <= 0) continue;
+		const head = trimmed.slice(0, separatorIndex).trim();
+		const message = trimmed.slice(separatorIndex + 1).trim();
+		if (head.length === 0 || WORK_REFLOG_MESSAGE_PATTERN.test(message) !== true) continue;
+		if (latestWorkHead === null) latestWorkHead = head;
+		const result = await runGitCommand({
+			cwd: repoRoot,
+			args: [
+				"merge-base",
+				"--is-ancestor",
+				head,
+				baseBranch
+			],
+			reject: false
+		});
+		if (result.exitCode === 0) return {
+			merged: true,
+			divergedHead: head
+		};
+		if (result.exitCode !== 1) return {
+			merged: null,
+			divergedHead: latestWorkHead
+		};
+	}
+	return {
+		merged: false,
+		divergedHead: latestWorkHead
+	};
+};
+const resolveMergedState = async ({ repoRoot, branch, head, baseBranch, prStatusByBranch }) => {
 	if (branch === null) return {
 		byAncestry: null,
 		byPR: null,
@@ -1070,17 +1154,49 @@ const resolveMergedState = async ({ repoRoot, branch, head, baseBranch, mergedBy
 		if (result.exitCode === 0) byAncestry = true;
 		else if (result.exitCode === 1) byAncestry = false;
 	}
-	const byPR = branch === baseBranch ? null : mergedByPrByBranch.get(branch) ?? null;
+	const prStatus = branch === baseBranch ? null : prStatusByBranch.get(branch) ?? null;
+	let byPR = null;
+	if (prStatus === "merged") byPR = true;
+	else if (prStatus === "none" || prStatus === "open" || prStatus === "closed_unmerged") byPR = false;
 	let byLifecycle = null;
 	if (baseBranch !== null) {
 		const lifecycle = await upsertWorktreeMergeLifecycle({
 			repoRoot,
 			branch,
 			baseBranch,
-			createdHead: head
+			observedDivergedHead: byAncestry === false ? head : null
 		});
-		if (byAncestry === true) byLifecycle = lifecycle.createdHead !== head;
-		else if (byAncestry === false) byLifecycle = false;
+		if (byAncestry === false) byLifecycle = false;
+		else if (byAncestry === true) if (lifecycle.everDiverged !== true || lifecycle.lastDivergedHead === null) if (byPR === true) byLifecycle = null;
+		else {
+			const probe = await resolveLifecycleFromReflog({
+				repoRoot,
+				branch,
+				baseBranch
+			});
+			byLifecycle = probe.merged;
+			if (probe.divergedHead !== null) await upsertWorktreeMergeLifecycle({
+				repoRoot,
+				branch,
+				baseBranch,
+				observedDivergedHead: probe.divergedHead
+			});
+		}
+		else {
+			const lifecycleResult = await runGitCommand({
+				cwd: repoRoot,
+				args: [
+					"merge-base",
+					"--is-ancestor",
+					lifecycle.lastDivergedHead,
+					baseBranch
+				],
+				reject: false
+			});
+			if (lifecycleResult.exitCode === 0) byLifecycle = true;
+			else if (lifecycleResult.exitCode === 1) byLifecycle = false;
+			else byLifecycle = null;
+		}
 	}
 	return {
 		byAncestry,
@@ -1092,6 +1208,10 @@ const resolveMergedState = async ({ repoRoot, branch, head, baseBranch, mergedBy
 		})
 	};
 };
+const resolvePrState = ({ branch, baseBranch, prStatusByBranch }) => {
+	if (branch === null || branch === baseBranch) return { status: null };
+	return { status: prStatusByBranch.get(branch) ?? null };
+};
 const resolveMergedOverall = ({ byAncestry, byPR, byLifecycle }) => {
 	if (byPR === true || byLifecycle === true) return true;
 	if (byAncestry === false) return false;
@@ -1138,7 +1258,7 @@ const resolveUpstreamState = async (worktreePath) => {
 		remote: upstreamRef.stdout.trim()
 	};
 };
-const enrichWorktree = async ({ repoRoot, worktree, baseBranch, mergedByPrByBranch }) => {
+const enrichWorktree = async ({ repoRoot, worktree, baseBranch, prStatusByBranch }) => {
 	const [dirty, locked, merged, upstream] = await Promise.all([
 		resolveDirty(worktree.path),
 		resolveLockState({
@@ -1150,10 +1270,15 @@ const enrichWorktree = async ({ repoRoot, worktree, baseBranch, mergedByPrByBran
 			branch: worktree.branch,
 			head: worktree.head,
 			baseBranch,
-			mergedByPrByBranch
+			prStatusByBranch
 		}),
 		resolveUpstreamState(worktree.path)
 	]);
+	const pr = resolvePrState({
+		branch: worktree.branch,
+		baseBranch,
+		prStatusByBranch
+	});
 	return {
 		branch: worktree.branch,
 		path: worktree.path,
@@ -1161,6 +1286,7 @@ const enrichWorktree = async ({ repoRoot, worktree, baseBranch, mergedByPrByBran
 		dirty,
 		locked,
 		merged,
+		pr,
 		upstream
 	};
 };
@@ -1170,7 +1296,7 @@ const collectWorktreeSnapshot = async (repoRoot, { noGh = false } = {}) => {
 		listGitWorktrees(repoRoot),
 		resolveEnableGh(repoRoot)
 	]);
-	const mergedByPrByBranch = await resolveMergedByPrBatch({
+	const prStatusByBranch = await resolvePrStatusByBranchBatch({
 		repoRoot,
 		baseBranch,
 		branches: worktrees.map((worktree) => worktree.branch),
@@ -1184,7 +1310,7 @@ const collectWorktreeSnapshot = async (repoRoot, { noGh = false } = {}) => {
 				repoRoot,
 				worktree,
 				baseBranch,
-				mergedByPrByBranch
+				prStatusByBranch
 			});
 		}))
 	};
@@ -1440,9 +1566,9 @@ const colorizeListTableLine = ({ line, theme }) => {
 	const segments = line.split("│");
 	if (segments.length < 3) return line;
 	const cells = segments.slice(1, -1);
-	if (cells.length !== 7) return line;
+	if (cells.length !== 8) return line;
 	const headers = cells.map((cell) => cell.trim());
-	if (headers[0] === "branch" && headers[1] === "dirty" && headers[2] === "merged" && headers[3] === "locked" && headers[4] === "ahead" && headers[5] === "behind" && headers[6] === "path") {
+	if (headers[0] === "branch" && headers[1] === "dirty" && headers[2] === "merged" && headers[3] === "pr" && headers[4] === "locked" && headers[5] === "ahead" && headers[6] === "behind" && headers[7] === "path") {
 		const nextCells = cells.map((cell) => colorizeCellContent({
 			cell,
 			color: theme.header
@@ -1456,15 +1582,18 @@ const colorizeListTableLine = ({ line, theme }) => {
 	const branchCell = cells[0];
 	const dirtyCell = cells[1];
 	const mergedCell = cells[2];
-	const lockedCell = cells[3];
-	const aheadCell = cells[4];
-	const behindCell = cells[5];
-	const pathCell = cells[6];
+	const prCell = cells[3];
+	const lockedCell = cells[4];
+	const aheadCell = cells[5];
+	const behindCell = cells[6];
+	const pathCell = cells[7];
 	const branchColor = branchCell.includes("(detached)") === true ? theme.branchDetached : branchCell.trimStart().startsWith("*") ? theme.branchCurrent : theme.branch;
 	const dirtyTrimmed = dirtyCell.trim();
 	const dirtyColor = dirtyTrimmed === "dirty" ? theme.dirty : dirtyTrimmed === "clean" ? theme.clean : theme.value;
 	const mergedTrimmed = mergedCell.trim();
 	const mergedColor = mergedTrimmed === "merged" ? theme.merged : mergedTrimmed === "unmerged" ? theme.unmerged : mergedTrimmed === "-" ? theme.base : theme.unknown;
+	const prTrimmed = prCell.trim();
+	const prColor = prTrimmed === "merged" ? theme.merged : prTrimmed === "open" ? theme.value : prTrimmed === "closed_unmerged" ? theme.unmerged : prTrimmed === "none" ? theme.muted : prTrimmed === "-" ? theme.base : theme.unknown;
 	const lockedColor = lockedCell.trim() === "locked" ? theme.locked : theme.muted;
 	const aheadTrimmed = aheadCell.trim();
 	const aheadValue = Number.parseInt(aheadTrimmed, 10);
@@ -1485,6 +1614,10 @@ const colorizeListTableLine = ({ line, theme }) => {
 			cell: mergedCell,
 			color: mergedColor
 		}),
+		colorizeCellContent({
+			cell: prCell,
+			color: prColor
+		}),
 		colorizeCellContent({
 			cell: lockedCell,
 			color: lockedColor
@@ -1525,7 +1658,7 @@ const commandHelpEntries = [
 		name: "list",
 		usage: "vw list [--json]",
 		summary: "List worktrees with status metadata.",
-		details: ["Table output includes branch, path, dirty, lock, merged, and ahead/behind vs base branch.", "JSON output includes upstream metadata fields."]
+		details: ["Table output includes branch, path, dirty, lock, merged, PR state, and ahead/behind vs base branch.", "JSON output includes PR and upstream metadata fields."]
 	},
 	{
 		name: "status",
@@ -1897,22 +2030,6 @@ const resolveBaseBranch = async (repoRoot) => {
 	for (const candidate of ["main", "master"]) if (await doesGitRefExist(repoRoot, `refs/heads/${candidate}`)) return candidate;
 	throw createCliError("INVALID_ARGUMENT", { message: "Unable to resolve base branch. Configure vde-worktree.baseBranch." });
 };
-const resolveBranchHead = async ({ repoRoot, branch }) => {
-	const resolved = await runGitCommand({
-		cwd: repoRoot,
-		args: [
-			"rev-parse",
-			"--verify",
-			branch
-		],
-		reject: false
-	});
-	if (resolved.exitCode !== 0 || resolved.stdout.trim().length === 0) throw createCliError("INVALID_ARGUMENT", {
-		message: `Failed to resolve branch head: ${branch}`,
-		details: { branch }
-	});
-	return resolved.stdout.trim();
-};
 const ensureTargetPathWritable = async (targetPath) => {
 	try {
 		await access(targetPath, constants.F_OK);
@@ -2358,6 +2475,11 @@ const formatMergedColor = ({ mergedState, theme }) => {
 	if (normalized === "base") return theme.base(mergedState);
 	return theme.unknown(mergedState);
 };
+const formatPrDisplayState = ({ prStatus, isBaseBranch }) => {
+	if (isBaseBranch || prStatus === null) return "-";
+	if (prStatus === "none" || prStatus === "open" || prStatus === "merged" || prStatus === "closed_unmerged" || prStatus === "unknown") return prStatus;
+	return "unknown";
+};
 const formatListUpstreamCount = (value) => {
 	if (value === null) return "-";
 	return String(value);
@@ -2519,7 +2641,7 @@ const renderGeneralHelpText = ({ version }) => {
 		"  --json                  Output machine-readable JSON.",
 		"  --verbose               Enable verbose logs.",
 		"  --no-hooks              Disable hooks for this run (requires --allow-unsafe).",
-		"  --no-gh                 Disable GitHub CLI based PR merge checks for this run.",
+		"  --no-gh                 Disable GitHub CLI based PR status checks for this run.",
 		"  --allow-unsafe          Explicitly allow unsafe behavior in non-TTY mode.",
 		"  --hook-timeout-ms <ms>  Override hook timeout.",
 		"  --lock-timeout-ms <ms>  Override repository lock timeout.",
@@ -2622,7 +2744,7 @@ const createCli = (options = {}) => {
 		},
 		gh: {
 			type: "boolean",
-			description: "Enable GitHub CLI based PR merge checks (disable with --no-gh)",
+			description: "Enable GitHub CLI based PR status checks (disable with --no-gh)",
 			default: true
 		},
 		allowUnsafe: {
@@ -2956,6 +3078,7 @@ const createCli = (options = {}) => {
 						"branch",
 						"dirty",
 						"merged",
+						"pr",
 						"locked",
 						"ahead",
 						"behind",
@@ -2966,11 +3089,17 @@ const createCli = (options = {}) => {
 							baseBranch: snapshot.baseBranch,
 							worktree
 						});
-						const mergedState = (worktree.branch !== null && snapshot.baseBranch !== null && worktree.branch === snapshot.baseBranch) === true ? "-" : worktree.merged.overall === true ? "merged" : worktree.merged.overall === false ? "unmerged" : "unknown";
+						const isBaseBranch = worktree.branch !== null && snapshot.baseBranch !== null && worktree.branch === snapshot.baseBranch;
+						const mergedState = isBaseBranch === true ? "-" : worktree.merged.overall === true ? "merged" : worktree.merged.overall === false ? "unmerged" : "unknown";
+						const prState = formatPrDisplayState({
+							prStatus: worktree.pr.status,
+							isBaseBranch
+						});
 						return [
 							`${worktree.path === repoContext.currentWorktreeRoot ? "*" : " "} ${worktree.branch ?? "(detached)"}`,
 							worktree.dirty ? "dirty" : "clean",
 							mergedState,
+							prState,
 							worktree.locked.value ? "locked" : "-",
 							formatListUpstreamCount(distanceFromBase.ahead),
 							formatListUpstreamCount(distanceFromBase.behind),
@@ -3095,10 +3224,7 @@ const createCli = (options = {}) => {
 						repoRoot,
 						branch,
 						baseBranch,
-						createdHead: await resolveBranchHead({
-							repoRoot,
-							branch
-						})
+						observedDivergedHead: null
 					});
 					await runPostHook({
 						name: "new",
@@ -3133,18 +3259,12 @@ const createCli = (options = {}) => {
 					const snapshot = await collectWorktreeSnapshot$1(repoRoot);
 					const existing = snapshot.worktrees.find((worktree) => worktree.branch === branch);
 					if (existing !== void 0) {
-						if (snapshot.baseBranch !== null) {
-							const branchHead = await resolveBranchHead({
-								repoRoot,
-								branch
-							});
-							await upsertWorktreeMergeLifecycle({
-								repoRoot,
-								branch,
-								baseBranch: snapshot.baseBranch,
-								createdHead: branchHead
-							});
-						}
+						if (snapshot.baseBranch !== null) await upsertWorktreeMergeLifecycle({
+							repoRoot,
+							branch,
+							baseBranch: snapshot.baseBranch,
+							observedDivergedHead: null
+						});
 						return {
 							status: "existing",
 							branch,
@@ -3190,18 +3310,12 @@ const createCli = (options = {}) => {
 							]
 						});
 					}
-					if (lifecycleBaseBranch !== null) {
-						const branchHead = await resolveBranchHead({
-							repoRoot,
-							branch
-						});
-						await upsertWorktreeMergeLifecycle({
-							repoRoot,
-							branch,
-							baseBranch: lifecycleBaseBranch,
-							createdHead: branchHead
-						});
-					}
+					if (lifecycleBaseBranch !== null) await upsertWorktreeMergeLifecycle({
+						repoRoot,
+						branch,
+						baseBranch: lifecycleBaseBranch,
+						observedDivergedHead: null
+					});
 					await runPostHook({
 						name: "switch",
 						context: hookContext
@@ -3301,19 +3415,13 @@ const createCli = (options = {}) => {
 							newPath
 						]
 					});
-					if (snapshot.baseBranch !== null) {
-						const branchHead = await resolveBranchHead({
-							repoRoot,
-							branch: newBranch
-						});
-						await moveWorktreeMergeLifecycle({
-							repoRoot,
-							fromBranch: oldBranch,
-							toBranch: newBranch,
-							baseBranch: snapshot.baseBranch,
-							createdHead: branchHead
-						});
-					}
+					if (snapshot.baseBranch !== null) await moveWorktreeMergeLifecycle({
+						repoRoot,
+						fromBranch: oldBranch,
+						toBranch: newBranch,
+						baseBranch: snapshot.baseBranch,
+						observedDivergedHead: null
+					});
 					await runPostHook({
 						name: "mv",
 						context: hookContext
@@ -3582,10 +3690,7 @@ const createCli = (options = {}) => {
 							repoRoot,
 							branch,
 							baseBranch: lifecycleBaseBranch,
-							createdHead: await resolveBranchHead({
-								repoRoot,
-								branch
-							})
+							observedDivergedHead: null
 						});
 						await runPostHook({
 							name: "get",
@@ -3612,10 +3717,7 @@ const createCli = (options = {}) => {
 						repoRoot,
 						branch,
 						baseBranch: lifecycleBaseBranch,
-						createdHead: await resolveBranchHead({
-							repoRoot,
-							branch
-						})
+						observedDivergedHead: null
 					});
 					await runPostHook({
 						name: "get",
@@ -3727,10 +3829,7 @@ const createCli = (options = {}) => {
 						repoRoot,
 						branch,
 						baseBranch,
-						createdHead: await resolveBranchHead({
-							repoRoot,
-							branch
-						})
+						observedDivergedHead: null
 					});
 					if (stashOid !== null) {
 						if ((await runGitCommand({