@overdeck/desktop 0.47.1 → 0.48.0

package/server/{workflows-D87ajwV6.js → workflows-BMBwLYPV.js}

@@ -1,18 +1,20 @@
-import { Ft as markRecordPipelineClosedOutSync, Gr as OVERDECK_HOME, Lt as readIssueRecord, Nt as getProjectConfigFromWorkspacePath, Pt as init_record, Vt as resolveProjectForIssue, Wt as writeCloseOutDodGate, gr as init_issue_id, hr as extractPrefixSync, li as init_paths, mr as extractNumberSync } from "./config-yaml-CxdwhAIA.js";
-import { D as resolvePipelineTelemetryContext, E as init_pipeline, p as init_review_status, u as getReviewStatus, w as capturePipelineStage } from "./review-status-CwhA9wmd.js";
-import { b as init_agents, i as listRunningAgents } from "./queries-DCX27GRr.js";
-import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-DhswNiXx.js";
-import { f as init_config, s as getDashboardApiUrlSync } from "./config-CX4vk1CV.js";
-import { i as loadCloisterConfig, r as init_config$1 } from "./config-ktAVnp4s.js";
-import { r as getAutoCloseOutCanonicalState, t as pruneStoppedAgentsForIssue } from "./agent-gc-BMcgTDl7.js";
-import { i as isTrackerIssueClosed, n as init_issue_closed } from "./issue-closed-CNNGbhWm.js";
-import { i as findWorkspacePath, t as archivePlanning } from "./archive-planning-Binfb99i.js";
-import { a as stepSkipped, i as stepOk, n as init_types, r as stepFailed, t as getLinearApiKey } from "./types-Dh6RI5Vj.js";
-import { i as gatherIssueBranchContainment, s as init_pipeline_membership_gather } from "./pipeline-membership-gather-BIcJ-N0W.js";
-import { t as closeIssue } from "./close-issue-BX1bATJy.js";
-import { o as init_pull_requests, r as fetchIssuePullRequest, t as fetchCommitCheckRuns } from "./pull-requests-BonZ4WVG.js";
-import { a as canAcceptDodMisses, i as buildAbandonedDodGate, n as DOD_ROWS, r as acceptFlagFor, t as BRANCH_ABSENT_MERGE_ERROR } from "./dod-Bg6wsKTV.js";
-import { t as teardownWorkspace } from "./teardown-workspace-CvBpvc85.js";
+import { J as markRecordPipelineClosedOutSync, K as getProjectConfigFromWorkspacePath, Mn as extractPrefixSync, Nn as init_issue_id, X as readIssueRecord, Zr as OVERDECK_HOME, et as resolveProjectForIssue, hi as init_paths, jn as extractNumberSync, q as init_record, rt as writeCloseOutDodGate } from "./config-yaml-BSCqwmX0.js";
+import { f as init_config, s as getDashboardApiUrlSync } from "./config-DnLJATZk.js";
+import { D as resolvePipelineTelemetryContext, E as init_pipeline, p as init_review_status, u as getReviewStatus, w as capturePipelineStage } from "./review-status-CKLk5aZ-.js";
+import { b as init_agents, i as listRunningAgents } from "./queries-DVpl1vsU.js";
+import { c as resolveProjectReposForIssueSync, i as init_project_repos } from "./project-repos-BAqDwtvi.js";
+import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-DWGBKyWd.js";
+import { i as loadCloisterConfig, r as init_config$1 } from "./config-DvM8jtQK.js";
+import { r as getAutoCloseOutCanonicalState, t as pruneStoppedAgentsForIssue } from "./agent-gc-BmYeT6eH.js";
+import { i as isTrackerIssueClosed, n as init_issue_closed } from "./issue-closed-Bj_bCv_0.js";
+import { n as getForgeAdapter, r as init_forge } from "./forge-c8LeC-tw.js";
+import { i as findWorkspacePath, t as archivePlanning } from "./archive-planning-Cq7cyinS.js";
+import { a as stepSkipped, i as stepOk, n as init_types, r as stepFailed, t as getLinearApiKey } from "./types-kI9ik8XO.js";
+import { i as gatherIssueBranchContainment, s as init_pipeline_membership_gather } from "./pipeline-membership-gather-CtJ_7aGf.js";
+import { t as closeIssue } from "./close-issue-DPxRddGR.js";
+import { o as init_pull_requests, r as fetchIssuePullRequest, t as fetchCommitCheckRuns } from "./pull-requests-B-KrUph5.js";
+import { a as canAcceptDodMisses, i as buildAbandonedDodGate, n as DOD_ROWS, r as acceptFlagFor, t as BRANCH_ABSENT_MERGE_ERROR } from "./dod-D7-9dCOD.js";
+import { t as teardownWorkspace } from "./teardown-workspace-CqKKVJr1.js";
 import { resolve } from "node:path";
 import { Effect } from "effect";
 import { existsSync } from "fs";
@@ -36,6 +38,8 @@ init_review_status();
 init_record();
 init_issue_closed();
 init_pull_requests();
+init_forge();
+init_project_repos();
 init_pipeline_membership_gather();
 const execFileAsync = promisify(execFile);
 const defaultMergedRowDeps = {
@@ -54,6 +58,14 @@ const defaultMergedRowDeps = {
 	readDurableMerges: async (ctx) => {
 		return (await readIssueRecord(resolveProjectForIssue(ctx.issueId) ?? getProjectConfigFromWorkspacePath(ctx.projectPath), ctx.issueId))?.closeOut.merges ?? [];
 	},
+	readMergedForgeArtifacts: async (ctx) => {
+		const repos = resolveProjectReposForIssueSync(ctx.issueId)?.filter((repo) => repo.required) ?? [];
+		return (await Promise.all(repos.map((repo) => getForgeAdapter(repo.forge).findMergedArtifact({
+			sourceBranch: repo.sourceBranch,
+			targetBranch: repo.targetBranch,
+			cwd: repo.repoPath
+		})))).filter((artifact) => artifact !== null);
+	},
 	readBranchContainment: async (ctx) => {
 		const project = resolveProjectForIssue(ctx.issueId) ?? getProjectConfigFromWorkspacePath(ctx.projectPath);
 		if (!project) return {
@@ -69,17 +81,33 @@ const defaultPostMergeRowDeps = {
 	readCanonicalState: async (ctx) => {
 		return getAutoCloseOutCanonicalState(ctx.issueId);
 	},
-	readMergeStatus: async (issueId) => (await Effect.runPromise(getReviewStatus(issueId)))?.mergeStatus,
+	readMergeStatus: async (issueId) => (await loadStatus(issueId, defaultDeps))?.status.mergeStatus,
 	listAgents: async () => Effect.runPromise(listRunningAgents())
 };
-const defaultMainVerifyRowDeps = { readCheckRuns: async (ctx, mergeCommit) => {
-	if (!ctx.github) return {
-		total: 0,
-		failed: [],
-		pending: []
-	};
-	return fetchCommitCheckRuns(ctx.github.owner, ctx.github.repo, mergeCommit);
-} };
+const defaultMainVerifyRowDeps = {
+	readCheckRuns: async (ctx, commit) => {
+		if (!ctx.github) return {
+			total: 0,
+			failed: [],
+			pending: []
+		};
+		return fetchCommitCheckRuns(ctx.github.owner, ctx.github.repo, commit);
+	},
+	readContainingDefaultBranchCommits: async (ctx, mergeCommit) => {
+		const { stdout } = await execFileAsync("git", [
+			"rev-list",
+			"--ancestry-path",
+			"--first-parent",
+			`${mergeCommit}..origin/main`
+		], {
+			cwd: ctx.projectPath,
+			encoding: "utf-8",
+			timeout: 1e4,
+			maxBuffer: 8 * 1024 * 1024
+		});
+		return stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+	}
+};
 const defaultEvaluateDodGateDeps = {
 	review: (issueId, settlement) => checkReviewRow(issueId, defaultDeps, settlement),
 	tests: (issueId, settlement) => checkTestsRow(issueId, defaultDeps, settlement),
@@ -238,11 +266,24 @@ async function checkMergedRow(ctx, deps = defaultMergedRowDeps) {
 	const merged = result("merged", verified.success || verified.skipped ? "pass" : "miss", observed);
 	const branchAbsent = verified.error === BRANCH_ABSENT_MERGE_ERROR;
 	let durableMerges = [];
-	if (branchAbsent) try {
-		durableMerges = await (deps.readDurableMerges ?? defaultMergedRowDeps.readDurableMerges)(ctx);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		merged.observed = `${merged.observed}; durable merge evidence unavailable: ${message}`;
+	let forgeArtifacts = [];
+	if (branchAbsent) {
+		try {
+			durableMerges = await (deps.readDurableMerges ?? defaultMergedRowDeps.readDurableMerges)(ctx);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			merged.observed = `${merged.observed}; durable merge evidence unavailable: ${message}`;
+		}
+		if (!ctx.github && deps.readMergedForgeArtifacts) try {
+			forgeArtifacts = await deps.readMergedForgeArtifacts(ctx);
+			const labels = forgeArtifacts.map((artifact) => {
+				return `${artifact.forge === "gitlab" ? artifact.id ? `MR !${artifact.id}` : "GitLab MR" : artifact.id ? `PR #${artifact.id}` : "GitHub PR"} merged${artifact.url ? ` (${artifact.url})` : ""}`;
+			});
+			if (labels.length > 0) merged.observed = `${merged.observed}; ${labels.join("; ")}`;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			merged.observed = `${merged.observed}; forge artifact evidence unavailable: ${message}`;
+		}
 	}
 	let pullRequestState;
 	if (ctx.github) try {
@@ -261,7 +302,7 @@ async function checkMergedRow(ctx, deps = defaultMergedRowDeps) {
 	}
 	if (branchAbsent) {
 		const forgeMerged = pullRequestState?.toUpperCase() === "MERGED";
-		if (durableMerges.length > 0 || forgeMerged) {
+		if (durableMerges.length > 0 || forgeMerged || forgeArtifacts.length > 0) {
 			merged.status = "pass";
 			if (durableMerges.length > 0) merged.observed = `${merged.observed}; durable close-out record contains ${durableMerges.length} merge artifact(s)`;
 		} else merged.observed = `${merged.observed}; no merged forge artifact or durable close-out merge record found`;
@@ -297,13 +338,65 @@ async function checkPostMergeRow(ctx, merged, deps = defaultPostMergeRowDeps) {
 		return result("post-merge", "miss", `post-merge evidence unavailable: ${error instanceof Error ? error.message : String(error)}`);
 	}
 }
+/**
+* PAN-3202: how many default-branch heads above the merge commit are probed for
+* the later-green-run evidence form. The tip of main is often mid-CI, so a single
+* candidate would usually read as pending; five reaches back far enough to find
+* the newest concluded green head without turning one row into a check-run storm.
+*/
+const LATER_GREEN_CANDIDATE_LIMIT = 5;
+/**
+* PAN-3202: the fallback evidence form for DoD row 6. When a merge lands inside a
+* red-main window, the merge commit's own check-runs can never turn green, so the
+* row was permanently unsatisfiable even after main went green hundreds of times
+* with the commit included. A later default-branch head whose check-runs all
+* concluded green, and which contains the merge commit, is strictly stronger
+* evidence than the original run: it proves main is healthy *with* the merge in it,
+* which is exactly what "verified on main" means. Row 7 (deploy) already reasons
+* this way through the same containment relation.
+*/
+async function findLaterGreenDefaultBranchRun(ctx, mergeCommit, deps) {
+	const readCandidates = deps.readContainingDefaultBranchCommits ?? defaultMainVerifyRowDeps.readContainingDefaultBranchCommits;
+	let candidates;
+	try {
+		candidates = await readCandidates(ctx, mergeCommit);
+	} catch (error) {
+		return {
+			run: null,
+			note: `later-run evidence unavailable: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+	const probed = candidates.slice(0, LATER_GREEN_CANDIDATE_LIMIT);
+	for (const sha of probed) try {
+		const checks = await deps.readCheckRuns(ctx, sha);
+		if (checks.total > 0 && checks.failed.length === 0 && checks.pending.length === 0) return {
+			run: {
+				sha,
+				total: checks.total
+			},
+			note: ""
+		};
+	} catch (error) {
+		return {
+			run: null,
+			note: `later-run evidence unavailable: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+	return {
+		run: null,
+		note: probed.length === 0 ? "no later default-branch commit contains the merge" : `no green CI run among the ${probed.length} newest default-branch commit(s) containing the merge`
+	};
+}
 async function checkMainVerifyRow(ctx, mergeCommit, deps = defaultMainVerifyRowDeps) {
 	if (!ctx.github || !mergeCommit) return result("main-verify", "skip", "no merge commit resolvable — verified-on-main has no durable marker (see DoD row 6)");
 	try {
 		const checks = await deps.readCheckRuns(ctx, mergeCommit);
-		if (checks.total === 0) return result("main-verify", "skip", `no CI check-runs on merge commit ${mergeCommit}`);
-		if (checks.failed.length > 0 || checks.pending.length > 0) return result("main-verify", "miss", `${[...checks.failed.length > 0 ? [`failed checks: ${checks.failed.join(", ")}`] : [], ...checks.pending.length > 0 ? [`still running: ${checks.pending.join(", ")}`] : []].join("; ")} on ${mergeCommit}`);
-		return result("main-verify", "pass", `${checks.total} check-runs concluded successfully on ${mergeCommit}`);
+		if (checks.total > 0 && checks.failed.length === 0 && checks.pending.length === 0) return result("main-verify", "pass", `${checks.total} check-runs concluded successfully on ${mergeCommit}`);
+		const parts = [...checks.failed.length > 0 ? [`failed checks: ${checks.failed.join(", ")}`] : [], ...checks.pending.length > 0 ? [`still running: ${checks.pending.join(", ")}`] : []];
+		const primary = checks.total === 0 ? `no CI check-runs on merge commit ${mergeCommit}` : `${parts.join("; ")} on ${mergeCommit}`;
+		const later = await findLaterGreenDefaultBranchRun(ctx, mergeCommit, deps);
+		if (later.run) return result("main-verify", "pass", `${primary}; verified on main by later green CI run ${later.run.sha} containing the merge (${later.run.total} check-runs concluded successfully)`);
+		return result("main-verify", checks.total === 0 ? "skip" : "miss", `${primary}; ${later.note}`);
 	} catch (error) {
 		return result("main-verify", "miss", `could not read merge-commit check-runs: ${error instanceof Error ? error.message : String(error)}`);
 	}
@@ -385,6 +478,23 @@ async function evaluateDodGate(ctx, opts = {}, deps = defaultEvaluateDodGateDeps
 		passed: rows.every((row) => row.status !== "miss" || Boolean(row.acceptedBy))
 	};
 }
+/**
+* PAN-3025: completion witness for the close-out ceremony. Returns closedOutAt
+* only when the journal is terminal AND the live row is gone (the ceremony's
+* final mutating step). closedOut with live status present means a prior run
+* aborted mid-ceremony and must fall through to complete it.
+*/
+async function readCompletedCloseOut(issueId, projectPath) {
+	try {
+		const record = await readIssueRecord(resolveProjectForIssue(issueId) ?? getProjectConfigFromWorkspacePath(projectPath), issueId.toUpperCase());
+		if (!record?.pipeline.closedOut) return null;
+		const live = await Effect.runPromise(getReviewStatus(issueId)).catch(() => "unknown");
+		if (live === "unknown") return null;
+		return live ? null : record.pipeline.closedOutAt ?? "unknown";
+	} catch {
+		return null;
+	}
+}
 //#endregion
 //#region ../../lib/lifecycle/workflows.ts
 /**
@@ -395,6 +505,8 @@ async function evaluateDodGate(ctx, opts = {}, deps = defaultEvaluateDodGateDeps
 * closeOut() — Full ceremony: verify-merged + archive + teardown + close + label + clear-status
 * deepWipe() — Destructive: teardown(deleteBranches) + delete agent state + reset issue
 */
+init_forge();
+init_project_repos();
 init_record();
 init_pipeline();
 const execAsync = promisify$1(exec$1);
@@ -483,9 +595,14 @@ function closeOut(ctx, opts = {}) {
 	return Effect.gen(function* () {
 		const start = Date.now();
 		const allSteps = [];
+		const closedOutAt = yield* Effect.promise(() => readCompletedCloseOut(ctx.issueId, ctx.projectPath).catch(() => null));
+		if (closedOutAt) {
+			allSteps.push(stepSkipped("close-out:idempotent", [`Issue already closed out at ${closedOutAt} — skipping the Definition-of-Done gate and ceremony`]));
+			return buildResult("close-out", ctx.issueId, allSteps, start);
+		}
 		const uatEvidenceStep = yield* Effect.promise(async () => {
 			try {
-				const { healUatPromotionVerification } = await import("./uat-promote-verification-DyvQXvIn.js");
+				const { healUatPromotionVerification } = await import("./uat-promote-verification-c_pxoxEc.js");
 				const evidence = await healUatPromotionVerification(ctx.issueId);
 				if (!evidence) return stepSkipped("dod:uat-promotion-evidence", ["No missing UAT-promotion verification evidence found"]);
 				return stepOk("dod:uat-promotion-evidence", [`Recorded verification from ${evidence.generation}`, ...evidence.mergeSha ? [`Promoted to main at ${evidence.mergeSha.slice(0, 9)}`] : []]);
@@ -684,7 +801,7 @@ function cancelIssueWorkflow(ctx, opts = {}) {
 async function completeXBriefStep(ctx) {
 	const step = "close-out:vbrief-completed";
 	try {
-		const { transitionXBriefOnMain } = await import("./lifecycle-io-eVG6v_8-.js");
+		const { transitionXBriefOnMain } = await import("./lifecycle-io-C5nVk55o.js");
 		const result = await Effect.runPromise(transitionXBriefOnMain(ctx.projectPath, ctx.issueId, "completed", "completed", `scope: complete ${ctx.issueId.toUpperCase()} xBRIEF`));
 		const details = [result.moved ? "Updated xBRIEF lifecycle to completed" : "xBRIEF lifecycle already completed", result.statusUpdated ? "Updated plan.status to completed" : "plan.status already completed"];
 		if (result.committed) details.push("Committed xBRIEF completion on main");
@@ -696,171 +813,237 @@ async function completeXBriefStep(ctx) {
 		return stepFailed(step, `xBRIEF completion failed: ${message}`);
 	}
 }
+async function verifyRootConventionBranches(ctx, root, issueLower) {
+	const featureResult = await verifyConventionBranchMerged(ctx, root);
+	if (featureResult?.success) return featureResult;
+	const strikeResult = await verifyConventionBranchMerged(ctx, {
+		...root,
+		sourceBranch: `strike/${issueLower}`
+	});
+	if (strikeResult?.success && !strikeResult.skipped) return stepOk("close-out:verify-merged", [...strikeResult.details ?? [], `Superseded ${root.sourceBranch} residual: ${featureResult?.error ?? "Feature branch is absent; positive merge evidence is required"}`]);
+	return featureResult;
+}
 async function verifyBranchMergedImpl(ctx) {
 	const step = "close-out:verify-merged";
 	const issueLower = ctx.issueId.toLowerCase();
-	const featureBranchName = `feature/${issueLower}`;
-	const strikeBranchName = `strike/${issueLower}`;
+	const defaultRoot = {
+		repoKey: issueLower,
+		dir: ctx.projectPath,
+		sourceBranch: `feature/${issueLower}`,
+		targetBranch: "main",
+		forge: "github"
+	};
 	try {
 		try {
-			const { loadReviewStatuses } = await import("./review-status-CacDM78F.js");
+			const { loadReviewStatuses } = await import("./review-status-B6wYcOtP.js");
 			if (loadReviewStatuses()[ctx.issueId.toUpperCase()]?.mergeStatus === "merged") return stepOk(step, ["Merge specialist confirmed merge completed"]);
 		} catch {}
-		const featureResult = await verifyConventionBranchMerged(ctx, featureBranchName);
-		if (featureResult?.success) return featureResult;
-		const strikeResult = await verifyConventionBranchMerged(ctx, strikeBranchName);
-		if (strikeResult?.success && !strikeResult.skipped) return stepOk(step, [...strikeResult.details ?? [], `Superseded ${featureBranchName} residual: ${featureResult?.error ?? "Feature branch is absent; positive merge evidence is required"}`]);
-		if (featureResult) return featureResult;
+		const resolvedRoots = resolveProjectReposForIssueSync(ctx.issueId)?.filter((repo) => repo.required).map((repo) => ({
+			repoKey: repo.repoKey,
+			dir: repo.repoPath,
+			sourceBranch: repo.sourceBranch,
+			targetBranch: repo.targetBranch,
+			forge: repo.forge
+		}));
+		const roots = resolvedRoots?.length ? resolvedRoots : [defaultRoot];
+		if (roots.length === 1) return await verifyRootConventionBranches(ctx, roots[0], issueLower) ?? stepFailed(step, "Feature branch is absent; positive merge evidence is required");
+		const results = await Promise.all(roots.map(async (root) => ({
+			root,
+			result: await verifyRootConventionBranches(ctx, root, issueLower)
+		})));
+		const failures = results.filter(({ result }) => result && !result.success);
+		if (failures.length > 0) return stepFailed(step, failures.map(({ root, result }) => `${root.repoKey}: ${result?.error}`).join("; "));
+		const successes = results.filter(({ result }) => result?.success);
+		if (successes.length > 0) return stepOk(step, successes.flatMap(({ root, result }) => (result?.details ?? []).map((detail) => `${root.repoKey}: ${detail}`)));
 		return stepFailed(step, BRANCH_ABSENT_MERGE_ERROR);
 	} catch (err) {
 		return stepFailed(step, `Could not verify merge: ${err.message}`);
 	}
 }
-async function verifyConventionBranchMerged(ctx, branchName) {
+async function verifyConventionBranchMerged(ctx, root) {
 	const step = "close-out:verify-merged";
-	const { stdout: branchExists } = await execAsync(`git branch --list "${branchName}" 2>/dev/null || true`, {
-		cwd: ctx.projectPath,
+	const gitlabLookup = { attempted: false };
+	const { stdout: branchExists } = await execAsync(`git branch --list "${root.sourceBranch}" 2>/dev/null || true`, {
+		cwd: root.dir,
 		encoding: "utf-8"
 	});
 	if (branchExists.trim()) try {
-		await execAsync(`git merge-base --is-ancestor ${branchName} main`, {
-			cwd: ctx.projectPath,
+		await execAsync(`git merge-base --is-ancestor ${root.sourceBranch} ${root.targetBranch}`, {
+			cwd: root.dir,
 			encoding: "utf-8"
 		});
-		const remoteCheck = await verifyRemoteBranchIfPresent(ctx, branchName);
+		const remoteCheck = await verifyRemoteBranchIfPresent(ctx, root, gitlabLookup);
 		if (remoteCheck && !remoteCheck.success) return remoteCheck;
 		return stepOk(step, ["All commits merged to main", ...remoteCheck?.details ?? []]);
 	} catch {
+		const gitlabMerged = await verifySquashMergedMrByBranch(root, root.sourceBranch, gitlabLookup);
+		if (gitlabMerged) {
+			const remoteCheck = await verifyRemoteBranchIfPresent(ctx, root, gitlabLookup);
+			if (remoteCheck && !remoteCheck.success) return remoteCheck;
+			return stepOk(step, [...gitlabMerged.result.details ?? [], ...remoteCheck?.details ?? []]);
+		}
 		try {
-			const { stdout: codeDiff } = await execAsync(`git diff main...${branchName} -- ':!.planning' ':!docs/prds' ':!.overdeck/prompts' 2>/dev/null || true`, {
-				cwd: ctx.projectPath,
+			const { stdout: codeDiff } = await execAsync(`git diff ${root.targetBranch}...${root.sourceBranch} -- ':!.planning' ':!docs/prds' ':!.overdeck/prompts' 2>/dev/null || true`, {
+				cwd: root.dir,
 				encoding: "utf-8"
 			});
 			if (!codeDiff.trim()) {
-				const remoteCheck = await verifyRemoteBranchIfPresent(ctx, branchName);
+				const remoteCheck = await verifyRemoteBranchIfPresent(ctx, root, gitlabLookup);
 				if (remoteCheck && !remoteCheck.success) return remoteCheck;
 				return stepOk(step, ["Code changes squash-merged to main (only planning artifacts remain on branch)", ...remoteCheck?.details ?? []]);
 			}
 		} catch {}
-		const githubMerged = await verifySquashMergedPrByBranch(ctx, branchName, branchName);
+		const githubMerged = root.forge === "github" ? await verifySquashMergedPrByBranch(ctx, root, root.sourceBranch) : null;
 		if (githubMerged?.success) {
-			const remoteCheck = await verifyRemoteBranchIfPresent(ctx, branchName);
+			const remoteCheck = await verifyRemoteBranchIfPresent(ctx, root, gitlabLookup);
 			if (remoteCheck && !remoteCheck.success) return remoteCheck;
 			return stepOk(step, [...githubMerged.details ?? [], ...remoteCheck?.details ?? []]);
 		}
 		if (githubMerged) return githubMerged;
-		const { stdout: unmerged } = await execAsync(`git log main..${branchName} --oneline 2>/dev/null || true`, {
-			cwd: ctx.projectPath,
+		const { stdout: unmerged } = await execAsync(`git log ${root.targetBranch}..${root.sourceBranch} --oneline 2>/dev/null || true`, {
+			cwd: root.dir,
 			encoding: "utf-8"
 		});
 		const count = unmerged.trim() ? unmerged.trim().split("\n").length : 0;
-		if (ctx.github) try {
+		if (ctx.github && root.forge === "github") try {
 			const { stdout: issueState } = await execAsync(`gh issue view ${ctx.github.number} --repo ${ctx.github.owner}/${ctx.github.repo} --json state --jq '.state'`, {
-				cwd: ctx.projectPath,
+				cwd: root.dir,
 				encoding: "utf-8"
 			});
-			if (issueState.trim().toUpperCase() === "CLOSED") return stepSkipped(step, [`Issue already closed on GitHub; ${count} unmerged commit(s) remain on ${branchName}`]);
+			if (issueState.trim().toUpperCase() === "CLOSED") return stepSkipped(step, [`Issue already closed on GitHub; ${count} unmerged commit(s) remain on ${root.sourceBranch}`]);
 		} catch {}
-		return stepFailed(step, `${count} unmerged commit(s) on ${branchName}. Merge before closing out.`);
+		return stepFailed(step, `${count} unmerged commit(s) on ${root.sourceBranch}. Merge before closing out.`);
 	}
-	const { stdout: remoteBranch } = await execAsync(`git ls-remote --heads origin "${branchName}" 2>/dev/null || true`, {
-		cwd: ctx.projectPath,
+	const { stdout: remoteBranch } = await execAsync(`git ls-remote --heads origin "${root.sourceBranch}" 2>/dev/null || true`, {
+		cwd: root.dir,
 		encoding: "utf-8"
 	});
 	if (remoteBranch.trim()) {
-		await execAsync(`git fetch origin ${branchName}`, { cwd: ctx.projectPath }).catch(() => {});
-		const remoteCheck = await verifyRemoteBranchIfPresent(ctx, branchName);
+		await execAsync(`git fetch origin ${root.sourceBranch}`, { cwd: root.dir }).catch(() => {});
+		const remoteCheck = await verifyRemoteBranchIfPresent(ctx, root, gitlabLookup);
 		if (remoteCheck) return remoteCheck;
 	}
 	return null;
 }
-async function verifyRemoteBranchIfPresent(ctx, branchName) {
+async function verifySquashMergedMrByBranch(root, branchRef, lookup) {
+	if (root.forge !== "gitlab") return null;
+	try {
+		const { stdout } = await execAsync(`git rev-parse ${branchRef} 2>/dev/null`, {
+			cwd: root.dir,
+			encoding: "utf-8"
+		});
+		const headSha = stdout.trim();
+		if (!headSha) return null;
+		const reused = lookup.attempted;
+		if (!reused) {
+			lookup.attempted = true;
+			lookup.headSha = headSha;
+			lookup.artifact = await getForgeAdapter("gitlab").findMergedArtifact({
+				sourceBranch: root.sourceBranch,
+				targetBranch: root.targetBranch,
+				headSha,
+				cwd: root.dir
+			});
+		}
+		if (!lookup.artifact || lookup.headSha !== headSha) return null;
+		return {
+			result: stepOk("close-out:verify-merged", [`${lookup.artifact.id ? `MR !${lookup.artifact.id}` : "GitLab MR"} is merged and ${branchRef} matches the merged MR head${lookup.artifact.url ? ` (${lookup.artifact.url})` : ""}`]),
+			reused
+		};
+	} catch {
+		return null;
+	}
+}
+async function verifyRemoteBranchIfPresent(ctx, root, gitlabLookup) {
 	const step = "close-out:verify-merged";
-	const remoteRef = `origin/${branchName}`;
-	const { stdout: remoteBranch } = await execAsync(`git ls-remote --heads origin "${branchName}" 2>/dev/null || true`, {
-		cwd: ctx.projectPath,
+	const remoteRef = `origin/${root.sourceBranch}`;
+	const { stdout: remoteBranch } = await execAsync(`git ls-remote --heads origin "${root.sourceBranch}" 2>/dev/null || true`, {
+		cwd: root.dir,
 		encoding: "utf-8"
 	});
 	if (!remoteBranch.trim()) return null;
-	await execAsync(`git fetch origin ${branchName}`, { cwd: ctx.projectPath }).catch(() => {});
+	await execAsync(`git fetch origin ${root.sourceBranch}`, { cwd: root.dir }).catch(() => {});
 	try {
-		await execAsync(`git merge-base --is-ancestor ${remoteRef} main`, {
-			cwd: ctx.projectPath,
+		await execAsync(`git merge-base --is-ancestor ${remoteRef} ${root.targetBranch}`, {
+			cwd: root.dir,
 			encoding: "utf-8"
 		});
 		return stepOk(step, ["Remote branch fully merged"]);
 	} catch {
 		try {
-			const { stdout: codeDiff } = await execAsync(`git diff main...${remoteRef} -- ':!.planning' ':!docs/prds' ':!.overdeck/prompts' 2>/dev/null || true`, {
-				cwd: ctx.projectPath,
+			const { stdout: codeDiff } = await execAsync(`git diff ${root.targetBranch}...${remoteRef} -- ':!.planning' ':!docs/prds' ':!.overdeck/prompts' 2>/dev/null || true`, {
+				cwd: root.dir,
 				encoding: "utf-8"
 			});
 			if (!codeDiff.trim()) return stepOk(step, ["Remote code changes squash-merged to main (only planning artifacts remain on branch)"]);
 		} catch {}
-		const githubMerged = await verifySquashMergedPrByBranch(ctx, branchName, remoteRef);
+		const gitlabMerged = await verifySquashMergedMrByBranch(root, remoteRef, gitlabLookup);
+		if (gitlabMerged) return gitlabMerged.reused ? stepOk(step, [`Remote ${remoteRef} matches the merged MR head`]) : gitlabMerged.result;
+		const githubMerged = root.forge === "github" ? await verifySquashMergedPrByBranch(ctx, root, remoteRef) : null;
 		if (githubMerged) return githubMerged;
-		const { stdout: remoteUnmerged } = await execAsync(`git log main..${remoteRef} --oneline 2>/dev/null || true`, {
-			cwd: ctx.projectPath,
+		const { stdout: remoteUnmerged } = await execAsync(`git log ${root.targetBranch}..${remoteRef} --oneline 2>/dev/null || true`, {
+			cwd: root.dir,
 			encoding: "utf-8"
 		});
 		const count = remoteUnmerged.trim() ? remoteUnmerged.trim().split("\n").length : 0;
-		if (ctx.github) try {
+		if (ctx.github && root.forge === "github") try {
 			const { stdout: issueState } = await execAsync(`gh issue view ${ctx.github.number} --repo ${ctx.github.owner}/${ctx.github.repo} --json state --jq '.state'`, {
-				cwd: ctx.projectPath,
+				cwd: root.dir,
 				encoding: "utf-8"
 			});
-			if (issueState.trim().toUpperCase() === "CLOSED") return stepSkipped(step, [`Issue already closed on GitHub; ${count} unmerged commit(s) remain on remote ${branchName}`]);
+			if (issueState.trim().toUpperCase() === "CLOSED") return stepSkipped(step, [`Issue already closed on GitHub; ${count} unmerged commit(s) remain on remote ${root.sourceBranch}`]);
 		} catch {}
-		return stepFailed(step, `${count} unmerged commit(s) on remote ${branchName}.`);
+		return stepFailed(step, `${count} unmerged commit(s) on remote ${root.sourceBranch}.`);
 	}
 }
-async function verifySquashMergedPrByBranch(ctx, branchName, branchRef) {
+async function verifySquashMergedPrByBranch(ctx, root, branchRef) {
 	if (!ctx.github) return null;
 	const step = "close-out:verify-merged";
 	const { owner, repo } = ctx.github;
+	const remoteTargetRef = `origin/${root.targetBranch}`;
 	try {
-		const { stdout: prJson } = await execAsync(`gh pr list --repo ${owner}/${repo} --state merged --head ${JSON.stringify(branchName)} --json number,mergedAt,headRefOid,url`, {
-			cwd: ctx.projectPath,
+		const { stdout: prJson } = await execAsync(`gh pr list --repo ${owner}/${repo} --state merged --head ${JSON.stringify(root.sourceBranch)} --json number,mergedAt,headRefOid,url`, {
+			cwd: root.dir,
 			encoding: "utf-8"
 		});
 		const mergedPr = JSON.parse(prJson).filter((pr) => typeof pr.mergedAt === "string" && pr.mergedAt.length > 0 && typeof pr.headRefOid === "string" && pr.headRefOid.length > 0).sort((a, b) => Date.parse(String(b.mergedAt)) - Date.parse(String(a.mergedAt)))[0];
 		if (!mergedPr?.headRefOid) return null;
 		const { stdout: tipShaRaw } = await execAsync(`git rev-parse ${branchRef} 2>/dev/null`, {
-			cwd: ctx.projectPath,
+			cwd: root.dir,
 			encoding: "utf-8"
 		});
 		const tipSha = tipShaRaw.trim();
 		if (!tipSha) return null;
 		if (tipSha === mergedPr.headRefOid) return stepOk(step, [`${typeof mergedPr.number === "number" ? `PR #${mergedPr.number}` : "GitHub PR"} is squash-merged and ${branchRef} matches the merged PR head`]);
-		let commitsNotOnMain = null;
+		let commitsNotOnTarget = null;
 		try {
 			const { stdout: commitsRaw } = await execAsync(`git log --no-merges --format=%H ${mergedPr.headRefOid}..${tipSha}`, {
-				cwd: ctx.projectPath,
+				cwd: root.dir,
 				encoding: "utf-8"
 			});
 			const commits = commitsRaw.split("\n").map((sha) => sha.trim()).filter(Boolean);
 			const unmerged = [];
 			for (const commit of commits) try {
-				await execAsync(`git merge-base --is-ancestor ${commit} origin/main`, {
-					cwd: ctx.projectPath,
+				await execAsync(`git merge-base --is-ancestor ${commit} ${remoteTargetRef}`, {
+					cwd: root.dir,
 					encoding: "utf-8"
 				});
 			} catch {
 				unmerged.push(commit);
 			}
-			if (unmerged.length === 0) return stepOk(step, [`${typeof mergedPr.number === "number" ? `PR #${mergedPr.number}` : "GitHub PR"} is squash-merged; all ${commits.length} post-PR non-merge commit(s) on ${branchRef} are already on origin/main`]);
-			commitsNotOnMain = unmerged;
+			if (unmerged.length === 0) return stepOk(step, [`${typeof mergedPr.number === "number" ? `PR #${mergedPr.number}` : "GitHub PR"} is squash-merged; all ${commits.length} post-PR non-merge commit(s) on ${branchRef} are already on ${remoteTargetRef}`]);
+			commitsNotOnTarget = unmerged;
 		} catch {}
 		try {
 			const { stdout: deltaRaw } = await execAsync(`git diff --name-only ${mergedPr.headRefOid}..${tipSha}`, {
-				cwd: ctx.projectPath,
+				cwd: root.dir,
 				encoding: "utf-8"
 			});
 			let deltaFiles = deltaRaw.split("\n").map((f) => f.trim()).filter(Boolean);
 			let statePlaneOnly = deltaFiles.length > 0 && deltaFiles.every((f) => f.startsWith(".pan/"));
 			if (!statePlaneOnly) {
-				const { stdout: uniqueRaw } = await execAsync(`git diff --name-only origin/main...${tipSha}`, {
-					cwd: ctx.projectPath,
+				const { stdout: uniqueRaw } = await execAsync(`git diff --name-only ${remoteTargetRef}...${tipSha}`, {
+					cwd: root.dir,
 					encoding: "utf-8"
 				});
 				deltaFiles = uniqueRaw.split("\n").map((f) => f.trim()).filter(Boolean);
@@ -869,7 +1052,7 @@ async function verifySquashMergedPrByBranch(ctx, branchName, branchRef) {
 			if (statePlaneOnly) return stepOk(step, [`${typeof mergedPr.number === "number" ? `PR #${mergedPr.number}` : "GitHub PR"} is squash-merged; ${branchRef} is ahead only by state-plane commits (${deltaFiles.length} file(s): .pan) — accepted per state-plane policy`]);
 		} catch {}
 		const prLabel = typeof mergedPr.number === "number" ? `PR #${mergedPr.number}` : "merged GitHub PR";
-		if (commitsNotOnMain) return stepFailed(step, `${branchRef} has ${commitsNotOnMain.length} commit(s) after merged ${prLabel} that are not on origin/main: ${commitsNotOnMain.join(", ")}`);
+		if (commitsNotOnTarget) return stepFailed(step, `${branchRef} has ${commitsNotOnTarget.length} commit(s) after merged ${prLabel} that are not on ${remoteTargetRef}: ${commitsNotOnTarget.join(", ")}`);
 		return stepFailed(step, `${branchRef} does not match the head commit of merged ${prLabel}; inspect before closing out.`);
 	} catch {
 		return null;
@@ -936,7 +1119,7 @@ async function resetIssueToTodoImpl(ctx) {
 */
 async function resetPostMergeStateForIssue(issueId) {
 	try {
-		const { resetPostMergeState } = await import("./merge-agent-C1-9zbP_.js");
+		const { resetPostMergeState } = await import("./merge-agent-DWd0KfiS.js");
 		resetPostMergeState(issueId);
 		resetPostMergeState(issueId.toUpperCase());
 	} catch {
@@ -952,7 +1135,7 @@ function clearReviewStatusStep(issueId) {
 async function clearReviewStatusStepImpl(issueId) {
 	const step = "clear-review-status";
 	try {
-		const { clearReviewStatus } = await import("./review-status-CacDM78F.js");
+		const { clearReviewStatus } = await import("./review-status-B6wYcOtP.js");
 		clearReviewStatus(issueId.toUpperCase());
 		return stepOk(step, ["Review status cleared"]);
 	} catch {
@@ -1017,6 +1200,6 @@ async function resetIssueToCanceledImpl(ctx) {
 	}
 }
 //#endregion
-export { deepWipe as a, closeOut as i, cancelIssueWorkflow as n, resetToTodo as o, close as r, verifyBranchMergedImpl as s, approve as t };
+export { deepWipe as a, verifyConventionBranchMerged as c, closeOut as i, cancelIssueWorkflow as n, resetToTodo as o, close as r, verifyBranchMergedImpl as s, approve as t };
 
-//# sourceMappingURL=workflows-D87ajwV6.js.map
+//# sourceMappingURL=workflows-BMBwLYPV.js.map

package/server/workflows-BOmWGpIh.js

@@ -0,0 +1,2 @@
+import { a as deepWipe, i as closeOut } from "./workflows-BMBwLYPV.js";
+export { closeOut, deepWipe };

package/server/{workspace-iD8oULqu.js → workspace-BgflNCH0.js}

@@ -1,6 +1,6 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Fr as init_errors, Tr as FsError } from "./config-yaml-CxdwhAIA.js";
-import { i as init_settings, t as areMemoryObservationsEnabled } from "./settings-BLbcDqUp.js";
+import { Ar as FsError, Vr as init_errors } from "./config-yaml-BSCqwmX0.js";
+import { i as init_settings, t as areMemoryObservationsEnabled } from "./settings-E3FnEIUx.js";
 import { Effect } from "effect";
 import { existsSync } from "fs";
 import { join } from "path";
@@ -238,4 +238,4 @@ var init_workspace = __esmMin((() => {
 //#endregion
 export { readCavemanVariant as a, injectMemoryHookSettings as i, init_workspace as n, injectCavemanSettings as r, determineCavemanVariant as t };
 
-//# sourceMappingURL=workspace-iD8oULqu.js.map
+//# sourceMappingURL=workspace-BgflNCH0.js.map

package/server/{workspace-AIOM7n00.js → workspace-Cn9ywfSW.js}

@@ -1,3 +1,3 @@
-import { i as injectMemoryHookSettings, n as init_workspace, r as injectCavemanSettings, t as determineCavemanVariant } from "./workspace-iD8oULqu.js";
+import { i as injectMemoryHookSettings, n as init_workspace, r as injectCavemanSettings, t as determineCavemanVariant } from "./workspace-BgflNCH0.js";
 init_workspace();
 export { determineCavemanVariant, injectCavemanSettings, injectMemoryHookSettings };

package/server/{workspace-anchor-drift-19cJ1bH5.js → workspace-anchor-drift-C8Fy3shi.js}

@@ -1,3 +1,3 @@
-import { n as init_workspace_anchor_drift, t as evaluateWorkspaceAnchorDrift } from "./workspace-anchor-drift-C3mK5wNI.js";
+import { n as init_workspace_anchor_drift, t as evaluateWorkspaceAnchorDrift } from "./workspace-anchor-drift-CMiNncwq.js";
 init_workspace_anchor_drift();
 export { evaluateWorkspaceAnchorDrift };