@overdeck/desktop 0.45.24 → 0.47.0

package/server/{workflows-mbQzh6mQ.js → workflows-D0vP1WrK.js}

@@ -1,16 +1,18 @@
-import { Dt as getProjectConfigFromWorkspacePath, Ft as resolveProjectForIssue, Jn as extractPrefixSync, Lt as writeCloseOutDodGate, Ot as init_record, Vr as init_paths, Yn as init_issue_id, jt as readIssueRecord, kt as markRecordPipelineClosedOutSync, qn as extractNumberSync, wr as OVERDECK_HOME } from "./config-yaml-DySPNmKN.js";
-import { l as init_review_status, s as getReviewStatus } from "./review-status-kZj_KyCk.js";
-import { b as init_agents, i as listRunningAgents } from "./queries-CjNIf-Ub.js";
-import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-DKZFMbFt.js";
-import { f as init_config, s as getDashboardApiUrlSync } from "./config-BZ0sHTju.js";
-import { i as loadCloisterConfig, r as init_config$1 } from "./config-CKxYiCmX.js";
-import { r as getAutoCloseOutCanonicalState, t as pruneStoppedAgentsForIssue } from "./agent-gc-CHcnvonI.js";
-import { i as findWorkspacePath, o as init_archive_planning, t as archivePlanning } from "./archive-planning-Du25Jtst.js";
-import { a as stepSkipped, i as stepOk, n as init_types, r as stepFailed, t as getLinearApiKey } from "./types-5M0lupud.js";
-import { t as closeIssue } from "./close-issue-DoOifFIK.js";
-import { o as init_pull_requests, r as fetchIssuePullRequest, t as fetchCommitCheckRuns } from "./pull-requests-_lHueOHW.js";
-import { n as acceptFlagFor, t as DOD_ROWS } from "./dod-C6n9RV3G.js";
-import { t as teardownWorkspace } from "./teardown-workspace-DeTTImn-.js";
+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-CGvlA4o_.js";
+import { b as init_agents, i as listRunningAgents } from "./queries-C-MUZaIy.js";
+import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-B6HpNWRy.js";
+import { f as init_config, s as getDashboardApiUrlSync } from "./config-BvLe652W.js";
+import { i as loadCloisterConfig, r as init_config$1 } from "./config-Bi3u1VK7.js";
+import { r as getAutoCloseOutCanonicalState, t as pruneStoppedAgentsForIssue } from "./agent-gc-C3h9Or3a.js";
+import { i as isTrackerIssueClosed, n as init_issue_closed } from "./issue-closed-BehTG1be.js";
+import { i as findWorkspacePath, t as archivePlanning } from "./archive-planning-BwhxeP7C.js";
+import { a as stepSkipped, i as stepOk, n as init_types, r as stepFailed, t as getLinearApiKey } from "./types-Di8wdakq.js";
+import { i as gatherIssueBranchContainment, s as init_pipeline_membership_gather } from "./pipeline-membership-gather-CeVGnNJ2.js";
+import { t as closeIssue } from "./close-issue-BPh1ARCF.js";
+import { o as init_pull_requests, r as fetchIssuePullRequest, t as fetchCommitCheckRuns } from "./pull-requests-7BgLDsIo.js";
+import { a as canAcceptDodMisses, i as buildAbandonedDodGate, n as DOD_ROWS, r as acceptFlagFor, t as BRANCH_ABSENT_MERGE_ERROR } from "./dod-DlNtcH6n.js";
+import { t as teardownWorkspace } from "./teardown-workspace-DRdi_CPa.js";
 import { resolve } from "node:path";
 import { Effect } from "effect";
 import { existsSync } from "fs";
@@ -27,13 +29,14 @@ init_issue_id();
 init_feature_registry_population();
 init_config$1();
 init_types();
-init_archive_planning();
 /** Mechanical Definition-of-Done row checks. */
 init_agents();
 init_config();
 init_review_status();
 init_record();
+init_issue_closed();
 init_pull_requests();
+init_pipeline_membership_gather();
 const execFileAsync = promisify(execFile);
 const defaultMergedRowDeps = {
 	verifyMerged: async () => ({
@@ -47,9 +50,22 @@ const defaultMergedRowDeps = {
 		const response = await fetchIssuePullRequest(ctx.issueId);
 		if (response.error) throw new Error(response.error);
 		return response.pr ?? {};
+	},
+	readDurableMerges: async (ctx) => {
+		return (await readIssueRecord(resolveProjectForIssue(ctx.issueId) ?? getProjectConfigFromWorkspacePath(ctx.projectPath), ctx.issueId))?.closeOut.merges ?? [];
+	},
+	readBranchContainment: async (ctx) => {
+		const project = resolveProjectForIssue(ctx.issueId) ?? getProjectConfigFromWorkspacePath(ctx.projectPath);
+		if (!project) return {
+			unmergedRefs: [],
+			mergedWorkRefs: [],
+			pointerRefs: []
+		};
+		return gatherIssueBranchContainment(project, ctx.issueId);
 	}
 };
 const defaultPostMergeRowDeps = {
+	readStrikeLanded: async (issueId) => strikeLanded((await loadStatus(issueId, defaultDeps))?.status),
 	readCanonicalState: async (ctx) => {
 		return getAutoCloseOutCanonicalState(ctx.issueId);
 	},
@@ -65,13 +81,14 @@ const defaultMainVerifyRowDeps = { readCheckRuns: async (ctx, mergeCommit) => {
 	return fetchCommitCheckRuns(ctx.github.owner, ctx.github.repo, mergeCommit);
 } };
 const defaultEvaluateDodGateDeps = {
-	review: checkReviewRow,
-	tests: checkTestsRow,
-	verification: checkVerificationRow,
+	review: (issueId, settlement) => checkReviewRow(issueId, defaultDeps, settlement),
+	tests: (issueId, settlement) => checkTestsRow(issueId, defaultDeps, settlement),
+	verification: (issueId, settlement) => checkVerificationRow(issueId, defaultDeps, settlement),
 	merged: checkMergedRow,
 	postMerge: checkPostMergeRow,
 	mainVerify: checkMainVerifyRow,
 	deploy: checkDeployRow,
+	trackerClosed: isTrackerIssueClosed,
 	now: () => (/* @__PURE__ */ new Date()).toISOString()
 };
 const defaultDeployRowDeps = {
@@ -137,30 +154,78 @@ async function loadStatus(issueId, deps) {
 		return null;
 	}
 }
-async function checkVerdict(issueId, id, field, deps) {
+/**
+* PAN-3180: `landed` is the strike path's own durable statement that this issue's
+* work reached main through `strike/<id>`. It is written by the server merge door
+* (`mergeCompletionStatus` in `merge-strike.ts`) and mirrored into the per-issue
+* record's `pipeline` block, so it outlives review-status clearing. Every earlier
+* landing state (`ready`/`landing`/`recovering`/`needs_you`) is a strike still in
+* flight and earns no waiver.
+*/
+function strikeLanded(status) {
+	return status?.strikeLandingState === "landed";
+}
+/**
+* PAN-3180: a strike dispatches neither a review nor a test specialist — that
+* bypass is the whole point of the path. So for a strike-landed issue these rows
+* are `skip` (deliberately not run), never `pass` (ran and succeeded) and never
+* `miss` (outstanding). A reader of the close-out record still sees the real
+* verdict and the reason it was never produced.
+*/
+const STRIKE_BYPASS_NOTE = {
+	review: "no review specialist is dispatched for a strike",
+	tests: "no test specialist is dispatched for a strike"
+};
+/**
+* A specialist that ran and returned a negative verdict is a different fact from
+* one that was never dispatched, so the strike waiver never covers it — those
+* still block until an operator records an explicit `--accept-<row>` override.
+*/
+const NEGATIVE_VERDICTS = new Set([
+	"failed",
+	"blocked",
+	"dispatch_failed"
+]);
+/**
+* PAN-3187: a tracker-closed issue with landed work cannot produce a verdict it
+* never produced while active. Negative test/verification verdicts settle only
+* when main verification proves the landed state green; review negatives remain.
+*/
+function terminalVerdictSettlement(id, value, observed, settlement) {
+	if (!settlement?.trackerClosed || !settlement.landedWork) return null;
+	if (!NEGATIVE_VERDICTS.has(value ?? "")) return result(id, "skip", `${observed}; settled because the tracker issue is closed and merged work is landed`);
+	if (id !== "review" && settlement.mainVerifyStatus === "pass") return result(id, "skip", `${observed}; superseded because the tracker issue is closed, merged work is landed, and main verification passed`);
+	return null;
+}
+async function checkVerdict(issueId, id, field, deps, settlement) {
 	const loaded = await loadStatus(issueId, deps);
 	if (!loaded) return result(id, "miss", "no review status or journal record found");
 	const value = loaded.status[field];
 	const source = loaded.source === "journal" ? " from pipeline journal" : "";
 	const observed = `${field}: ${value ?? "missing"}${source}${value === "skipped" ? " (skipped per issue policy)" : ""}`;
-	return result(id, value === "passed" || value === "skipped" ? "pass" : "miss", observed);
+	if (value === "passed" || value === "skipped") return result(id, "pass", observed);
+	if (strikeLanded(loaded.status) && !NEGATIVE_VERDICTS.has(value ?? "")) return result(id, "skip", `${observed}; skipped by the strike path (strikeLandingState: landed) — ${STRIKE_BYPASS_NOTE[id]}`);
+	return terminalVerdictSettlement(id, value, observed, settlement) ?? result(id, "miss", observed);
 }
-function checkReviewRow(issueId, deps = defaultDeps) {
-	return checkVerdict(issueId, "review", "reviewStatus", deps);
+function checkReviewRow(issueId, deps = defaultDeps, settlement) {
+	return checkVerdict(issueId, "review", "reviewStatus", deps, settlement);
 }
-function checkTestsRow(issueId, deps = defaultDeps) {
-	return checkVerdict(issueId, "tests", "testStatus", deps);
+function checkTestsRow(issueId, deps = defaultDeps, settlement) {
+	return checkVerdict(issueId, "tests", "testStatus", deps, settlement);
 }
-async function checkVerificationRow(issueId, deps = defaultDeps) {
+async function checkVerificationRow(issueId, deps = defaultDeps, settlement) {
 	const loaded = await loadStatus(issueId, deps);
 	if (!loaded) return result("verification", "miss", "no review status or journal record found");
 	const value = loaded.status.verificationStatus;
 	const commit = loaded.status.lastVerifiedCommit;
-	const source = loaded.source === "journal" ? " from pipeline journal" : "";
-	const policy = value === "skipped" ? " (skipped per issue policy)" : "";
-	const commitNote = commit ? ` at ${commit}` : "";
-	const observed = `verificationStatus: ${value ?? "missing"}${commitNote}${source}${policy}`;
-	return result("verification", (value === "passed" || value === "skipped") && Boolean(commit) ? "pass" : "miss", observed);
+	const accepted = value === "passed" || value === "skipped";
+	const notes = [];
+	if (loaded.source === "journal") notes.push("from pipeline journal");
+	if (value === "skipped") notes.push("skipped per issue policy");
+	if (accepted && !commit) notes.push("no lastVerifiedCommit recorded");
+	const observed = `verificationStatus: ${value ?? "missing"}${commit ? ` at ${commit}` : ""}${notes.length > 0 ? ` (${notes.join("; ")})` : ""}`;
+	if (accepted) return result("verification", "pass", observed);
+	return terminalVerdictSettlement("verification", value, observed, settlement) ?? result("verification", "miss", observed);
 }
 async function checkMergedRow(ctx, deps = defaultMergedRowDeps) {
 	const verified = await deps.verifyMerged(ctx).catch((error) => ({
@@ -171,10 +236,19 @@ async function checkMergedRow(ctx, deps = defaultMergedRowDeps) {
 	}));
 	const observed = verified.details?.join("; ") || verified.error || (verified.skipped ? "issue already closed on forge" : "merge not verified");
 	const merged = result("merged", verified.success || verified.skipped ? "pass" : "miss", observed);
-	if (!ctx.github) return merged;
-	try {
+	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 pullRequestState;
+	if (ctx.github) try {
 		const branchName = `feature/${ctx.issueId.toLowerCase()}`;
 		const pullRequest = await deps.readPullRequest(ctx, branchName);
+		pullRequestState = pullRequest.state;
 		merged.mergedAt = pullRequest.mergedAt;
 		merged.mergeCommit = typeof pullRequest.mergeCommit === "string" ? pullRequest.mergeCommit : pullRequest.mergeCommit?.oid;
 		const number = pullRequest.number ? `PR #${pullRequest.number}` : "PR";
@@ -185,9 +259,27 @@ async function checkMergedRow(ctx, deps = defaultMergedRowDeps) {
 		const message = error instanceof Error ? error.message : String(error);
 		merged.observed = `${merged.observed}; forge metadata unavailable: ${message}`;
 	}
+	if (branchAbsent) {
+		const forgeMerged = pullRequestState?.toUpperCase() === "MERGED";
+		if (durableMerges.length > 0 || forgeMerged) {
+			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`;
+	}
+	if (merged.status === "miss") try {
+		const containment = await (deps.readBranchContainment ?? defaultMergedRowDeps.readBranchContainment)(ctx);
+		if (containment.mergedWorkRefs.length > 0 && containment.unmergedRefs.length === 0) {
+			merged.status = "pass";
+			merged.evidence = "branch-containment";
+			merged.observed = `${merged.observed}; branch work contained in default branch with no merged PR — non-PR landing (membership L2-work lens): ${containment.mergedWorkRefs.join(", ")}`;
+		}
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		merged.observed = `${merged.observed}; branch containment evidence unavailable: ${message}`;
+	}
 	return merged;
 }
-async function checkPostMergeRow(ctx, deps = defaultPostMergeRowDeps) {
+async function checkPostMergeRow(ctx, merged, deps = defaultPostMergeRowDeps) {
 	try {
 		const canonicalState = await deps.readCanonicalState(ctx);
 		const mergeStatus = await deps.readMergeStatus(ctx.issueId);
@@ -195,7 +287,12 @@ async function checkPostMergeRow(ctx, deps = defaultPostMergeRowDeps) {
 		const runningAgents = (await deps.listAgents()).filter((agent) => agent.issueId.toUpperCase() === issueId && (agent.role === "work" || agent.role === "plan") && (agent.status === "starting" || agent.status === "running"));
 		const stateObserved = canonicalState ? `canonical state: ${canonicalState}` : `canonical state unavailable; mergeStatus: ${mergeStatus ?? "missing"}`;
 		const agentsObserved = runningAgents.length > 0 ? `running agents: ${runningAgents.map((agent) => agent.id).join(", ")}` : "no running work/planning agents";
-		return result("post-merge", (canonicalState === "verifying_on_main" || mergeStatus === "merged") && runningAgents.length === 0 ? "pass" : "miss", `${stateObserved}; ${agentsObserved}`);
+		if (canonicalState === "done") return result("post-merge", runningAgents.length === 0 ? "pass" : "miss", `terminal canonical state: done — the post-merge lifecycle already ran to close-out; ${agentsObserved}`);
+		if (canonicalState === "canceled") return result("post-merge", runningAgents.length === 0 ? "skip" : "miss", `terminal canonical state: canceled — post-merge lifecycle not applicable; ${agentsObserved}`);
+		const lifecycleObserved = canonicalState === "verifying_on_main" || mergeStatus === "merged";
+		if (!lifecycleObserved && await (deps.readStrikeLanded ?? defaultPostMergeRowDeps.readStrikeLanded)(ctx.issueId)) return result("post-merge", runningAgents.length === 0 ? "skip" : "miss", `strike landing (strikeLandingState: landed) — the work-agent post-merge handoff is not the strike path's lifecycle; ${stateObserved}; ${agentsObserved}`);
+		if (!lifecycleObserved && merged?.evidence === "branch-containment") return result("post-merge", runningAgents.length === 0 ? "pass" : "miss", `non-PR landing (branch-containment evidence) — post-merge lifecycle not applicable; ${agentsObserved}`);
+		return result("post-merge", lifecycleObserved && runningAgents.length === 0 ? "pass" : "miss", `${stateObserved}; ${agentsObserved}`);
 	} catch (error) {
 		return result("post-merge", "miss", `post-merge evidence unavailable: ${error instanceof Error ? error.message : String(error)}`);
 	}
@@ -212,6 +309,11 @@ async function checkMainVerifyRow(ctx, mergeCommit, deps = defaultMainVerifyRowD
 	}
 }
 async function checkDeployRow(ctx, merge, deps = defaultDeployRowDeps) {
+	if (!merge.mergeCommit) {
+		if (merge.mergedRowStatus === "miss") return result("deploy", "skip", "no merge commit resolved because the merged row missed — deploy ancestry depends on row 4; build ancestry unchecked");
+		if (merge.mainVerifyRowStatus === "skip") return result("deploy", "skip", "verified-on-main skipped — no merge commit resolvable, so deploy build-ancestry has no durable anchor either (same landing class as DoD row 6 skip)");
+		return result("deploy", "miss", "merged row passed without a resolvable merge commit; build ancestry cannot be checked");
+	}
 	const baseUrl = deps.dashboardUrl().replace(/\/$/, "");
 	let health;
 	try {
@@ -224,8 +326,9 @@ async function checkDeployRow(ctx, merge, deps = defaultDeployRowDeps) {
 	if (resolve(repoRoot) !== resolve(ctx.projectPath)) return result("deploy", "skip", `live dashboard serves ${repoRoot}, not this project — deploy semantics undefined for ${ctx.projectPath}`);
 	const buildCommit = typeof health.buildCommit === "string" && health.buildCommit.trim() ? health.buildCommit : void 0;
 	if (!buildCommit) return result("deploy", "miss", `dashboard at ${baseUrl} did not report buildCommit; live deployment cannot be proven`);
-	if (!merge.mergeCommit) return result("deploy", "miss", "cannot resolve merge commit; live deployment cannot be proven");
 	try {
+		if (health.buildDirty === true) return result("deploy", "miss", `live build ${buildCommit.slice(0, 8)} was built from a dirty working tree — uncommitted changes may be serving; redeploy canonically with \`pan reload\``);
+		if (!await deps.commitContains(repoRoot, buildCommit, "origin/main")) return result("deploy", "miss", `live build commit ${buildCommit.slice(0, 8)} is not an ancestor of origin/main — the server is running a build of local-only commits; redeploy with \`pan reload\``);
 		const contains = await deps.commitContains(repoRoot, merge.mergeCommit, buildCommit);
 		const observed = `build commit ${buildCommit.slice(0, 8)} ${contains ? "contains" : "does not contain"} merge ${merge.mergeCommit.slice(0, 8)}`;
 		return result("deploy", contains ? "pass" : "miss", observed);
@@ -237,23 +340,39 @@ async function evaluateDodGate(ctx, opts = {}, deps = defaultEvaluateDodGateDeps
 	const acceptedRows = new Set(opts.acceptedRows ?? []);
 	const overridable = new Set(DOD_ROWS.filter((row) => row.overridable).map((row) => row.id));
 	for (const id of acceptedRows) if (!overridable.has(id)) throw new TypeError(`DoD row "${id}" cannot be accepted; valid rows: ${[...overridable].join(", ")}`);
+	const by = opts.acceptedBy ?? process.env.OVERDECK_AGENT_ID ?? userInfo().username;
+	if (acceptedRows.size > 0 && !canAcceptDodMisses(by)) throw new TypeError("The flywheel orchestrator cannot accept missed Definition-of-Done rows; an operator must apply --accept-<row> overrides.");
 	const merged = opts.verifyMerged ? await checkMergedRow(ctx, {
 		...defaultMergedRowDeps,
 		verifyMerged: opts.verifyMerged
 	}) : await deps.merged(ctx);
-	const rows = await Promise.all([
-		deps.review(ctx.issueId),
-		deps.tests(ctx.issueId),
-		deps.verification(ctx.issueId),
-		Promise.resolve(merged),
-		deps.postMerge(ctx),
-		deps.mainVerify(ctx, merged.mergeCommit),
+	const mainVerify = await deps.mainVerify(ctx, merged.mergeCommit);
+	const settlement = {
+		trackerClosed: await (deps.trackerClosed ?? defaultEvaluateDodGateDeps.trackerClosed)(ctx.issueId),
+		landedWork: merged.status === "pass",
+		mainVerifyStatus: mainVerify.status
+	};
+	const [review, tests, verification, postMerge, deploy] = await Promise.all([
+		deps.review(ctx.issueId, settlement),
+		deps.tests(ctx.issueId, settlement),
+		deps.verification(ctx.issueId, settlement),
+		deps.postMerge(ctx, merged),
 		deps.deploy(ctx, {
 			mergedAt: merged.mergedAt,
-			mergeCommit: merged.mergeCommit
+			mergeCommit: merged.mergeCommit,
+			mergedRowStatus: merged.status,
+			mainVerifyRowStatus: mainVerify.status
 		})
 	]);
-	const by = opts.acceptedBy ?? process.env.OVERDECK_AGENT_ID ?? userInfo().username;
+	const rows = [
+		review,
+		tests,
+		verification,
+		merged,
+		postMerge,
+		mainVerify,
+		deploy
+	];
 	for (const row of rows) if (row.status === "miss" && acceptedRows.has(row.id)) row.acceptedBy = {
 		flag: acceptFlagFor(rowDefinition(row.id)),
 		by,
@@ -277,6 +396,7 @@ async function evaluateDodGate(ctx, opts = {}, deps = defaultEvaluateDodGateDeps
 * deepWipe() — Destructive: teardown(deleteBranches) + delete agent state + reset issue
 */
 init_record();
+init_pipeline();
 const execAsync = promisify$1(exec$1);
 function trackerName(ctx, fallback) {
 	const name = ctx.tracker?.name ?? fallback;
@@ -363,7 +483,19 @@ function closeOut(ctx, opts = {}) {
 	return Effect.gen(function* () {
 		const start = Date.now();
 		const allSteps = [];
-		const dodGate = yield* Effect.promise(() => evaluateDodGate(ctx, {
+		const uatEvidenceStep = yield* Effect.promise(async () => {
+			try {
+				const { healUatPromotionVerification } = await import("./uat-promote-verification-CoJuh7XO.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)}`] : []]);
+			} catch (err) {
+				return stepSkipped("dod:uat-promotion-evidence", [`Evidence recovery unavailable: ${err instanceof Error ? err.message : String(err)}`]);
+			}
+		});
+		allSteps.push(uatEvidenceStep);
+		const abandon = opts.abandonDisposition;
+		const dodGate = abandon ? buildAbandonedDodGate(abandon.reason, abandon.by) : yield* Effect.promise(() => evaluateDodGate(ctx, {
 			acceptedRows: opts.dodAcceptedRows,
 			acceptedBy: opts.dodAcceptedBy,
 			verifyMerged: verifyBranchMergedImpl
@@ -392,6 +524,13 @@ function closeOut(ctx, opts = {}) {
 			allSteps.push(stepFailed("close-out:abort", "Stopped — xBRIEF completion failed, workspace preserved"));
 			return buildResult("close-out", ctx.issueId, allSteps, start, dodGate);
 		}
+		const telemetryContext = yield* Effect.promise(async () => {
+			try {
+				return await resolvePipelineTelemetryContext(ctx.issueId);
+			} catch {
+				return null;
+			}
+		});
 		const closeOutConfig = (yield* Effect.promise(() => Effect.runPromise(loadCloisterConfig()))).close_out;
 		const teardownSteps = yield* teardownWorkspace(ctx, {
 			deleteWorkspace: closeOutConfig?.remove_workspace ?? false,
@@ -410,7 +549,7 @@ function closeOut(ctx, opts = {}) {
 		});
 		const closeSteps = yield* closeIssue(ctx, {
 			tracker: opts.tracker,
-			comment: ctx.auto ? "Closed via automatic close-out ceremony" : "Closed via close-out ceremony",
+			comment: abandon ? `Closed without landing evidence — disposition recorded: ${abandon.reason}` : ctx.auto ? "Closed via automatic close-out ceremony" : "Closed via close-out ceremony",
 			applyLabel: true
 		});
 		allSteps.push(...closeSteps);
@@ -420,7 +559,7 @@ function closeOut(ctx, opts = {}) {
 		}
 		const markTerminal = yield* markPipelineClosedOutStep(ctx);
 		allSteps.push(markTerminal);
-		const recordDodGate = yield* recordDodGateStep(ctx, dodGate);
+		const recordDodGate = yield* recordDodGateStep(ctx, dodGate, abandon);
 		allSteps.push(recordDodGate);
 		if (!recordDodGate.success) {
 			allSteps.push(stepFailed("close-out:abort", "Stopped — Definition-of-Done audit could not be persisted; review status preserved"));
@@ -437,7 +576,9 @@ function closeOut(ctx, opts = {}) {
 			issueId: ctx.issueId,
 			status: "archived"
 		}));
-		return buildResult("close-out", ctx.issueId, allSteps, start, dodGate);
+		const result = buildResult("close-out", ctx.issueId, allSteps, start, dodGate);
+		if (result.success && !markTerminal.skipped) capturePipelineStage("closed_out", telemetryContext);
+		return result;
 	});
 }
 function markPipelineClosedOutStep(ctx) {
@@ -450,14 +591,15 @@ function markPipelineClosedOutStep(ctx) {
 		catch: (err) => err
 	}).pipe(Effect.catch((err) => Effect.succeed(stepSkipped(step, [`Pipeline terminal marker failed (non-fatal): ${err.message ?? String(err)}`]))));
 }
-function recordDodGateStep(ctx, dodGate) {
+function recordDodGateStep(ctx, dodGate, abandonDisposition) {
 	const step = "close-out:record-dod-gate";
 	return Effect.tryPromise({
 		try: async () => {
 			await writeCloseOutDodGate(getProjectConfigFromWorkspacePath(ctx.projectPath), ctx.issueId.toUpperCase(), {
 				evaluatedAt: (/* @__PURE__ */ new Date()).toISOString(),
 				rows: dodGate.rows,
-				accepted: dodGate.accepted
+				accepted: dodGate.accepted,
+				...abandonDisposition ? { disposition: abandonDisposition } : {}
 			});
 			return stepOk(step, ["Recorded Definition-of-Done gate with 8 rows"]);
 		},
@@ -542,7 +684,7 @@ function cancelIssueWorkflow(ctx, opts = {}) {
 async function completeXBriefStep(ctx) {
 	const step = "close-out:vbrief-completed";
 	try {
-		const { transitionXBriefOnMain } = await import("./lifecycle-io-DPo7x11I.js");
+		const { transitionXBriefOnMain } = await import("./lifecycle-io-CzTHEooc.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");
@@ -556,70 +698,81 @@ async function completeXBriefStep(ctx) {
 }
 async function verifyBranchMergedImpl(ctx) {
 	const step = "close-out:verify-merged";
-	const branchName = `feature/${ctx.issueId.toLowerCase()}`;
+	const issueLower = ctx.issueId.toLowerCase();
+	const featureBranchName = `feature/${issueLower}`;
+	const strikeBranchName = `strike/${issueLower}`;
 	try {
 		try {
-			const { loadReviewStatuses } = await import("./review-status-btEYlaxA.js");
+			const { loadReviewStatuses } = await import("./review-status-Dma9SFaN.js");
 			if (loadReviewStatuses()[ctx.issueId.toUpperCase()]?.mergeStatus === "merged") return stepOk(step, ["Merge specialist confirmed merge completed"]);
 		} catch {}
-		const { stdout: branchExists } = await execAsync(`git branch --list "${branchName}" 2>/dev/null || true`, {
+		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;
+		return stepFailed(step, BRANCH_ABSENT_MERGE_ERROR);
+	} catch (err) {
+		return stepFailed(step, `Could not verify merge: ${err.message}`);
+	}
+}
+async function verifyConventionBranchMerged(ctx, branchName) {
+	const step = "close-out:verify-merged";
+	const { stdout: branchExists } = await execAsync(`git branch --list "${branchName}" 2>/dev/null || true`, {
+		cwd: ctx.projectPath,
+		encoding: "utf-8"
+	});
+	if (branchExists.trim()) try {
+		await execAsync(`git merge-base --is-ancestor ${branchName} main`, {
 			cwd: ctx.projectPath,
 			encoding: "utf-8"
 		});
-		if (branchExists.trim()) try {
-			await execAsync(`git merge-base --is-ancestor ${branchName} main`, {
+		const remoteCheck = await verifyRemoteBranchIfPresent(ctx, branchName);
+		if (remoteCheck && !remoteCheck.success) return remoteCheck;
+		return stepOk(step, ["All commits merged to main", ...remoteCheck?.details ?? []]);
+	} catch {
+		try {
+			const { stdout: codeDiff } = await execAsync(`git diff main...${branchName} -- ':!.planning' ':!docs/prds' ':!.overdeck/prompts' 2>/dev/null || true`, {
 				cwd: ctx.projectPath,
 				encoding: "utf-8"
 			});
-			const remoteCheck = await verifyRemoteBranchIfPresent(ctx, branchName);
-			if (remoteCheck && !remoteCheck.success) return remoteCheck;
-			return stepOk(step, ["All commits merged to main", ...remoteCheck?.details ?? []]);
-		} catch {
-			try {
-				const { stdout: codeDiff } = await execAsync(`git diff main...${branchName} -- ':!.planning' ':!docs/prds' ':!.overdeck/prompts' 2>/dev/null || true`, {
-					cwd: ctx.projectPath,
-					encoding: "utf-8"
-				});
-				if (!codeDiff.trim()) {
-					const remoteCheck = await verifyRemoteBranchIfPresent(ctx, branchName);
-					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);
-			if (githubMerged?.success) {
+			if (!codeDiff.trim()) {
 				const remoteCheck = await verifyRemoteBranchIfPresent(ctx, branchName);
 				if (remoteCheck && !remoteCheck.success) return remoteCheck;
-				return stepOk(step, [...githubMerged.details ?? [], ...remoteCheck?.details ?? []]);
+				return stepOk(step, ["Code changes squash-merged to main (only planning artifacts remain on branch)", ...remoteCheck?.details ?? []]);
 			}
-			if (githubMerged) return githubMerged;
-			const { stdout: unmerged } = await execAsync(`git log main..${branchName} --oneline 2>/dev/null || true`, {
-				cwd: ctx.projectPath,
-				encoding: "utf-8"
-			});
-			const count = unmerged.trim() ? unmerged.trim().split("\n").length : 0;
-			if (ctx.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,
-					encoding: "utf-8"
-				});
-				if (issueState.trim().toUpperCase() === "CLOSED") return stepSkipped(step, [`Issue already closed on GitHub; ${count} unmerged commit(s) remain on ${branchName}`]);
-			} catch {}
-			return stepFailed(step, `${count} unmerged commit(s) on ${branchName}. Merge before closing out.`);
+		} catch {}
+		const githubMerged = await verifySquashMergedPrByBranch(ctx, branchName, branchName);
+		if (githubMerged?.success) {
+			const remoteCheck = await verifyRemoteBranchIfPresent(ctx, branchName);
+			if (remoteCheck && !remoteCheck.success) return remoteCheck;
+			return stepOk(step, [...githubMerged.details ?? [], ...remoteCheck?.details ?? []]);
 		}
-		const { stdout: remoteBranch } = await execAsync(`git ls-remote --heads origin "${branchName}" 2>/dev/null || true`, {
+		if (githubMerged) return githubMerged;
+		const { stdout: unmerged } = await execAsync(`git log main..${branchName} --oneline 2>/dev/null || true`, {
 			cwd: ctx.projectPath,
 			encoding: "utf-8"
 		});
-		if (remoteBranch.trim()) {
-			await execAsync(`git fetch origin ${branchName}`, { cwd: ctx.projectPath }).catch(() => {});
-			const remoteCheck = await verifyRemoteBranchIfPresent(ctx, branchName);
-			if (remoteCheck) return remoteCheck;
-		}
-		return stepOk(step, ["Branch already cleaned up (squash-merged)"]);
-	} catch (err) {
-		return stepFailed(step, `Could not verify merge: ${err.message}`);
+		const count = unmerged.trim() ? unmerged.trim().split("\n").length : 0;
+		if (ctx.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,
+				encoding: "utf-8"
+			});
+			if (issueState.trim().toUpperCase() === "CLOSED") return stepSkipped(step, [`Issue already closed on GitHub; ${count} unmerged commit(s) remain on ${branchName}`]);
+		} catch {}
+		return stepFailed(step, `${count} unmerged commit(s) on ${branchName}. Merge before closing out.`);
+	}
+	const { stdout: remoteBranch } = await execAsync(`git ls-remote --heads origin "${branchName}" 2>/dev/null || true`, {
+		cwd: ctx.projectPath,
+		encoding: "utf-8"
+	});
+	if (remoteBranch.trim()) {
+		await execAsync(`git fetch origin ${branchName}`, { cwd: ctx.projectPath }).catch(() => {});
+		const remoteCheck = await verifyRemoteBranchIfPresent(ctx, branchName);
+		if (remoteCheck) return remoteCheck;
 	}
+	return null;
 }
 async function verifyRemoteBranchIfPresent(ctx, branchName) {
 	const step = "close-out:verify-merged";
@@ -783,7 +936,7 @@ async function resetIssueToTodoImpl(ctx) {
 */
 async function resetPostMergeStateForIssue(issueId) {
 	try {
-		const { resetPostMergeState } = await import("./merge-agent-CKkgIBPB.js");
+		const { resetPostMergeState } = await import("./merge-agent-DQTXZk8z.js");
 		resetPostMergeState(issueId);
 		resetPostMergeState(issueId.toUpperCase());
 	} catch {
@@ -799,7 +952,7 @@ function clearReviewStatusStep(issueId) {
 async function clearReviewStatusStepImpl(issueId) {
 	const step = "clear-review-status";
 	try {
-		const { clearReviewStatus } = await import("./review-status-btEYlaxA.js");
+		const { clearReviewStatus } = await import("./review-status-Dma9SFaN.js");
 		clearReviewStatus(issueId.toUpperCase());
 		return stepOk(step, ["Review status cleared"]);
 	} catch {
@@ -866,4 +1019,4 @@ 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 };
 
-//# sourceMappingURL=workflows-mbQzh6mQ.js.map
+//# sourceMappingURL=workflows-D0vP1WrK.js.map

package/server/workflows-DtDX08ed.js

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

package/server/{workspace--8tnhDI0.js → workspace-COWvdibH.js}

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

package/server/{workspace-BPUws1-_.js → workspace-DQkRPLlQ.js}

@@ -1,6 +1,6 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { ir as FsError, mr as init_errors } from "./config-yaml-DySPNmKN.js";
-import { i as init_settings, t as areMemoryObservationsEnabled } from "./settings-BTMvpNFU.js";
+import { Fr as init_errors, Tr as FsError } from "./config-yaml-CxdwhAIA.js";
+import { i as init_settings, t as areMemoryObservationsEnabled } from "./settings-VN0qOh4U.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-BPUws1-_.js.map
+//# sourceMappingURL=workspace-DQkRPLlQ.js.map