@overdeck/desktop 0.45.23 → 0.46.0

package/server/{workspaces-hWvy9eKs.js → workspaces-j1e_6aAT.js}

@@ -1,44 +1,49 @@
-import { $n as resolveIssueIdSync, Br as getOverdeckHome, Jn as extractPrefixSync, Nr as encodeClaudeProjectDir, Tn as init_projects, Vr as init_paths, Xt as isStatePlaneOnlyStatus, Yn as init_issue_id, Yt as init_state_plane, Zn as parseIssueIdSync, ar as GitError, ir as FsError, kn as listProjectsSync, mn as findProjectByTeamSync, mr as init_errors, qn as extractNumberSync, t as init_config_yaml, tt as resolveModel, un as extractTeamPrefix, yn as getProjectSync, zn as resolveProjectFromIssueSync } from "./config-yaml-DvyMuOle.js";
-import { d as rejectUnsafeDashboardMutationRequest, ht as getHeaderFromMap, it as getWorkAgentLifecycleStateSync, l as rejectUnauthorizedDashboardRequest, n as _serverManagedMerges, ot as spawnPanCli, xt as jsonResponse, yt as httpHandler } from "./specialists-JVO00bs7.js";
-import { a as init_activity_logger, n as emitActivityEntrySync } from "./activity-logger-DDlOIAML.js";
-import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-CzaSOgul.js";
-import { $ as init_child_env, H as sessionExists, M as listSessionNames, Q as buildChildEnvWithoutTmuxSync, i as capturePane, w as init_tmux } from "./tmux-ftABRAmc.js";
-import { a as init_event_store, n as getEventStore } from "./event-store-tdiY5eDZ.js";
-import { _ as setAutoMerge, b as setReviewStatusSync, c as getReviewStatusSync, d as loadReviewStatuses, l as init_review_status, p as markWorkspaceStuck, v as setDeaconIgnored } from "./review-status-A7quS5KJ.js";
-import { _ as init_queue_position, a as EventStoreService, g as findPositionInQueueSync, h as computeQueuePositionFromStatusSync, s as init_domain_services } from "./issue-lifecycle-CreaCkjW.js";
-import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-Ca0YTWDw.js";
-import { Cr as getAgentRuntimeStateSync, Hn as getAgentState, Kt as transitionIssueToInReview, Tr as saveAgentRuntimeState, X as messageAgent, b as init_agents, i as listRunningAgents, lt as spawnAgent } from "./queries-6d7Cdtm7.js";
-import { f as CostWriter, l as CostDoorLive } from "./service-DCpB_SGd.js";
-import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-B4itFzDo.js";
-import { i as resolveGitHubIssueSync, n as init_tracker_utils } from "./tracker-utils-tnxxqROg.js";
-import { o as getInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-Bb4XeV2x.js";
+import { An as extractTeamPrefix, Er as GitError, Fr as init_errors, Gn as init_projects, Pn as findProjectByTeamSync, Tr as FsError, Yn as listProjectsSync, ar as resolveProjectFromIssueSync, br as resolveIssueIdSync, ci as init_paths, ei as encodeClaudeProjectDir, gn as isStatePlaneOnlyStatus, gr as init_issue_id, hn as init_state_plane, hr as extractPrefixSync, mr as extractNumberSync, si as getOverdeckHome, t as init_config_yaml, tt as resolveModel, vr as parseIssueIdSync, zn as getProjectSync } from "./config-yaml-CmOPzmBb.js";
+import { Et as httpHandler, Ot as jsonResponse, St as getHeaderFromMap, _t as rejectUnauthorizedDashboardRequest, it as getWorkAgentLifecycleStateSync, n as _serverManagedMerges, ot as spawnPanCli, yt as rejectUnsafeDashboardMutationRequest } from "./specialists-CNfYO3G2.js";
+import { o as init_activity_logger, r as emitActivityEntrySync } from "./activity-logger-CyteR4JO.js";
+import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-BjuxvjdS.js";
+import { H as sessionExists, M as listSessionNames, et as buildChildEnvWithoutTmuxSync, i as capturePane, tt as init_child_env, w as init_tmux } from "./tmux-B1Wbxz5o.js";
+import { a as init_event_store, n as getEventStore } from "./event-store-zY5MJHgF.js";
+import { S as setReviewStatusSync, b as setDeaconIgnored, f as init_review_status, g as markWorkspaceStuck, m as loadReviewStatuses, r as clearFeedbackDeliveryStuck, u as getReviewStatusSync, y as setAutoMerge } from "./review-status-yljtTd-q.js";
+import { _ as findPositionInQueueSync, a as EventStoreService, g as computeQueuePositionFromStatusSync, s as init_domain_services, v as init_queue_position } from "./issue-lifecycle-C4Zj0WmE.js";
+import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-Bgcub5kW.js";
+import { Ir as getAgentRuntimeStateSync, Qn as decideResumeGate, Rr as saveAgentRuntimeState, X as messageAgent, Zn as clearYieldForResumeSync, Zt as transitionIssueToInReview, _r as saveAgentStateSync, b as init_agents, er as getAgentResumeGateBlockReason, i as listRunningAgents, ir as init_agent_state, rr as getAgentStateSync, tr as getAgentState, ut as spawnAgent } from "./queries-DHJm7bTd.js";
+import { f as CostWriter, l as CostDoorLive } from "./service-Br9rpBNA.js";
+import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-DZ8Zn2nQ.js";
+import { n as resolveGitHubIssueSync, t as init_tracker_utils } from "./tracker-utils-L0FKtjq2.js";
+import { o as getInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-DvMTQSOS.js";
+import { r as notifyPipelineSync, t as init_pipeline_notifier } from "./pipeline-notifier-BuQ0e4hF.js";
 import { a as PAN_DIRNAME, i as PAN_CONTINUE_FILENAME, p as init_types } from "./types-hraoaQIp.js";
-import { o as init_merge_sync, r as getAllActiveQueues } from "./merge-sync-DZ9dojJn.js";
-import { A as init_xbrief_index, M as readXBriefDocument, _ as XBRIEF_INSPECTION_POLICIES, c as mergeRecordStatusOverrides, g as serializeXBriefDocument, k as findXBriefByIssue, o as init_io, r as findPlan, s as isPlanningComplete, u as readPlan, v as init_types$1 } from "./io-B3_AHDfr.js";
-import { it as findConversationForCostSessionSync, k as init_conversations } from "./conversations-DbOs1e9Q.js";
-import { i as normalizeModelOverrideSync, r as init_model_validation } from "./launcher-generator-CHVm7bGT.js";
-import { f as init_config, m as loadConfigSync$1 } from "./config-CCvjQf27.js";
-import { a as init_stack_health, i as getWorkspaceStackHealth, n as collectDockerContainerLifecycleSnapshot } from "./stack-health-puygdaMd.js";
-import { a as criticalPath, l as init_dag, t as actionableDoc } from "./dag-CdOjJVDT.js";
-import { A as withConcurrencyLimit, E as verifyAppCanMerge, f as init_github_app, k as init_concurrency, m as isIntegrationPermissionError } from "./github-app-CMBdIFBQ.js";
-import { a as readEventsFromLineSync, i as init_events, l as init_wal, o as readEventsSync, r as getLastEventMetadataSync, t as appendCostEventSync } from "./events-CC1dgUpx.js";
-import { n as getContainersReferencingWorkspacePath, r as init_workspace_manager } from "./workspace-manager-hLUv3ADC.js";
-import { r as init_devcontainer_renderer, t as DEVCONTAINER_DIRNAME } from "./devcontainer-renderer-CtUgrVKW.js";
-import { a as init_jsonl_parser, t as getActiveSessionModelSync } from "./jsonl-parser-Dhflo1SH.js";
-import { r as init_in_flight_guard, t as createInFlightGuard } from "./in-flight-guard-aQ1IxeI3.js";
-import { i as findWorkspacePath, o as init_archive_planning } from "./archive-planning-DYrYojxl.js";
-import { a as loadWorkspaceMetadataSync, i as listWorkspaceMetadataSync } from "./workspace-metadata-CskwzzhL.js";
-import { n as enrichReviewStatusFromSessions } from "./review-status-enrichment-tbOn_A_u.js";
-import { n as generateDailySummary, r as init_cli } from "./cli-vBeXbPrq.js";
-import { a as getDiffStat, i as getDiffBase, o as init_review_context, r as getChangedFiles } from "./review-context-BgX3lcCx.js";
-import { n as getTldrDaemonServiceSync, r as init_tldr_daemon } from "./tldr-daemon-BDtLOIlO.js";
-import { C as init_operations, S as gitPush, T as listGitOperationsSync, a as init_merge_agent, w as init_git_activity, x as MainDivergedError, y as syncMainIntoWorkspace } from "./merge-agent-XrB80vfT.js";
-import { F as enqueueMerge, I as getAllActiveQueues$1, L as getCurrentMerge, P as dequeueMerge, z as markMergeProcessing } from "./merge-C_ZEhbqI.js";
-import { n as init_release_set, t as getReleaseSetSync } from "./release-set-hnXd_kga.js";
-import { i as init_conflict_gate, r as getCachedConflictGateMergeability } from "./conflict-gate-CmrYpa47.js";
-import { r as runVerificationForIssue } from "./verification-runner-Br0S_Ous.js";
-import { t as teardownWorkspace } from "./teardown-workspace-CEgauF4U.js";
-import { n as init_rebuild_stack, t as composeProjectNameForWorkspace } from "./rebuild-stack-Dp4eLkt4.js";
+import { i as getAllActiveQueues, s as init_merge_sync } from "./merge-sync-CQ-LgZ1_.js";
+import { l as resolveWorkspaceRepoRootsSync, r as init_project_repos } from "./project-repos-C0nuoBGv.js";
+import { O as findXBriefByIssue, _ as XBRIEF_INSPECTION_POLICIES, c as mergeRecordStatusOverrides, g as serializeXBriefDocument, j as readXBriefDocument, k as init_xbrief_index, o as init_io, r as findPlan, s as isPlanningComplete, u as readPlan, v as init_types$1 } from "./io-VHvc0Ssp.js";
+import { it as findConversationForCostSessionSync, k as init_conversations } from "./conversations-BUpYsOZg.js";
+import { h as normalizeModelOverrideSync, m as init_model_validation } from "./tmux-dedup-DbN6MGzM.js";
+import { f as init_config, m as loadConfigSync$1 } from "./config-Dr3pW6w6.js";
+import { a as getWorkspaceStackHealth, n as collectDockerContainerLifecycleSnapshot, r as composeProjectNameForWorkspace, s as init_stack_health } from "./stack-health-DqSqx0zv.js";
+import { a as criticalPath, l as init_dag, t as actionableDoc } from "./dag-ombYYt4s.js";
+import { E as verifyAppCanMerge, M as withConcurrencyLimit, f as init_github_app, j as init_concurrency, m as isIntegrationPermissionError } from "./github-app-CQ1Lo6LA.js";
+import { a as readEventsFromLineSync, i as init_events, l as init_wal, o as readEventsSync, r as getLastEventMetadataSync, t as appendCostEventSync } from "./events-D9PR1IC0.js";
+import { n as getContainersReferencingWorkspacePath, r as init_workspace_manager } from "./workspace-manager-CwO-Hek7.js";
+import { r as init_devcontainer_renderer, t as DEVCONTAINER_DIRNAME } from "./devcontainer-renderer-68CSCRnu.js";
+import { a as init_jsonl_parser, t as getActiveSessionModelSync } from "./jsonl-parser-DJOH_O-w.js";
+import { i as findWorkspacePath } from "./archive-planning-C0lAbNB_.js";
+import { n as init_merge_verification, t as handlePostRebaseVerificationDeferral } from "./merge-verification-x3JO8Dtz.js";
+import { r as init_in_flight_guard, t as createInFlightGuard } from "./in-flight-guard-Bq3epG58.js";
+import { a as loadWorkspaceMetadataSync, i as listWorkspaceMetadataSync } from "./workspace-metadata-CQv00QwK.js";
+import { n as enrichReviewStatusFromSessions } from "./review-status-enrichment-QV_hQkgS.js";
+import { n as generateDailySummary, r as init_cli } from "./cli-oCWYA1pE.js";
+import { a as getDiffStat, i as getDiffBase, o as init_review_context, r as getChangedFiles } from "./review-context-oFuBbiEE.js";
+import { n as getTldrDaemonServiceSync, r as init_tldr_daemon } from "./tldr-daemon-CBaWkV9k.js";
+import { C as init_operations, S as gitPush, T as listGitOperationsSync, a as init_merge_agent, w as init_git_activity, x as MainDivergedError, y as syncMainIntoWorkspace } from "./merge-agent-DdMVSV2Y.js";
+import { F as enqueueMerge, I as getAllActiveQueues$1, L as getCurrentMerge, P as dequeueMerge, z as markMergeProcessing } from "./merge-Bpx4jjht.js";
+import { t as rebaseFeatureBranch } from "./merge-rebase-xLnMlw5h.js";
+import { n as init_release_set, t as getReleaseSetSync } from "./release-set-BwGeyZKX.js";
+import { i as init_conflict_gate, r as getCachedConflictGateMergeability } from "./conflict-gate-B9cN3SBi.js";
+import { r as runVerificationForIssue } from "./verification-runner-KDZIsBj4.js";
+import { n as registerDurableReviewPipelineHandler, t as init_durable_review_pipeline } from "./durable-review-pipeline-CGZ5QBxh.js";
+import { t as teardownWorkspace } from "./teardown-workspace-l2F4_zim.js";
+import { t as init_rebuild_stack } from "./rebuild-stack-0EEYReVZ.js";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { Effect, Layer, Option, Stream } from "effect";
 import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, writeFileSync } from "fs";
@@ -97,7 +102,7 @@ async function captureInterestedAgent(state, agentId) {
 		try {
 			const remoteState = await readFile(join(homedir$1(), ".overdeck", "agents", agentId, "remote-state.json"), "utf-8").then((text) => JSON.parse(text)).catch(() => null);
 			if (remoteState?.location === "remote" && remoteState?.vmName) {
-				const { getRemoteAgentOutput } = await import("./remote-agents-CRCg1L4H.js");
+				const { getRemoteAgentOutput } = await import("./remote-agents-C1bssi41.js");
 				stdout = await getRemoteAgentOutput(agentId, remoteState.vmName, 50);
 			} else stdout = await Effect.runPromise(capturePane(agentId, 50));
 		} catch {
@@ -390,7 +395,7 @@ var DatabaseProvisionerError = class extends Error {
 };
 //#endregion
 //#region ../../lib/db-provisioners/flyway-postgres.ts
-const execAsync$8 = promisify(exec);
+const execAsync$9 = promisify(exec);
 function shellQuote(value) {
 	return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -463,7 +468,7 @@ async function cleanFile(filePath) {
 async function repairFlywayIfNeeded$1(issueId, pgContainer, dbName, projectConfig, workspacePath, log) {
 	const emit = log || ((msg) => console.log(`[flyway-repair] ${msg}`));
 	try {
-		await execAsync$8(`docker exec "${pgContainer}" pg_isready -U postgres`, {
+		await execAsync$9(`docker exec "${pgContainer}" pg_isready -U postgres`, {
 			encoding: "utf-8",
 			timeout: 5e3
 		});
@@ -475,7 +480,7 @@ async function repairFlywayIfNeeded$1(issueId, pgContainer, dbName, projectConfi
 	}
 	let rowCount = 0;
 	try {
-		const { stdout } = await execAsync$8(`docker exec "${pgContainer}" psql -U postgres -d ${dbName} -t -A -c "SELECT count(*) FROM flyway_schema_history;"`, {
+		const { stdout } = await execAsync$9(`docker exec "${pgContainer}" psql -U postgres -d ${dbName} -t -A -c "SELECT count(*) FROM flyway_schema_history;"`, {
 			encoding: "utf-8",
 			timeout: 1e4
 		});
@@ -499,7 +504,7 @@ async function repairFlywayIfNeeded$1(issueId, pgContainer, dbName, projectConfi
 		message: `Flyway baseline not found: ${flywayFile}`
 	};
 	emit(`Loading Flyway baseline from ${flywayFile}`);
-	await execAsync$8(`docker exec -i "${pgContainer}" psql -U postgres -d ${dbName} < "${flywayFile}"`, {
+	await execAsync$9(`docker exec -i "${pgContainer}" psql -U postgres -d ${dbName} < "${flywayFile}"`, {
 		encoding: "utf-8",
 		timeout: 6e4
 	});
@@ -523,7 +528,7 @@ async function repairFlywayIfNeeded$1(issueId, pgContainer, dbName, projectConfi
 				const tmpSql = `/tmp/flyway-checksum-sync-${Date.now()}.sql`;
 				await writeFile(tmpSql, updates.join("\n"));
 				try {
-					const { stdout } = await execAsync$8(`docker exec -i "${pgContainer}" psql -U postgres -d ${dbName} < "${tmpSql}"`, {
+					const { stdout } = await execAsync$9(`docker exec -i "${pgContainer}" psql -U postgres -d ${dbName} < "${tmpSql}"`, {
 						encoding: "utf-8",
 						timeout: 3e4
 					});
@@ -538,7 +543,7 @@ async function repairFlywayIfNeeded$1(issueId, pgContainer, dbName, projectConfi
 		}
 	}
 	try {
-		const { stdout } = await execAsync$8(`docker exec "${pgContainer}" psql -U postgres -d ${dbName} -t -A -c "SELECT count(*) FROM flyway_schema_history;"`, {
+		const { stdout } = await execAsync$9(`docker exec "${pgContainer}" psql -U postgres -d ${dbName} -t -A -c "SELECT count(*) FROM flyway_schema_history;"`, {
 			encoding: "utf-8",
 			timeout: 1e4
 		});
@@ -565,34 +570,34 @@ const flywayPostgresProvisioner = {
 		const logger = requireLogger(ctx.logger, "[refresh-db]");
 		logger.log(`Starting DB refresh for ${ctx.issueId}`);
 		try {
-			await execAsync$8(`docker stop "${ctx.apiContainer}"`, {
+			await execAsync$9(`docker stop "${ctx.apiContainer}"`, {
 				encoding: "utf-8",
 				timeout: 3e4
 			});
 		} catch {
 			logger.log("API container not running or already stopped");
 		}
-		await execAsync$8(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d postgres -c "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = '${sqlString(ctx.databaseName)}' AND pid <> pg_backend_pid();"`, {
+		await execAsync$9(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d postgres -c "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = '${sqlString(ctx.databaseName)}' AND pid <> pg_backend_pid();"`, {
 			encoding: "utf-8",
 			timeout: 1e4
 		});
-		await execAsync$8(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d postgres -c "DROP DATABASE IF EXISTS ${sqlIdentifier(ctx.databaseName)};"`, {
+		await execAsync$9(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d postgres -c "DROP DATABASE IF EXISTS ${sqlIdentifier(ctx.databaseName)};"`, {
 			encoding: "utf-8",
 			timeout: 1e4
 		});
-		await execAsync$8(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d postgres -c "CREATE DATABASE ${sqlIdentifier(ctx.databaseName)} OWNER postgres;"`, {
+		await execAsync$9(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d postgres -c "CREATE DATABASE ${sqlIdentifier(ctx.databaseName)} OWNER postgres;"`, {
 			encoding: "utf-8",
 			timeout: 1e4
 		});
 		logger.log(`Loading seed file: ${ctx.seedFile}`);
-		await execAsync$8(`docker exec -i ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} < ${shellQuote(ctx.seedFile)}`, {
+		await execAsync$9(`docker exec -i ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} < ${shellQuote(ctx.seedFile)}`, {
 			encoding: "utf-8",
 			timeout: 6e5
 		});
 		const repairResult = await repairFlywayIfNeeded$1(ctx.issueId, ctx.pgContainer, ctx.databaseName, ctx.projectConfig, ctx.workspacePath, (msg) => logger.log(msg));
 		logger.log(`Flyway setup: ${repairResult.message}`);
 		try {
-			await execAsync$8(`docker start "${ctx.apiContainer}"`, {
+			await execAsync$9(`docker start "${ctx.apiContainer}"`, {
 				encoding: "utf-8",
 				timeout: 3e4
 			});
@@ -601,7 +606,7 @@ const flywayPostgresProvisioner = {
 		}
 		let seedVerifyResult;
 		if (ctx.seedVerifyQuery) try {
-			const { stdout } = await execAsync$8(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -t -A -c ${shellQuote(ctx.seedVerifyQuery)}`, {
+			const { stdout } = await execAsync$9(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -t -A -c ${shellQuote(ctx.seedVerifyQuery)}`, {
 				encoding: "utf-8",
 				timeout: 1e4
 			});
@@ -614,7 +619,7 @@ const flywayPostgresProvisioner = {
 		const logger = requireLogger(ctx.logger, "[db-seed]");
 		logger.setText(`Finding database container ${ctx.pgContainer}...`);
 		try {
-			const { stdout } = await execAsync$8(`docker ps --filter "name=${ctx.pgContainer}" --format "{{.Names}}"`);
+			const { stdout } = await execAsync$9(`docker ps --filter "name=${ctx.pgContainer}" --format "{{.Names}}"`);
 			if (!stdout.trim()) {
 				logger.fail(`Database container not running: ${ctx.pgContainer}`);
 				logger.log("\nStart the workspace containers first:");
@@ -626,7 +631,7 @@ const flywayPostgresProvisioner = {
 			return;
 		}
 		if (!ctx.force) try {
-			const { stdout } = await execAsync$8(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -c "SELECT count(*) FROM flyway_schema_history" -t 2>/dev/null`);
+			const { stdout } = await execAsync$9(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -c "SELECT count(*) FROM flyway_schema_history" -t 2>/dev/null`);
 			const count = parseInt(stdout.trim(), 10);
 			if (count > 0) {
 				logger.info(`Database already seeded (${count} migrations). Use --force to reseed.`);
@@ -636,16 +641,16 @@ const flywayPostgresProvisioner = {
 		if (ctx.force) {
 			logger.setText("Dropping existing database...");
 			try {
-				await execAsync$8(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -c "DROP DATABASE IF EXISTS ${sqlIdentifier(ctx.databaseName)}; CREATE DATABASE ${sqlIdentifier(ctx.databaseName)};"`);
+				await execAsync$9(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -c "DROP DATABASE IF EXISTS ${sqlIdentifier(ctx.databaseName)}; CREATE DATABASE ${sqlIdentifier(ctx.databaseName)};"`);
 			} catch (error) {
 				logger.warn(`Could not drop database: ${error instanceof Error ? error.message : String(error)}`);
 			}
 		}
 		logger.setText("Copying seed file to container...");
-		await execAsync$8(`docker cp ${shellQuote(ctx.seedFile)} ${shellQuote(`${ctx.pgContainer}:/tmp/seed.sql`)}`);
+		await execAsync$9(`docker cp ${shellQuote(ctx.seedFile)} ${shellQuote(`${ctx.pgContainer}:/tmp/seed.sql`)}`);
 		logger.setText("Executing seed...");
 		try {
-			await execAsync$8(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -f /tmp/seed.sql`, { timeout: 6e5 });
+			await execAsync$9(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -f /tmp/seed.sql`, { timeout: 6e5 });
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			if (message.includes("ERROR")) {
@@ -653,10 +658,10 @@ const flywayPostgresProvisioner = {
 				return;
 			}
 		}
-		await execAsync$8(`docker exec ${shellQuote(ctx.pgContainer)} rm /tmp/seed.sql`);
+		await execAsync$9(`docker exec ${shellQuote(ctx.pgContainer)} rm /tmp/seed.sql`);
 		logger.succeed("Database seeded successfully");
 		try {
-			const { stdout } = await execAsync$8(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -c "SELECT version, description FROM flyway_schema_history ORDER BY installed_rank DESC LIMIT 3" -t`);
+			const { stdout } = await execAsync$9(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -c "SELECT version, description FROM flyway_schema_history ORDER BY installed_rank DESC LIMIT 3" -t`);
 			logger.log("\nRecent migrations:");
 			stdout.trim().split("\n").forEach((line) => logger.log(`  ${line.trim()}`));
 		} catch {}
@@ -675,7 +680,7 @@ const flywayPostgresProvisioner = {
 		if (!snapshotCmd) throw new DatabaseProvisionerError("No snapshot configuration found");
 		const fullCmd = `${snapshotCmd} > "${outputPath}" 2>&1`;
 		try {
-			await execAsync$8(fullCmd, { timeout: 3e5 });
+			await execAsync$9(fullCmd, { timeout: 3e5 });
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			if (existsSync$1(outputPath)) if (readFileSync$1(outputPath, "utf-8").includes("PostgreSQL database dump")) {
@@ -692,7 +697,7 @@ const flywayPostgresProvisioner = {
 		if (ctx.sanitize && ctx.dbConfig.seed_command) {
 			logger.setText("Running sanitization...");
 			try {
-				await execAsync$8(ctx.dbConfig.seed_command, { cwd: ctx.projectConfig.path });
+				await execAsync$9(ctx.dbConfig.seed_command, { cwd: ctx.projectConfig.path });
 			} catch (error) {
 				logger.warn(`Sanitization warning: ${error instanceof Error ? error.message : String(error)}`);
 			}
@@ -747,7 +752,7 @@ const flywayPostgresProvisioner = {
 	async status(ctx) {
 		const logger = requireLogger(ctx.logger, "[db-status]");
 		logger.setText(`Checking container ${ctx.pgContainer}...`);
-		const { stdout: containerStatus } = await execAsync$8(`docker ps --filter "name=${ctx.pgContainer}" --format "{{.Status}}"`);
+		const { stdout: containerStatus } = await execAsync$9(`docker ps --filter "name=${ctx.pgContainer}" --format "{{.Status}}"`);
 		if (!containerStatus.trim()) {
 			logger.fail(`Container not running: ${ctx.pgContainer}`);
 			return;
@@ -755,18 +760,18 @@ const flywayPostgresProvisioner = {
 		logger.succeed(`Container: ${ctx.pgContainer}`);
 		logger.log(`  Status: ${containerStatus.trim()}`);
 		try {
-			const { stdout: version } = await execAsync$8(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -c "SELECT version, description FROM flyway_schema_history ORDER BY installed_rank DESC LIMIT 1" -t`);
+			const { stdout: version } = await execAsync$9(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -c "SELECT version, description FROM flyway_schema_history ORDER BY installed_rank DESC LIMIT 1" -t`);
 			const [ver, desc] = version.trim().split("|").map((s) => s.trim());
 			logger.log(`  Flyway: V${ver} - ${desc}`);
 		} catch {
 			logger.warn("  Flyway: Not initialized");
 		}
 		try {
-			const { stdout: tableCount } = await execAsync$8(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -c "SELECT count(*) FROM information_schema.tables WHERE table_schema = 'public'" -t`);
+			const { stdout: tableCount } = await execAsync$9(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -c "SELECT count(*) FROM information_schema.tables WHERE table_schema = 'public'" -t`);
 			logger.log(`  Tables: ${tableCount.trim()}`);
 		} catch {}
 		try {
-			const { stdout: dbSize } = await execAsync$8(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -c "SELECT pg_size_pretty(pg_database_size('${sqlString(ctx.databaseName)}'))" -t`);
+			const { stdout: dbSize } = await execAsync$9(`docker exec ${shellQuote(ctx.pgContainer)} psql -U postgres -d ${shellQuote(ctx.databaseName)} -c "SELECT pg_size_pretty(pg_database_size('${sqlString(ctx.databaseName)}'))" -t`);
 			logger.log(`  Size: ${dbSize.trim()}`);
 		} catch {}
 	}
@@ -798,7 +803,7 @@ init_issue_id();
 init_cli();
 init_projects();
 init_devcontainer_renderer();
-const execAsync$7 = promisify(exec);
+const execAsync$8 = promisify(exec);
 function requireDatabaseName(dbConfig) {
 	if (!dbConfig) throw new Error("No database configuration found in projects.yaml");
 	const name = dbConfig.name?.trim();
@@ -814,7 +819,7 @@ const postWorkspaceContainerizeRoute = HttpRouter.add("POST", "/api/workspaces/:
 	const workspacePath = join(projectPath, "workspaces", `feature-${issueLower}`);
 	if (existsSync$1(join(workspacePath, ".devcontainer"))) return jsonResponse({ error: "Workspace is already containerized" }, { status: 400 });
 	try {
-		yield* Effect.promise(() => execAsync$7("docker info >/dev/null 2>&1", { encoding: "utf-8" }));
+		yield* Effect.promise(() => execAsync$8("docker info >/dev/null 2>&1", { encoding: "utf-8" }));
 	} catch {
 		return jsonResponse({ error: "Docker is not running. Start Docker Desktop first." }, { status: 400 });
 	}
@@ -931,7 +936,7 @@ const postWorkspaceContainerActionRoute = HttpRouter.add("POST", "/api/workspace
 	}
 	if (!workspacePath) return jsonResponse({ error: `Workspace not found for ${issueId}` }, { status: 404 });
 	if (!composeFile && ["start", "restart"].includes(action)) {
-		const { ensureDevcontainerSync } = yield* Effect.promise(() => import("./ensure-devcontainer-DRqaAkBR.js"));
+		const { ensureDevcontainerSync } = yield* Effect.promise(() => import("./ensure-devcontainer-C98V8yW-.js"));
 		if (ensureDevcontainerSync({
 			workspacePath,
 			issueId
@@ -948,7 +953,7 @@ const postWorkspaceContainerActionRoute = HttpRouter.add("POST", "/api/workspace
 	}
 	if (!composeFile) return jsonResponse({ error: `No docker-compose file found in workspace` }, { status: 404 });
 	try {
-		yield* Effect.promise(() => execAsync$7("docker info >/dev/null 2>&1", { encoding: "utf-8" }));
+		yield* Effect.promise(() => execAsync$8("docker info >/dev/null 2>&1", { encoding: "utf-8" }));
 	} catch {
 		return jsonResponse({ error: "Docker is not running. Start Docker Desktop first." }, { status: 400 });
 	}
@@ -962,7 +967,7 @@ const postWorkspaceContainerActionRoute = HttpRouter.add("POST", "/api/workspace
 	};
 	const serviceNames = serviceMap[containerName.toLowerCase()];
 	if (!serviceNames) return jsonResponse({ error: `Unknown container: ${containerName}. Valid: ${Object.keys(serviceMap).join(", ")}` }, { status: 400 });
-	const { stdout: projectNameOut } = yield* Effect.promise(() => execAsync$7(`docker compose -f "${composeFile}" config --format json 2>/dev/null | jq -r '.name // empty'`, { encoding: "utf-8" }));
+	const { stdout: projectNameOut } = yield* Effect.promise(() => execAsync$8(`docker compose -f "${composeFile}" config --format json 2>/dev/null | jq -r '.name // empty'`, { encoding: "utf-8" }));
 	const projectName = projectNameOut.trim();
 	if (containerName.toLowerCase() === "api" && ["start", "restart"].includes(action)) {
 		const tPrefix = extractTeamPrefix(issueId);
@@ -991,7 +996,7 @@ const postWorkspaceContainerActionRoute = HttpRouter.add("POST", "/api/workspace
 	for (const serviceName of serviceNames) try {
 		const cmd = `docker compose -f "${composeFile}" ${projectName ? `--project-name "${projectName}"` : ""} ${action} ${serviceName}`;
 		console.log(`[container-control] Running: ${cmd}`);
-		yield* Effect.promise(() => execAsync$7(cmd, {
+		yield* Effect.promise(() => execAsync$8(cmd, {
 			encoding: "utf-8",
 			timeout: 3e4
 		}));
@@ -1052,7 +1057,7 @@ const postWorkspaceRefreshDbRoute = HttpRouter.add("POST", "/api/workspaces/:iss
 		break;
 	}
 	if (!composeFile) return jsonResponse({ error: "No docker-compose file found in workspace" }, { status: 404 });
-	const { stdout: projectNameOut } = yield* Effect.promise(() => execAsync$7(`docker compose -f "${composeFile}" config --format json 2>/dev/null | jq -r '.name // empty'`, { encoding: "utf-8" }));
+	const { stdout: projectNameOut } = yield* Effect.promise(() => execAsync$8(`docker compose -f "${composeFile}" config --format json 2>/dev/null | jq -r '.name // empty'`, { encoding: "utf-8" }));
 	const projectName = projectNameOut.trim();
 	if (!projectName) return jsonResponse({ error: "Could not determine docker compose project name" }, { status: 500 });
 	const pgContainer = `${projectName}-postgres-1`;
@@ -1086,7 +1091,7 @@ const containerOpsRouteLayer = Layer.mergeAll(postWorkspaceContainerizeRoute, po
 //#endregion
 //#region ../../lib/stashes.ts
 init_errors();
-const execAsync$6 = promisify(exec);
+const execAsync$7 = promisify(exec);
 const ISO_STASH_TIMESTAMP_PATTERN = "(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2}))";
 const ISSUE_ID_PATTERN = "([A-Z]+(?:-[A-Z]+)*-\\d+)";
 const ISSUE_ID_REGEX = new RegExp(`^${ISSUE_ID_PATTERN}$`);
@@ -1162,16 +1167,22 @@ function parseStashListLine(line) {
 	};
 }
 async function listStashesPromise(repoPath) {
-	const { stdout } = await execAsync$6("git stash list --format=\"%gd%x09%H%x09%cI%x09%gs\"", {
-		cwd: repoPath,
-		encoding: "utf-8"
-	});
+	let stdout;
+	try {
+		({stdout} = await execAsync$7("git stash list --format=\"%gd%x09%H%x09%cI%x09%gs\"", {
+			cwd: repoPath,
+			encoding: "utf-8"
+		}));
+	} catch (error) {
+		if ((error instanceof Error ? error.message : String(error)).includes("not a git repository")) return [];
+		throw error;
+	}
 	return stdout.split("\n").map((line) => parseStashListLine(line)).filter((entry) => entry !== null);
 }
 async function resolveStashOperationRef(repoPath, ref, stackRef) {
 	const candidateRef = /^stash@\{\d+\}$/.test(ref) ? ref : stackRef;
 	if (candidateRef) {
-		const { stdout: resolvedSha } = await execAsync$6(`git rev-parse --verify ${JSON.stringify(candidateRef)}`, {
+		const { stdout: resolvedSha } = await execAsync$7(`git rev-parse --verify ${JSON.stringify(candidateRef)}`, {
 			cwd: repoPath,
 			encoding: "utf-8"
 		});
@@ -1180,7 +1191,7 @@ async function resolveStashOperationRef(repoPath, ref, stackRef) {
 	}
 	const matchingEntry = (await Effect.runPromise(listStashes(repoPath))).find((entry) => entry.ref === ref);
 	if (!matchingEntry?.stackRef) throw new Error(`Stash ${ref} not found`);
-	const { stdout: resolvedSha } = await execAsync$6(`git rev-parse --verify ${JSON.stringify(matchingEntry.stackRef)}`, {
+	const { stdout: resolvedSha } = await execAsync$7(`git rev-parse --verify ${JSON.stringify(matchingEntry.stackRef)}`, {
 		cwd: repoPath,
 		encoding: "utf-8"
 	});
@@ -1189,7 +1200,7 @@ async function resolveStashOperationRef(repoPath, ref, stackRef) {
 }
 async function dropStashPromise(repoPath, ref, stackRef) {
 	const operationRef = await resolveStashOperationRef(repoPath, ref, stackRef);
-	await execAsync$6(`git stash drop ${JSON.stringify(operationRef)}`, {
+	await execAsync$7(`git stash drop ${JSON.stringify(operationRef)}`, {
 		cwd: repoPath,
 		encoding: "utf-8"
 	});
@@ -1197,7 +1208,7 @@ async function dropStashPromise(repoPath, ref, stackRef) {
 async function createRecoveryBranchFromStashPromise(repoPath, stashRef, issueId, shortDescription, stackRef) {
 	const operationRef = await resolveStashOperationRef(repoPath, stashRef, stackRef);
 	const branchName = `recovery/${validateIssueId(issueId)}-${sanitizeShortDescription(shortDescription)}`;
-	await execAsync$6(`git branch ${JSON.stringify(branchName)} ${JSON.stringify(operationRef)}`, {
+	await execAsync$7(`git branch ${JSON.stringify(branchName)} ${JSON.stringify(operationRef)}`, {
 		cwd: repoPath,
 		encoding: "utf-8"
 	});
@@ -2762,12 +2773,80 @@ const internalEventsRouteLayer = Layer.mergeAll(internalEventsRoute, internalEve
 //#endregion
 //#region routes/workspaces/merge-strike.ts
 init_agents();
+init_agent_state();
+init_tmux();
+const execAsync$6 = promisify(exec);
 function mergeVerificationOptions(request) {
 	return {
 		syncTargetBranch: false,
 		...request.kind === "strike" ? { skipPlanChecklist: true } : {}
 	};
 }
+/**
+* PAN-3067: the PAN-2487 CI-green skip bypasses the verification runner — which
+* is what records verificationStatus on local runs — and that skip is the exact
+* path every strike merge takes (its CI is already green). Record the verdict
+* here so DoD row 3 has evidence and close-out can proceed.
+*/
+async function recordCiGreenVerificationVerdict(issueId, workspacePath) {
+	try {
+		const { snapshotWorkspaceHeadsPromise } = await import("./git-utils-CI6cwyyC.js");
+		const verifiedAnchor = await snapshotWorkspaceHeadsPromise(issueId, workspacePath).catch(() => void 0);
+		const { setReviewStatusSync } = await import("./review-status-BZH8h-6W.js");
+		setReviewStatusSync(issueId, {
+			verificationStatus: "passed",
+			verificationNotes: "merge-verify: CI green on the merged tip (PAN-2487 local-gate skip)",
+			...verifiedAnchor ? { lastVerifiedCommit: verifiedAnchor } : {}
+		});
+	} catch (recordErr) {
+		const message = recordErr instanceof Error ? recordErr.message : String(recordErr);
+		console.warn(`[merge] Could not record CI-green verification verdict for ${issueId}: ${message}`);
+	}
+}
+/**
+* PAN-3120: resume the work agent for a merge-requested rebase and narrate it to
+* the operator (Awaiting Merge tracker + ship log), so a scheduler-yielded agent
+* shows as "Preparing work agent" rather than a silent step or a dead end.
+* Status writes go through the caller's `setStatus` to keep this module free of
+* the workspaces-route import cycle.
+*/
+async function prepareWorkAgentForRebase(opts) {
+	const { appendShipLog } = await import("./ship-log-xplJ8t75.js");
+	opts.setStatus({
+		mergeStep: "preparing-work-agent",
+		mergeNotes: `Preparing work agent ${opts.agentId} to rebase ${opts.scopeNote}…`
+	});
+	appendShipLog(opts.issueId, `Preparing work agent ${opts.agentId} for rebase…`, "rebasing");
+	try {
+		const recovery = await ensureAgentReadyForMerge(opts.issueId, opts.workspacePath, opts.rebaseMsg, {
+			agentId: opts.agentId,
+			...opts.allowFreshStart === void 0 ? {} : { allowFreshStart: opts.allowFreshStart }
+		});
+		opts.setStatus({
+			mergeStep: "rebasing",
+			mergeNotes: `${recovery.detail} Waiting for ${opts.scopeNote} to be rebased and pushed.`
+		});
+		appendShipLog(opts.issueId, `✓ ${recovery.detail}`, "rebasing");
+		console.log(`[merge] ${recovery.detail}`);
+		return {
+			ok: true,
+			detail: recovery.detail
+		};
+	} catch (prepError) {
+		const message = prepError instanceof Error ? prepError.message : String(prepError);
+		const error = `Work agent ${opts.agentId} could not be prepared for the rebase: ${message}`;
+		opts.setStatus(opts.deferFailureStatus ? { mergeNotes: error } : {
+			mergeStatus: "failed",
+			readyForMerge: false,
+			mergeNotes: error
+		});
+		appendShipLog(opts.issueId, `✗ ${error}`, "rebasing");
+		return {
+			ok: false,
+			error
+		};
+	}
+}
 function parseStrikeMergeRequest(raw) {
 	if (!raw || typeof raw !== "object") return null;
 	const request = raw;
@@ -2777,7 +2856,9 @@ function mergeCompletionStatus(request) {
 	return request.kind === "strike" ? {
 		strikeLandingState: "landed",
 		strikeReadyHead: void 0,
-		strikeReadyAt: void 0
+		strikeReadyAt: void 0,
+		strikeTransportRetryCount: void 0,
+		strikeNextAttemptAt: void 0
 	} : {};
 }
 function activeStrikeMerge(currentMerge, pendingOperation) {
@@ -2828,23 +2909,55 @@ async function validateStrikeMergeRequest(issueId, request, status, deps) {
 	}
 	return null;
 }
+/**
+* PAN-3120: clear whatever gate would stop THIS merge from reaching the work
+* agent. The preemptive scheduler yields idle work agents to free slots, so the
+* agent a merge needs is routinely paused by the system itself — and a paused
+* agent silently diverts `messageAgent` into a mail queue nothing drains, which
+* the merge then waits 30 minutes on. Returns a human-readable note when a gate
+* was cleared so the operator sees why the agent came back.
+*/
+async function clearMergePreparationGate(agentId) {
+	const state = getAgentStateSync(agentId);
+	if (!state) return null;
+	const decision = decideResumeGate(getAgentResumeGateBlockReason(state), "merge-preparation");
+	if (decision.decision === "block") throw new Error(decision.reason);
+	if (decision.decision !== "proceed") return null;
+	if (decision.clearYield) {
+		clearYieldForResumeSync(agentId);
+		return `cleared scheduler yield (${state.pausedReason ?? "yielded"})`;
+	}
+	if (decision.clearStoppedByUser) {
+		delete state.stoppedByUser;
+		saveAgentStateSync(state);
+		return "cleared operator-stop gate for the requested merge";
+	}
+	return null;
+}
+/** A message diverted to the mail queue never reaches the agent — treat it as a failure, not a resume. */
+function assertDelivered(agentId, outcome) {
+	if (outcome.delivered) return;
+	throw new Error(`Merge preparation request for ${agentId} was not delivered${outcome.reason ? ` (${outcome.reason})` : ""}${outcome.queuedToMail ? " — it went to the mail queue, so no rebase would ever happen" : ""}.`);
+}
 async function ensureAgentReadyForMerge(issueId, workspacePath, rebaseMsg, options) {
 	const agentId = options?.agentId ?? `agent-${issueId.toLowerCase()}`;
+	const gateNote = await clearMergePreparationGate(agentId);
+	const gateSuffix = gateNote ? ` (${gateNote})` : "";
 	const lifecycle = getWorkAgentLifecycleStateSync(agentId);
 	if (lifecycle.hasLiveTmuxSession) {
-		await messageAgent(agentId, rebaseMsg);
+		assertDelivered(agentId, await messageAgent(agentId, rebaseMsg));
 		return {
 			recovered: true,
 			agentId,
-			detail: "Work agent already running; sent merge preparation request."
+			detail: `Work agent already running; sent merge preparation request${gateSuffix}.`
 		};
 	}
 	if (await Effect.runPromise(getAgentState(agentId))) try {
-		await messageAgent(agentId, rebaseMsg);
+		assertDelivered(agentId, await messageAgent(agentId, rebaseMsg));
 		return {
 			recovered: true,
 			agentId,
-			detail: getWorkAgentLifecycleStateSync(agentId).canResumeSession ? "Resumed work agent and sent merge preparation request." : "Restarted work agent and sent merge preparation request."
+			detail: `${getWorkAgentLifecycleStateSync(agentId).canResumeSession ? "Resumed" : "Restarted"} work agent and sent merge preparation request${gateSuffix}.`
 		};
 	} catch (error) {
 		if (!lifecycle.canStartFresh) throw error;
@@ -2861,6 +2974,97 @@ async function ensureAgentReadyForMerge(issueId, workspacePath, rebaseMsg, optio
 		})).id} and sent merge preparation request.`
 	};
 }
+async function rebaseWithAgentFallback(options) {
+	const { issueId, workspacePath, branchName, targetBranch, agentId, rebaseMsg, allowFreshStart, setStatus } = options;
+	let serverRebaseReason;
+	let conflictFiles = [];
+	if (existsSync$1(workspacePath)) try {
+		const result = await Effect.runPromise(rebaseFeatureBranch(workspacePath, branchName, targetBranch, issueId));
+		console.log(`[merge] Server-side rebase completed for ${issueId}`);
+		return {
+			success: true,
+			newHead: result.newHead
+		};
+	} catch (error) {
+		const detail = error;
+		conflictFiles = Array.isArray(detail.conflictedFiles) ? detail.conflictedFiles.filter((file) => typeof file === "string") : [];
+		const message = error instanceof Error ? error.message : typeof detail.message === "string" ? detail.message : void 0;
+		serverRebaseReason = conflictFiles.length > 0 ? `Rebase conflicts in: ${conflictFiles.join(", ")}` : message || "Server-side rebase failed";
+		console.warn(`[merge] ${serverRebaseReason} — escalating to the work agent for ${issueId}`);
+	}
+	try {
+		const preparation = await prepareWorkAgentForRebase({
+			issueId,
+			workspacePath,
+			agentId,
+			rebaseMsg,
+			allowFreshStart,
+			scopeNote: branchName,
+			setStatus,
+			deferFailureStatus: true
+		});
+		if (!preparation.ok) throw new Error(preparation.error);
+		const { stdout: headBefore } = await execAsync$6(`git rev-parse origin/${branchName} 2>/dev/null || echo NONE`, {
+			cwd: workspacePath,
+			encoding: "utf-8",
+			timeout: 1e4
+		});
+		const timeoutMs = 1800 * 1e3;
+		const startTime = Date.now();
+		let newHead = null;
+		while (Date.now() - startTime < timeoutMs) {
+			await new Promise((resolve) => setTimeout(resolve, 5e3));
+			try {
+				await execAsync$6("git fetch origin", {
+					cwd: workspacePath,
+					encoding: "utf-8",
+					timeout: 15e3
+				});
+				const { stdout: headNow } = await execAsync$6(`git rev-parse origin/${branchName}`, {
+					cwd: workspacePath,
+					encoding: "utf-8",
+					timeout: 5e3
+				});
+				if (headNow.trim() !== headBefore.trim()) {
+					newHead = headNow.trim();
+					console.log(`[merge] Work agent pushed rebased branch for ${issueId} (new HEAD: ${newHead.slice(0, 8)})`);
+					break;
+				}
+			} catch {}
+			if (!await Effect.runPromise(sessionExists(agentId))) {
+				console.log(`[merge] Work agent ${agentId} stopped during rebase`);
+				break;
+			}
+		}
+		if (newHead) return {
+			success: true,
+			newHead
+		};
+		if (!await Effect.runPromise(sessionExists(agentId))) {
+			const agentReason = `Work agent ${agentId} stopped before completing the rebase onto ${targetBranch}`;
+			return {
+				success: false,
+				reason: serverRebaseReason ? `${serverRebaseReason}; ${agentReason}` : agentReason,
+				conflictFiles,
+				retryable: conflictFiles.length === 0
+			};
+		}
+		return {
+			success: false,
+			reason: `Work agent did not push the rebased branch within ${timeoutMs / 6e4} minutes`,
+			conflictFiles,
+			retryable: conflictFiles.length === 0
+		};
+	} catch (error) {
+		const agentReason = error instanceof Error ? error.message : `Work agent ${agentId} could not be prepared for merge`;
+		return {
+			success: false,
+			reason: serverRebaseReason ? `${serverRebaseReason}; ${agentReason}` : agentReason,
+			conflictFiles,
+			retryable: conflictFiles.length === 0
+		};
+	}
+}
 //#endregion
 //#region routes/workspaces/internal-strike-merge.ts
 init_issue_id();
@@ -2914,6 +3118,7 @@ function internalStrikeMergeRoute(triggerMerge) {
 * stay owned by ../workspaces.js and are imported here.
 */
 init_merge_agent();
+init_merge_verification();
 init_operations();
 init_git_activity();
 init_issue_id();
@@ -2926,7 +3131,7 @@ init_tracker_utils();
 init_tmux();
 init_domain_services();
 const execAsync$5 = promisify(exec);
-const execFileAsync$3 = promisify(execFile);
+const execFileAsync$4 = promisify(execFile);
 const shouldBlockApproveForDirtyStatus = (status) => status.trim() !== "" && !isStatePlaneOnlyStatus(status);
 /**
 * Check whether origin/branchName already contains origin/targetBranch.
@@ -2934,7 +3139,7 @@ const shouldBlockApproveForDirtyStatus = (status) => status.trim() !== "" && !is
 */
 async function isBranchAlreadyRebased(workspacePath, branchName, targetBranch) {
 	try {
-		await Promise.all([execFileAsync$3("git", [
+		await Promise.all([execFileAsync$4("git", [
 			"fetch",
 			"origin",
 			targetBranch
@@ -2942,7 +3147,7 @@ async function isBranchAlreadyRebased(workspacePath, branchName, targetBranch) {
 			cwd: workspacePath,
 			encoding: "utf-8",
 			timeout: 15e3
-		}), execFileAsync$3("git", [
+		}), execFileAsync$4("git", [
 			"fetch",
 			"origin",
 			branchName
@@ -2951,7 +3156,7 @@ async function isBranchAlreadyRebased(workspacePath, branchName, targetBranch) {
 			encoding: "utf-8",
 			timeout: 15e3
 		})]);
-		await execFileAsync$3("git", [
+		await execFileAsync$4("git", [
 			"merge-base",
 			"--is-ancestor",
 			`origin/${targetBranch}`,
@@ -2961,7 +3166,7 @@ async function isBranchAlreadyRebased(workspacePath, branchName, targetBranch) {
 			encoding: "utf-8",
 			timeout: 5e3
 		});
-		const { stdout: currentHead } = await execFileAsync$3("git", ["rev-parse", `origin/${branchName}`], {
+		const { stdout: currentHead } = await execFileAsync$4("git", ["rev-parse", `origin/${branchName}`], {
 			cwd: workspacePath,
 			encoding: "utf-8",
 			timeout: 5e3
@@ -2970,7 +3175,8 @@ async function isBranchAlreadyRebased(workspacePath, branchName, targetBranch) {
 			alreadyRebased: true,
 			currentHead: currentHead.trim()
 		};
-	} catch {
+	} catch (error) {
+		console.warn(`[merge] Could not determine whether ${branchName} contains origin/${targetBranch}: ${error instanceof Error ? error.message : String(error)}`);
 		return { alreadyRebased: false };
 	}
 }
@@ -2989,7 +3195,7 @@ async function reconcileGitHubMergeStatus(issueId, status) {
 	const prRef = parseGitHubPullRequestUrl(status.prUrl);
 	if (!prRef) return false;
 	try {
-		const { getPullRequestState, isGitHubAppConfigured } = await import("./github-app-CPfoFAdV.js");
+		const { getPullRequestState, isGitHubAppConfigured } = await import("./github-app-DtAsvwzK.js");
 		if (!isGitHubAppConfigured()) return false;
 		const prState = await Effect.runPromise(getPullRequestState(prRef.owner, prRef.repo, prRef.number));
 		console.log(`[merge] reconcileGitHubMergeStatus: ${issueId} PR #${prRef.number} merged=${prState.merged} state=${prState.state}`);
@@ -3041,7 +3247,7 @@ async function ensurePRExists(issueId, options) {
 		if (options?.cwd) execOptions.cwd = options.cwd;
 		let existingOut = "";
 		try {
-			const { stdout } = await execFileAsync$3("gh", [
+			const { stdout } = await execFileAsync$4("gh", [
 				"pr",
 				"view",
 				branchName,
@@ -3064,7 +3270,7 @@ async function ensurePRExists(issueId, options) {
 		const bodyFile = pathJoin(tmpdir(), `pan-pr-body-${issueId}-${Date.now()}.md`);
 		await writeFileAsync(bodyFile, prBody, "utf-8");
 		try {
-			const { stdout: rawOut } = await execFileAsync$3("gh", [
+			const { stdout: rawOut } = await execFileAsync$4("gh", [
 				"pr",
 				"create",
 				"--head",
@@ -3135,20 +3341,23 @@ const postWorkspaceSyncMainRoute = HttpRouter.add("POST", "/api/issues/:issueId/
 		if (result.alreadyUpToDate) return jsonResponse({
 			success: true,
 			alreadyUpToDate: true,
-			message: "Already up to date with main"
+			message: "Already up to date with main",
+			repos: result.repos
 		});
 		return jsonResponse({
 			success: true,
 			commitCount: result.commitCount || 0,
 			changedFiles: result.changedFiles || [],
-			message: `Synced ${result.commitCount || 0} commit(s) from main`
+			message: `Synced ${result.commitCount || 0} commit(s) from main`,
+			repos: result.repos
 		});
 	} else {
 		const status = result.reason?.includes("uncommitted") ? 400 : 500;
 		return jsonResponse({
 			success: false,
 			error: result.reason || "Sync failed",
-			conflictFiles: result.conflictFiles
+			conflictFiles: result.conflictFiles,
+			repos: result.repos
 		}, { status });
 	}
 })));
@@ -3178,7 +3387,7 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 		};
 		const strikeError = await validateStrikeMergeRequest(issueId, request, reviewStatus, {
 			projectPath: getProjectPath(void 0, extractPrefixSync(issueId) ?? issueId.split("-")[0]),
-			git: async (args, cwd) => (await execFileAsync$3("git", args, {
+			git: async (args, cwd) => (await execFileAsync$4("git", args, {
 				cwd,
 				encoding: "utf-8"
 			})).stdout.trim()
@@ -3246,7 +3455,7 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 	const normalizedMergeId = issueId.toUpperCase();
 	_serverManagedMerges.add(normalizedMergeId);
 	setPendingOperation(issueId, "merge");
-	let queueAdvanced = false;
+	let queueAdvanced = false, preserveQueue = false;
 	const advanceQueue = () => {
 		if (queueAdvanced) return;
 		queueAdvanced = true;
@@ -3256,8 +3465,8 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 	try {
 		if (request.kind === "normal" && workspaceInfo.isRemote && workspaceInfo.vmName) {
 			console.log(`[merge] Remote workspace detected for ${issueId}, using review artifact merge...`);
-			const { getMergeSetSync, ensureMergeSetForIssueSync } = await import("./merge-set-DnSYdBEp.js");
-			const { getForgeAdapter } = await import("./forge-B-ZWyTRm.js");
+			const { getMergeSetSync, ensureMergeSetForIssueSync } = await import("./merge-set-DzsOTBg5.js");
+			const { getForgeAdapter } = await import("./forge-DK3blQb_.js");
 			const remotePrimaryRepo = (getMergeSetSync(issueId) || ensureMergeSetForIssueSync(issueId))?.repos[0];
 			const remoteTargetBranch = remotePrimaryRepo?.targetBranch || "main";
 			const remoteForge = remotePrimaryRepo?.forge || "github";
@@ -3293,7 +3502,7 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 					...mergeCompletionStatus(request)
 				});
 				completePendingOperation(issueId, null);
-				const { postMergeLifecycle } = await import("./merge-agent-BQM3a8z5.js");
+				const { postMergeLifecycle } = await import("./merge-agent-DrXa1CpW.js");
 				await postMergeLifecycle(issueId, projectPath);
 				return {
 					success: true,
@@ -3319,21 +3528,30 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 				};
 			}
 		}
+		const projectConfig = findProjectByTeamSync(issuePrefix);
+		const isPolyrepo = projectConfig?.workspace?.type === "polyrepo";
 		if (!existsSync$1(workspacePath)) {
-			completePendingOperation(issueId, "Workspace does not exist");
+			const error = "Workspace does not exist";
+			const retryable = request.kind === "normal" && !workspaceInfo.isRemote && !isPolyrepo;
+			if (retryable) setReviewStatus(issueId, {
+				mergeStatus: "queued",
+				mergeNotes: error
+			});
+			completePendingOperation(issueId, error);
 			return {
 				success: false,
-				statusCode: 400,
-				error: "Workspace does not exist"
+				statusCode: retryable ? 500 : 400,
+				error,
+				...retryable ? { retryable: true } : {}
 			};
 		}
-		const projectConfig = findProjectByTeamSync(issuePrefix);
-		if (projectConfig?.workspace?.type === "polyrepo" && projectConfig?.workspace?.repos) {
+		if (isPolyrepo && projectConfig?.workspace?.repos) {
 			console.log(`[merge] Polyrepo detected for ${issueId}, coordinating merge set...`);
-			const { getMergeSetSync, ensureMergeSetForIssueSync, upsertMergeSetSync, withRepoStateSync } = await import("./merge-set-DnSYdBEp.js");
-			const { runQualityGates } = await import("./validation-CIi6pnI2.js");
-			const { getForgeAdapter } = await import("./forge-B-ZWyTRm.js");
-			const { messageAgent } = await import("./agents-FlIgQ3ql.js");
+			const { getMergeSetSync, ensureMergeSetForIssueSync, upsertMergeSetSync, withRepoStateSync } = await import("./merge-set-DzsOTBg5.js");
+			const { runQualityGates } = await import("./validation-DEaTZafj.js");
+			const { reconcileStrandedRepos } = await import("./merge-completeness-D0ljXbk3.js");
+			const { getForgeAdapter } = await import("./forge-DK3blQb_.js");
+			const { messageAgent } = await import("./agents-BKKkxKgK.js");
 			let mergeSet = getMergeSetSync(issueId) || ensureMergeSetForIssueSync(issueId);
 			if (!mergeSet) {
 				const error = `No merge set found for ${issueId}`;
@@ -3349,21 +3567,59 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 					error
 				};
 			}
-			const activeRepos = mergeSet.repos.filter((repo) => repo.mergeStatus !== "skipped" && !!repo.artifactUrl).sort((a, b) => a.mergeOrder - b.mergeOrder);
-			if (activeRepos.length === 0) {
-				const error = `No changed repos are marked ready for coordinated merge in ${issueId}`;
+			const reconciliation = await reconcileStrandedRepos(mergeSet);
+			mergeSet = reconciliation.mergeSet;
+			if (reconciliation.blockers.length > 0) {
+				const error = reconciliation.blockers.map((blocker) => blocker.reason).join("; ");
+				mergeSet = {
+					...mergeSet,
+					status: "failed",
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				upsertMergeSetSync(mergeSet);
 				setReviewStatus(issueId, {
 					mergeStatus: "failed",
 					readyForMerge: false,
-					mergeNotes: error
+					mergeNotes: error,
+					blockerReasons: reconciliation.blockers.map((blocker) => ({
+						type: "unmerged_sibling_repo",
+						summary: blocker.reason,
+						detectedAt: (/* @__PURE__ */ new Date()).toISOString()
+					}))
 				});
 				completePendingOperation(issueId, error);
 				return {
 					success: false,
-					statusCode: 400,
+					statusCode: 409,
 					error
 				};
 			}
+			const activeRepos = mergeSet.repos.filter((repo) => repo.mergeStatus !== "skipped" && repo.mergeStatus !== "merged" && !!repo.artifactUrl).sort((a, b) => a.mergeOrder - b.mergeOrder);
+			if (activeRepos.length === 0) {
+				mergeSet = {
+					...mergeSet,
+					status: "merged",
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				upsertMergeSetSync(mergeSet);
+				setReviewStatus(issueId, {
+					mergeStatus: "merged",
+					mergeNotes: void 0,
+					readyForMerge: false,
+					...mergeCompletionStatus(request)
+				});
+				completePendingOperation(issueId, null);
+				const { postMergeLifecycle } = await import("./merge-agent-DrXa1CpW.js");
+				advanceQueue();
+				await postMergeLifecycle(issueId, projectPath);
+				return {
+					success: true,
+					statusCode: 200,
+					message: `No changed repos remain for ${issueId}`,
+					mergeStatus: "merged",
+					repos: []
+				};
+			}
 			const agentId = `agent-${issueId.toLowerCase()}`;
 			mergeSet = {
 				...mergeSet,
@@ -3426,21 +3682,24 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 				};
 			}
 			const reposNeedingRebase = activeRepos.filter((repo) => !alreadyRebased.has(repo.repoKey));
-			if (reposNeedingRebase.length > 0 && !await Effect.runPromise(sessionExists(agentId))) {
-				const error = `Work agent ${agentId} is not running. Polyrepo merge requires the work agent to rebase every affected repo and push.`;
-				setReviewStatus(issueId, {
-					mergeStatus: "failed",
-					readyForMerge: false,
-					mergeNotes: error
+			if (reposNeedingRebase.length > 0) {
+				const prep = await prepareWorkAgentForRebase({
+					issueId,
+					workspacePath,
+					agentId,
+					rebaseMsg: `MERGE REQUESTED: The human has clicked MERGE for ${issueId}. Rebase and push every affected repo in this merge set:\n\n${reposNeedingRebase.map((repo, index) => `${index + 1}. cd ${repo.repoKey}\n   git fetch origin ${repo.targetBranch}\n   git rebase origin/${repo.targetBranch}\n   git push --force-with-lease`).join("\n")}\n\nResolve any conflicts in the workspaces above, complete every rebase, and push all affected branches. Do NOT merge PRs/MRs yourself.`,
+					scopeNote: `${reposNeedingRebase.length} repo(s)`,
+					setStatus: (u) => setReviewStatus(issueId, u)
 				});
-				completePendingOperation(issueId, error);
-				return {
-					success: false,
-					statusCode: 400,
-					error
-				};
+				if (!prep.ok) {
+					completePendingOperation(issueId, prep.error);
+					return {
+						success: false,
+						statusCode: 400,
+						error: prep.error
+					};
+				}
 			}
-			if (reposNeedingRebase.length > 0) await messageAgent(agentId, `MERGE REQUESTED: The human has clicked MERGE for ${issueId}. Rebase and push every affected repo in this merge set:\n\n${reposNeedingRebase.map((repo, index) => `${index + 1}. cd ${repo.repoKey}\n   git fetch origin ${repo.targetBranch}\n   git rebase origin/${repo.targetBranch}\n   git push --force-with-lease`).join("\n")}\n\nResolve any conflicts in the workspaces above, complete every rebase, and push all affected branches. Do NOT merge PRs/MRs yourself.`);
 			const REBASE_TIMEOUT_MS = 1800 * 1e3;
 			const POLL_INTERVAL_MS = 5e3;
 			const pushedRepos = new Set(alreadyRebased);
@@ -3604,7 +3863,7 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 				...mergeCompletionStatus(request)
 			});
 			completePendingOperation(issueId, null);
-			const { postMergeLifecycle } = await import("./merge-agent-BQM3a8z5.js");
+			const { postMergeLifecycle } = await import("./merge-agent-DrXa1CpW.js");
 			advanceQueue();
 			await postMergeLifecycle(issueId, projectPath);
 			return {
@@ -3615,8 +3874,8 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 				repos: mergeResults
 			};
 		}
-		const { getMergeSetSync, ensureMergeSetForIssueSync } = await import("./merge-set-DnSYdBEp.js");
-		const { getForgeAdapter } = await import("./forge-B-ZWyTRm.js");
+		const { getMergeSetSync, ensureMergeSetForIssueSync } = await import("./merge-set-DzsOTBg5.js");
+		const { getForgeAdapter } = await import("./forge-DK3blQb_.js");
 		const primaryRepo = (getMergeSetSync(issueId) || ensureMergeSetForIssueSync(issueId))?.repos[0];
 		const targetBranch = primaryRepo?.targetBranch || "main";
 		const primaryForge = primaryRepo?.forge || "github";
@@ -3657,10 +3916,12 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 				error
 			};
 		}
+		let preMergePrState;
 		if (githubPrRef) try {
-			const { getPullRequestState, isGitHubAppConfigured } = await import("./github-app-CPfoFAdV.js");
+			const { getPullRequestState, isGitHubAppConfigured } = await import("./github-app-DtAsvwzK.js");
 			if (isGitHubAppConfigured()) {
 				const prState = await Effect.runPromise(getPullRequestState(githubPrRef.owner, githubPrRef.repo, githubPrRef.number));
+				preMergePrState = prState;
 				if (prState.state !== "OPEN" && !prState.merged) {
 					const error = `PR #${githubPrRef.number} is ${prState.state} (not OPEN). Overdeck state is out of sync — likely a cancel-flow left a stale prUrl. Re-open the work agent to create a fresh PR, or reset review state.`;
 					console.error(`[merge] ${error}`);
@@ -3720,7 +3981,7 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 						...mergeCompletionStatus(request)
 					});
 					completePendingOperation(issueId, null);
-					const { postMergeLifecycle } = await import("./merge-agent-BQM3a8z5.js");
+					const { postMergeLifecycle } = await import("./merge-agent-DrXa1CpW.js");
 					await postMergeLifecycle(issueId, projectPath, branchName);
 					return {
 						success: true,
@@ -3734,83 +3995,56 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 		} catch (prStateErr) {
 			console.warn(`[merge] Pre-merge PR state check failed for ${issueId}: ${prStateErr.message} — proceeding (check is best-effort)`);
 		}
-		const { postMergeLifecycle } = await import("./merge-agent-BQM3a8z5.js");
-		const agentId = request.kind === "strike" ? request.recoveryTarget : `agent-${issueId.toLowerCase()}`;
-		const rebaseMsg = request.kind === "strike" ? `STRIKE LANDING REQUEST: Rebase ${branchName} onto ${targetBranch}, resolve conflicts, run the full quality gates, push ${branchName}, then run pan strike-ready ${issueId} to persist the new HEAD. Do NOT merge or push main.` : `MERGE REQUESTED: The human has clicked MERGE for ${issueId}. Please rebase onto ${targetBranch} and push:\n\n1. git fetch origin ${targetBranch}\n2. git rebase origin/${targetBranch}\n3. If conflicts: resolve them, git add, git rebase --continue\n4. git push --force-with-lease\n\nAfter pushing, the server will handle verification and merge automatically. Do NOT run gh pr merge yourself.`;
-		setReviewStatus(issueId, { mergeStep: "rebasing" });
-		console.log(`[merge] Rebasing ${branchName} onto ${targetBranch} for ${issueId} (agent=${await Effect.runPromise(sessionExists(agentId)) ? "running" : "stopped"})...`);
-		{
-			const { beginShipLog, appendShipLog } = await import("./ship-log-ClSMIzZX.js");
-			beginShipLog(issueId);
-			appendShipLog(issueId, `Ship started: rebasing ${branchName} onto ${targetBranch}…`, "rebasing");
-		}
+		const { postMergeLifecycle } = await import("./merge-agent-DrXa1CpW.js");
+		const { beginShipLog, appendShipLog } = await import("./ship-log-xplJ8t75.js");
 		let rebaseResult;
-		const { alreadyRebased, currentHead } = await isBranchAlreadyRebased(workspacePath, branchName, targetBranch);
-		if (alreadyRebased && currentHead) {
-			console.log(`[merge] ${branchName} already contains origin/${targetBranch} — skipping rebase request for ${issueId}`);
+		if (preMergePrState?.mergeable === true && preMergePrState.mergeableState === "clean" && !preMergePrState.checksFailed && !preMergePrState.checksPending && !preMergePrState.draft && !preMergePrState.merged) {
+			console.log(`[merge] PR is CLEAN — merging directly without rebase for ${issueId}`);
 			rebaseResult = {
 				success: true,
-				newHead: currentHead
+				newHead: preMergePrState.headSha
 			};
-		} else try {
-			const recovery = await ensureAgentReadyForMerge(issueId, workspacePath, rebaseMsg, {
+		} else {
+			const agentId = request.kind === "strike" ? request.recoveryTarget : `agent-${issueId.toLowerCase()}`;
+			const rebaseMsg = request.kind === "strike" ? `STRIKE LANDING REQUEST: Rebase ${branchName} onto ${targetBranch}, resolve conflicts, run the full quality gates, push ${branchName}, then run pan strike-ready ${issueId} to persist the new HEAD. Do NOT merge or push main.` : `MERGE REQUESTED: The human has clicked MERGE for ${issueId}. Please rebase onto ${targetBranch} and push:\n\n1. git fetch origin ${targetBranch}\n2. git rebase origin/${targetBranch}\n3. If conflicts: resolve them, git add, git rebase --continue\n4. git push --force-with-lease\n\nAfter pushing, the server will handle verification and merge automatically. Do NOT run gh pr merge yourself.`;
+			setReviewStatus(issueId, { mergeStep: "rebasing" });
+			console.log(`[merge] Rebasing ${branchName} onto ${targetBranch} for ${issueId} (agent=${await Effect.runPromise(sessionExists(agentId)) ? "running" : "stopped"})...`);
+			beginShipLog(issueId);
+			appendShipLog(issueId, `Ship started: rebasing ${branchName} onto ${targetBranch}…`, "rebasing");
+			const { alreadyRebased, currentHead } = await isBranchAlreadyRebased(workspacePath, branchName, targetBranch);
+			if (alreadyRebased && currentHead) {
+				console.log(`[merge] ${branchName} already contains origin/${targetBranch} — skipping rebase request for ${issueId}`);
+				rebaseResult = {
+					success: true,
+					newHead: currentHead
+				};
+			} else rebaseResult = await rebaseWithAgentFallback({
+				issueId,
+				workspacePath,
+				branchName,
+				targetBranch,
 				agentId,
-				allowFreshStart: request.kind !== "strike"
+				rebaseMsg,
+				allowFreshStart: request.kind !== "strike",
+				setStatus: (update) => setReviewStatus(issueId, update)
 			});
-			console.log(`[merge] ${recovery.detail}`);
-			const { stdout: headBefore } = await execAsync$5(`git rev-parse origin/${branchName} 2>/dev/null || echo NONE`, {
-				cwd: workspacePath,
-				encoding: "utf-8",
-				timeout: 1e4
-			});
-			const REBASE_TIMEOUT_MS = 1800 * 1e3;
-			const POLL_INTERVAL_MS = 5e3;
-			const startTime = Date.now();
-			let newHead = null;
-			while (Date.now() - startTime < REBASE_TIMEOUT_MS) {
-				await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
-				try {
-					await execAsync$5("git fetch origin", {
-						cwd: workspacePath,
-						encoding: "utf-8",
-						timeout: 15e3
-					});
-					const { stdout: headNow } = await execAsync$5(`git rev-parse origin/${branchName}`, {
-						cwd: workspacePath,
-						encoding: "utf-8",
-						timeout: 5e3
-					});
-					if (headNow.trim() !== headBefore.trim()) {
-						newHead = headNow.trim();
-						console.log(`[merge] Work agent pushed rebased branch for ${issueId} (new HEAD: ${newHead.slice(0, 8)})`);
-						break;
-					}
-				} catch {}
-				if (!await Effect.runPromise(sessionExists(agentId))) {
-					console.log(`[merge] Work agent ${agentId} stopped during rebase`);
-					break;
-				}
-			}
-			if (newHead) rebaseResult = {
-				success: true,
-				newHead
-			};
-			else if (!await Effect.runPromise(sessionExists(agentId))) rebaseResult = {
-				success: false,
-				reason: `Work agent ${agentId} stopped before completing the rebase onto ${targetBranch}`
-			};
-			else rebaseResult = {
-				success: false,
-				reason: `Work agent did not push the rebased branch within ${REBASE_TIMEOUT_MS / 6e4} minutes`
-			};
-		} catch (recoveryErr) {
-			rebaseResult = {
-				success: false,
-				reason: recoveryErr.message || `Work agent ${agentId} could not be prepared for merge`
-			};
 		}
+		if (!rebaseResult) throw new Error(`Rebase escalation produced no result for ${issueId}`);
 		if (!rebaseResult.success) {
 			const error = rebaseResult.reason || "Rebase failed";
+			if (rebaseResult.retryable) {
+				setReviewStatus(issueId, {
+					mergeStatus: "queued",
+					mergeNotes: error
+				});
+				completePendingOperation(issueId, error);
+				return {
+					success: false,
+					statusCode: 500,
+					error,
+					retryable: true
+				};
+			}
 			setReviewStatus(issueId, {
 				mergeStatus: "failed",
 				mergeNotes: error,
@@ -3871,7 +4105,7 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 		});
 		let skipLocalVerification = false;
 		if (primaryForge === "github" && artifactUrl) try {
-			const { parsePullRequestRef, getCiCheckRunsStatePromise, isGitHubAppConfigured } = await import("./github-app-CPfoFAdV.js");
+			const { parsePullRequestRef, getCiCheckRunsStatePromise, isGitHubAppConfigured } = await import("./github-app-DtAsvwzK.js");
 			if (isGitHubAppConfigured()) {
 				const ref = parsePullRequestRef({ url: artifactUrl });
 				if (ref) {
@@ -3892,17 +4126,27 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 		} catch (ciErr) {
 			console.warn(`[merge] CI-state check failed (${ciErr.message?.slice(0, 120)}) — falling back to local verification for ${issueId}`);
 		}
-		const { appendShipLog } = await import("./ship-log-ClSMIzZX.js");
 		if (skipLocalVerification) appendShipLog(issueId, "✓ Local verification skipped — CI already green on this exact commit", "verifying");
 		const verifyResult = skipLocalVerification ? { outcome: "passed" } : await (async () => {
 			console.log(`[merge] Running post-rebase verification for ${issueId}...`);
 			appendShipLog(issueId, "Running post-rebase verification (full quality-gate suite)…", "verifying");
-			const { runVerificationForIssue } = await import("./verification-runner-CDj4lD4t.js");
+			const { runVerificationForIssue } = await import("./verification-runner-DlZI8yhw.js");
 			return Effect.runPromise(runVerificationForIssue(issueId, workspacePath, { isRemote: false }, "merge-verify", {
 				...mergeVerificationOptions(request),
 				onGateLog: (line) => appendShipLog(issueId, line, "verifying")
 			}));
 		})();
+		const verificationDeferral = handlePostRebaseVerificationDeferral(issueId, verifyResult, reviewStatus, {
+			appendShipLog,
+			setReviewStatus,
+			completePendingOperation
+		});
+		if (verificationDeferral) {
+			markMergeProcessing(projectKey, normalizedId, false);
+			_serverManagedMerges.delete(normalizedMergeId);
+			preserveQueue = true;
+			return verificationDeferral;
+		}
 		if (verifyResult.outcome === "failed") {
 			const error = `Post-rebase verification failed at ${verifyResult.failedCheck}`;
 			console.log(`[merge] ${error}`);
@@ -3928,9 +4172,10 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 			};
 		}
 		console.log(`[merge] Post-rebase verification ${verifyResult.outcome} for ${issueId}`);
+		if (skipLocalVerification) await recordCiGreenVerificationVerdict(issueId, workspacePath);
 		setReviewStatus(issueId, { mergeStep: "reporting-statuses" });
 		try {
-			const { getPullRequestState, isGitHubAppConfigured, reportCommitStatus } = await import("./github-app-CPfoFAdV.js");
+			const { getPullRequestState, isGitHubAppConfigured, reportCommitStatus } = await import("./github-app-DtAsvwzK.js");
 			if (githubPrRef && isGitHubAppConfigured()) {
 				const sha = (await Effect.runPromise(getPullRequestState(githubPrRef.owner, githubPrRef.repo, githubPrRef.number))).headSha.trim();
 				if (sha) {
@@ -3958,7 +4203,7 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 		} catch (prMergeErr) {
 			console.error(`[merge] Review artifact merge threw for ${issueId}:`, prMergeErr);
 			try {
-				const { getPullRequestState, isGitHubAppConfigured } = await import("./github-app-CPfoFAdV.js");
+				const { getPullRequestState, isGitHubAppConfigured } = await import("./github-app-DtAsvwzK.js");
 				if (githubPrRef && isGitHubAppConfigured()) {
 					artifactMerged = (await Effect.runPromise(getPullRequestState(githubPrRef.owner, githubPrRef.repo, githubPrRef.number))).merged;
 					if (artifactMerged) console.log(`[merge] Race-detected: PR #${githubPrRef.number} for ${issueId} was already merged despite thrown error; proceeding`);
@@ -4053,7 +4298,7 @@ async function triggerMerge(issueId, request = { kind: "normal" }) {
 			error: error.message
 		};
 	} finally {
-		advanceQueue();
+		if (!preserveQueue) advanceQueue();
 	}
 }
 setMergeQueueTriggerHandler(triggerMerge);
@@ -4077,8 +4322,8 @@ const postForgeApproveRoute = HttpRouter.add("POST", "/api/issues/:issueId/forge
 	if (!parseIssueIdSync(issueId)) return jsonResponse({ error: "Invalid issue ID" }, { status: 400 });
 	if (!/^[A-Z]+-\d+$/i.test(issueId)) return jsonResponse({ error: "Invalid issue ID format" }, { status: 400 });
 	return yield* Effect.promise(async () => {
-		const { getMergeSetSync, upsertMergeSetSync, withRepoArtifactUrlSync, withRepoStateSync } = await import("./merge-set-DnSYdBEp.js");
-		const { getForgeAdapter } = await import("./forge-B-ZWyTRm.js");
+		const { getMergeSetSync, upsertMergeSetSync, withRepoArtifactUrlSync, withRepoStateSync } = await import("./merge-set-DzsOTBg5.js");
+		const { getForgeAdapter } = await import("./forge-DK3blQb_.js");
 		let mergeSet = getMergeSetSync(issueId);
 		if (!mergeSet) return jsonResponse({ error: `No merge set found for ${issueId}` }, { status: 404 });
 		const results = [];
@@ -4139,7 +4384,7 @@ const postForgeApproveRoute = HttpRouter.add("POST", "/api/issues/:issueId/forge
 			}
 		}
 		if (results.filter((r) => r.approved).length > 0) {
-			const { emitActivityEntrySync, emitActivityTtsSync } = await import("./activity-logger-OEUBdfZ8.js");
+			const { emitActivityEntrySync, emitActivityTtsSync } = await import("./activity-logger-CMthG6Vd.js");
 			emitActivityEntrySync({
 				source: "dashboard",
 				level: "success",
@@ -4166,8 +4411,9 @@ const postForgeMergeRoute = HttpRouter.add("POST", "/api/issues/:issueId/forge-m
 	if (!parseIssueIdSync(issueId)) return jsonResponse({ error: "Invalid issue ID" }, { status: 400 });
 	if (!/^[A-Z]+-\d+$/i.test(issueId)) return jsonResponse({ error: "Invalid issue ID format" }, { status: 400 });
 	return yield* Effect.promise(async () => {
-		const { getMergeSetSync, upsertMergeSetSync, withRepoArtifactUrlSync, withRepoStateSync } = await import("./merge-set-DnSYdBEp.js");
-		const { getForgeAdapter } = await import("./forge-B-ZWyTRm.js");
+		const { getMergeSetSync, upsertMergeSetSync, withRepoArtifactUrlSync, withRepoStateSync } = await import("./merge-set-DzsOTBg5.js");
+		const { getForgeAdapter } = await import("./forge-DK3blQb_.js");
+		const { assessRepoMergeCompleteness } = await import("./merge-completeness-D0ljXbk3.js");
 		let mergeSet = getMergeSetSync(issueId);
 		if (!mergeSet) return jsonResponse({ error: `No merge set found for ${issueId}` }, { status: 404 });
 		const results = [];
@@ -4183,34 +4429,44 @@ const postForgeMergeRoute = HttpRouter.add("POST", "/api/issues/:issueId/forge-m
 			const workspacePath = mergeSet.workspaceType === "polyrepo" ? join(mergeSet.projectPath, "workspaces", `feature-${issueId.toLowerCase()}`, repo.repoKey) : join(mergeSet.projectPath, "workspaces", `feature-${issueId.toLowerCase()}`);
 			let artifactUrl = repo.artifactUrl;
 			let artifactId = repo.artifactId;
-			if (!artifactUrl && !artifactId) try {
-				const discovered = await adapter.discoverArtifact({
-					sourceBranch: repo.sourceBranch,
-					cwd: existsSync$1(workspacePath) ? workspacePath : repo.repoPath
-				});
-				if (discovered?.url || discovered?.id) {
-					artifactUrl = discovered.url;
-					artifactId = discovered.id;
+			if (!artifactUrl && !artifactId) {
+				try {
+					const discovered = await adapter.discoverArtifact({
+						sourceBranch: repo.sourceBranch,
+						cwd: existsSync$1(workspacePath) ? workspacePath : repo.repoPath
+					});
+					artifactUrl = discovered?.url;
+					artifactId = discovered?.id;
+				} catch {}
+				if (artifactUrl || artifactId) {
 					mergeSet = withRepoArtifactUrlSync(mergeSet, repo.repoKey, artifactUrl ?? "", artifactId);
 					upsertMergeSetSync(mergeSet);
 					console.log(`[forge-merge] Discovered artifact for ${issueId}/${repo.repoKey}: ${artifactUrl}`);
 				} else {
-					mergeSet = withRepoStateSync(mergeSet, repo.repoKey, { mergeStatus: "skipped" });
+					const classification = await assessRepoMergeCompleteness(repo);
+					if (classification.state === "merged") {
+						mergeSet = withRepoStateSync(mergeSet, repo.repoKey, { mergeStatus: "merged" });
+						results.push({
+							repoKey: repo.repoKey,
+							merged: true
+						});
+					} else if (classification.state === "no-changes") {
+						mergeSet = withRepoStateSync(mergeSet, repo.repoKey, { mergeStatus: "skipped" });
+						results.push({
+							repoKey: repo.repoKey,
+							merged: true
+						});
+					} else {
+						mergeSet = withRepoStateSync(mergeSet, repo.repoKey, { mergeStatus: "blocked" });
+						results.push({
+							repoKey: repo.repoKey,
+							merged: false,
+							error: classification.reason
+						});
+					}
 					upsertMergeSetSync(mergeSet);
-					results.push({
-						repoKey: repo.repoKey,
-						merged: true
-					});
 					continue;
 				}
-			} catch {
-				mergeSet = withRepoStateSync(mergeSet, repo.repoKey, { mergeStatus: "skipped" });
-				upsertMergeSetSync(mergeSet);
-				results.push({
-					repoKey: repo.repoKey,
-					merged: true
-				});
-				continue;
 			}
 			try {
 				await adapter.mergeReviewArtifact({
@@ -4235,7 +4491,7 @@ const postForgeMergeRoute = HttpRouter.add("POST", "/api/issues/:issueId/forge-m
 			}
 		}
 		if (results.filter((r) => r.merged).length > 0) {
-			const { emitActivityEntrySync, emitActivityTtsSync } = await import("./activity-logger-OEUBdfZ8.js");
+			const { emitActivityEntrySync, emitActivityTtsSync } = await import("./activity-logger-CMthG6Vd.js");
 			emitActivityEntrySync({
 				source: "dashboard",
 				level: "success",
@@ -4360,7 +4616,7 @@ const postWorkspaceApproveRoute = HttpRouter.add("POST", "/api/issues/:issueId/a
 		console.log(`[approve] Starting role pipeline for ${issueId}...`);
 		let reviewResult;
 		try {
-			const { spawnReviewRoleForIssue } = await import("./review-agent-DJRO8EG8.js");
+			const { spawnReviewRoleForIssue } = await import("./review-agent-CD4RCI0Y.js");
 			reviewResult = await Effect.runPromise(spawnReviewRoleForIssue({
 				issueId,
 				workspace: workspacePath,
@@ -4407,7 +4663,7 @@ const postWorkspaceApproveRoute = HttpRouter.add("POST", "/api/issues/:issueId/a
 		}
 		console.log(`[approve] Step 3/3: Running server-side rebase for ${issueId}...`);
 		try {
-			const { rebaseFeatureBranch } = await import("./merge-rebase-C1KIVr0s.js");
+			const { rebaseFeatureBranch } = await import("./merge-rebase-DGQpYJU3.js");
 			const workspacePathForRebase = join(projectPath, "workspaces", `feature-${issueId.toLowerCase()}`);
 			const rebaseResult = await Effect.runPromise(rebaseFeatureBranch(workspacePathForRebase, branchName, "main", issueId));
 			if (!rebaseResult.success) {
@@ -4427,7 +4683,7 @@ const postWorkspaceApproveRoute = HttpRouter.add("POST", "/api/issues/:issueId/a
 			completePendingOperation(issueId, pushResult.error);
 			return jsonResponse({ error: pushResult.error }, { status: pushResult.httpStatus });
 		}
-		const { approve: lifecycleApprove } = await import("./lifecycle-sycO16hj.js");
+		const { approve: lifecycleApprove } = await import("./lifecycle-DDN8ApVY.js");
 		const ghResolved = resolveGitHubIssueSync(issueId);
 		const isGitHubIssueFlag = ghResolved.isGitHub;
 		const lifecycleCtx = {
@@ -4461,7 +4717,7 @@ const getMergeQueueRoute = HttpRouter.add("GET", "/api/merge-queue", httpHandler
 })));
 const postInternalPipelineNotifyRoute = HttpRouter.add("POST", "/api/internal/pipeline/notify", httpHandler(Effect.gen(function* () {
 	const request = yield* HttpServerRequest.HttpServerRequest;
-	const { INTERNAL_TOKEN_HEADER, getInternalTokenSync } = yield* Effect.promise(() => import("./internal-token-DXdfprGr.js"));
+	const { INTERNAL_TOKEN_HEADER, getInternalTokenSync } = yield* Effect.promise(() => import("./internal-token-M9omeXM1.js"));
 	const expected = getInternalTokenSync();
 	if (!expected) return jsonResponse({
 		ok: false,
@@ -4475,7 +4731,7 @@ const postInternalPipelineNotifyRoute = HttpRouter.add("POST", "/api/internal/pi
 	}, 403);
 	const event = yield* readJsonBody;
 	const type = event.type;
-	const { notifyPipelineSync } = yield* Effect.promise(() => import("./pipeline-notifier-6iCJplFZ.js"));
+	const { notifyPipelineSync } = yield* Effect.promise(() => import("./pipeline-notifier-ImNXknf0.js"));
 	switch (type) {
 		case "status_changed": {
 			const issueId = event.issueId;
@@ -4643,7 +4899,7 @@ init_types$1();
 init_review_context();
 init_tldr_daemon();
 const execAsync$4 = promisify(exec);
-const execFileAsync$2 = promisify(execFile);
+const execFileAsync$3 = promisify(execFile);
 function getWorkspaceLocation(issueId) {
 	try {
 		const meta = loadWorkspaceMetadataSync(issueId);
@@ -4702,7 +4958,7 @@ async function getRepoGitStatusAsync(workspacePath) {
 }
 async function getMrUrlAsync(issueId, workspacePath) {
 	try {
-		const { stdout } = await execFileAsync$2("gh", [
+		const { stdout } = await execFileAsync$3("gh", [
 			"pr",
 			"view",
 			`feature/${issueId.toLowerCase()}`,
@@ -5250,7 +5506,7 @@ const patchWorkspaceTieredExecutionRoute = HttpRouter.add("PATCH", "/api/workspa
 	if (override !== "on" && override !== "off" && override !== null && override !== void 0) return jsonResponse({ error: "Invalid tiered-execution override" }, { status: 400 });
 	const project = getProjectSync(extractPrefixSync(issueId) ?? issueId.split("-")[0]);
 	if (!project) return jsonResponse({ error: "Project not found" }, { status: 404 });
-	yield* Effect.promise(() => import("./record-t6V-3Dcj.js").then((m) => m.writeRecordTieredExecutionOverride(project, issueId, override)));
+	yield* Effect.promise(() => import("./record-CtroO946.js").then((m) => m.writeRecordTieredExecutionOverride(project, issueId, override)));
 	const projectPath = project.path;
 	const location = yield* resolvePlanLocation(projectPath, issueId);
 	if (!location) return jsonResponse({ error: "No xBRIEF plan found for this workspace" }, { status: 404 });
@@ -5538,6 +5794,48 @@ const postWorkspaceCleanRoute = HttpRouter.add("POST", "/api/workspaces/:issueId
 })));
 const stashCleanRouteLayer = Layer.mergeAll(getWorkspaceStashesRoute, postWorkspaceRecoverStashRoute, deleteWorkspaceStashRoute, getWorkspaceCleanPreviewRoute, postWorkspaceCleanRoute);
 //#endregion
+//#region ../../lib/cloister/review-branch-push.ts
+init_project_repos();
+const execFileAsync$2 = promisify(execFile);
+const REVIEW_PUSH_TIMEOUT_MS = 3e4;
+async function runReviewGit(args, options) {
+	await execFileAsync$2("git", args, options);
+}
+function reviewGitOptions(cwd) {
+	return {
+		cwd,
+		timeout: REVIEW_PUSH_TIMEOUT_MS,
+		killSignal: "SIGKILL",
+		env: {
+			...process.env,
+			GIT_TERMINAL_PROMPT: "0",
+			GIT_ASKPASS: "true",
+			SSH_ASKPASS: "true"
+		}
+	};
+}
+async function pushLocalReviewBranches(issueId, workspacePath, dependencies = {}) {
+	const roots = (dependencies.resolveRoots ?? resolveWorkspaceRepoRootsSync)(issueId, workspacePath);
+	const runGit = dependencies.runGit ?? runReviewGit;
+	for (const root of roots) {
+		try {
+			await runGit([
+				"rev-parse",
+				"--verify",
+				"--quiet",
+				`refs/heads/${root.sourceBranch}`
+			], reviewGitOptions(root.dir));
+		} catch {
+			continue;
+		}
+		await runGit([
+			"push",
+			"origin",
+			root.sourceBranch
+		], reviewGitOptions(root.dir));
+	}
+}
+//#endregion
 //#region ../../lib/cloister/request-review-pipeline.ts
 init_in_flight_guard();
 /**
@@ -5558,6 +5856,10 @@ function createRequestReviewPipeline() {
 					await deps.onVerificationError(outcome);
 					return;
 				}
+				if (outcome.outcome === "deferred") {
+					await deps.onVerificationDeferred?.(outcome);
+					return;
+				}
 				await deps.pushBranch();
 				await deps.dispatchReview();
 			}, deps.onError);
@@ -5567,6 +5869,92 @@ function createRequestReviewPipeline() {
 		}
 	};
 }
+/** Shared host-side pipeline so HTTP requests and durable intent recovery coalesce. */
+const requestReviewPipeline = createRequestReviewPipeline();
+//#endregion
+//#region services/durable-review-pipeline.ts
+init_durable_review_pipeline();
+init_projects();
+async function startDashboardDurableReviewPipeline(input, dependencies) {
+	const { issueId, prUrl, setReviewPending, dispatchReview } = input;
+	const resolved = dependencies.resolveWorkspace(issueId);
+	if (!resolved) return false;
+	const { workspacePath, workspaceInfo, branchName } = resolved;
+	return requestReviewPipeline.start(issueId, {
+		verify: () => dependencies.verify ? dependencies.verify(issueId, workspacePath, workspaceInfo) : Effect.runPromise(runVerificationForIssue(issueId, workspacePath, workspaceInfo, "durable-review")),
+		onVerificationFailed: (outcome) => {
+			setReviewPending({
+				reviewStatus: "pending",
+				reviewNotes: `Verification failed at ${outcome.failedCheck} — fix and resubmit`
+			});
+		},
+		onVerificationError: (outcome) => {
+			setReviewPending({
+				reviewStatus: "pending",
+				reviewNotes: `Verification infrastructure error: ${outcome.message}`
+			});
+		},
+		onVerificationDeferred: (outcome) => {
+			setReviewPending({
+				reviewStatus: "pending",
+				reviewNotes: outcome.reason
+			});
+			console.log(`[review-status] durable review verification deferred for ${issueId}: ${outcome.reason}`);
+		},
+		pushBranch: () => dependencies.pushBranch(resolved),
+		dispatchReview: async () => {
+			const result = await dispatchReview({
+				issueId,
+				workspace: workspacePath,
+				branch: branchName,
+				...prUrl ? { prUrl } : {}
+			});
+			if (!result.success) {
+				setReviewPending({
+					reviewStatus: "pending",
+					reviewNotes: result.error || result.message || "Failed to dispatch review"
+				});
+				return;
+			}
+			const message = result.message?.startsWith("Review already in progress") ? "already in progress — no-op" : "auto-dispatched from durable journal intent";
+			console.log(`[review-status] review dispatch for ${issueId}: ${message} (host-side)`);
+		},
+		onError: (error) => {
+			const detail = error instanceof Error ? error.message : String(error);
+			setReviewPending({
+				reviewStatus: "pending",
+				reviewNotes: `Review pipeline error: ${detail}`
+			});
+			console.warn(`[review-status] host-side durable review pipeline for ${issueId} failed (non-fatal): ${detail}`);
+		}
+	});
+}
+async function pushDashboardReviewBranch(workspace, dependencies) {
+	if (workspace.workspaceInfo.isRemote && workspace.workspaceInfo.vmName) {
+		await dependencies.pushRemote(workspace.workspaceInfo.vmName, workspace.workspacePath, workspace.branchName);
+		return;
+	}
+	await pushLocalReviewBranches(workspace.issueId, workspace.workspacePath);
+}
+function registerDashboardDurableReviewPipeline(dependencies) {
+	registerDurableReviewPipelineHandler((input) => startDashboardDurableReviewPipeline(input, {
+		resolveWorkspace: (issueId) => {
+			const workspaceInfo = dependencies.getWorkspaceInfo(issueId);
+			if (!workspaceInfo.exists) return null;
+			const resolved = resolveProjectFromIssueSync(issueId);
+			if (!resolved) return null;
+			const workspacePath = workspaceInfo.isRemote ? workspaceInfo.remotePath : workspaceInfo.localPath || join(resolved.projectPath, "workspaces", `feature-${issueId.toLowerCase()}`);
+			if (!workspacePath) return null;
+			return {
+				issueId,
+				workspacePath,
+				workspaceInfo,
+				branchName: `feature/${issueId.toLowerCase()}`
+			};
+		},
+		pushBranch: (workspace) => pushDashboardReviewBranch(workspace, dependencies)
+	}));
+}
 //#endregion
 //#region routes/workspaces/review-pipeline.ts
 /**
@@ -5594,9 +5982,31 @@ init_conflict_gate();
 init_agents();
 const execAsync$2 = promisify(exec);
 const MAX_AUTO_REQUEUE = 25;
-const requestReviewPipeline = createRequestReviewPipeline();
+const pushRemoteReviewBranch = async (vmName, workspacePath, branchName) => {
+	await execAsync$2(flyExecCmd(vmName, `cd ${workspacePath} && GIT_TERMINAL_PROMPT=0 GIT_ASKPASS=true SSH_ASKPASS=true git push origin ${branchName}`), {
+		encoding: "utf-8",
+		timeout: 3e4
+	});
+};
+registerDashboardDurableReviewPipeline({
+	getWorkspaceInfo: getWorkspaceInfoForIssue,
+	pushRemote: pushRemoteReviewBranch
+});
 /** Safe `.message` read for caught values of unknown shape. */
 const errorMessage = (e) => e instanceof Error ? e.message : void 0;
+/**
+* Push the feature branch of every repo in the workspace (PAN-2948).
+*
+* A polyrepo workspace root is a one-commit wrapper repo with no remote and no
+* feature branch — pushing there fails and, on the verified-dispatch path,
+* kills the whole re-review pipeline. Loop the resolved repo roots instead
+* (mirrors rebase-helper.ts), skipping repos whose feature branch doesn't
+* exist locally (untouched sub-repos). Monorepo resolves to a single root at
+* the workspace path, preserving the previous behavior.
+*/
+async function pushFeatureBranches(issueId, workspacePath) {
+	await pushLocalReviewBranches(issueId, workspacePath);
+}
 function shouldTreatAsRerun(status) {
 	if (!status) return false;
 	return status.readyForMerge === true || status.reviewStatus === "passed" || status.testStatus === "passed" || status.mergeStatus === "failed";
@@ -5708,15 +6118,12 @@ const postWorkspaceReviewRoute = HttpRouter.add("POST", "/api/review/:issueId/tr
 				console.warn(`[review] Could not transition ${issueId} to in_review: ${errorMessage(err)}`);
 			});
 			try {
-				await execAsync$2(`git push origin ${branchName}`, {
-					cwd: workspacePath,
-					encoding: "utf-8"
-				});
+				await pushFeatureBranches(issueId, workspacePath);
 			} catch (pushErr) {
 				console.log(`Feature branch push note: ${errorMessage(pushErr)}`);
 			}
 			try {
-				const { createReviewArtifactsForIssue } = await import("./review-artifacts-BLbSC4ke.js");
+				const { createReviewArtifactsForIssue } = await import("./review-artifacts-DSMRIfuJ.js");
 				const artifactResult = await Effect.runPromise(createReviewArtifactsForIssue(issueId, workspacePath));
 				const primaryArtifact = artifactResult.mergeSet?.repos.find((repo) => !!repo.artifactUrl);
 				artifactResult.mergeSet?.repos.find((repo) => repo.mergeStatus !== "skipped")?.targetBranch;
@@ -5771,7 +6178,12 @@ const postWorkspaceReviewRoute = HttpRouter.add("POST", "/api/review/:issueId/tr
 				} catch {}
 				return;
 			}
-			const { spawnReviewRoleForIssue } = await import("./review-agent-DJRO8EG8.js");
+			if (verifyOutcome.outcome === "deferred") {
+				console.log(`[review] Verification deferred for ${issueId}: ${verifyOutcome.reason}`);
+				completePendingOperation(issueId, verifyOutcome.reason);
+				return;
+			}
+			const { spawnReviewRoleForIssue } = await import("./review-agent-CD4RCI0Y.js");
 			const prUrl = getReviewStatusSync(issueId)?.prUrl;
 			const reviewResult = await Effect.runPromise(spawnReviewRoleForIssue({
 				issueId,
@@ -5902,15 +6314,12 @@ const postWorkspaceRequestReviewRoute = HttpRouter.add("POST", "/api/review/:iss
 						console.warn(`[request-review] Could not transition ${issueId} to in_review: ${errorMessage(err)}`);
 					});
 					try {
-						await execAsync$2(`git push origin ${branchNameRerun}`, {
-							cwd: workspacePathRerun,
-							encoding: "utf-8"
-						});
+						await pushFeatureBranches(issueId, workspacePathRerun);
 					} catch (pushErr) {
 						console.log(`[request-review] Feature branch push note: ${errorMessage(pushErr)}`);
 					}
 					const prUrl = getReviewStatusSync(issueId)?.prUrl;
-					const { spawnReviewRoleForIssue } = await import("./review-agent-DJRO8EG8.js");
+					const { spawnReviewRoleForIssue } = await import("./review-agent-CD4RCI0Y.js");
 					const result = await Effect.runPromise(spawnReviewRoleForIssue({
 						issueId,
 						workspace: workspacePathRerun,
@@ -5960,7 +6369,7 @@ const postWorkspaceRequestReviewRoute = HttpRouter.add("POST", "/api/review/:iss
 					});
 				} else {
 					const workspacePath = join(resolved.projectPath, "workspaces", `feature-${issueId.toLowerCase()}`);
-					const { spawnRun } = yield* Effect.promise(() => import("./agents-FlIgQ3ql.js"));
+					const { spawnRun } = yield* Effect.promise(() => import("./agents-BKKkxKgK.js"));
 					try {
 						const testRun = yield* Effect.promise(() => spawnRun(issueId, "test", { workspace: workspacePath }));
 						setReviewStatus(issueId, { testStatus: "testing" });
@@ -6037,6 +6446,7 @@ const postWorkspaceRequestReviewRoute = HttpRouter.add("POST", "/api/review/:iss
 		verificationStatus: "pending",
 		reviewNotes
 	});
+	clearFeedbackDeliveryStuck(canonicalIssueId);
 	if (!requestReviewPipeline.start(canonicalIssueId, {
 		verify: () => Effect.runPromise(runVerificationForIssue(issueId, workspacePath, workspaceInfo, "request-review")),
 		onVerificationFailed: (outcome) => {
@@ -6055,13 +6465,17 @@ const postWorkspaceRequestReviewRoute = HttpRouter.add("POST", "/api/review/:iss
 				autoRequeueCount: currentCount
 			});
 		},
+		onVerificationDeferred: (outcome) => {
+			console.log(`[request-review] Verification deferred for ${issueId}: ${outcome.reason}`);
+			completePendingOperation(issueId, outcome.reason);
+		},
 		pushBranch: async () => {
-			const pushCommand = `git push origin ${branchName}`;
-			if (workspaceInfo.isRemote && workspaceInfo.vmName) await execAsync$2(flyExecCmd(workspaceInfo.vmName, `cd ${workspacePath} && ${pushCommand}`), { encoding: "utf-8" });
-			else await execAsync$2(pushCommand, {
-				cwd: workspacePath,
-				encoding: "utf-8"
-			});
+			await pushDashboardReviewBranch({
+				issueId,
+				workspacePath,
+				workspaceInfo,
+				branchName
+			}, { pushRemote: pushRemoteReviewBranch });
 			console.log(`[request-review] Pushed verified branch ${branchName} for ${issueId}`);
 		},
 		dispatchReview: async () => {
@@ -6070,7 +6484,7 @@ const postWorkspaceRequestReviewRoute = HttpRouter.add("POST", "/api/review/:iss
 				testStatus: "pending",
 				reviewNotes
 			});
-			const { spawnReviewRoleForIssue } = await import("./review-agent-DJRO8EG8.js");
+			const { spawnReviewRoleForIssue } = await import("./review-agent-CD4RCI0Y.js");
 			const result = await Effect.runPromise(spawnReviewRoleForIssue({
 				issueId,
 				workspace: workspacePath,
@@ -6157,12 +6571,12 @@ const reviewPipelineRouteLayer = Layer.mergeAll(postWorkspaceReviewRoute, postWo
 * stay owned by ../workspaces.js.
 */
 init_issue_id();
-init_archive_planning();
 init_projects();
 init_review_status();
 init_agents();
 init_model_validation();
 init_config_yaml();
+init_pipeline_notifier();
 const execAsync$1 = promisify(exec);
 function resolveConfiguredReviewModel() {
 	try {
@@ -6172,6 +6586,32 @@ function resolveConfiguredReviewModel() {
 	}
 }
 /**
+* Read and re-emit canonical review status without mutating it. This is the
+* operator escape hatch for PAN-2988-style lost review.status_changed events.
+*/
+function processResyncReviewStatus(issueId) {
+	const status = getReviewStatusSync(issueId);
+	if (!status) return {
+		httpStatus: 404,
+		body: {
+			ok: false,
+			error: `no review status found for ${issueId}`
+		}
+	};
+	notifyPipelineSync({
+		type: "status_changed",
+		issueId,
+		status
+	});
+	return {
+		httpStatus: 200,
+		body: {
+			ok: true,
+			status
+		}
+	};
+}
+/**
 * Core logic for POST /api/review/:issueId/reset (synchronous, testable).
 *
 * Resets the specialist pipeline state (review / test / merge / verification) for
@@ -6379,7 +6819,7 @@ const postWorkspaceResetReviewRoute = HttpRouter.add("POST", "/api/review/:issue
 	const result = processResetReviewPipeline(issueId, resetWorkspace.exists);
 	if (result.httpStatus !== 200) return jsonResponse(result.body, { status: result.httpStatus });
 	try {
-		const { resetPostMergeState } = yield* Effect.promise(() => import("./merge-agent-BQM3a8z5.js"));
+		const { resetPostMergeState } = yield* Effect.promise(() => import("./merge-agent-DrXa1CpW.js"));
 		resetPostMergeState(issueId);
 	} catch (err) {
 		console.warn(`[reset-review] resetPostMergeState best-effort failed for ${issueId}:`, err);
@@ -6388,7 +6828,7 @@ const postWorkspaceResetReviewRoute = HttpRouter.add("POST", "/api/review/:issue
 	const rerun = body?.rerun === true;
 	if (rerun) try {
 		yield* Effect.promise(async () => {
-			const { spawnReviewRoleForIssue } = await import("./review-agent-DJRO8EG8.js");
+			const { spawnReviewRoleForIssue } = await import("./review-agent-CD4RCI0Y.js");
 			const dispatchArgs = buildReviewRedispatchArgs(issueId, resetWorkspace, workspaceInfo, resolved);
 			if (dispatchArgs) {
 				const result = await Effect.runPromise(spawnReviewRoleForIssue({
@@ -6414,10 +6854,16 @@ const postWorkspaceResetReviewRoute = HttpRouter.add("POST", "/api/review/:issue
 		rerun
 	});
 })));
+const postReviewResyncRoute = HttpRouter.add("POST", "/api/review/:issueId/resync", httpHandler(Effect.gen(function* () {
+	const issueId = (yield* HttpRouter.params)["issueId"] ?? "";
+	if (!parseIssueIdSync(issueId)) return jsonResponse({ error: "Invalid issue ID" }, { status: 400 });
+	const result = processResyncReviewStatus(issueId.toUpperCase());
+	return jsonResponse(result.body, { status: result.httpStatus });
+})));
 const postWorkspaceReviewPurgeRoute = HttpRouter.add("POST", "/api/review/:issueId/purge", httpHandler(Effect.gen(function* () {
 	const issueId = (yield* HttpRouter.params)["issueId"] ?? "";
 	if (!parseIssueIdSync(issueId)) return jsonResponse({ error: "Invalid issue ID" }, { status: 400 });
-	const { purgeReviewAgentsForIssue } = yield* Effect.promise(() => import("./review-agent-DJRO8EG8.js"));
+	const { purgeReviewAgentsForIssue } = yield* Effect.promise(() => import("./review-agent-CD4RCI0Y.js"));
 	const projectKey = resolveProjectFromIssueSync(issueId)?.projectKey;
 	const purge = yield* Effect.promise(() => purgeReviewAgentsForIssue(projectKey, issueId));
 	const workspaceInfo = getWorkspaceInfoForIssue(issueId);
@@ -6447,8 +6893,8 @@ const postWorkspaceAbortReviewRoute = HttpRouter.add("POST", "/api/review/:issue
 		success: false,
 		error: "Workspace does not exist"
 	}, { status: 400 });
-	const { resolveProjectFromIssueSync } = yield* Effect.promise(() => import("./projects-9SkRpES9.js"));
-	const { killAllReviewerSessions } = yield* Effect.promise(() => import("./review-agent-DJRO8EG8.js"));
+	const { resolveProjectFromIssueSync } = yield* Effect.promise(() => import("./projects-B03Wr-xc.js"));
+	const { killAllReviewerSessions } = yield* Effect.promise(() => import("./review-agent-CD4RCI0Y.js"));
 	const { killed, failed } = yield* killAllReviewerSessions(resolveProjectFromIssueSync(issueId)?.projectKey, issueId);
 	setReviewStatus(issueId, {
 		reviewStatus: "pending",
@@ -6520,8 +6966,8 @@ const getReviewConfigRoute = HttpRouter.add("GET", "/api/review/:issueId/config"
 	const issueId = ((yield* HttpRouter.params)["issueId"] ?? "").toUpperCase();
 	if (!parseIssueIdSync(issueId)) return jsonResponse({ error: "Invalid issue ID" }, { status: 400 });
 	return jsonResponse(yield* Effect.promise(async () => {
-		const { readIssueRecordSync, resolveProjectForIssue } = await import("./record-t6V-3Dcj.js");
-		const { resolveReviewMode, resolveReReviewScope } = await import("./review-agent-DJRO8EG8.js");
+		const { readIssueRecordSync, resolveProjectForIssue } = await import("./record-CtroO946.js");
+		const { resolveReviewMode, resolveReReviewScope } = await import("./review-agent-CD4RCI0Y.js");
 		const project = resolveProjectForIssue(issueId);
 		const record = project ? readIssueRecordSync(project, issueId) : null;
 		return {
@@ -6556,9 +7002,9 @@ const postReviewConfigRoute = HttpRouter.add("POST", "/api/review/:issueId/confi
 		return jsonResponse({ error: error instanceof Error ? error.message : String(error) }, { status: 400 });
 	}
 	return jsonResponse(yield* Effect.promise(async () => {
-		const { resolveProjectForIssue } = await import("./record-t6V-3Dcj.js");
-		const { updateIssueRecord } = await import("./record-update-DACtKh6_.js");
-		const { resolveReviewMode, resolveReReviewScope } = await import("./review-agent-DJRO8EG8.js");
+		const { resolveProjectForIssue } = await import("./record-CtroO946.js");
+		const { updateIssueRecord } = await import("./record-update-DH6dLJID.js");
+		const { resolveReviewMode, resolveReReviewScope } = await import("./review-agent-CD4RCI0Y.js");
 		const record = await updateIssueRecord(resolveProjectForIssue(issueId), issueId, (current) => {
 			if (hasMode) if (body.reviewMode === null) delete current.reviewMode;
 			else current.reviewMode = body.reviewMode;
@@ -6583,7 +7029,7 @@ const postReviewConfigRoute = HttpRouter.add("POST", "/api/review/:issueId/confi
 		};
 	}));
 })));
-const reviewControlRouteLayer = Layer.mergeAll(postWorkspaceResetReviewRoute, postWorkspaceReviewPurgeRoute, postWorkspaceAbortReviewRoute, postWorkspaceUnstickRoute, postWorkspaceDeaconIgnoreRoute, postWorkspaceAutoMergeRoute, deleteWorkspacePendingRoute, getReviewConfigRoute, postReviewConfigRoute);
+const reviewControlRouteLayer = Layer.mergeAll(postWorkspaceResetReviewRoute, postReviewResyncRoute, postWorkspaceReviewPurgeRoute, postWorkspaceAbortReviewRoute, postWorkspaceUnstickRoute, postWorkspaceDeaconIgnoreRoute, postWorkspaceAutoMergeRoute, deleteWorkspacePendingRoute, getReviewConfigRoute, postReviewConfigRoute);
 //#endregion
 //#region routes/workspaces/uat-stack-actions.ts
 init_activity_logger();
@@ -6991,7 +7437,7 @@ async function readWorkspacePlanningMarkdown(issueId, fileName) {
 */
 async function readWorkspaceContinueFile(_projectPath, workspacePath, issueId) {
 	try {
-		const { readRecordContinueViewSync, getProjectConfigFromWorkspacePath, resolveProjectForIssue } = await import("./record-t6V-3Dcj.js");
+		const { readRecordContinueViewSync, getProjectConfigFromWorkspacePath, resolveProjectForIssue } = await import("./record-CtroO946.js");
 		const recordView = readRecordContinueViewSync(resolveProjectForIssue(issueId) ?? getProjectConfigFromWorkspacePath(workspacePath), issueId);
 		return recordView ? JSON.stringify(recordView, null, 2) : null;
 	} catch {
@@ -7750,7 +8196,7 @@ const getWorkspaceReviewStatusRoute = HttpRouter.add("GET", "/api/review/:issueI
 	if (queuePosition === null) try {
 		const resolved = resolveProjectFromIssueSync(issueId);
 		if (resolved) {
-			const { getQueueForProject } = yield* Effect.promise(() => import("./merge-DK23JEdS.js"));
+			const { getQueueForProject } = yield* Effect.promise(() => import("./merge-idOG--29.js"));
 			const mergePos = findPositionInQueueSync(issueId, getQueueForProject(resolved.projectKey).map((e) => ({
 				id: String(e.id),
 				type: "task",
@@ -7788,10 +8234,10 @@ const postWorkspaceReviewStatusRoute = HttpRouter.add("POST", "/api/review/:issu
 		const workspaceInfo = getWorkspaceInfoForIssue(issueId);
 		if (workspaceInfo.exists && workspaceInfo.localPath) {
 			const localPath = workspaceInfo.localPath;
-			const { getWorkspaceGitInfo } = yield* Effect.promise(() => import("./git-utils-Dry_Ka_D.js"));
+			const { snapshotWorkspaceHeadsPromise } = yield* Effect.promise(() => import("./git-utils-CI6cwyyC.js"));
 			try {
-				const gitInfo = yield* getWorkspaceGitInfo(localPath);
-				if (gitInfo.HEAD) update.reviewedAtCommit = gitInfo.HEAD;
+				const headAnchor = yield* Effect.promise(() => snapshotWorkspaceHeadsPromise(issueId, localPath));
+				if (headAnchor) update.reviewedAtCommit = headAnchor;
 			} catch {}
 		}
 	}
@@ -7803,7 +8249,7 @@ const postWorkspaceReviewStatusRoute = HttpRouter.add("POST", "/api/review/:issu
 	if (verificationStatus) update.verificationStatus = verificationStatus;
 	if (readyForMerge !== void 0) update.readyForMerge = readyForMerge;
 	const status = setReviewStatus(issueId, update);
-	const { getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-DVj0hvaL.js"));
+	const { getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-Tdezg_6N.js"));
 	const projectKey = resolveProjectFromIssueSync(issueId)?.projectKey;
 	if (reviewStatus && [
 		"passed",
@@ -7821,7 +8267,7 @@ const postWorkspaceReviewStatusRoute = HttpRouter.add("POST", "/api/review/:issu
 			const agentId = `agent-${issueId.toLowerCase()}`;
 			const feedbackBody = `CODE REVIEW ${reviewStatus.toUpperCase()} for ${issueId}:\n\n${reviewNotes}\n\n## REQUIRED: Fix ALL issues above, then invoke the /rebase-and-submit skill\n\n1. Read each blocking issue carefully\n2. Fix the code for EVERY issue listed\n3. Run tests locally to verify your fixes\n4. Commit every change\n5. Invoke the /rebase-and-submit skill for ${issueId} — this is an atomic task that runs pan done (which handles rebase + push + re-submit internally)\n\nDo NOT stop between steps. Do NOT run git push manually — the skill handles it. Do NOT stop until pan done has completed successfully.`;
 			try {
-				const { writeFeedbackFile } = yield* Effect.promise(() => import("./feedback-writer-qmiMbqTZ.js"));
+				const { writeFeedbackFile } = yield* Effect.promise(() => import("./feedback-writer-D1fm-5Z8.js"));
 				const wsInfo = getWorkspaceInfoForIssue(issueId);
 				const fileResult = yield* Effect.promise(() => writeFeedbackFile({
 					issueId,
@@ -7885,7 +8331,7 @@ const postWorkspaceReviewStatusRoute = HttpRouter.add("POST", "/api/review/:issu
 			const agentId = `agent-${issueId.toLowerCase()}`;
 			const feedbackBody = `TESTS FAILED for ${issueId}:\n\n${testNotes}\n\n## REQUIRED: Fix ALL test failures, then invoke the /rebase-and-submit skill\n\n1. Read each test failure carefully\n2. Fix the code causing EVERY failure\n3. Run the test suite locally to verify your fixes pass\n4. Commit every change\n5. Invoke the /rebase-and-submit skill for ${issueId} — this is an atomic task that runs pan done (which handles rebase + push + re-submit internally)\n\nDo NOT stop between steps. Do NOT run git push manually — the skill handles it. Do NOT stop until pan done has completed successfully.`;
 			try {
-				const { writeFeedbackFile } = yield* Effect.promise(() => import("./feedback-writer-qmiMbqTZ.js"));
+				const { writeFeedbackFile } = yield* Effect.promise(() => import("./feedback-writer-D1fm-5Z8.js"));
 				const wsInfo = getWorkspaceInfoForIssue(issueId);
 				const fileResult = yield* Effect.promise(() => writeFeedbackFile({
 					issueId,
@@ -7918,14 +8364,14 @@ const postWorkspaceReviewStatusRoute = HttpRouter.add("POST", "/api/review/:issu
 			});
 			yield* Effect.promise(async () => {
 				try {
-					const { resolveProjectFromIssueSync, getProjectSync } = await import("./projects-9SkRpES9.js");
+					const { resolveProjectFromIssueSync, getProjectSync } = await import("./projects-B03Wr-xc.js");
 					const project = resolveProjectFromIssueSync(issueId);
 					const repo = (project ? getProjectSync(project.projectKey) : null)?.github_repo;
 					if (!repo || !repo.includes("/")) return;
 					const [owner, name] = repo.split("/");
 					const wsInfo = getWorkspaceInfoForIssue(issueId);
 					if (!wsInfo?.localPath) return;
-					const { postOverdeckTestsStatus } = await import("./github-app-CPfoFAdV.js");
+					const { postOverdeckTestsStatus } = await import("./github-app-DtAsvwzK.js");
 					await postOverdeckTestsStatus(wsInfo.localPath, owner, name, "success", "Test specialist passed");
 				} catch (err) {
 					console.warn(`[review-status] Failed to post overdeck/tests for ${issueId}: ${err.message}`);
@@ -7967,7 +8413,7 @@ const postWorkspaceRefreshTokenRoute = HttpRouter.add("POST", "/api/workspaces/:
 	if (!parseIssueIdSync(issueId)) return jsonResponse({ error: "Invalid issue ID" }, { status: 400 });
 	const issueLower = issueId.toLowerCase();
 	const workspacePath = join(getProjectPath(void 0, extractPrefixSync(issueId) ?? issueId.split("-")[0]), "workspaces", `feature-${issueLower}`);
-	const { refreshWorkspaceToken, isGitHubAppConfigured } = yield* Effect.promise(() => import("./github-app-CPfoFAdV.js"));
+	const { refreshWorkspaceToken, isGitHubAppConfigured } = yield* Effect.promise(() => import("./github-app-DtAsvwzK.js"));
 	if (!isGitHubAppConfigured()) return jsonResponse({
 		success: false,
 		error: "GitHub App not configured"
@@ -7982,4 +8428,4 @@ const workspacesRouteLayer = Layer.mergeAll(workspaceDataRouteLayer, postWorkspa
 //#endregion
 export { getWorkspacePathForIssue as C, stopAgentOutputService as E, resolveIssueHeadlineCost as S, startAgentOutputService as T, getCostsForIssueSync as _, pushApproveMain as a, processPendingFeedbackDeliveries as b, triggerMerge as c, resumeQueuedMerges as d, syncWalFromAllProjects as f, migrateAllSessionsSync as g, reclassifyUnknownCostEventsSync as h, mergeOpsRouteLayer as i, internalEventsRouteLayer as l, reconcilePiTranscripts as m, buildRichPRBody as n, reconcileGitHubMergeStatus as o, reconcile as p, isBranchAlreadyRebased as r, shouldBlockApproveForDirtyStatus as s, workspacesRouteLayer as t, eventsRouteLayer as u, rebuildCacheSync as v, retainAgentOutputInterest as w, getCachedRunningAgents as x, syncCacheSync as y };
 
-//# sourceMappingURL=workspaces-hWvy9eKs.js.map
+//# sourceMappingURL=workspaces-j1e_6aAT.js.map