@overdeck/desktop 0.49.1 → 0.50.0

package/server/{deacon-TPYssFYt.js → deacon-CsisLmPt.js}

@@ -1,58 +1,63 @@
-import { Bi as sessionFilePath, Fi as init_paths, Gn as init_issue_id, Ht as init_state_read_home, Mt as init_state_plane, On as resolveProjectFromIssueSync, Ot as reconcileStatePlaneDrift, Tt as init_auto_commit, Wt as resolveStateReadHomeSync, Y as init_record, Yr as FsError, _n as listProjectsAsync, et as readIssueRecordForWorkspaceSync, fn as init_projects, gi as OVERDECK_HOME, gn as listProjects, j as RECORD_DIRNAME, jt as getMainDivergence, oi as init_errors, on as getProjectSync, qn as parseIssueIdSync, si as AGENTS_DIR, tt as readIssueRecordSync, vn as listProjectsSync } from "./config-yaml-BwOEANMr.js";
-import { m as loadConfig$1, p as init_config } from "./config-tucKBCCc.js";
-import { a as emitActivityEntrySync, c as init_activity_logger, o as emitActivityTtsSync, r as emitActivityEntryOnce } from "./activity-logger-BAVLrkR7.js";
-import { a as recordLockPath, i as readOwner, n as init_fs_lock } from "./fs-lock-cw25uO_E.js";
-import { a as updateIssueRecord, i as init_record_update, n as clearRecordPipelineClosedOut } from "./record-update-D23jPU6b.js";
-import { A as listSessionNames, B as sessionExists, L as sendKeys, O as listPaneValues, P as querySessionSync, R as sendKeysAsync, S as init_tmux, T as killSession, V as sessionExistsSync, j as listSessions, r as capturePane, w as isPaneDead } from "./tmux-BqXzRuaH.js";
-import { _ as logDeaconEventSync, c as init_agents, d as removeAgentRecordSync, g as logAgentLifecycleSync, h as init_persistent_logger, m as isTerminalIssueStage, p as getIssueStageSync, u as listAllAgentsSync } from "./agents-CqQJW75N.js";
-import { A as setAgentPausedSync, Bn as tryReserveAdvancingSlot, C as recordAgentFailure, D as saveAgentState, E as resetAgentFailureCount, Fn as getConcurrencyLimits, G as init_agents$1, H as getAgentRuntimeStateSync, Hn as workResumeSlotsAvailable, In as init_concurrency, It as isContextOverflowTail, Ln as releaseAdvancingSlot, Lr as hasAgentRuntimeInSubtree, Lt as init_messaging, Nn as describeRunningAgents, Nt as resumeAgent, O as saveAgentStateSync, Pt as init_context_overflow, Qn as deliverInitialPromptWithRetry, Rr as init_runtime_command, Rt as messageAgent, Un as init_swarm_slot_lifecycle, W as saveAgentRuntimeState, Wn as isTerminalSwarmSlotAgent, _n as removeAgentStateDir, ar as init_transcript_landing, c as clearYieldForResumeSync, ci as buildResumeContinueMessage, cn as listAgentStates, f as getAgentState, fn as RETAINED_TRANSCRIPTS_MARKER, fr as init_codex_auth, h as init_agent_state, in as stopAgent, ir as captureTranscriptUserRecordSnapshot, j as setAgentYieldedSync, jn as countRunningAgents, ln as listRunningAgents, m as getAgentStateSync, mn as init_state_dir_removal, mr as paneShowsCodexAuthBurn, pr as isCodexAuthRouted, s as clearAgentTroubledSync, u as getAgentDir, un as listRunningAgentsSync, ur as applyCodexAuthBurnFlag, y as markAgentRunningState, zn as resetPatrolDispatchBudget } from "./agent-state-Bb3UUxQm.js";
-import { i as ensureInternalTokenSync, o as getInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-zY75jrRJ.js";
-import { N as listConversations, j as listArchivedConversations, k as init_conversations } from "./conversations-DhwxsOru.js";
-import { O as stampBootReconciliation, _ as setBootReconciliationGrace, c as init_control_settings, g as setBootReconciliationDecision, o as getLastCleanShutdownAt, r as getBootReconciliationState, u as isDeaconGloballyPaused } from "./control-settings-5k6ixdFW.js";
-import { d as PENDING_PROMOTION_FILENAME, f as WORKSPACE_RUNTIME_DIRNAME, m as init_types } from "./types-DbxY2QB6.js";
-import { C as init_specs, S as findSpecByIssue, f as readPlanSync, h as readWorkspacePlanSync, o as findWorkspaceDraftPlanSync, s as init_io } from "./io-DfvO2xyh.js";
-import { l as init_dag, o as getDispatchableItems } from "./dag-DI9LaK_q.js";
-import { a as loadCloisterConfigSync, r as init_config$1 } from "./config-DC75T4Mr.js";
-import { a as init_state_home, o as inspectLegacyStatePaths } from "./state-home-DhAZlk5k.js";
-import { l as init_review_status_sync, u as markWorkspaceStuck } from "./review-status-sync-B7V_Gg51.js";
-import { B as needsReviewDispatch, G as findBlockingFindings, J as findWorkspaceVerdictConflicts, K as init_review_findings, Q as readWorkspaceVerdictFallback, Y as init_review_status_record_sync, d as getReviewStatusSync, h as loadReviewStatuses, p as init_review_status, q as drainWorkspaceVerdictFallback, w as setReviewStatusSync, z as init_review_dispatch_decision } from "./review-status-DBnR5t4z.js";
-import { d as init_review_verdict_report, f as parseVerdictReport, l as findVerdictReport, u as findVerdictReportAsync } from "./synthesis-verdict-N5Z11pg7.js";
-import { t as assessMemoryPressure } from "./memory-governor-A4O6vI9d.js";
-import { a as getAgentEffectiveLastActivityMs, o as isAgentIdleForNudge, t as checkStuckAgentRemediation } from "./stuck-remediation-Di5JYkoo.js";
-import { n as pruneTerminalStoppedAgents, r as pidsWithCwdUnder } from "./agent-gc-5E0lgxI1.js";
-import { t as recordDeaconNudge } from "./deacon-nudge-log-BtlTWgWu.js";
-import { a as readLiveTrackerIssueState, n as init_issue_closed, r as isIssueClosed } from "./issue-closed-dvEWKO7Q.js";
-import { t as getAutoCloseOutCanonicalState } from "./deacon-canonical-state-DFYymrDw.js";
-import { a as ciRetryMap, c as reconcileMergedButReviewing, d as reconcileStuckReadyForMerge, f as reconcileAutoMergeRows, i as checkReadyForMergeStuck$1, l as reconcileStaleMergeBlockers, n as checkFailedMergeRetry, o as reconcileClosedPrReadyForMerge, p as reconcileStuckMergingStates, r as checkFirstCompletionAgents, s as reconcileFalseMerged, t as autoCloseOut, u as reconcileStaleMergeStatus } from "./deacon-merge-BOGFEV8_.js";
-import { a as writeFeedbackFile, i as init_feedback_writer } from "./feedback-writer-D4ULO4qG.js";
-import { r as surfaceIssueFeedbackNeedsYou, t as init_feedback_target } from "./feedback-target-Ci6N5p4G.js";
-import { t as recordReviewVerdict } from "./review-verdict-writer-CKaJWp75.js";
-import { a as observeActiveReviewArtifact, i as convergeRowFromVerdictOfRecord, n as reviewTimestampMs, r as REVIEW_SUB_ROLES, t as evaluateReviewConvoyLiveness } from "./review-convoy-liveness-DfF9eXjI.js";
-import { J as parseReviewerSessionName, U as getTmuxSessionName, g as getAllProjectSpecialistStatuses, t as init_specialists } from "./specialists-8LcQi9Np.js";
-import { a as inferBranchFromWorkspace, i as findWorkspacePath } from "./archive-planning-BwEhu9Oq.js";
-import { n as shouldSkipDispatchAsMerged } from "./merge-verification-BRp08IzI.js";
-import { t as deliverReviewVerdictFeedback } from "./review-verdict-feedback-C-dBon_-.js";
-import { n as reconcileTraefikNetworks, t as init_traefik_connect } from "./traefik-connect-A5k54mCv.js";
-import { g as decideAgentAutonomousRedrive, r as coordinateSwarmSlots, y as listFeatureWorkspaces } from "./deacon-swarm-BiLfNm_v.js";
-import { i as recordRecoveryFailure, n as findRecoveryTrip, r as init_recovery_trip } from "./recovery-trip-C4dTl8DO.js";
-import { t as isExplicitNoResumeRequest } from "./no-resume-mode-MWI6pnrK.js";
-import { t as createInFlightGuard } from "./in-flight-guard-pcwXKLGz.js";
-import { r as reconcileClosedIssueAgents } from "./closed-issue-reaper-bFppuk6F.js";
-import { b as reconcilePipelineLabelsPatrol, y as init_label_reconciler } from "./pipeline-membership-gather-CGFY1v-y.js";
-import { t as recordDeadEndNeedsYou } from "./dead-end-trip-P0IF1O0E.js";
-import { a as triggerRebuildAndStart, i as reconcileOrphanProposedSpecs } from "./orphan-proposed-reconciler-cV3URUqk.js";
-import { n as spawnWorkAgentThroughAgentsEndpoint } from "./work-agent-start-BNQO65W7.js";
-import { n as reconcileIdleWorkspaceStacks } from "./idle-stack-reaper-BeU_KxWx.js";
-import { a as recordUnsignaledTestEscalation, i as readTestVerdictArtifact, n as decideUnsignaledTestAction, r as init_test_verdict } from "./test-verdict-BWtRmdiR.js";
-import { dirname, join } from "node:path";
+import { E as init_tier_table, It as isStatePlaneOnlyStatus, J as getProjectConfigFromWorkspacePath, K as getIssueRecordPathForWorkspace, Mt as init_state_plane, O as resolveTieredExecutionEnabled, On as resolveProjectFromIssueSync, Ot as reconcileStatePlaneDrift, Qr as FsError, Tt as init_auto_commit, Wi as sessionFilePath, Y as init_record, Yn as parseIssueIdSync, _n as listProjectsAsync, et as readIssueRecordForWorkspaceSync, fn as init_projects, gn as listProjects, jt as getMainDivergence, li as init_errors, on as getProjectSync, p as loadConfigSync, qn as init_issue_id, rt as resolveProjectForIssue, t as init_config_yaml, tt as readIssueRecordSync, ui as AGENTS_DIR, vn as listProjectsSync, yi as OVERDECK_HOME, zi as init_paths } from "./config-yaml-D60AnTIu.js";
+import { m as loadConfig$1, p as init_config } from "./config-NxI9Yl2f.js";
+import { i as emitActivityEntryOnce, l as init_activity_logger, o as emitActivityEntrySync, s as emitActivityTtsSync } from "./activity-logger-SlTXYCVf.js";
+import { a as recordLockPath, i as readOwner, n as init_fs_lock } from "./fs-lock-DQ_gUxfq.js";
+import { a as updateIssueRecord, i as init_record_update, n as clearRecordPipelineClosedOut, o as updateIssueRecordForWorkspace } from "./record-update-BPqpBu3O.js";
+import { B as sendKeys, C as init_tmux, E as killSession, I as querySessionSync, M as listSessionNamesSync, N as listSessions, T as isPaneDead, U as sessionExists, V as sendKeysAsync, W as sessionExistsSync, j as listSessionNames, k as listPaneValues, r as capturePane, v as getManagedTmuxSocketName } from "./tmux-wnT_hg-s.js";
+import { _ as logDeaconEventSync, c as init_agents, d as removeAgentRecordSync, g as logAgentLifecycleSync, h as init_persistent_logger, m as isTerminalIssueStage, p as getIssueStageSync, u as listAllAgentsSync } from "./agents-DzpQidT8.js";
+import { O as stampBootReconciliation, _ as setBootReconciliationGrace, c as init_control_settings, d as isDeaconGloballyPausedSync, g as setBootReconciliationDecision, o as getLastCleanShutdownAt, r as getBootReconciliationState, u as isDeaconGloballyPaused } from "./control-settings-Db0uXgVM.js";
+import { $ as deliverCommitForReview, $n as isTerminalSwarmSlotAgent, A as saveAgentStateSync, Ai as getAgentRuntimeSnapshot, Bn as countRunningAgents, Cn as init_state_dir_removal, Cr as paneShowsCodexAuthBurn, Dr as init_spawn_prep, En as removeAgentStateDir, Er as defaultRunWorkspace, Fr as init_resolve_tier, Ft as resumeAgent, Gn as init_concurrency, Hn as describeRunningAgents, Ht as init_messaging, Ir as resolveTier, Jn as resetPatrolDispatchBudget, K as saveAgentRuntimeState, Kn as releaseAdvancingSlot, Kr as hasAgentRuntimeInSubtree, M as setAgentPausedSync, N as setAgentYieldedSync, O as resetAgentFailureCount, Qn as init_swarm_slot_lifecycle, Sr as isCodexAuthRouted, T as recordAgentFailure, Ut as messageAgent, Vn as countRunningSwarmSlotsForIssue, Vt as isContextOverflowTail, W as getAgentRuntimeStateSync, Wn as getConcurrencyLimits, Xn as tryReserveSwarmSlot, Yn as tryReserveAdvancingSlot, Zn as workResumeSlotsAvailable, _ as init_agent_state, _i as buildResumeContinueMessage, _n as listAgentStates, _t as init_pending_decision_gate, an as init_spawn, at as broadcastCommit, cn as ensureRegisteredSlotWorktree, d as decideResumeGate, dt as reconcileSlotState, er as getCachedMemoryVerdict, et as init_tier_supervisor, f as getAgentDir, fn as init_termination, g as getAgentStateSync, gt as detectPendingOperatorDecision, it as supervisorAgentId, ji as init_agent_runtime, k as saveAgentState, l as clearAgentTroubledSync, ln as init_registered_slot_spawn, lt as init_slot_reconcile, m as getAgentState, mr as init_transcript_landing, nt as shouldSupervise, ot as init_tier_feed, p as getAgentResumeGateBlockReason, pn as stopAgent, pr as captureTranscriptUserRecordSnapshot, q as init_agents$1, qn as releaseSwarmSlot, qr as init_runtime_command, rt as spawnTierSupervisor, sn as spawnRun, sr as deliverInitialPromptWithRetry, tr as init_memory_verdict_cache, tt as loadPrdDraft, u as clearYieldForResumeSync, ut as listSlotAssignments, vn as listRunningAgents, x as markAgentRunningState, xn as RETAINED_TRANSCRIPTS_MARKER, xr as init_codex_auth, yn as listRunningAgentsSync, yr as applyCodexAuthBurnFlag, zt as init_context_overflow } from "./agent-state-FABw8neJ.js";
+import { i as ensureInternalTokenSync, o as getInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-BeIWG_kT.js";
+import { A as init_conversations, M as listArchivedConversations, P as listConversations } from "./conversations-nS6QgYpD.js";
+import { d as PENDING_PROMOTION_FILENAME, f as WORKSPACE_RUNTIME_DIRNAME, m as init_types } from "./types-pLpbsNto.js";
+import { C as init_specs, S as findSpecByIssue, b as subItemsOf, f as readPlanSync, h as readWorkspacePlanSync, i as findPlanSync, n as applyStatusOverrides, o as findWorkspaceDraftPlanSync, s as init_io, y as init_types$1 } from "./io-BCtZoXHo.js";
+import { a as getDispatchableItems, c as init_dag } from "./dag-o-dUpw1L.js";
+import { a as loadCloisterConfigSync, r as init_config$1 } from "./config-_qaa1UXH.js";
+import { a as init_state_home, o as inspectLegacyStatePaths } from "./state-home-DhsMqg8W.js";
+import { d as resolveWorkspaceRepoRootsSync, i as init_project_repos, u as resolveSlotWorkspaceWorktreesSync } from "./project-repos-CsfvLtmr.js";
+import { r as init_swarm_readiness, t as analyzeSwarmReadiness } from "./swarm-readiness-LF8ZF_hc.js";
+import { l as init_review_status_sync, u as markWorkspaceStuck } from "./review-status-sync-C6ZKTI8f.js";
+import { B as needsReviewDispatch, G as findBlockingFindings, J as findWorkspaceVerdictConflicts, K as init_review_findings, Q as readWorkspaceVerdictFallback, Y as init_review_status_record_sync, d as getReviewStatusSync, h as loadReviewStatuses, p as init_review_status, q as drainWorkspaceVerdictFallback, w as setReviewStatusSync, z as init_review_dispatch_decision } from "./review-status-DpniqzPT.js";
+import { d as init_review_verdict_report, f as parseVerdictReport, l as findVerdictReport, u as findVerdictReportAsync } from "./synthesis-verdict-CGFF8uQI.js";
+import { t as assessMemoryPressure } from "./memory-governor-Cvv_9K0M.js";
+import { r as isAgentIdleForNudge, t as getAgentEffectiveLastActivityMs } from "./agent-idle-D-UQ7gDv.js";
+import { n as pruneTerminalStoppedAgents, r as pidsWithCwdUnder } from "./agent-gc-bhikjoJ_.js";
+import { t as recordDeaconNudge } from "./deacon-nudge-log-pcliw8Dr.js";
+import { a as readLiveTrackerIssueState, n as init_issue_closed, r as isIssueClosed } from "./issue-closed-CiYAa6bX.js";
+import { t as getAutoCloseOutCanonicalState } from "./deacon-canonical-state-DkdkQS5p.js";
+import { a as checkFailedMergeRetry, c as ciRetryMap, d as reconcileMergedButReviewing, f as reconcileStaleMergeBlockers, g as reconcileStuckMergingStates, h as reconcileAutoMergeRows, i as autoCloseOut, l as reconcileClosedPrReadyForMerge, m as reconcileStuckReadyForMerge, n as reconcileTerminalIssueResidue, o as checkFirstCompletionAgents, p as reconcileStaleMergeStatus, r as listIssueRecords, s as checkReadyForMergeStuck$1, u as reconcileFalseMerged } from "./parked-residue-8WbU0y1z.js";
+import { a as writeFeedbackFile, i as init_feedback_writer } from "./feedback-writer-Ds1Wjsz4.js";
+import { r as surfaceIssueFeedbackNeedsYou, t as init_feedback_target } from "./feedback-target-yPD_wclF.js";
+import { t as recordReviewVerdict } from "./review-verdict-writer-Cy_1pnIj.js";
+import { a as observeActiveReviewArtifact, i as convergeRowFromVerdictOfRecord, n as reviewTimestampMs, r as REVIEW_SUB_ROLES, t as evaluateReviewConvoyLiveness } from "./review-convoy-liveness-BBvyuRLC.js";
+import { g as getAllProjectSpecialistStatuses, t as init_specialists } from "./specialists-D6MUU31Q.js";
+import { m as parseReviewerSessionName, s as getTmuxSessionName } from "./specialists-registry-Bng0OFGH.js";
+import { a as inferBranchFromWorkspace, i as findWorkspacePath } from "./archive-planning-BL1ABtW0.js";
+import { n as shouldSkipDispatchAsMerged } from "./merge-verification-BfJRNMiD.js";
+import { t as deliverReviewVerdictFeedback } from "./review-verdict-feedback-B2ojHFH5.js";
+import { n as reconcileTraefikNetworks, t as init_traefik_connect } from "./traefik-connect-DoQvQ6oJ.js";
+import { i as recordRecoveryFailure, n as findRecoveryTrip, r as init_recovery_trip } from "./recovery-trip-CpfW6LCJ.js";
+import { a as init_work_agent_prompt, n as buildWorkAgentPrompt } from "./work-agent-prompt-CaD2ue8m.js";
+import { t as isExplicitNoResumeRequest } from "./no-resume-mode-DjMQRkId.js";
+import { t as createInFlightGuard } from "./in-flight-guard-B7khcBdQ.js";
+import { t as checkStuckAgentRemediation } from "./stuck-remediation-kta3KN7c.js";
+import { r as reconcileClosedIssueAgents } from "./closed-issue-reaper-CdcJRvUx.js";
+import { b as reconcilePipelineLabelsPatrol, y as init_label_reconciler } from "./pipeline-membership-gather-Ba0wJNCR.js";
+import { t as recordDeadEndNeedsYou } from "./dead-end-trip-Bs3hxIn6.js";
+import { a as triggerRebuildAndStart, i as reconcileOrphanProposedSpecs } from "./orphan-proposed-reconciler-nFUlquZt.js";
+import { n as spawnWorkAgentThroughAgentsEndpoint } from "./work-agent-start-0nJ-6UeA.js";
+import { n as reconcileIdleWorkspaceStacks } from "./idle-stack-reaper-DtoI4al6.js";
+import { a as recordUnsignaledTestEscalation, i as readTestVerdictArtifact, n as decideUnsignaledTestAction, r as init_test_verdict } from "./test-verdict-oNSv1rVr.js";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { Effect } from "effect";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "fs";
 import { basename as basename$1, dirname as dirname$1, join as join$1 } from "path";
 import { cpus, loadavg } from "os";
-import { existsSync as existsSync$1, promises as promises$1, readFileSync as readFileSync$1 } from "node:fs";
+import { hostname } from "node:os";
+import { existsSync as existsSync$1, readFileSync as readFileSync$1 } from "node:fs";
 import { access, mkdir, readFile, readdir, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
 import { readdir as readdir$1 } from "fs/promises";
-import { execFile, execFileSync } from "node:child_process";
+import { exec, execFile, execFileSync } from "node:child_process";
 import { promisify } from "node:util";
 import { exec as exec$1, execFile as execFile$1 } from "child_process";
 import { promisify as promisify$1 } from "util";
@@ -61,10 +66,11 @@ init_paths();
 init_errors();
 init_issue_id();
 init_projects();
-init_state_read_home();
 init_state_plane();
 init_auto_commit();
 init_record();
+init_tier_table();
+init_config_yaml();
 init_config();
 init_activity_logger();
 init_fs_lock();
@@ -73,19 +79,36 @@ init_tmux();
 init_persistent_logger();
 init_agents();
 init_internal_token();
+init_agent_runtime();
 init_conversations();
 init_runtime_command();
+init_control_settings();
 init_types();
 init_specs();
+init_types$1();
 init_io();
+init_dag();
+init_resolve_tier();
+init_spawn_prep();
 init_codex_auth();
 init_transcript_landing();
 init_config$1();
+init_memory_verdict_cache();
 init_swarm_slot_lifecycle();
 init_concurrency();
 init_state_dir_removal();
+init_state_home();
+init_termination();
+init_project_repos();
+init_registered_slot_spawn();
+init_spawn();
 init_messaging();
 init_context_overflow();
+init_pending_decision_gate();
+init_swarm_readiness();
+init_slot_reconcile();
+init_tier_feed();
+init_tier_supervisor();
 init_agents$1();
 init_agent_state();
 init_review_status_sync();
@@ -142,7 +165,7 @@ async function checkInspectAgentTimeouts(now = /* @__PURE__ */ new Date()) {
 			console.warn(`[deacon] Failed to kill inspect session ${sessionName}: ${msg}`);
 		});
 		try {
-			const { messageAgent } = await import("./agents-megfmQHM.js");
+			const { messageAgent } = await import("./agents-DixZjXWm.js");
 			await messageAgent(`agent-${issueId.toLowerCase()}`, verdict, "deacon:inspect-watchdog");
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
@@ -182,12 +205,12 @@ function paneShowsModelSwitch(pane, launchModel) {
 	}
 	return Boolean(target && target.toLowerCase() !== launchModel.toLowerCase());
 }
-const defaultDeps$3 = {
+const defaultDeps$7 = {
 	capturePane: (agentId) => Effect.runPromise(capturePane(agentId, 100)),
 	sendKey: (agentId, key) => sendKeysAsync(agentId, key, "known-modal-handler"),
 	settle: () => new Promise((resolve) => setTimeout(resolve, 300))
 };
-async function handleKnownAgentModal(agentId, deps = defaultDeps$3, initialPane) {
+async function handleKnownAgentModal(agentId, deps = defaultDeps$7, initialPane) {
 	const pane = initialPane ?? await deps.capturePane(agentId);
 	const modal = KNOWN_AGENT_MODALS.find((candidate) => candidate.matches(pane));
 	if (!modal) return "none";
@@ -280,7 +303,7 @@ const apiErrorRecoveryState = /* @__PURE__ */ new Map();
 * backend's own limit produces a hard 400 instead.
 */
 /** Continuation nudge sent after a successful harness /compact (specialist/planning sessions). */
-const CONTEXT_OVERFLOW_CONTINUE_MSG = "Your context was compacted to recover from a context-window overflow. Continue from where you left off using the compacted summary and your beads / continue.json — do NOT start over.";
+const CONTEXT_OVERFLOW_CONTINUE_MSG = "Your context was compacted to recover from a context-window overflow. Continue from where you left off using the compacted summary and your xBRIEF items / continue.json — do NOT start over.";
 /**
 * Let a recovery attempt finish before judging the result. MUST exceed the
 * patrol interval (60s): at exactly one interval the guard expires on the very
@@ -405,9 +428,9 @@ async function checkApiErrorAgents() {
 		}
 		if (!tmuxOutput.includes("❯")) continue;
 		try {
-			const { maybeContinueCompactedAgent } = await import("./compaction-continuation-D5voR1ME.js");
-			const { findLastCompactBoundary } = await import("./conversation-service-BxrB5lUT.js");
-			const { deliverAgentMessage } = await import("./delivery-cJM6zRjJ.js");
+			const { maybeContinueCompactedAgent } = await import("./compaction-continuation-CVjbdGKt.js");
+			const { findLastCompactBoundary } = await import("./conversation-service-BL-asWPX.js");
+			const { deliverAgentMessage } = await import("./delivery-DhZGRShH.js");
 			const continued = await maybeContinueCompactedAgent({
 				agentId: sessionName,
 				tmuxOutput,
@@ -458,13 +481,13 @@ async function checkApiErrorAgents() {
 							const st = getAgentStateSync(sessionName);
 							const sid = st?.sessionId ?? runtimeState?.claudeSessionId;
 							if (st?.workspace && sid && st.model) {
-								const { computeContextUsage } = await import("./conversation-service-BxrB5lUT.js");
+								const { computeContextUsage } = await import("./conversation-service-BL-asWPX.js");
 								const usage = await computeContextUsage(sessionFilePath(st.workspace, sid), st.model);
 								if (usage && usage.percentUsed < 85) recoveredPct = usage.percentUsed;
 							}
 						} catch {}
 						if (recoveredPct !== null) {
-							const { clearWorkspaceStuck } = await import("./review-status-sync-YthpOH_q.js");
+							const { clearWorkspaceStuck } = await import("./review-status-sync-CvpHWyvR.js");
 							clearWorkspaceStuck(issueId);
 							stuckOverflowNativeRecoveryState.delete(sessionName);
 							actions.push(`Context overflow recovery: cleared stuck flag for ${sessionName} (context back to ${Math.round(recoveredPct)}%)`);
@@ -480,7 +503,7 @@ async function checkApiErrorAgents() {
 					rec.attempts += 1;
 					rec.lastAttempt = now;
 					stuckOverflowNativeRecoveryState.set(sessionName, rec);
-					const { resumeAgent } = await import("./agents-megfmQHM.js");
+					const { resumeAgent } = await import("./agents-DixZjXWm.js");
 					const recovered = await resumeAgent(sessionName, void 0, { compact: true });
 					if (recovered.success) {
 						stuckOverflowNativeRecoveryState.delete(sessionName);
@@ -528,7 +551,7 @@ async function checkApiErrorAgents() {
 					}
 					const compactAttempts = (ov?.compactAttempts ?? 0) + 1;
 					if (issueId !== null) {
-						const { resumeAgent } = await import("./agents-megfmQHM.js");
+						const { resumeAgent } = await import("./agents-DixZjXWm.js");
 						const resumeResult = await resumeAgent(sessionName, void 0, { compact: true });
 						contextOverflowRecoveryState.set(sessionName, {
 							lastAttempt: now,
@@ -783,7 +806,7 @@ async function checkPostReviewCommits() {
 	const actions = [];
 	try {
 		const statuses = loadReviewStatuses();
-		const { resolveProjectFromIssueSync } = await import("./projects-DvPEAP18.js");
+		const { resolveProjectFromIssueSync } = await import("./projects-BMuEf14J.js");
 		for (const [issueId, status] of Object.entries(statuses)) {
 			const isBlocked = status.reviewStatus === "blocked";
 			if (!isBlocked) blockedReviewDriftObservations.delete(issueId);
@@ -815,8 +838,8 @@ async function checkPostReviewCommits() {
 			if (!project) continue;
 			const workspacePath = join$1(project.projectPath, "workspaces", `feature-${issueId.toLowerCase()}`);
 			if (!existsSync(workspacePath)) continue;
-			const { formatAnchorShort, rehydrateHeadAnchor } = await import("./git-utils-Y0zG25ez.js");
-			const { evaluateWorkspaceAnchorDrift } = await import("./workspace-anchor-drift-DTt6h2Em.js");
+			const { formatAnchorShort, rehydrateHeadAnchor } = await import("./git-utils-BAMwn9Nf.js");
+			const { evaluateWorkspaceAnchorDrift } = await import("./workspace-anchor-drift-Bpa3xoni.js");
 			const verdict = await evaluateWorkspaceAnchorDrift(issueId, workspacePath, rehydrateHeadAnchor(reviewedAnchor));
 			if (verdict.kind === "unreadable" || verdict.kind === "current") {
 				blockedReviewDriftObservations.delete(issueId);
@@ -834,7 +857,7 @@ async function checkPostReviewCommits() {
 					resetLoopEscalated.add(issueId);
 					const message = `${issueId} — review reset suppressed: drift against ${formatAnchorShort(currentHead)} already caused a reset and the workspace has not moved since. This indicates an anchor-producer disagreement, not new commits; review will not re-dispatch until the workspace head actually changes.`;
 					logDeaconEventSync(`checkPostReviewCommits: ${message}`);
-					const { recordDeadEndNeedsYou } = await import("./dead-end-trip-BWpDg1Qd.js");
+					const { recordDeadEndNeedsYou } = await import("./dead-end-trip-DUbiRMtT.js");
 					await recordDeadEndNeedsYou(issueId, "review-reset-loop", currentHead, message);
 				}
 				continue;
@@ -878,7 +901,7 @@ async function checkPostReviewCommits() {
 				actions.push(`Deferred post-review re-dispatch for ${issueId} — advancing-role concurrency ceiling reached`);
 				logDeaconEventSync(`checkPostReviewCommits: deferred review for ${issueId} — advancing ceiling reached (PAN-1665) — ${describeRunningAgents()}`);
 			} else if (freshStatus?.reviewStatus === "pending") {
-				const { spawnReviewRoleForIssue } = await import("./review-agent-BUNTVJK2.js");
+				const { spawnReviewRoleForIssue } = await import("./review-agent-Caodi0PX.js");
 				const branch = `feature/${issueId.toLowerCase()}`;
 				const dispatchResult = await Effect.runPromise(spawnReviewRoleForIssue({
 					issueId,
@@ -920,7 +943,7 @@ async function checkPostReviewCommits() {
 * of life regardless of tmux. The deacon's liveness arbiter consults this
 * before declaring an agent orphaned.
 */
-const execFileAsync$4 = promisify(execFile);
+const execFileAsync$5 = promisify(execFile);
 const defaultPgrep = (pattern) => {
 	try {
 		execFileSync("pgrep", ["-f", pattern], { stdio: [
@@ -935,7 +958,7 @@ const defaultPgrep = (pattern) => {
 };
 const defaultAsyncPgrep = async (pattern) => {
 	try {
-		await execFileAsync$4("pgrep", ["-f", pattern], { encoding: "utf8" });
+		await execFileAsync$5("pgrep", ["-f", pattern], { encoding: "utf8" });
 		return true;
 	} catch (error) {
 		if (typeof error === "object" && error !== null && "code" in error && error.code === 1) return false;
@@ -962,7 +985,7 @@ init_review_status();
 init_tmux();
 init_feedback_writer();
 init_feedback_target();
-const execFileAsync$3 = promisify(execFile);
+const execFileAsync$4 = promisify(execFile);
 function internalDashboardUrl() {
 	const port = Number.parseInt(process.env.API_PORT ?? process.env.PORT ?? "3011", 10);
 	return process.env.OVERDECK_INTERNAL_DASHBOARD_URL ?? `http://127.0.0.1:${port}`;
@@ -1042,14 +1065,14 @@ async function defaultIsStrikeAgentAlive(agentId) {
 		return true;
 	}
 }
-function defaultDeps$2() {
+function defaultDeps$6() {
 	return {
 		loadStatuses: loadReviewStatuses,
 		getStatus: getReviewStatusSync,
 		setStatus: setReviewStatusSync,
 		resolveProject: resolveProjectFromIssueSync,
 		mergeIssue: requestStrikeMerge,
-		getMainHead: async (projectPath) => (await execFileAsync$3("git", ["rev-parse", "origin/main"], {
+		getMainHead: async (projectPath) => (await execFileAsync$4("git", ["rev-parse", "origin/main"], {
 			cwd: projectPath,
 			encoding: "utf8"
 		})).stdout.trim(),
@@ -1071,7 +1094,7 @@ function defaultDeps$2() {
 		isScheduled: (key) => strikeLandingSupervisor.has(key),
 		isPersistentlyOwned: () => false,
 		listProjects: listProjectsAsync,
-		git: async (args, cwd) => (await execFileAsync$3("git", args, {
+		git: async (args, cwd) => (await execFileAsync$4("git", args, {
 			cwd,
 			encoding: "utf8"
 		})).stdout.trim(),
@@ -1273,7 +1296,7 @@ async function salvageStrandedStrikeBranches(deps) {
 }
 async function patrolStrikeLandings(overrides = {}) {
 	const deps = {
-		...defaultDeps$2(),
+		...defaultDeps$6(),
 		...overrides
 	};
 	const actions = await salvageStrandedStrikeBranches(deps);
@@ -1450,7 +1473,7 @@ function reviewConvoyLiveness(issueId) {
 */
 async function recoverUnhealthyTestStack(issueId, workspacePath) {
 	const key = issueId.toUpperCase();
-	const { getWorkspaceStackHealth } = await import("./stack-health-CbyiYS9H.js");
+	const { getWorkspaceStackHealth } = await import("./stack-health-Bz711z1Y.js");
 	const health = await Effect.runPromise(getWorkspaceStackHealth(issueId, { workspacePath }));
 	if (health.healthy) {
 		testStackRebuildState.delete(key);
@@ -1482,7 +1505,7 @@ async function recoverUnhealthyTestStack(issueId, workspacePath) {
 	record.attempts += 1;
 	testStackRebuildState.set(key, record);
 	console.log(`[deacon] Test stack for ${key} unhealthy (${health.reasons.join("; ")}) — rebuilding (attempt ${record.attempts}/${TEST_STACK_REBUILD_MAX_ATTEMPTS})`);
-	const { rebuildWorkspaceStack } = await import("./rebuild-stack-CCwKHZb6.js");
+	const { rebuildWorkspaceStack } = await import("./rebuild-stack-BcBVFJp3.js");
 	const result = await Effect.runPromise(rebuildWorkspaceStack(issueId, { onProgress: (m) => console.log(`[deacon]   ${key} stack rebuild: ${m}`) }));
 	if (!result.success) {
 		console.warn(`[deacon] Test stack rebuild failed for ${key}: ${result.error}`);
@@ -1668,7 +1691,7 @@ async function handleReviewCoordinatorDied(issueId, _sessionName, _reason) {
 		return actions;
 	}
 	try {
-		const { spawnReviewRoleForIssue } = await import("./review-agent-BUNTVJK2.js");
+		const { spawnReviewRoleForIssue } = await import("./review-agent-Caodi0PX.js");
 		const dispatchResult = await Effect.runPromise(spawnReviewRoleForIssue({
 			issueId,
 			workspace,
@@ -1743,7 +1766,7 @@ async function reconcileReviewStatusOrphan(issueId, rawStatus, options = {}) {
 		const issueLower = issueId.toLowerCase();
 		const workspace = getAgentStateSync(`agent-${issueLower}`)?.workspace || (resolved ? findWorkspacePath(resolved.projectPath, issueLower) : null);
 		if (workspace) try {
-			if ((options.readWorkspaceHead ? await options.readWorkspaceHead(workspace) : await (await import("./git-utils-Y0zG25ez.js")).snapshotWorkspaceHeadsPromise(issueId, workspace)) === status.lastVerifiedCommit) {
+			if ((options.readWorkspaceHead ? await options.readWorkspaceHead(workspace) : await (await import("./git-utils-BAMwn9Nf.js")).snapshotWorkspaceHeadsPromise(issueId, workspace)) === status.lastVerifiedCommit) {
 				setReviewStatusSync(issueId, {
 					reviewStatus: "pending",
 					reviewNotes: void 0
@@ -1765,7 +1788,7 @@ async function reconcileReviewStatusOrphan(issueId, rawStatus, options = {}) {
 				if (project) {
 					const workspacePath = join$1(project.projectPath, "workspaces", `feature-${issueId.toLowerCase()}`);
 					if (existsSync(workspacePath)) {
-						const { snapshotWorkspaceHeadsPromise } = await import("./git-utils-Y0zG25ez.js");
+						const { snapshotWorkspaceHeadsPromise } = await import("./git-utils-BAMwn9Nf.js");
 						reviewUpdate["reviewedAtCommit"] = await snapshotWorkspaceHeadsPromise(issueId, workspacePath);
 					}
 				}
@@ -1827,7 +1850,7 @@ async function reconcileReviewStatusOrphan(issueId, rawStatus, options = {}) {
 		const workspace = agentState?.workspace || (resolved ? findWorkspacePath(resolved.projectPath, issueLower) : null);
 		if (workspace && resolved && !tryReserveAdvancingSlot() && !await tryYieldForAdvancingDispatch("review", issueId)) actions.push(`Deferred review re-dispatch for ${issueId} — advancing-role concurrency ceiling reached`);
 		else if (workspace && resolved) try {
-			const { spawnReviewRoleForIssue } = await import("./review-agent-BUNTVJK2.js");
+			const { spawnReviewRoleForIssue } = await import("./review-agent-Caodi0PX.js");
 			const dispatchResult = await Effect.runPromise(spawnReviewRoleForIssue({
 				issueId,
 				workspace,
@@ -1852,8 +1875,8 @@ async function reconcileReviewStatusOrphan(issueId, rawStatus, options = {}) {
 		const workspace = agentState?.workspace || (resolved ? findWorkspacePath(resolved.projectPath, issueLower) : null);
 		if (workspace && resolved) {
 			const branch = `feature/${issueLower}`;
-			const { spawnRun } = await import("./agents-megfmQHM.js");
-			const { buildTestRolePrompt } = await import("./test-agent-queue-BUtWhNcc.js");
+			const { spawnRun } = await import("./agents-DixZjXWm.js");
+			const { buildTestRolePrompt } = await import("./test-agent-queue-Cu0D6BYe.js");
 			const stackRecovery = await recoverUnhealthyTestStack(issueId, workspace);
 			if (stackRecovery === "cooldown" || stackRecovery === "exhausted") {
 				setReviewStatusSync(issueId, { testStatus: "dispatch_failed" });
@@ -1992,7 +2015,7 @@ async function recoverStalledReviewConvoys(getCanonicalState = getAutoCloseOutCa
 		record.lastAttempt = now;
 		record.attempts += 1;
 		stalledReviewConvoyRecoveryState.set(key, record);
-		const { spawnReviewRoleForIssue } = await import("./review-agent-BUNTVJK2.js");
+		const { spawnReviewRoleForIssue } = await import("./review-agent-Caodi0PX.js");
 		try {
 			const result = await Effect.runPromise(spawnReviewRoleForIssue({
 				issueId,
@@ -2063,7 +2086,7 @@ async function checkMissingReviewStatuses() {
 				continue;
 			}
 			try {
-				const { spawnReviewRoleForIssue } = await import("./review-agent-BUNTVJK2.js");
+				const { spawnReviewRoleForIssue } = await import("./review-agent-Caodi0PX.js");
 				await Effect.runPromise(spawnReviewRoleForIssue({
 					issueId,
 					workspace,
@@ -2114,7 +2137,7 @@ async function checkStuckReviewing() {
 	const actions = [];
 	const REVIEW_STUCK_THRESHOLD_MS = 1800 * 1e3;
 	try {
-		const { loadReviewStatuses, setReviewStatusSync } = await import("./review-status-CUnjjOUu.js");
+		const { loadReviewStatuses, setReviewStatusSync } = await import("./review-status-Bge_3XTR.js");
 		const statuses = loadReviewStatuses();
 		const now = Date.now();
 		const activeReviewIssues = /* @__PURE__ */ new Set();
@@ -2273,7 +2296,7 @@ async function reconcileUnappliedReviewVerdicts() {
 				let currentHead;
 				let reviewedHead;
 				try {
-					const { rehydrateHeadAnchor, snapshotWorkspaceHeadsPromise } = await import("./git-utils-Y0zG25ez.js");
+					const { rehydrateHeadAnchor, snapshotWorkspaceHeadsPromise } = await import("./git-utils-BAMwn9Nf.js");
 					currentHead = await snapshotWorkspaceHeadsPromise(issueId, wsPath);
 					const persistedAnchor = reviewAnchorFromContext(latestContext);
 					reviewedHead = persistedAnchor ? rehydrateHeadAnchor(persistedAnchor) : void 0;
@@ -2297,7 +2320,7 @@ async function reconcileUnappliedReviewVerdicts() {
 						const notes = parsed.topBlocker || `See ${latestReport.filename}`;
 						const nudge = `Your review verdict is already written on disk but review status is still pending. Your ONLY remaining task is to execute this Bash command immediately — do not analyze, do not summarize, do not ask questions, just run it:\n\n${buildReviewCompletionCommand(issueId, parsed.verdict, notes, basename$1(latestDir))}\n\nRun this command NOW. Do not write any other response before executing it.`;
 						try {
-							const { messageAgent } = await import("./agents-megfmQHM.js");
+							const { messageAgent } = await import("./agents-DixZjXWm.js");
 							await messageAgent(reviewSession, nudge);
 							pendingVerdictNudges.set(latestDir, now);
 							const action = `Nudged ${reviewSession} to apply pending ${parsed.verdict} verdict from ${latestReport.filename}`;
@@ -2416,7 +2439,7 @@ async function checkCompletedButUnsignaledReviews() {
 				const cmd = buildReviewCompletionCommand(issueId, verdict, topBlocker || `See ${latestReport.filename}`, basename$1(latestDir));
 				const nudge = `Your review verdict in ${latestReport.filename} is already written and saved. Your ONLY remaining task is to execute this Bash command immediately — do not analyze, do not summarize, do not ask questions, just run it:\n\n${cmd}\n\nRun this command NOW. Do not write any other response before executing it.`;
 				try {
-					const { messageAgent } = await import("./agents-megfmQHM.js");
+					const { messageAgent } = await import("./agents-DixZjXWm.js");
 					await messageAgent(reviewSession, nudge);
 					unsignaledReviewNudges.set(latestDir, now);
 					actions.push(`Nudged ${reviewSession} to signal ${verdict} (${latestReport.filename} written ${Math.round((now - latestMtime) / 6e4)}min ago)`);
@@ -2521,7 +2544,7 @@ async function retryReviewer(state, agentId, trigger) {
 		return false;
 	}
 	try {
-		const { spawnReviewSubRoleForIssue } = await import("./review-agent-BUNTVJK2.js");
+		const { spawnReviewSubRoleForIssue } = await import("./review-agent-Caodi0PX.js");
 		const contextManifestPath = join$1(dirname$1(outputPath), "context.json");
 		const result = await Effect.runPromise(spawnReviewSubRoleForIssue({
 			issueId: state.issueId,
@@ -2607,11 +2630,11 @@ async function nudgeSynthesisForCompleteReviewerReports(states) {
 			writeFileSync(join$1(reviewDir, "synthesis.md"), synthesis.body);
 			let fallbackHead;
 			try {
-				const { snapshotWorkspaceHeadsPromise } = await import("./git-utils-Y0zG25ez.js");
+				const { snapshotWorkspaceHeadsPromise } = await import("./git-utils-BAMwn9Nf.js");
 				fallbackHead = await snapshotWorkspaceHeadsPromise(state.issueId, state.workspace);
 			} catch {}
 			const notes = synthesis.topBlocker || "Review approved by Deacon fallback from completed reviewer reports";
-			const { recordReviewVerdict } = await import("./review-verdict-writer-jldSh3Bm.js");
+			const { recordReviewVerdict } = await import("./review-verdict-writer-DjrJ64eS.js");
 			const outcome = await recordReviewVerdict(state.issueId, {
 				verdict: synthesis.verdict,
 				notes,
@@ -2652,7 +2675,7 @@ async function nudgeSynthesisForCompleteReviewerReports(states) {
 			"Read the four reports, write synthesis.md, then signal review status exactly as roles/review.md instructs."
 		].join("\n");
 		try {
-			const { messageAgent } = await import("./agents-megfmQHM.js");
+			const { messageAgent } = await import("./agents-DixZjXWm.js");
 			await messageAgent(state.id, message);
 			reviewReportsPresentNudges.set(nudgeKey, now);
 			const action = `Nudged ${state.id} to synthesize from ${REVIEW_SUB_ROLES.length} reviewer reports`;
@@ -2764,7 +2787,7 @@ async function monitorReviewConvoySignals() {
 		if (!signal) continue;
 		const message = signal === "ready" ? `REVIEWER_READY ${state.reviewSubRole} ${outputPath}` : signal === "timeout" ? `REVIEWER_TIMEOUT ${state.reviewSubRole} ${reason}` : `REVIEWER_FAILED ${state.reviewSubRole} ${reason}`;
 		try {
-			const { messageAgent } = await import("./agents-megfmQHM.js");
+			const { messageAgent } = await import("./agents-DixZjXWm.js");
 			await messageAgent(state.reviewSynthesisAgentId, message);
 			state.reviewMonitorSignaled = signal;
 			saveAgentStateSync(state);
@@ -2772,7 +2795,7 @@ async function monitorReviewConvoySignals() {
 			actions.push(action);
 			logDeaconEventSync(`monitorReviewConvoySignals: ${action}`);
 			if (signal === "ready") try {
-				const { notifyPipelineSync } = await import("./pipeline-notifier-C4fZ2ito.js");
+				const { notifyPipelineSync } = await import("./pipeline-notifier-B5DPXvnr.js");
 				notifyPipelineSync({
 					type: "reviewer_completed",
 					issueId: state.issueId,
@@ -2780,7 +2803,7 @@ async function monitorReviewConvoySignals() {
 				});
 			} catch {}
 			else if (signal === "timeout") try {
-				const { notifyPipelineSync } = await import("./pipeline-notifier-C4fZ2ito.js");
+				const { notifyPipelineSync } = await import("./pipeline-notifier-B5DPXvnr.js");
 				notifyPipelineSync({
 					type: "reviewer_timed_out",
 					issueId: state.issueId,
@@ -2889,8 +2912,8 @@ async function cleanupOrphanedReviewSessions() {
 async function checkStalledReviewParents() {
 	const actions = [];
 	try {
-		const { listAgentStates } = await import("./agents-megfmQHM.js");
-		const { PARENT_REVIEW_TIMEOUT_MS } = await import("./review-agent-BUNTVJK2.js");
+		const { listAgentStates } = await import("./agents-DixZjXWm.js");
+		const { PARENT_REVIEW_TIMEOUT_MS } = await import("./review-agent-Caodi0PX.js");
 		const states = listAgentStates();
 		const now = Date.now();
 		for (const state of states) {
@@ -2914,7 +2937,7 @@ async function checkStalledReviewParents() {
 				paneTail: paneTail.split("\n").filter(Boolean).slice(-5).join(" | ").slice(0, 400)
 			};
 			try {
-				const { markWorkspaceStuck } = await import("./review-status-CUnjjOUu.js");
+				const { markWorkspaceStuck } = await import("./review-status-Bge_3XTR.js");
 				markWorkspaceStuck(state.issueId, "review_parent_stalled_needs_you", {
 					reason: `Review parent ${state.id} is past its review deadline with no verdict on record`,
 					...evidence
@@ -2926,7 +2949,7 @@ async function checkStalledReviewParents() {
 			actions.push(message);
 			logDeaconEventSync(message);
 			try {
-				const { emitActivityEntrySync } = await import("./activity-logger-BejO16Am.js");
+				const { emitActivityEntrySync } = await import("./activity-logger-B0X2JJwM.js");
 				emitActivityEntrySync({
 					source: "review",
 					level: "warn",
@@ -2957,9 +2980,1564 @@ function hasTerminalVerdictOfRecord(state) {
 	}
 }
 //#endregion
-//#region ../../lib/cloister/boot-reconciliation-predicates.ts
-init_control_settings();
+//#region ../../lib/agents/slot-merge.ts
 init_traefik_connect();
+const execAsync$5 = promisify(exec);
+async function verifyAndMergeSlot(issue, slotIndex, item, options = {}) {
+	const issueId = typeof issue === "string" ? issue : issue.issueId;
+	const featureWorkspace = typeof issue === "string" ? defaultRunWorkspace(issue) : issue.featureWorkspace ?? defaultRunWorkspace(issue.issueId);
+	const slotWorkspace = typeof issue === "string" ? `${featureWorkspace}-slot-${slotIndex}` : issue.slotWorkspace ?? `${featureWorkspace}-slot-${slotIndex}`;
+	const slotBranch = typeof issue === "string" ? `feature/${issueId.toLowerCase()}-slot-${slotIndex}` : issue.slotBranch ?? `feature/${issueId.toLowerCase()}-slot-${slotIndex}`;
+	const deps = {
+		run: async (command, cwd) => execAsync$5(command, { cwd }),
+		resolveRepoRoots: resolveWorkspaceRepoRootsSync,
+		...options.deps
+	};
+	const verifyCommands = item.metadata?.verify_commands ?? [];
+	const expectedOutputs = item.metadata?.expected_outputs ?? [];
+	const evidence = {
+		verifyCommands,
+		expectedOutputs,
+		commandOutputs: []
+	};
+	if (!Number.isInteger(slotIndex) || slotIndex < 1) return {
+		verified: false,
+		merged: false,
+		conflicts: false,
+		evidence,
+		failure: `Invalid slot index: ${slotIndex}`
+	};
+	if (verifyCommands.length === 0) return {
+		verified: false,
+		merged: false,
+		conflicts: false,
+		evidence,
+		failure: `Item ${item.id} has no verify_commands`
+	};
+	if (expectedOutputs.length === 0) return {
+		verified: false,
+		merged: false,
+		conflicts: false,
+		evidence,
+		failure: `Item ${item.id} has no expected_outputs`
+	};
+	for (const command of verifyCommands) try {
+		const output = await deps.run(command, slotWorkspace);
+		evidence.commandOutputs.push({
+			command,
+			stdout: output.stdout,
+			stderr: output.stderr
+		});
+	} catch (error) {
+		const failed = commandFailure(error);
+		evidence.commandOutputs.push({
+			command,
+			stdout: failed.stdout,
+			stderr: failed.stderr
+		});
+		return {
+			verified: false,
+			merged: false,
+			conflicts: false,
+			evidence,
+			failure: `Verify command failed for ${item.id}: ${command}`
+		};
+	}
+	const slotRoots = deps.resolveRepoRoots(issueId, slotWorkspace);
+	if (slotRoots.some((root) => root.degradedPolyrepo)) return {
+		verified: true,
+		merged: false,
+		conflicts: false,
+		evidence,
+		failure: `Could not resolve polyrepo roots for slot ${slotIndex} — refusing to infer a merge`
+	};
+	const aheadByRepo = /* @__PURE__ */ new Map();
+	for (const root of slotRoots) aheadByRepo.set(root.repoKey, await aheadCount(deps.run, root.dir, root.sourceBranch, slotBranch));
+	const rootsWithWork = slotRoots.filter((root) => (aheadByRepo.get(root.repoKey) ?? 0) > 0);
+	if (rootsWithWork.length === 0) return {
+		verified: true,
+		merged: false,
+		conflicts: false,
+		evidence,
+		failure: `Slot branch ${slotBranch} has no unmerged current-item changes in any repo — refusing to mark item ${item.id} merged`
+	};
+	if (!slotRoots.some((root) => root.isPolyrepo)) try {
+		evidence.mergeOutput = await deps.run(`git merge --no-ff ${JSON.stringify(slotBranch)}`, featureWorkspace);
+		return {
+			verified: true,
+			merged: true,
+			conflicts: false,
+			evidence
+		};
+	} catch (error) {
+		const failed = commandFailure(error);
+		evidence.mergeOutput = {
+			stdout: failed.stdout,
+			stderr: failed.stderr
+		};
+		await deps.run("git merge --abort", featureWorkspace).catch(() => {});
+		return {
+			verified: true,
+			merged: false,
+			conflicts: true,
+			evidence,
+			failure: `Slot branch ${slotBranch} did not merge cleanly`
+		};
+	}
+	const baseRoots = new Map(deps.resolveRepoRoots(issueId, featureWorkspace).map((root) => [root.repoKey, root]));
+	const repoMergeOutputs = [];
+	for (const root of rootsWithWork) {
+		const baseRoot = baseRoots.get(root.repoKey);
+		if (!baseRoot) return {
+			verified: true,
+			merged: false,
+			conflicts: false,
+			evidence: {
+				...evidence,
+				repoMergeOutputs
+			},
+			failure: `No base feature-workspace checkout for repo ${root.repoKey} — cannot integrate slot ${slotIndex}`
+		};
+		try {
+			const output = await deps.run(`git merge --no-ff ${JSON.stringify(slotBranch)}`, baseRoot.dir);
+			repoMergeOutputs.push({
+				repoKey: root.repoKey,
+				stdout: output.stdout,
+				stderr: output.stderr
+			});
+		} catch (error) {
+			const failed = commandFailure(error);
+			repoMergeOutputs.push({
+				repoKey: root.repoKey,
+				stdout: failed.stdout,
+				stderr: failed.stderr
+			});
+			await deps.run("git merge --abort", baseRoot.dir).catch(() => {});
+			return {
+				verified: true,
+				merged: false,
+				conflicts: true,
+				evidence: {
+					...evidence,
+					repoMergeOutputs
+				},
+				failure: `Slot branch ${slotBranch} did not merge cleanly into ${root.repoKey}`
+			};
+		}
+	}
+	return {
+		verified: true,
+		merged: true,
+		conflicts: false,
+		evidence: {
+			...evidence,
+			repoMergeOutputs
+		}
+	};
+}
+/** Count base..branch commits in one repo; a missing branch or repo means zero. */
+async function aheadCount(run, cwd, baseBranch, branch) {
+	try {
+		const { stdout } = await run(`git rev-list --count ${JSON.stringify(baseBranch)}..${JSON.stringify(branch)}`, cwd);
+		const count = Number(stdout.trim());
+		return Number.isFinite(count) && count > 0 ? count : 0;
+	} catch {
+		return 0;
+	}
+}
+function commandFailure(error) {
+	const partial = error;
+	return {
+		stdout: typeof partial.stdout === "string" ? partial.stdout : "",
+		stderr: typeof partial.stderr === "string" ? partial.stderr : typeof partial.message === "string" ? partial.message : String(error)
+	};
+}
+//#endregion
+//#region ../../lib/pan-dir/task-door.ts
+/** Single task-mutation write door over the immutable xBRIEF specification. */
+var TaskStatusChangeError = class extends Error {
+	constructor(message, details) {
+		super(message);
+		this.details = details;
+		this.name = "TaskStatusChangeError";
+	}
+};
+const TERMINAL = new Set(["completed", "cancelled"]);
+function statusFor(type) {
+	if (type === "claim") return "running";
+	if (type === "done") return "completed";
+	if (type === "block") return "blocked";
+	if (type === "unblock") return "pending";
+	if (type === "reopen") return "pending";
+	return "cancelled";
+}
+function subItemOverrideKey(itemId, subItemId) {
+	return subItemId.includes(".") ? subItemId : `${itemId}.${subItemId}`;
+}
+function allowedFrom(type, status) {
+	if (type === "claim") return status === "pending";
+	if (type === "done") return status === "running";
+	if (type === "block") return status === "pending" || status === "running";
+	if (type === "unblock") return status === "blocked";
+	if (type === "reopen") return status === "completed";
+	return status === "pending" || status === "running" || status === "blocked";
+}
+function taskError(issueId, itemId, operation, currentStatus, owner, extra) {
+	const ownerText = owner ? ` The current claim owner is ${owner}.` : "";
+	const recovery = `Run \`pan task show ${issueId} ${itemId}\` to inspect the current task state before retrying.`;
+	return new TaskStatusChangeError(`Task ${itemId} on ${issueId} is ${currentStatus}, so ${operation} is not allowed.${ownerText}${extra ? ` ${extra}` : ""} ${recovery}`, {
+		issueId,
+		itemId,
+		operation,
+		currentStatus,
+		owner
+	});
+}
+function archiveClaim(record, itemId, outcome, reason, forced, now) {
+	const claim = record.tasks?.claims[itemId];
+	if (!claim || !record.tasks) return;
+	const entry = {
+		...claim,
+		itemId,
+		outcome,
+		reason,
+		forced: forced || void 0,
+		releasedAt: now
+	};
+	record.tasks.claimHistory = [...record.tasks.claimHistory ?? [], entry].slice(-50);
+	delete record.tasks.claims[itemId];
+}
+async function applyTaskStatusChange(project, issueId, operation) {
+	const normalizedIssueId = issueId.toUpperCase();
+	const writerId = operation.writerId ?? process.env.OVERDECK_AGENT_ID ?? `cli-${process.pid}@${hostname()}`;
+	let result;
+	await updateIssueRecord(project, normalizedIssueId, (record) => {
+		const planPath = findPlanSync(join(project.path, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`));
+		if (!planPath) throw new Error(`The xBRIEF for ${normalizedIssueId} is missing or unreadable. Return the issue to planning before changing task state.`);
+		const item = applyStatusOverrides(readPlanSync(planPath), record.statusOverrides ?? {}).plan.items.find(({ id }) => id === operation.itemId);
+		if (!item) throw new Error(`Task ${operation.itemId} does not exist in the immutable xBRIEF for ${normalizedIssueId}. Return the issue to planning to change scope.`);
+		const currentStatus = item.status;
+		const currentSequence = record.tasks?.sequence ?? 0;
+		const existingClaim = record.tasks?.claims[operation.itemId];
+		const nextStatus = statusFor(operation.type);
+		const subItems = subItemsOf(item);
+		const subIds = operation.subItemIds?.length ? new Set(operation.subItemIds) : new Set(operation.type === "done" || operation.type === "cancel" || operation.type === "reopen" ? subItems.map(({ id }) => id) : []);
+		const repeatedCancellation = operation.type === "cancel" && currentStatus === "cancelled";
+		if (operation.expectedSequence !== void 0 && operation.expectedSequence !== currentSequence) throw new TaskStatusChangeError(`Task sequence conflict for ${normalizedIssueId}: expected ${operation.expectedSequence}, but the current sequence is ${currentSequence}. Run \`pan task next ${normalizedIssueId}\` and retry with the new sequence.`, {
+			issueId: normalizedIssueId,
+			itemId: operation.itemId,
+			operation: operation.type,
+			currentStatus,
+			currentSequence
+		});
+		if (TERMINAL.has(currentStatus) && !repeatedCancellation && operation.type !== "reopen") throw taskError(normalizedIssueId, operation.itemId, operation.type, currentStatus, existingClaim?.writerId);
+		if (operation.force && !operation.reason) throw taskError(normalizedIssueId, operation.itemId, operation.type, currentStatus, existingClaim?.writerId, "A forced transition requires --reason.");
+		if ((operation.type === "block" || operation.type === "cancel" || operation.type === "reopen") && !operation.reason) throw taskError(normalizedIssueId, operation.itemId, operation.type, currentStatus, existingClaim?.writerId, "This transition requires --reason.");
+		if (repeatedCancellation && subItems.every((subItem) => subItem.status === "cancelled")) {
+			result = {
+				issueId: normalizedIssueId,
+				itemId: operation.itemId,
+				status: "cancelled",
+				sequence: currentSequence,
+				idempotent: true
+			};
+			return record;
+		}
+		if (operation.type === "claim" && currentStatus === "running" && existingClaim?.writerId === writerId) {
+			result = {
+				issueId: normalizedIssueId,
+				itemId: operation.itemId,
+				status: "running",
+				sequence: currentSequence,
+				claim: existingClaim,
+				idempotent: true
+			};
+			return record;
+		}
+		const ownerRestricted = (operation.type === "done" || operation.type === "block" || operation.type === "cancel") && currentStatus === "running";
+		if (!operation.force && ownerRestricted && existingClaim?.writerId !== writerId) throw taskError(normalizedIssueId, operation.itemId, operation.type, currentStatus, existingClaim?.writerId ?? "missing claim owner");
+		if (!operation.force && !repeatedCancellation && !allowedFrom(operation.type, currentStatus)) throw taskError(normalizedIssueId, operation.itemId, operation.type, currentStatus, existingClaim?.writerId);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		record.tasks ??= {
+			sequence: 0,
+			claims: {}
+		};
+		record.statusOverrides = {
+			...record.statusOverrides ?? {},
+			[operation.itemId]: nextStatus
+		};
+		for (const subId of subIds) record.statusOverrides[subItemOverrideKey(operation.itemId, subId)] = nextStatus;
+		if (operation.type === "claim") record.tasks.claims[operation.itemId] = {
+			writerId,
+			agentId: process.env.OVERDECK_AGENT_ID ?? null,
+			pid: process.pid,
+			host: hostname(),
+			claimedAt: now
+		};
+		else if (existingClaim) archiveClaim(record, operation.itemId, nextStatus === "completed" ? "completed" : nextStatus === "blocked" ? "blocked" : "cancelled", operation.reason, operation.force ?? false, now);
+		if (operation.reason) record.tasks.statusReasons = {
+			...record.tasks.statusReasons ?? {},
+			[operation.itemId]: {
+				reason: operation.reason,
+				updatedAt: now,
+				forced: operation.force || void 0
+			}
+		};
+		record.tasks.sequence = currentSequence + 1;
+		result = {
+			issueId: normalizedIssueId,
+			itemId: operation.itemId,
+			status: nextStatus,
+			sequence: record.tasks.sequence,
+			claim: record.tasks.claims[operation.itemId]
+		};
+		return record;
+	}, { writerId });
+	if (!result) throw new Error(`Task mutation for ${normalizedIssueId}/${operation.itemId} produced no result.`);
+	return result;
+}
+//#endregion
+//#region ../../lib/swarm-policy.ts
+init_projects();
+function resolveSwarmPolicyLayers(global = {}, project = {}, issue = {}, cli = {}) {
+	const resolve = (key, fallback) => {
+		for (const [source, layer] of [
+			["cli", cli],
+			["issue", issue],
+			["project", project],
+			["global", global]
+		]) if (layer[key] !== void 0) return {
+			value: layer[key],
+			source
+		};
+		return {
+			value: fallback,
+			source: "default"
+		};
+	};
+	const mode = resolve("mode", "off");
+	const maxSlots = resolve("maxSlots", 3);
+	const autoAdvance = resolve("autoAdvance", true);
+	return {
+		mode: mode.value,
+		maxSlots: maxSlots.value,
+		autoAdvance: autoAdvance.value,
+		source: {
+			mode: mode.source,
+			maxSlots: maxSlots.source,
+			autoAdvance: autoAdvance.source
+		}
+	};
+}
+function resolveSwarmPolicy(issueId, cli = {}) {
+	const global = loadConfigSync().config.swarm;
+	if (!issueId) return resolveSwarmPolicyLayers(global, {}, {}, cli);
+	const resolved = resolveProjectFromIssueSync(issueId);
+	const project = resolved ? getProjectSync(resolved.projectKey) : void 0;
+	const issue = project ? readIssueRecordSync(project, issueId)?.swarm?.policy : void 0;
+	return resolveSwarmPolicyLayers(global, project?.swarm, issue, cli);
+}
+function resolveAutomaticSwarmPolicy(issueId, swarmEligible, manual = false) {
+	const policy = resolveSwarmPolicy(issueId);
+	return {
+		policy,
+		spawnForeman: manual || policy.mode !== "off" && swarmEligible,
+		requireSwarmReadiness: policy.mode === "always",
+		advanceWavesWithoutConfirmation: policy.autoAdvance,
+		reason: manual ? "manual" : policy.mode === "off" ? "mode-off" : swarmEligible ? "eligible" : "not-ready"
+	};
+}
+//#endregion
+//#region ../../lib/cloister/deacon-workspaces.ts
+init_projects();
+function listFeatureWorkspaces(options = {}) {
+	const includeSlotWorkspaces = options.includeSlotWorkspaces ?? true;
+	const projects = listProjectsSync();
+	const workspaces = [];
+	for (const { config: projectConfig } of projects) {
+		const workspacesRoot = join$1(projectConfig.path, "workspaces");
+		if (!existsSync(workspacesRoot)) continue;
+		let entries;
+		try {
+			entries = readdirSync(workspacesRoot, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("feature-")).filter((e) => includeSlotWorkspaces || !/-slot-\d+$/.test(e.name)).map((e) => e.name);
+		} catch {
+			continue;
+		}
+		for (const entry of entries) workspaces.push({
+			issueId: entry.replace(/^feature-/, "").toUpperCase(),
+			workspacePath: join$1(workspacesRoot, entry),
+			projectPath: projectConfig.path
+		});
+	}
+	return workspaces;
+}
+//#endregion
+//#region ../../lib/cloister/deacon-swarm-orphan-gc.ts
+/**
+* Reconcile GC for truly-orphaned slots (PAN-2214, completes PAN-2213(c)).
+*
+* An orphan is a slot index with an on-disk worktree or a local slot branch but
+* no slotAssignments entry and no live agent tmux session. Zero-commit-ahead
+* orphans are removed; orphans with unmerged commits are only reported so the
+* operator can push them via `pan swarm reset` — never deleted.
+*/
+async function gcOrphanedSlots(issueId, workspacePath, reconciled, deps) {
+	const actions = [];
+	const issueLower = issueId.toLowerCase();
+	const worktreeSlotIndexes = await listSlotWorktreeIndexes(workspacePath, deps.runGitCommand);
+	const branchesBySlot = new Map(reconciled.branches.map((branch) => [branch.slotIndex, branch.branch]));
+	const candidateSlotIndexes = [...new Set([...worktreeSlotIndexes, ...branchesBySlot.keys()])].sort((a, b) => a - b);
+	if (candidateSlotIndexes.length === 0) return actions;
+	const ownedSlotIndexes = new Set([
+		...(deps.listSlotAssignments ?? listSlotAssignments)(issueId, workspacePath).map((assignment) => assignment.slotIndex),
+		...reconciled.merged.map((slot) => slot.slotIndex),
+		...reconciled.inFlight.map((slot) => slot.slotIndex)
+	]);
+	const sessionNames = new Set(await deps.listSessionNames());
+	for (const slotIndex of candidateSlotIndexes) {
+		if (ownedSlotIndexes.has(slotIndex)) continue;
+		if (sessionNames.has(`agent-${issueLower}-slot-${slotIndex}`)) continue;
+		const branch = branchesBySlot.get(slotIndex);
+		const aheadCount = branch ? await countCommitsAhead$1(workspacePath, branch, deps.runGitCommand) : 0;
+		if (aheadCount === null || aheadCount > 0) {
+			actions.push(`[swarm] orphan slot ${slotIndex} for ${issueId} preserved: ${branch} has ${aheadCount ?? "an unknown number of"} unmerged commit(s) — run \`pan swarm reset ${issueId}\` to push it to origin before cleanup`);
+			continue;
+		}
+		if (worktreeSlotIndexes.has(slotIndex)) await deps.runGitCommand(`git worktree remove --force ${JSON.stringify(`${workspacePath}-slot-${slotIndex}`)}`, workspacePath);
+		if (branch) await deps.runGitCommand(`git branch -D ${JSON.stringify(branch)}`, workspacePath);
+		actions.push(`[swarm] gc-orphan slot ${slotIndex} for ${issueId}`);
+	}
+	return actions;
+}
+async function listSlotWorktreeIndexes(workspacePath, runGitCommand) {
+	const indexes = /* @__PURE__ */ new Set();
+	try {
+		const result = await runGitCommand("git worktree list --porcelain", workspacePath);
+		const pattern = new RegExp(`^worktree ${escapeRegExp(workspacePath)}-slot-(\\d+)$`);
+		for (const line of String(result?.stdout ?? "").split("\n")) {
+			const match = pattern.exec(line.trim());
+			if (match) indexes.add(Number(match[1]));
+		}
+	} catch {}
+	return indexes;
+}
+async function countCommitsAhead$1(workspacePath, branch, runGitCommand) {
+	try {
+		const result = await runGitCommand(`git rev-list --count HEAD..${JSON.stringify(branch)}`, workspacePath);
+		const count = Number(String(result?.stdout ?? "").trim());
+		return Number.isFinite(count) ? count : null;
+	} catch {
+		return null;
+	}
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region ../../lib/cloister/deacon-swarm-record.ts
+init_record();
+init_record_update();
+function readSwarmHold(workspacePath, issueId) {
+	return readIssueRecordForWorkspaceSync(workspacePath, issueId.toUpperCase())?.swarm?.hold;
+}
+async function writeSwarmHold(workspacePath, issueId, hold) {
+	await updateIssueRecordForWorkspace(workspacePath, issueId.toUpperCase(), (record) => ({
+		...record,
+		swarm: {
+			...record.swarm ?? {},
+			hold
+		}
+	}));
+}
+function readSwarmCompletionObservation(workspacePath, issueId, progressKey) {
+	return readIssueRecordForWorkspaceSync(workspacePath, issueId.toUpperCase())?.swarm?.completionObservations?.[progressKey];
+}
+async function writeSwarmCompletionObservation(workspacePath, issueId, progressKey, observation) {
+	await updateIssueRecordForWorkspace(workspacePath, issueId.toUpperCase(), (record) => ({
+		...record,
+		swarm: {
+			...record.swarm ?? {},
+			completionObservations: {
+				...record.swarm?.completionObservations ?? {},
+				[progressKey]: observation
+			}
+		}
+	}));
+}
+async function clearSwarmCompletionObservationRecord(workspacePath, issueId, progressKey) {
+	await updateIssueRecordForWorkspace(workspacePath, issueId.toUpperCase(), (record) => {
+		const existing = record.swarm?.completionObservations;
+		if (!existing?.[progressKey]) return record;
+		const completionObservations = { ...existing };
+		delete completionObservations[progressKey];
+		return {
+			...record,
+			swarm: {
+				...record.swarm ?? {},
+				completionObservations
+			}
+		};
+	});
+}
+async function writeSwarmForemanTakeover(workspacePath, issueId, itemId, slotIndex) {
+	await updateIssueRecordForWorkspace(workspacePath, issueId.toUpperCase(), (record) => ({
+		...record,
+		swarm: {
+			...record.swarm ?? {},
+			reclaimedItems: {
+				...record.swarm?.reclaimedItems ?? {},
+				[itemId]: {
+					slotIndex,
+					reclaimedAt: (/* @__PURE__ */ new Date()).toISOString()
+				}
+			}
+		}
+	}));
+}
+/**
+* PAN-2372 WI-3 / FR-6: clear a slot's completion marker once the coordinator
+* (WI-4) has consumed it (merge/requeue). No-op when no marker exists for the
+* slot, so callers can clear unconditionally on the terminal transition.
+*/
+async function clearSwarmSlotCompletion(workspacePath, issueId, slotIndex) {
+	const normalizedIssueId = issueId.toUpperCase();
+	const current = readIssueRecordForWorkspaceSync(workspacePath, normalizedIssueId);
+	if (!current?.swarm?.slotCompletions || !(String(slotIndex) in current.swarm.slotCompletions)) return;
+	await updateIssueRecordForWorkspace(workspacePath, normalizedIssueId, (record) => {
+		const existing = record.swarm?.slotCompletions;
+		if (!existing || !(String(slotIndex) in existing)) return record;
+		const next = { ...existing };
+		delete next[String(slotIndex)];
+		return {
+			...record,
+			swarm: {
+				...record.swarm,
+				slotCompletions: next
+			}
+		};
+	});
+}
+/**
+* Consume all durable ownership for a slot in one record update. Merged-slot
+* GC uses this after it removes the worktree and branch so a completion marker
+* cannot outlive the assignment and keep the freed index occupied.
+*/
+async function clearSwarmSlotOwnership(workspacePath, issueId, slotIndex, _itemId) {
+	await updateIssueRecordForWorkspace(workspacePath, issueId.toUpperCase(), (record) => {
+		const swarm = record.swarm ?? {};
+		const slotAssignments = (swarm.slotAssignments ?? []).filter((assignment) => assignment.slotIndex !== slotIndex);
+		const slotCompletions = { ...swarm.slotCompletions ?? {} };
+		delete slotCompletions[String(slotIndex)];
+		return {
+			...record,
+			swarm: {
+				...swarm,
+				slotAssignments,
+				slotCompletions
+			}
+		};
+	});
+}
+async function clearReleasedBlockedSwarmSlot(workspacePath, issueId, slotIndex) {
+	await updateIssueRecordForWorkspace(workspacePath, issueId.toUpperCase(), (record) => {
+		const releasedBlockedSlots = { ...record.swarm?.releasedBlockedSlots ?? {} };
+		delete releasedBlockedSlots[String(slotIndex)];
+		return {
+			...record,
+			swarm: {
+				...record.swarm ?? {},
+				releasedBlockedSlots
+			}
+		};
+	});
+}
+//#endregion
+//#region ../../lib/cloister/deacon-swarm-completion.ts
+init_messaging();
+init_project_repos();
+init_config$1();
+const execAsync$4 = promisify(exec);
+async function classifyDoneWithoutSignal(slot, deps, options, observation) {
+	if ((options.inferCompletion ?? "off") === "off" || !slot.agentId || !slot.branch || !options.workspacePath || !options.issueId) {
+		if (options.workspacePath && options.issueId) await (deps.clearCompletionObservation ?? clearSwarmCompletionObservationRecord)(options.workspacePath, options.issueId, observation.progressKey);
+		return null;
+	}
+	const aheadCount = await (deps.getSlotBranchAheadCount ?? defaultGetSlotBranchAheadCount)(options.workspacePath, options.issueId, slot.branch).catch(() => 0);
+	const clean = await (deps.isSlotWorktreeClean ?? defaultIsSlotWorktreeClean)(`${options.workspacePath}-slot-${slot.slotIndex}`).catch(() => false);
+	if (aheadCount < 1 || !clean) {
+		await (deps.clearCompletionObservation ?? clearSwarmCompletionObservationRecord)(options.workspacePath, options.issueId, observation.progressKey);
+		return null;
+	}
+	const signature = `${observation.commitTime ?? "none"}:${observation.outputDigest}:${aheadCount}:clean`;
+	const previous = (deps.readCompletionObservation ?? readSwarmCompletionObservation)(options.workspacePath, options.issueId, observation.progressKey);
+	const current = {
+		signature,
+		nudged: previous?.signature === signature ? previous.nudged : false,
+		consecutiveDoneCount: previous?.signature === signature ? previous.consecutiveDoneCount + 1 : 1
+	};
+	const actions = [];
+	const normalizedIssueId = options.issueId.toUpperCase();
+	if (!current.nudged) {
+		if (deps.sendCompletionNudge) await deps.sendCompletionNudge(slot.agentId, normalizedIssueId);
+		current.nudged = true;
+		actions.push(`[swarm] nudged slot ${slot.slotIndex} (item ${slot.itemId}) for ${normalizedIssueId}: run pan done ${normalizedIssueId}`);
+	}
+	await (deps.writeCompletionObservation ?? writeSwarmCompletionObservation)(options.workspacePath, options.issueId, observation.progressKey, current);
+	return {
+		...slot,
+		lifecycle: "awaiting-completion-signal",
+		reason: "no-progress-timeout",
+		stalledForMs: observation.stalledForMs,
+		signal: "completion-nudge",
+		actions
+	};
+}
+async function classifyDurableReadySlot(slot, deps, options) {
+	if (!slot.branch || !options.workspacePath || !options.issueId) return null;
+	if (await (deps.getSlotBranchAheadCount ?? defaultGetSlotBranchAheadCount)(options.workspacePath, options.issueId, slot.branch).catch(() => 0) < 1) return null;
+	if (!await (deps.isSlotWorktreeClean ?? defaultIsSlotWorktreeClean)(`${options.workspacePath}-slot-${slot.slotIndex}`).catch(() => false)) return null;
+	return {
+		...slot,
+		lifecycle: "ready-to-merge",
+		exitStatus: 0,
+		signal: "inferred"
+	};
+}
+async function clearSwarmCompletionObservation(workspacePath, issueId, progressKey, deps) {
+	await (deps.clearCompletionObservation ?? clearSwarmCompletionObservationRecord)(workspacePath, issueId, progressKey);
+}
+async function defaultGetSlotBranchAheadCount(workspacePath, issueId, branch) {
+	const baseBranch = `feature/${issueId.toLowerCase()}`;
+	const roots = resolveWorkspaceRepoRootsSync(issueId, branch.match(/-slot-(\d+)(?:-attempt-\d+)?$/) ? `${workspacePath}-slot-${branch.match(/-slot-(\d+)(?:-attempt-\d+)?$/)[1]}` : workspacePath);
+	let total = 0;
+	for (const root of roots) {
+		if (root.degradedPolyrepo) return 0;
+		const { stdout } = await execAsync$4(`git rev-list --count ${JSON.stringify(baseBranch)}..${JSON.stringify(branch)}`, { cwd: root.dir });
+		if (!/^\d+$/.test(stdout.trim())) return 0;
+		total += Number(stdout.trim());
+	}
+	return total;
+}
+async function defaultIsSlotWorktreeClean(slotWorkspacePath) {
+	const match = /feature-([a-z]+-\d+)-slot-\d+$/.exec(slotWorkspacePath);
+	const roots = match ? resolveWorkspaceRepoRootsSync(match[1].toUpperCase(), slotWorkspacePath) : [];
+	if (roots.some((root) => root.degradedPolyrepo)) return false;
+	return (roots.length > 0 ? await Promise.all(roots.map((root) => execAsync$4("git status --porcelain", { cwd: root.dir }).then((result) => result.stdout))) : [(await execAsync$4("git status --porcelain", { cwd: slotWorkspacePath })).stdout]).every(isStatePlaneOnlyStatus);
+}
+async function defaultSendCompletionNudge(agentId, issueId) {
+	await messageAgent(agentId, `You appear to have committed clean slot work but have not signaled completion. If the slot is complete, run exactly:\n\npan done ${issueId}`, "deacon:swarm-completion-inference");
+}
+//#endregion
+//#region ../../lib/cloister/deacon-swarm-gc.ts
+init_agent_state();
+init_project_repos();
+const MERGED_LIVE_SLOT_IDLE_MS = 1800 * 1e3;
+async function gcMergedSlots(issueId, workspacePath, slots, deps) {
+	return (await gcMergedSlotsWithStatus(issueId, workspacePath, slots, deps)).actions;
+}
+async function gcMergedSlotsWithStatus(issueId, workspacePath, slots, deps) {
+	const actions = [];
+	const uncleared = [];
+	const sessionNames = new Set(await deps.listSessionNames());
+	const worktreeExists = deps.slotWorktreeExists ?? existsSync$1;
+	for (const slot of slots) {
+		if (slot.status !== "merged") continue;
+		const agentId = slot.agentId ?? `agent-${issueId.toLowerCase()}-slot-${slot.slotIndex}`;
+		let reapAction = null;
+		if (sessionNames.has(agentId)) {
+			const completionProven = slot.mergedVia === "completed-status";
+			const lastActivity = (deps.getAgentLastActivity ?? ((id) => getAgentStateSync(id)?.lastActivity))(agentId);
+			const idleFor = lastActivity ? Date.now() - Date.parse(lastActivity) : 0;
+			if (!completionProven && (!Number.isFinite(idleFor) || idleFor < MERGED_LIVE_SLOT_IDLE_MS)) {
+				actions.push(`[swarm] gc skipped slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}: agent session alive`);
+				uncleared.push(slot);
+				continue;
+			}
+			reapAction = completionProven ? `[swarm] gc reaped merged agent ${agentId}` : `[swarm] gc reaped idle merged agent ${agentId}`;
+		}
+		const slotWorkspace = `${workspacePath}-slot-${slot.slotIndex}`;
+		const slotBranch = slot.branch ?? `feature/${issueId.toLowerCase()}-slot-${slot.slotIndex}`;
+		if (worktreeExists(slotWorkspace)) {
+			if (!await removeSlotWorkspace(issueId, workspacePath, slotWorkspace, slotBranch, slot, deps, actions)) {
+				uncleared.push(slot);
+				continue;
+			}
+		}
+		const branchExists = await slotBranchExists(deps.runGitCommand, workspacePath, slotBranch);
+		if (branchExists === null) {
+			actions.push(`[swarm] gc deferred slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}: branch state of ${slotBranch} could not be determined`);
+			uncleared.push(slot);
+			continue;
+		}
+		if (branchExists) try {
+			await deps.runGitCommand(`git branch -D ${JSON.stringify(slotBranch)}`, workspacePath);
+		} catch (error) {
+			actions.push(`[swarm] gc deferred slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}: branch delete failed: ${error instanceof Error ? error.message : String(error)}`);
+			uncleared.push(slot);
+			continue;
+		}
+		await deps.clearSlotAssignment(workspacePath, issueId, slot.slotIndex, slot.itemId);
+		if (reapAction) try {
+			await (deps.stopSlotAgent ?? ((id) => Effect.runPromise(stopAgent(id))))(agentId);
+			actions.push(reapAction);
+		} catch (error) {
+			actions.push(`[swarm] could not reap merged agent ${agentId}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		actions.push(`[swarm] gc slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}`);
+	}
+	return {
+		actions,
+		uncleared
+	};
+}
+/**
+* Whether the outer workspace has a local `slotBranch`, or null when that
+* cannot be determined. `git branch --list` exits 0 with empty output for an
+* absent branch, so a throw is always an indeterminate state, never "absent".
+*/
+async function slotBranchExists(runGitCommand, workspacePath, slotBranch) {
+	try {
+		const result = await runGitCommand(`git branch --list ${JSON.stringify(slotBranch)}`, workspacePath);
+		return String(result?.stdout ?? "").trim().length > 0;
+	} catch {
+		return null;
+	}
+}
+/**
+* Remove a merged slot's workspace (PAN-3686). A polyrepo slot workspace is an
+* aggregate directory whose registered git worktrees are the nested sub-repo
+* checkouts (<slot>/fe, <slot>/api, …), each owned by a different parent
+* repository. Git cannot remove the aggregate root while nested worktrees
+* live inside it ("Directory not empty"), so every nested worktree is
+* detached through the workspace abstraction first, in its owning parent
+* repo.
+*
+* Cleanup is atomic in intent: a read-only preflight proves every nested repo
+* safe AND removable, and decides the aggregate root's removal route, before
+* the first mutation. Discovering an unsafe or unremovable nested checkout
+* after an earlier one was already detached is the Tier-1 partial-cleanup
+* defect the preflight exists to prevent (PAN-3686 post-deploy review). Any
+* preflight failure defers the whole slot with zero removals.
+*
+* Never discards unmerged or locally-modified nested work. PAN-3695: a slot
+* that reached merged status with unmerged nested branches is INTEGRATED here,
+* not just deferred — each unmerged nested slot branch is merged through the
+* canonical nested merge path (`git merge --no-ff` into the per-repo base
+* feature-workspace checkout, same as verifyAndMergeSlot) and ancestry is
+* re-verified repo by repo before any removal. A repo whose merge is pending
+* or failed defers the whole slot with an actionable repo-specific reason;
+* successful per-repo merges are preserved and the next pass retries the rest.
+* Uncommitted nested changes still defer the slot untouched.
+*/
+async function removeSlotWorkspace(issueId, workspacePath, slotWorkspace, slotBranch, slot, deps, actions) {
+	const defer = (reason) => {
+		actions.push(`[swarm] gc deferred slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}: ${reason}`);
+		return false;
+	};
+	const { isPolyrepo, nested } = (deps.listSlotWorkspaceWorktrees ?? resolveSlotWorkspaceWorktreesSync)(issueId, slotWorkspace);
+	if (nested.length > 0) {
+		const mergeFailures = await mergeNestedSlotBranches(issueId, workspacePath, slotBranch, nested, deps);
+		if (mergeFailures.length > 0) return defer(`nested merge incomplete: ${mergeFailures.join("; ")}`);
+	}
+	for (const worktree of nested) {
+		const blocked = await nestedWorktreeDirtyReason(deps.runGitCommand, worktree);
+		if (blocked) return defer(`preserving nested work: ${blocked}`);
+	}
+	for (const worktree of nested) {
+		const registered = await isRegisteredWorktree(deps.runGitCommand, worktree.parentRepo, worktree.dir);
+		if (registered === null) return defer(`${worktree.repoKey}: worktree registration in parent repo could not be determined`);
+		if (!registered) return defer(`${worktree.repoKey}: nested worktree is not registered in its parent repo (an earlier partial cleanup may have detached it); run pan swarm reset ${issueId}`);
+	}
+	const aggregateRegistered = await isRegisteredWorktree(deps.runGitCommand, workspacePath, slotWorkspace);
+	if (aggregateRegistered === null) return defer("aggregate worktree registration could not be determined");
+	const detached = [];
+	for (const worktree of nested) {
+		try {
+			await deps.runGitCommand(`git worktree remove --force ${JSON.stringify(worktree.dir)}`, worktree.parentRepo);
+			detached.push(worktree.repoKey);
+		} catch (error) {
+			const partial = detached.length > 0 ? ` (already detached: ${detached.join(", ")})` : "";
+			return defer(`nested worktree remove failed in ${worktree.repoKey}${partial}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		try {
+			await deps.runGitCommand(`git branch -D ${JSON.stringify(slotBranch)}`, worktree.parentRepo);
+		} catch (error) {
+			actions.push(`[swarm] gc note slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}: nested branch ${slotBranch} delete failed in ${worktree.repoKey}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	if (!aggregateRegistered && isPolyrepo) try {
+		await (deps.removeDirectory ?? ((path) => rm(path, {
+			recursive: true,
+			force: true
+		})))(slotWorkspace);
+		return true;
+	} catch (rmError) {
+		return defer(`aggregate directory remove failed: ${rmError instanceof Error ? rmError.message : String(rmError)}`);
+	}
+	try {
+		await deps.runGitCommand(`git worktree remove --force ${JSON.stringify(slotWorkspace)}`, workspacePath);
+		return true;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (isPolyrepo && /is not a working tree/.test(message)) try {
+			await (deps.removeDirectory ?? ((path) => rm(path, {
+				recursive: true,
+				force: true
+			})))(slotWorkspace);
+			return true;
+		} catch (rmError) {
+			return defer(`aggregate directory remove failed: ${rmError instanceof Error ? rmError.message : String(rmError)}`);
+		}
+		return defer(`worktree remove failed: ${message}`);
+	}
+}
+/**
+* Whether `worktreeDir` is a registered worktree of the repository at
+* `repoDir`, or null when the registration state cannot be determined. The
+* porcelain list always names at least the repository's own main worktree, so
+* a response with no `worktree` lines is an anomaly, not proof of "absent".
+* Shared with `pan swarm reset` (PAN-3713), which must distinguish an
+* already-unregistered nested worktree (the desired postcondition) from a
+* genuine removal failure.
+*/
+async function isRegisteredWorktree(runGitCommand, repoDir, worktreeDir) {
+	try {
+		const result = await runGitCommand("git worktree list --porcelain", repoDir);
+		const paths = String(result?.stdout ?? "").split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.slice(9).trim());
+		if (paths.length === 0) return null;
+		return paths.includes(worktreeDir);
+	} catch {
+		return null;
+	}
+}
+/**
+* Merge every nested slot branch that still has commits its per-repo feature
+* branch lacks, through the canonical nested merge path (PAN-3695): the merge
+* runs in the repo's base feature-workspace checkout, then ancestry is
+* re-verified by re-counting `featureBranch..slotBranch` — a merge command
+* exiting 0 is not proof the slot head landed — and the parent feature branch
+* is pushed to origin so the work actually leaves the machine. A dirty base
+* checkout refuses the merge, and a missing or degraded base checkout fails
+* the repo outright — without it, remote durability cannot be verified, even
+* when the local feature branch already contains the slot head. Every repo is
+* attempted even after a sibling fails, so successful merges are preserved and
+* only the failed repos are retried on the next pass. Returns the per-repo
+* failure reasons; an empty list means every nested repo's slot branch is an
+* ancestor of its pushed feature branch.
+*/
+async function mergeNestedSlotBranches(issueId, workspacePath, slotBranch, nested, deps) {
+	const failures = [];
+	const baseRoots = new Map((deps.listFeatureWorkspaceRepoRoots ?? resolveWorkspaceRepoRootsSync)(issueId, workspacePath).map((root) => [root.repoKey, root]));
+	for (const worktree of nested) {
+		const ahead = await countCommitsAhead(deps.runGitCommand, worktree.parentRepo, worktree.featureBranch, slotBranch);
+		if (ahead === null) {
+			failures.push(`${worktree.repoKey}: merge state of ${slotBranch} against ${worktree.featureBranch} could not be determined`);
+			continue;
+		}
+		const baseRoot = baseRoots.get(worktree.repoKey);
+		if (!baseRoot || baseRoot.degradedPolyrepo) {
+			failures.push(ahead > 0 ? `${worktree.repoKey}: no base feature-workspace checkout for ${worktree.featureBranch} — cannot merge ${slotBranch} (${ahead} unmerged commit(s))` : `${worktree.repoKey}: no base feature-workspace checkout for ${worktree.featureBranch} — cannot verify and push remote durability`);
+			continue;
+		}
+		if (ahead > 0) {
+			const baseDirty = await baseCheckoutDirtyReason(deps.runGitCommand, worktree, baseRoot, slotBranch);
+			if (baseDirty) {
+				failures.push(baseDirty);
+				continue;
+			}
+			try {
+				await deps.runGitCommand(`git merge --no-ff ${JSON.stringify(slotBranch)}`, baseRoot.dir);
+			} catch (error) {
+				await deps.runGitCommand("git merge --abort", baseRoot.dir).catch(() => {});
+				failures.push(`${worktree.repoKey}: ${slotBranch} did not merge cleanly into ${worktree.featureBranch}: ${error instanceof Error ? error.message : String(error)}`);
+				continue;
+			}
+			const remaining = await countCommitsAhead(deps.runGitCommand, worktree.parentRepo, worktree.featureBranch, slotBranch);
+			if (remaining !== 0) {
+				failures.push(`${worktree.repoKey}: ancestry verification failed — ${slotBranch} still has ${remaining ?? "an unknown number of"} commit(s) not in ${worktree.featureBranch} after merge`);
+				continue;
+			}
+		}
+		const unpushed = await countCommitsAhead(deps.runGitCommand, baseRoot.dir, `origin/${worktree.featureBranch}`, worktree.featureBranch);
+		if (ahead > 0 || unpushed === null || unpushed > 0) try {
+			await deps.runGitCommand(`git push origin ${JSON.stringify(worktree.featureBranch)}`, baseRoot.dir);
+		} catch (error) {
+			failures.push(`${worktree.repoKey}: merged ${slotBranch} into ${worktree.featureBranch} but push to origin failed: ${error instanceof Error ? error.message : String(error)}`);
+			continue;
+		}
+	}
+	return failures;
+}
+/**
+* Why a base feature-workspace checkout must not receive a merge right now, or
+* null when it is clean. Tracked local modifications block the merge (git would
+* refuse or, worse, entangle someone's uncommitted work); untracked files do
+* not, so they are ignored here.
+*/
+async function baseCheckoutDirtyReason(runGitCommand, worktree, baseRoot, slotBranch) {
+	try {
+		const status = await runGitCommand("git status --porcelain --untracked-files=no", baseRoot.dir);
+		if (String(status?.stdout ?? "").trim().length > 0) return `${worktree.repoKey}: base feature checkout of ${worktree.featureBranch} has uncommitted changes — refusing to merge ${slotBranch}`;
+	} catch {
+		return `${worktree.repoKey}: base feature checkout state of ${worktree.featureBranch} could not be determined — refusing to merge ${slotBranch}`;
+	}
+	return null;
+}
+/**
+* Why a nested slot worktree must be preserved, or null when it is safe to
+* remove. Any tracked change or non-ignored untracked file blocks removal
+* (ignored build artifacts do not). Merge state is handled separately by
+* mergeNestedSlotBranches before this runs.
+*/
+async function nestedWorktreeDirtyReason(runGitCommand, worktree) {
+	try {
+		const status = await runGitCommand("git status --porcelain --untracked-files=all", worktree.dir);
+		if (String(status?.stdout ?? "").trim().length > 0) return `${worktree.repoKey}: worktree has uncommitted changes`;
+	} catch {
+		return `${worktree.repoKey}: worktree status could not be determined`;
+	}
+	return null;
+}
+async function countCommitsAhead(runGitCommand, parentRepo, featureBranch, slotBranch) {
+	try {
+		const result = await runGitCommand(`git rev-list --count ${JSON.stringify(featureBranch)}..${JSON.stringify(slotBranch)}`, parentRepo);
+		const stdout = String(result?.stdout ?? "").trim();
+		if (!/^\d+$/.test(stdout)) return null;
+		return Number(stdout);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region ../../lib/cloister/swarm-tiered-hooks.ts
+/**
+* PAN-2385 — tiered-execution commit hooks for the swarm dispatch path.
+*
+* The tier-feed and tier-supervisor libraries shipped with PAN-1791/2222 but
+* had no production caller: commits landed and neither the standing crew nor
+* the subscribe-policy supervisor ever heard about them (found live during
+* the first Standing Crew run, PAN-2383). This module is the ignition.
+*
+* Fired from mergeReadySlots after a slot's bead commits merge into the
+* feature workspace:
+*   1. broadcastCommit — every live slot agent hears the rendered diff
+*      (ingestion-only; everyone-hears-everything per docs/TIERED-EXECUTION.md).
+*   2. shouldSupervise(item, subscribe) → deliverCommitForReview — the
+*      standing supervisor reviews per its subscribe policy. This is
+*      independent of supervisor.owns_inspection, which only routes
+*      `pan inspect`.
+*
+* Both hooks are best-effort: the commit has already landed, so a delivery
+* failure logs loudly and never blocks the merge loop.
+*/
+init_tmux();
+init_config_yaml();
+init_slot_reconcile();
+const execAsync$3 = promisify(exec);
+const defaultDeps$5 = {
+	loadConfig: loadConfigSync,
+	getHeadSha: async (workspacePath) => (await execAsync$3("git rev-parse HEAD", { cwd: workspacePath })).stdout.trim(),
+	listAssignments: listSlotAssignments,
+	isSessionAlive: (sessionName) => Effect.runPromise(sessionExists(sessionName)),
+	broadcast: broadcastCommit,
+	ensureSupervisor: spawnTierSupervisor,
+	deliverReview: deliverCommitForReview,
+	loadPrd: loadPrdDraft
+};
+/** Resolve the tier name a bead belongs to, for the feed header. Falls back to
+* the slot label when the tier table cannot resolve the item (fail-open here is
+* correct: the feed is informational and the commit has already landed). */
+function tierNameForItem(item, tiered, slotIndex) {
+	if (item) try {
+		return resolveTier(item, tiered).tierName;
+	} catch {}
+	return `slot-${slotIndex}`;
+}
+/**
+* Fire the commit feed + supervisor review for a bead whose commits just
+* merged into the feature workspace. Returns deacon action-log lines.
+*/
+async function fireTieredCommitHooks(options, deps = defaultDeps$5) {
+	const actions = [];
+	const { issueId, workspacePath, item, doc } = options;
+	let tiered;
+	try {
+		tiered = deps.loadConfig().config.tieredExecution;
+	} catch (err) {
+		actions.push(`[tiered] skipped commit hooks for ${issueId}: config load failed (${err instanceof Error ? err.message : String(err)})`);
+		return actions;
+	}
+	if (!tiered || !resolveTieredExecutionEnabled(tiered, doc.plan.metadata)) return actions;
+	let sha;
+	try {
+		sha = await deps.getHeadSha(workspacePath);
+	} catch (err) {
+		actions.push(`[tiered] commit hooks for ${issueId} item ${item.id} could not resolve HEAD: ${err instanceof Error ? err.message : String(err)}`);
+		return actions;
+	}
+	try {
+		const itemsById = new Map(doc.plan.items.map((planItem) => [planItem.id, planItem]));
+		const assignments = deps.listAssignments(issueId, workspacePath);
+		const listeners = [];
+		for (const assignment of assignments) {
+			if (!assignment.agentId) continue;
+			if (!await deps.isSessionAlive(assignment.agentId)) continue;
+			listeners.push({
+				tierName: tierNameForItem(itemsById.get(assignment.itemId), tiered, assignment.slotIndex),
+				agentId: assignment.agentId
+			});
+		}
+		if (listeners.length > 0) {
+			const delivered = (await deps.broadcast({
+				workspace: workspacePath,
+				issueId,
+				sha,
+				itemTitle: item.title,
+				itemId: item.id,
+				tiers: listeners,
+				feedConfig: tiered.feed
+			})).filter((delivery) => delivery.result.ok).length;
+			actions.push(`[tiered] broadcast commit ${sha.slice(0, 10)} (item ${item.id}) for ${issueId} to ${delivered}/${listeners.length} standing agents`);
+		}
+	} catch (err) {
+		actions.push(`[tiered] feed broadcast FAILED for ${issueId} item ${item.id}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	try {
+		const supervisor = tiered.supervisor;
+		if (supervisor && shouldSupervise(item, supervisor.subscribe)) {
+			const agentId = supervisorAgentId(issueId);
+			if (!await deps.isSessionAlive(agentId)) {
+				await deps.ensureSupervisor(issueId, supervisor, { workspace: workspacePath });
+				actions.push(`[tiered] spawned standing supervisor ${agentId} for ${issueId}`);
+			}
+			const prdMarkdown = await deps.loadPrd(workspacePath, issueId).catch(() => void 0);
+			await deps.deliverReview({
+				supervisorAgentId: agentId,
+				workspacePath,
+				issueId,
+				item,
+				sha,
+				itemId: item.id,
+				prdMarkdown
+			});
+			actions.push(`[tiered] supervisor review dispatched for ${issueId} item ${item.id} (subscribe=${supervisor.subscribe})`);
+		}
+	} catch (err) {
+		actions.push(`[tiered] supervisor review FAILED for ${issueId} item ${item.id}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	return actions;
+}
+//#endregion
+//#region ../../lib/cloister/redrive-gate.ts
+init_recovery_trip();
+/**
+* PAN-2543 shared autonomous re-drive gate.
+*
+* Recovery entry points classify agent gates, apply the intent policy, and
+* consult the cached memory verdict through this one function before acting.
+* Callers still reserve their role-specific concurrency slot after admission.
+*/
+init_agent_state();
+function decideAutonomousRedrive(state, context = {}) {
+	const gateDecision = decideResumeGate(getAgentResumeGateBlockReason(state), "autonomous", context);
+	if (gateDecision.decision !== "proceed") return {
+		decision: "defer",
+		reason: gateDecision.reason,
+		...gateDecision.decision === "block" && gateDecision.needsYou ? { needsYou: true } : {}
+	};
+	const memoryVerdict = getCachedMemoryVerdict();
+	if (memoryVerdict && memoryVerdict.band !== "ok") return {
+		decision: "defer",
+		reason: `memory pressure is ${memoryVerdict.band}`
+	};
+	return {
+		decision: "proceed",
+		gateDecision
+	};
+}
+async function decideAgentAutonomousRedrive(state, agentDir, owesRework, deps = {}) {
+	const admission = decideAutonomousRedrive(state, {
+		hasCompletedHandoff: existsSync$1(join(agentDir, "completed")) || existsSync$1(join(agentDir, "completed.processed")),
+		owesRework
+	});
+	if (admission.decision === "defer") return admission;
+	const agentId = basename(agentDir);
+	const pendingDecision = await (deps.detectPendingOperatorDecision ?? detectPendingOperatorDecision)(agentId);
+	if (pendingDecision) return {
+		decision: "defer",
+		reason: `agent is waiting on an operator decision (${pendingDecision.reason})`,
+		needsYou: true
+	};
+	return admission;
+}
+//#endregion
+//#region ../../lib/cloister/swarm-failed-slot.ts
+init_record_update();
+init_agent_state();
+//#endregion
+//#region ../../lib/cloister/swarm-blocked-slot.ts
+init_project_repos();
+const execFileAsync$3 = promisify(execFile);
+async function prepareReleasedSwarmSlot(issueId, workspacePath, slotIndex, itemId, branch) {
+	await ensureRegisteredSlotWorktree(issueId, workspacePath, {
+		agentId: `agent-${issueId.toLowerCase()}-slot-${slotIndex}`,
+		branch,
+		workspace: `${workspacePath}-slot-${slotIndex}`,
+		slotIndex,
+		slotItemId: itemId
+	});
+}
+async function defaultIsSlotBranchPushed(workspacePath, issueId, branch) {
+	const slotIndex = branch.match(/-slot-(\d+)(?:-attempt-\d+)?$/)?.[1];
+	if (!slotIndex) return false;
+	const roots = resolveWorkspaceRepoRootsSync(issueId, `${workspacePath}-slot-${slotIndex}`);
+	if (roots.length === 0 || roots.some((root) => root.degradedPolyrepo)) return false;
+	try {
+		return (await Promise.all(roots.map(async (root) => {
+			await refreshDurableSlotRef(root.dir, branch);
+			return true;
+		}))).every(Boolean);
+	} catch {
+		return false;
+	}
+}
+/** Preserve a blocked attempt and provision a unique branch identity for slot reuse. */
+async function archiveBlockedSwarmSlot(issueId, workspacePath, slotIndex, branch, now = /* @__PURE__ */ new Date()) {
+	const releasedAt = now.toISOString();
+	const suffix = releasedAt.replace(/[-:.TZ]/g, "");
+	const slotWorkspace = `${workspacePath}-slot-${slotIndex}`;
+	const archivedWorktree = `${slotWorkspace}-blocked-${suffix}`;
+	const archivedBranch = `${branch}-blocked-${suffix}`;
+	const replacementBranch = `feature/${issueId.toLowerCase()}-slot-${slotIndex}-attempt-${suffix}`;
+	const slotRoots = resolveWorkspaceRepoRootsSync(issueId, slotWorkspace);
+	const baseRoots = new Map(resolveWorkspaceRepoRootsSync(issueId, workspacePath).map((root) => [root.repoKey, root]));
+	if (slotRoots.length === 0 || slotRoots.some((root) => root.degradedPolyrepo)) throw new Error(`Cannot archive blocked slot ${slotIndex}: repository roots are unavailable.`);
+	for (const root of slotRoots) await execFileAsync$3("git", [
+		"push",
+		"origin",
+		`${await refreshDurableSlotRef(root.dir, branch)}:refs/heads/${archivedBranch}`
+	], { cwd: root.dir });
+	await rename(slotWorkspace, archivedWorktree);
+	for (const root of slotRoots) {
+		const baseRoot = baseRoots.get(root.repoKey);
+		if (!baseRoot) throw new Error(`Cannot archive blocked slot ${slotIndex}: missing base repository ${root.repoKey}.`);
+		const nestedPath = relative(slotWorkspace, root.dir);
+		const archivedRoot = nestedPath ? resolve(archivedWorktree, nestedPath) : archivedWorktree;
+		await execFileAsync$3("git", [
+			"worktree",
+			"repair",
+			archivedRoot
+		], { cwd: baseRoot.dir });
+		await execFileAsync$3("git", [
+			"branch",
+			archivedBranch,
+			branch
+		], { cwd: baseRoot.dir });
+		await execFileAsync$3("git", ["switch", archivedBranch], { cwd: archivedRoot });
+	}
+	return {
+		archivedBranch,
+		archivedWorktree,
+		replacementBranch,
+		releasedAt
+	};
+}
+async function refreshDurableSlotRef(workspace, branch) {
+	const remoteRef = `refs/remotes/origin/${branch}`;
+	await execFileAsync$3("git", [
+		"fetch",
+		"--no-tags",
+		"origin",
+		`+refs/heads/${branch}:${remoteRef}`
+	], { cwd: workspace });
+	await execFileAsync$3("git", [
+		"merge-base",
+		"--is-ancestor",
+		`refs/heads/${branch}`,
+		remoteRef
+	], { cwd: workspace });
+	return remoteRef;
+}
+//#endregion
+//#region ../../lib/cloister/swarm-foreman.ts
+init_messaging();
+init_projects();
+init_tmux();
+init_work_agent_prompt();
+const defaultDeps$4 = {
+	listSessionNamesSync: () => listSessionNamesSync(),
+	messageAgent,
+	buildWorkAgentPrompt,
+	spawnRun,
+	resolveProjectFromIssueSync
+};
+async function ensureSwarmForeman(issueId, workspacePath, options, deps = defaultDeps$4) {
+	const issue = issueId.toUpperCase();
+	const agentId = `agent-${issue.toLowerCase()}`;
+	if (deps.listSessionNamesSync().includes(agentId)) {
+		await deps.messageAgent(agentId, options.prompt ?? `Continue managing ${issue} as its swarm foreman. Run pan swarm status ${issue} --json before acting.`, "pan-swarm");
+		return [`[swarm] attached to live foreman ${agentId} for ${issue}`];
+	}
+	const basePrompt = await deps.buildWorkAgentPrompt({
+		issueId: issue,
+		env: "LOCAL",
+		workspacePath,
+		projectRoot: deps.resolveProjectFromIssueSync(issue)?.projectPath
+	});
+	return [`[swarm] spawned foreman ${(await deps.spawnRun(issue, "work", {
+		workspace: workspacePath,
+		prompt: options.prompt ? `${basePrompt}\n\n${options.prompt}` : basePrompt,
+		foreman: true,
+		startedBy: options.startedBy
+	})).id} for ${issue}`];
+}
+//#endregion
+//#region ../../lib/cloister/swarm-foreman-liveness.ts
+init_activity_logger();
+init_slot_reconcile();
+init_concurrency();
+const defaultDeps$3 = {
+	listSlotAssignments,
+	readSwarmHold,
+	workResumeSlotsAvailable,
+	ensureSwarmForeman,
+	writeSwarmHold,
+	emitActivityEntry: emitActivityEntrySync
+};
+const respawnFailures = /* @__PURE__ */ new Map();
+async function maintainSwarmForeman(issueId, workspacePath, reconciled, sessions, overrides = {}, allowSpawn = true, bootstrap = false) {
+	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, value]) => value !== void 0));
+	const deps = {
+		...defaultDeps$3,
+		...definedOverrides
+	};
+	const issueLower = issueId.toLowerCase();
+	if (!allowSpawn) return [];
+	const mergedSlotIndexes = new Set(reconciled.merged.map((slot) => slot.slotIndex));
+	if (!(bootstrap || sessions.some((name) => name.startsWith(`agent-${issueLower}-slot-`)) || reconciled.branches.some((branch) => !mergedSlotIndexes.has(branch.slotIndex)) || deps.listSlotAssignments(issueId, workspacePath).length > 0)) {
+		respawnFailures.delete(issueId);
+		return [];
+	}
+	if (sessions.includes(`agent-${issueLower}`) || deps.readSwarmHold(workspacePath, issueId)) return [];
+	if (deps.workResumeSlotsAvailable() <= 0) return [`[swarm-janitor] deferred foreman respawn for ${issueId}: resource governor`];
+	const failures = respawnFailures.get(issueId) ?? 0;
+	if (failures >= 3) return [];
+	try {
+		const prompt = `Resume ${issueId} swarm foreman duties: read .pan/continue.json, run pan swarm status ${issueId} --json, reconcile current state, then continue the wave loop.`;
+		const actions = await deps.ensureSwarmForeman(issueId, workspacePath, {
+			startedBy: "deacon:swarm-janitor",
+			prompt
+		});
+		respawnFailures.delete(issueId);
+		return actions;
+	} catch (error) {
+		const count = failures + 1;
+		respawnFailures.set(issueId, count);
+		const actions = [`[swarm-janitor] foreman respawn failed for ${issueId} (${count}/3): ${error instanceof Error ? error.message : String(error)}`];
+		if (count < 3) return actions;
+		const message = `${issueId} swarm halted after 3 consecutive foreman respawn failures; operator action is required.`;
+		await deps.writeSwarmHold(workspacePath, issueId, {
+			reason: message,
+			setBy: "deacon:swarm-janitor",
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		deps.emitActivityEntry({
+			source: "cloister",
+			level: "error",
+			issueId,
+			message
+		});
+		actions.push(`[swarm-janitor] ${message}`);
+		return actions;
+	}
+}
+//#endregion
+//#region ../../lib/cloister/deacon-swarm.ts
+init_messaging();
+init_spawn();
+init_slot_reconcile();
+init_record();
+init_record_update();
+init_tmux();
+init_io();
+init_review_status();
+init_concurrency();
+const execAsync$2 = promisify(exec);
+const DEFAULT_SWARM_STALL_THRESHOLD_MS = 1800 * 1e3;
+const slotProgressObservations = /* @__PURE__ */ new Map();
+const defaultDeps$2 = {
+	findSpecByIssue,
+	listFeatureWorkspaces: () => listFeatureWorkspaces({ includeSlotWorkspaces: false }),
+	reconcileSlotState,
+	listSessionNames: () => Effect.runPromise(listSessionNames()),
+	isPaneDead: (sessionName) => Effect.runPromise(isPaneDead(sessionName)),
+	getPaneExitStatus: async (sessionName) => {
+		const raw = (await Effect.runPromise(listPaneValues(sessionName, "#{pane_dead_status}")))[0]?.trim();
+		if (!raw) return null;
+		const status = Number(raw);
+		return Number.isFinite(status) ? status : null;
+	},
+	getAgentRuntimeState: (agentId) => Effect.runPromise(getAgentRuntimeSnapshot(agentId)),
+	getPaneOutputDigest: async (sessionName) => Effect.runPromise(capturePane(sessionName, 200)),
+	getBranchTipCommitTime: async (workspacePath, branch) => {
+		try {
+			const { stdout } = await execAsync$2(`git log -1 --format=%ct ${JSON.stringify(branch)}`, { cwd: workspacePath });
+			const seconds = Number(stdout.trim());
+			return Number.isFinite(seconds) ? seconds * 1e3 : null;
+		} catch {
+			return null;
+		}
+	},
+	getSlotBranchAheadCount: defaultGetSlotBranchAheadCount,
+	isSlotWorktreeClean: defaultIsSlotWorktreeClean,
+	isSlotBranchPushed: defaultIsSlotBranchPushed,
+	archiveBlockedSlot: archiveBlockedSwarmSlot,
+	prepareReleasedSlot: prepareReleasedSwarmSlot,
+	sendCompletionNudge: defaultSendCompletionNudge,
+	slotWorktreeExists: existsSync$1,
+	verifyAndMergeSlot,
+	applyTaskOperationToPlanFile: (issueId, operation, workspacePath = "") => {
+		return applyTaskStatusChange(resolveProjectForIssue(issueId) ?? getProjectConfigFromWorkspacePath(workspacePath), issueId, operation);
+	},
+	fireTieredCommitHooks,
+	recordSlotAssignment,
+	clearSlotAssignment,
+	runGitCommand: (command, cwd) => execAsync$2(command, { cwd }),
+	registeredSlotCapacityAvailable: (issueId, selectedCount) => registeredSlotCapacityAvailable(issueId, selectedCount),
+	tryReserveSwarmSlot,
+	releaseSwarmSlot,
+	spawnRun,
+	getIssueHold: defaultGetIssueHold,
+	shouldDispatch: defaultShouldDispatch,
+	readSwarmHold,
+	getMaxSlotIndex: defaultGetMaxSlotIndex,
+	listSlotAssignments,
+	listReleasedSlotIndexes: (issueId, workspacePath) => Object.keys(readIssueRecordForWorkspaceSync(workspacePath, issueId)?.swarm?.releasedBlockedSlots ?? {}).map(Number),
+	getReleasedSlotBranch: (issueId, workspacePath, slotIndex) => readIssueRecordForWorkspaceSync(workspacePath, issueId)?.swarm?.releasedBlockedSlots?.[String(slotIndex)]?.replacementBranch,
+	clearReleasedSlot: clearReleasedBlockedSwarmSlot,
+	readStatusOverrides: defaultReadStatusOverrides,
+	readSlotCompletion: defaultReadSlotCompletion,
+	clearSlotCompletion: clearSwarmSlotCompletion,
+	recordForemanTakeover: writeSwarmForemanTakeover,
+	ensureSwarmForeman,
+	sendStallEvent: (agentId, message) => messageAgent(agentId, message, "deacon:swarm-stall"),
+	resolveAutomaticSwarmPolicy
+};
+function defaultGetMaxSlotIndex() {
+	return Math.max(1, getConcurrencyLimits().reservedSwarmSlots);
+}
+function defaultGetIssueHold(issueId) {
+	try {
+		return getReviewStatusSync(issueId);
+	} catch {
+		return null;
+	}
+}
+function defaultReadStatusOverrides(workspacePath, issueId) {
+	const normalized = issueId.toUpperCase();
+	const record = readIssueRecordForWorkspaceSync(workspacePath, normalized);
+	if (record === null && existsSync$1(getIssueRecordPathForWorkspace(workspacePath, normalized))) {
+		console.warn(`[swarm] record unreadable for ${normalized} — treating as no overrides; see .corrupt sidecar`);
+		return;
+	}
+	return record?.statusOverrides;
+}
+/**
+* PAN-2372 WI-4 / FR-6: read a slot's durable completion marker from the record
+* door. Returns undefined when no record or no marker exists. Used by
+* classifyInFlightSlots to recognize a slot whose `pan done` durably recorded
+* completion even when the runtime plane (agent state, tmux session) is gone.
+*/
+function defaultReadSlotCompletion(workspacePath, issueId, slotIndex) {
+	try {
+		return readIssueRecordForWorkspaceSync(workspacePath, issueId.toUpperCase())?.swarm?.slotCompletions?.[String(slotIndex)];
+	} catch {
+		return;
+	}
+}
+function defaultShouldDispatch(issueId) {
+	if (isDeaconGloballyPausedSync()) return false;
+	const hold = defaultGetIssueHold(issueId);
+	return !(hold?.stuck || hold?.deaconIgnored);
+}
+async function swarmJanitorPass(deps = defaultDeps$2) {
+	const actions = [];
+	const sessions = await deps.listSessionNames();
+	for (const workspace of deps.listFeatureWorkspaces()) {
+		const issueId = workspace.issueId.toUpperCase();
+		const spec = await Effect.runPromise((deps.findSpecByIssue ?? findSpecByIssue)(workspace.projectPath, issueId));
+		if (!spec) continue;
+		const reconciled = await deps.reconcileSlotState(issueId, workspace.workspacePath, spec.document);
+		actions.push(`[swarm-janitor] enumerated ${issueId}`);
+		actions.push(...await gcMergedSlots(issueId, workspace.workspacePath, reconciled.merged, deps));
+		actions.push(...await gcOrphanedSlots(issueId, workspace.workspacePath, reconciled, deps));
+		const automatic = (deps.resolveAutomaticSwarmPolicy ?? resolveAutomaticSwarmPolicy)(issueId, analyzeSwarmReadiness(spec.document).swarmEligible);
+		actions.push(...await maintainSwarmForeman(issueId, workspace.workspacePath, reconciled, sessions, deps, automatic.policy.mode !== "off", automatic.spawnForeman));
+		const classified = await classifyInFlightSlots(reconciled.inFlight, {
+			...deps,
+			listSessionNames: async () => sessions
+		}, {
+			issueId,
+			workspacePath: workspace.workspacePath
+		});
+		for (const slot of classified.filter((candidate) => candidate.signal === "stall-event")) {
+			await deps.sendStallEvent?.(`agent-${issueId.toLowerCase()}`, `[swarm-event] slot ${slot.slotIndex} stalled (no progress ${Math.floor((slot.stalledForMs ?? 0) / 6e4)}m)`);
+			actions.push(`[swarm-janitor] notified ${issueId} foreman that slot ${slot.slotIndex} stalled`);
+		}
+	}
+	return actions;
+}
+async function classifyInFlightSlots(slots, deps = defaultDeps$2, options = {}) {
+	const sessionNames = new Set(await deps.listSessionNames());
+	const classified = [];
+	const now = options.now ?? Date.now();
+	const stallThresholdMs = options.stallThresholdMs ?? swarmStallThresholdMs();
+	for (const slot of slots) {
+		if (options.workspacePath && options.issueId) {
+			const completion = await (deps.readSlotCompletion ?? defaultReadSlotCompletion)(options.workspacePath, options.issueId, slot.slotIndex);
+			if (completion) {
+				if (completion.itemId === slot.itemId) {
+					classified.push({
+						...slot,
+						lifecycle: "ready-to-merge",
+						exitStatus: 0,
+						signal: "durable-completion"
+					});
+					continue;
+				}
+				await (deps.clearSlotCompletion ?? clearSwarmSlotCompletion)(options.workspacePath, options.issueId, slot.slotIndex);
+			}
+		}
+		const durableReady = await classifyDurableReadySlot(slot, deps, options);
+		if (!slot.agentId) {
+			if (durableReady) {
+				classified.push(durableReady);
+				continue;
+			}
+			classified.push({
+				...slot,
+				lifecycle: "failed",
+				reason: "missing-agent"
+			});
+			continue;
+		}
+		if (!sessionNames.has(slot.agentId)) {
+			if (durableReady) {
+				classified.push(durableReady);
+				continue;
+			}
+			classified.push({
+				...slot,
+				lifecycle: "failed",
+				reason: "vanished-session"
+			});
+			continue;
+		}
+		if (!await deps.isPaneDead(slot.agentId)) {
+			const outputDigest = deps.getPaneOutputDigest ? await deps.getPaneOutputDigest(slot.agentId).catch(() => "") : "";
+			const commitTime = slot.branch && options.workspacePath && deps.getBranchTipCommitTime ? await deps.getBranchTipCommitTime(options.workspacePath, slot.branch).catch(() => null) : null;
+			const progressKey = slotProgressKey(slot);
+			const previous = slotProgressObservations.get(progressKey);
+			if (!previous || previous.commitTime !== commitTime || previous.outputDigest !== outputDigest) {
+				slotProgressObservations.set(progressKey, {
+					commitTime,
+					outputDigest,
+					lastProgressAt: now
+				});
+				if (options.workspacePath && options.issueId) await clearSwarmCompletionObservation(options.workspacePath, options.issueId, progressKey, deps);
+				classified.push({
+					...slot,
+					lifecycle: "running"
+				});
+				continue;
+			}
+			const stalledForMs = now - previous.lastProgressAt;
+			if (stalledForMs > stallThresholdMs) {
+				const awaitingSignal = await classifyDoneWithoutSignal(slot, deps, options, {
+					commitTime,
+					outputDigest,
+					progressKey,
+					stalledForMs
+				});
+				if (awaitingSignal) {
+					classified.push(awaitingSignal);
+					continue;
+				}
+				classified.push({
+					...slot,
+					lifecycle: "stalled",
+					reason: "no-progress-timeout",
+					stalledForMs,
+					...!previous.stallNotified ? { signal: "stall-event" } : {}
+				});
+				previous.stallNotified = true;
+				continue;
+			}
+			classified.push({
+				...slot,
+				lifecycle: "running"
+			});
+			continue;
+		}
+		const exitStatus = await deps.getPaneExitStatus(slot.agentId);
+		if (exitStatus === 0) {
+			classified.push({
+				...slot,
+				lifecycle: "ready-to-merge",
+				exitStatus
+			});
+			continue;
+		}
+		classified.push({
+			...slot,
+			lifecycle: "failed",
+			exitStatus,
+			reason: exitStatus === null ? "pane-exit-unknown" : "pane-exit-nonzero"
+		});
+	}
+	return classified;
+}
+function slotProgressKey(slot) {
+	return slot.agentId ?? slot.branch ?? `${slot.itemId}:${slot.slotIndex}`;
+}
+function swarmStallThresholdMs() {
+	const raw = process.env.PAN_SWARM_STALL_THRESHOLD_MS;
+	if (!raw) return DEFAULT_SWARM_STALL_THRESHOLD_MS;
+	const parsed = Number(raw);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_SWARM_STALL_THRESHOLD_MS;
+}
+function recordSlotAssignment(workspacePath, issueId, assignment) {
+	return updateIssueRecordForWorkspace(workspacePath, issueId.toUpperCase(), (record) => {
+		const slotAssignments = [...(record.swarm?.slotAssignments ?? []).filter((slot) => slot.slotIndex !== assignment.slotIndex && slot.itemId !== assignment.itemId), {
+			...assignment,
+			assignedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}].sort((a, b) => a.slotIndex - b.slotIndex);
+		const slotCompletions = { ...record.swarm?.slotCompletions ?? {} };
+		delete slotCompletions[String(assignment.slotIndex)];
+		return {
+			...record,
+			swarm: {
+				...record.swarm ?? {},
+				slotAssignments,
+				slotCompletions
+			}
+		};
+	}).then(() => void 0);
+}
+function clearSlotAssignment(workspacePath, issueId, slotIndex, itemId) {
+	return clearSwarmSlotOwnership(workspacePath, issueId, slotIndex, itemId);
+}
+/**
+* Whether the issue may register another slot. Counts only tmux-ALIVE slot
+* sessions (stale agents-table rows blocked all dispatch at zero live slots
+* after a reset), capped by the same swarm reserve tryReserveSwarmSlot
+* enforces — never maxWorkAgents (PAN-2214).
+*/
+function registeredSlotCapacityAvailable(issueId, selectedCount, liveSlotCount = countRunningSwarmSlotsForIssue(issueId), limits = getConcurrencyLimits()) {
+	return liveSlotCount + selectedCount < limits.reservedSwarmSlots;
+}
+//#endregion
+//#region ../../lib/cloister/boot-reconciliation-predicates.ts
 init_agent_state();
 init_review_status();
 function bootReconciliationSkipReason(agent) {
@@ -2973,6 +4551,7 @@ function bootReconciliationSkipReason(agent) {
 }
 //#endregion
 //#region ../../lib/cloister/boot-reconciliation.ts
+init_control_settings();
 init_agents();
 init_persistent_logger();
 init_config$1();
@@ -3183,7 +4762,6 @@ function startBootReconciliation(options = {}) {
 }
 //#endregion
 //#region ../../lib/agents/pinned-launch.ts
-init_dag();
 init_agent_state();
 function parseFlagValue(content, flag) {
 	const escapedFlag = flag.replace("-", "\\-");
@@ -3284,6 +4862,8 @@ init_review_status();
 init_control_settings();
 init_agents$1();
 init_tmux();
+init_io();
+init_dag();
 const orphanFailureRecordedForAutoResume = /* @__PURE__ */ new Set();
 function isVerifyPausedAgentState(state) {
 	if (state.paused !== true || !state.issueId) return false;
@@ -3539,7 +5119,7 @@ async function nudgeStalledResumeWorkAgents() {
 		const message = buildStalledResumePrompt(state);
 		if (!message) continue;
 		try {
-			const { messageAgent } = await import("./agents-megfmQHM.js");
+			const { messageAgent } = await import("./agents-DixZjXWm.js");
 			await messageAgent(agentId, message);
 			recordCooldown(agentId, ".last-stalled-resume-nudge");
 			const action = `Re-sent stalled resume prompt to ${agentId} (${state.issueId})`;
@@ -3653,7 +5233,7 @@ async function nudgeIdleWorkAgentsWithOpenBeads() {
 			"Continue the per-item workflow without asking — claim it (`pan task claim <item-id>`), implement, commit, push, then complete it through `pan task done <item-id>`. Inspection is conditional on metadata.requiresInspection (default false; check the plan item before deciding to call `pan inspect`). Do NOT end your turn with a multi-paragraph summary; just advance to the next bead."
 		].join("\n");
 		try {
-			const { messageAgent } = await import("./agents-megfmQHM.js");
+			const { messageAgent } = await import("./agents-DixZjXWm.js");
 			await messageAgent(agentId, message);
 			writeFileSync(join$1(getAgentDir(agentId), ".last-bead-nudge"), String(Date.now()), "utf-8");
 			const action = `Nudged idle ${agentId} (${state.issueId}) — ${openTasks.length} ready task(s)`;
@@ -3713,6 +5293,10 @@ async function handleAgentStoppedEvent$1(agentId, opts = {}, deps) {
 		logDeaconEventSync(`handleAgentStoppedEvent: ${agentId} skipped — role=${state.role} (not auto-resumable)`);
 		return null;
 	}
+	if (state.foreman === true) {
+		logDeaconEventSync(`handleAgentStoppedEvent: ${agentId} skipped — swarm janitor owns foreman liveness`);
+		return null;
+	}
 	if (state.phase === "retained-transcripts") {
 		logDeaconEventSync(`handleAgentStoppedEvent: ${agentId} skipped — retired (transcripts retained)`);
 		return null;
@@ -4191,6 +5775,7 @@ const cleanupClosedIssueAgentDirectories = (options) => Effect.tryPromise({
 //#region ../../lib/cloister/transcript-retention.ts
 init_state_dir_removal();
 init_agents();
+init_record();
 init_paths();
 init_tmux();
 function isTranscriptRetentionTerminalAgent(agent, readRecord = readIssueRecordForWorkspaceSync) {
@@ -4384,36 +5969,8 @@ async function sweepTranscriptRetention(options) {
 	return [action];
 }
 //#endregion
-//#region ../../lib/pan-dir/record-list.ts
-init_state_home();
-/** Canonical bounded enumeration facet of the issue-record read door. */
-init_record();
-async function readIssueRecordDirectory(recordsDir, records) {
-	const entries = await promises$1.readdir(recordsDir, { withFileTypes: true }).catch(() => []);
-	await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => {
-		try {
-			const record = JSON.parse(await promises$1.readFile(join(recordsDir, entry.name), "utf-8"));
-			if (record.issueId) records.set(record.issueId.toUpperCase(), record);
-		} catch (error) {
-			console.warn(`[record] Preserving unreadable issue record ${join(recordsDir, entry.name)} during enumeration: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}));
-}
-async function listIssueRecords(project) {
-	const stateHome = resolveStateReadHomeSync(project);
-	const records = /* @__PURE__ */ new Map();
-	if (stateHome.migrated) {
-		await readIssueRecordDirectory(join(stateHome.root, RECORD_DIRNAME), records);
-		return [...records.values()];
-	}
-	await readIssueRecordDirectory(join(project.path, ".pan", RECORD_DIRNAME), records);
-	const workspacesDir = join(project.path, "workspaces");
-	const workspaces = await promises$1.readdir(workspacesDir, { withFileTypes: true }).catch(() => []);
-	await Promise.all(workspaces.filter((entry) => entry.isDirectory()).map((entry) => readIssueRecordDirectory(join(workspacesDir, entry.name, ".pan", RECORD_DIRNAME), records)));
-	return [...records.values()];
-}
-//#endregion
 //#region ../../lib/cloister/state-plane-patrol.ts
+init_record_update();
 init_issue_closed();
 function statePlaneReconcileEveryCycles(patrolIntervalMs) {
 	return Math.max(1, Math.ceil(3600 * 1e3 / patrolIntervalMs));
@@ -4497,6 +6054,7 @@ const recreatedStateWarnings = createRecreatedStateWarningReporter();
 //#endregion
 //#region ../../lib/cloister/deacon-main-divergence.ts
 init_projects();
+init_state_plane();
 async function recordMainDivergenceHealth(state, projects = listProjectsSync(), measure = getMainDivergence) {
 	const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
 	const records = [];
@@ -4536,6 +6094,7 @@ function shouldRunRecoveryJanitor(janitor, patrolCycle) {
 //#region ../../lib/cloister/pending-promotion-reconciler.ts
 init_activity_logger();
 init_internal_token();
+init_specs();
 init_projects();
 init_io();
 init_issue_closed();
@@ -5777,8 +7336,8 @@ async function cleanupStaleAgentState() {
 */
 async function cleanupAbandonedFeedback() {
 	const actions = [];
-	const { getReviewStatusSync } = await import("./review-status-CUnjjOUu.js");
-	const { clearFeedbackFiles } = await import("./feedback-writer-DfuVjvH0.js");
+	const { getReviewStatusSync } = await import("./review-status-Bge_3XTR.js");
+	const { clearFeedbackFiles } = await import("./feedback-writer-BzN4qvaP.js");
 	for (const { issueId, workspacePath } of listFeatureWorkspaces()) {
 		const panFeedbackDir = join$1(workspacePath, ".pan", "feedback");
 		if (!existsSync(panFeedbackDir)) continue;
@@ -5809,7 +7368,7 @@ async function cleanupAbandonedFeedback() {
 const ORPHAN_REVIEWER_AGE_MS = 3600 * 1e3;
 async function loadTmuxSessionsWithCreationTimes() {
 	try {
-		const { stdout } = await execAsync(`tmux -L overdeck -f ${join$1(OVERDECK_HOME, "tmux", "overdeck.tmux.conf")} list-sessions -F '#{session_name} #{session_created}'`, { encoding: "utf-8" });
+		const { stdout } = await execAsync(`tmux -L ${getManagedTmuxSocketName()} -f ${join$1(OVERDECK_HOME, "tmux", "overdeck.tmux.conf")} list-sessions -F '#{session_name} #{session_created}'`, { encoding: "utf-8" });
 		const lines = stdout.split("\n").filter((l) => l.trim());
 		const sessions = [];
 		const creationTimes = /* @__PURE__ */ new Map();
@@ -5849,7 +7408,7 @@ async function handleOrphanReviewerSession(sessionName, sessions, creationTimes,
 	if (!issueId) return null;
 	const agentSession = `agent-${issueId.toLowerCase()}`;
 	if (sessions.includes(agentSession)) return null;
-	const { getReviewStatusSync } = await import("./review-status-CUnjjOUu.js");
+	const { getReviewStatusSync } = await import("./review-status-Bge_3XTR.js");
 	try {
 		if (getReviewStatusSync(issueId)?.reviewStatus === "reviewing") return null;
 	} catch {}
@@ -5971,7 +7530,7 @@ async function checkOrphanedCompletions() {
 async function checkPendingTestDispatch() {
 	const actions = [];
 	try {
-		const { loadReviewStatuses, setReviewStatusSync } = await import("./review-status-CUnjjOUu.js");
+		const { loadReviewStatuses, setReviewStatusSync } = await import("./review-status-Bge_3XTR.js");
 		const statuses = loadReviewStatuses();
 		const now = Date.now();
 		for (const [issueId, status] of Object.entries(statuses)) {
@@ -6004,7 +7563,7 @@ async function checkPendingTestDispatch() {
 				console.log(`[deacon] ${issueId}: skipping test re-dispatch — issue is closed`);
 				continue;
 			}
-			const { resolveProjectFromIssueSync } = await import("./projects-DvPEAP18.js");
+			const { resolveProjectFromIssueSync } = await import("./projects-BMuEf14J.js");
 			const resolved = resolveProjectFromIssueSync(issueId);
 			if (!resolved) continue;
 			const issueLower = issueId.toLowerCase();
@@ -6019,8 +7578,8 @@ async function checkPendingTestDispatch() {
 				logDeaconEventSync(`checkPendingTestDispatch: deferred test for ${issueId} — advancing ceiling reached (PAN-1665) — ${describeRunningAgents()}`);
 				continue;
 			}
-			const { spawnRun } = await import("./agents-megfmQHM.js");
-			const { buildTestRolePrompt } = await import("./test-agent-queue-BUtWhNcc.js");
+			const { spawnRun } = await import("./agents-DixZjXWm.js");
+			const { buildTestRolePrompt } = await import("./test-agent-queue-Cu0D6BYe.js");
 			try {
 				const run = await spawnRun(issueId, "test", {
 					workspace,
@@ -6150,7 +7709,7 @@ async function checkCompletedButUnsignaledTests() {
 					const cmd = `pan admin specialists done test ${issueId} --status ${decision.status}${noteArg}${decision.uatStatus ? ` --uat-status ${decision.uatStatus}${decision.uatNotes ? ` --uat-notes "${decision.uatNotes.replace(/"/g, "'").slice(0, 120)}"` : ""}` : ""}`;
 					const nudge = `Your test verdict (${decision.status}) is already written to .pan/test/result.json. Your ONLY remaining task is to execute this Bash command immediately — do not analyze, do not summarize, do not ask questions, just run it:\n\n${cmd}\n\nRun this command NOW. Do not write any other response before executing it.`;
 					try {
-						const { messageAgent } = await import("./agents-megfmQHM.js");
+						const { messageAgent } = await import("./agents-DixZjXWm.js");
 						await messageAgent(testSession, nudge);
 						unsignaledTestNudges.set(testSession, now);
 						const msg = `Nudged ${testSession} to signal ${decision.status} (verdict artifact present)`;
@@ -6164,7 +7723,7 @@ async function checkCompletedButUnsignaledTests() {
 				case "nudge-write": {
 					const nudge = `Your test run for ${issueId} looks finished but no verdict was recorded. Decide the automated-gate verdict and, when UAT was required, its separate verdict. Then do BOTH now: (1) write .pan/test/result.json as {"status":"passed"|"failed","notes":"<gate evidence>","uatStatus":"passed"|"failed","uatNotes":"<UAT evidence>"} (omit UAT fields only when UAT was not required), and (2) run: pan admin specialists done test ${issueId} --status passed|failed [--uat-status passed|failed]. Do this immediately — do not summarize or ask questions, just write the file and run the command.`;
 					try {
-						const { messageAgent } = await import("./agents-megfmQHM.js");
+						const { messageAgent } = await import("./agents-DixZjXWm.js");
 						await messageAgent(testSession, nudge);
 						unsignaledTestNudges.set(testSession, now);
 						const msg = `Nudged ${testSession} to write+signal a test verdict (no artifact yet)`;
@@ -6196,8 +7755,8 @@ async function checkCompletedButUnsignaledTests() {
 async function checkVerificationReviewContradiction() {
 	const actions = [];
 	try {
-		const { loadReviewStatuses } = await import("./review-status-CUnjjOUu.js");
-		const { resolveProjectFromIssueSync } = await import("./projects-DvPEAP18.js");
+		const { loadReviewStatuses } = await import("./review-status-Bge_3XTR.js");
+		const { resolveProjectFromIssueSync } = await import("./projects-BMuEf14J.js");
 		const statuses = loadReviewStatuses();
 		for (const [issueId, status] of Object.entries(statuses)) if (status.verificationStatus === "passed" && status.reviewStatus === "reviewing" && status.stuckReason === "review_infrastructure_failure") {
 			let reviewedAtCommit;
@@ -6206,12 +7765,12 @@ async function checkVerificationReviewContradiction() {
 				if (project) {
 					const workspacePath = join$1(project.projectPath, "workspaces", `feature-${issueId.toLowerCase()}`);
 					if (existsSync(workspacePath)) {
-						const { snapshotWorkspaceHeadsPromise } = await import("./git-utils-Y0zG25ez.js");
+						const { snapshotWorkspaceHeadsPromise } = await import("./git-utils-BAMwn9Nf.js");
 						reviewedAtCommit = await snapshotWorkspaceHeadsPromise(issueId, workspacePath);
 					}
 				}
 			} catch {}
-			const { recordReviewVerdict } = await import("./review-verdict-writer-jldSh3Bm.js");
+			const { recordReviewVerdict } = await import("./review-verdict-writer-DjrJ64eS.js");
 			const bypass = await recordReviewVerdict(issueId, {
 				verdict: "passed",
 				notes: "Review bypassed: verification passed but review infrastructure repeatedly failed.",
@@ -6306,7 +7865,7 @@ async function checkReadyForMergeStuck() {
 const testStatusGreenCiReconcileCooldowns = /* @__PURE__ */ new Map();
 const TEST_STATUS_GREEN_CI_RECONCILE_COOLDOWN_MS = 300 * 1e3;
 async function reconcileTestStatusFromGreenCi() {
-	const { getCiCheckRunsState, getPullRequestHeadState, isGitHubAppConfigured } = await import("./github-app-C33lDk9Z.js");
+	const { getCiCheckRunsState, getPullRequestHeadState, isGitHubAppConfigured } = await import("./github-app-BWziYCf3.js");
 	return reconcileTestStatusFromGreenCiWithDeps({
 		isGitHubAppConfigured,
 		loadReviewStatuses,
@@ -6327,7 +7886,7 @@ async function reconcileTestStatusFromGreenCi() {
 */
 async function clearStaleCiFeedback(issueId) {
 	const { readdir, rm } = await import("fs/promises");
-	const { resolveProjectFromIssueSync } = await import("./projects-DvPEAP18.js");
+	const { resolveProjectFromIssueSync } = await import("./projects-BMuEf14J.js");
 	const projectConfig = resolveProjectFromIssueSync(issueId);
 	if (!projectConfig) return;
 	const repoDir = projectConfig.projectPath;
@@ -6621,7 +8180,7 @@ async function checkWorkspaceContainerHealth(sharedState) {
 				}
 			}
 			try {
-				const { resolveProjectFromIssueSync } = await import("./projects-DvPEAP18.js");
+				const { resolveProjectFromIssueSync } = await import("./projects-BMuEf14J.js");
 				const resolved = resolveProjectFromIssueSync(issueLower.toUpperCase());
 				if (resolved) await killOrphanedWorkspaceProcesses(`${resolved.projectPath}/workspaces/feature-${issueLower}`);
 			} catch {}
@@ -6670,8 +8229,8 @@ async function checkWorkspaceContainerHealth(sharedState) {
 async function checkMergedWorkSessions() {
 	const actions = [];
 	try {
-		const { selectMergedWorkSessions } = await import("./reap-terminal-sessions-D7f3zSE9.js");
-		const { setAgentPaused } = await import("./agents-megfmQHM.js");
+		const { selectMergedWorkSessions } = await import("./reap-terminal-sessions-DgEIKMhH.js");
+		const { setAgentPaused } = await import("./agents-DixZjXWm.js");
 		const toKill = selectMergedWorkSessions(loadReviewStatuses(), [...await Effect.runPromise(listSessionNames())]);
 		for (const session of toKill) try {
 			await Effect.runPromise(setAgentPaused(session, "merged — awaiting close-out (verify on main)", true));
@@ -6711,7 +8270,7 @@ const AWAITING_TEST_IDLE_REAP_MS = 600 * 1e3;
 async function checkAwaitingTestWorkSessions() {
 	const actions = [];
 	try {
-		const { selectAwaitingTestWorkSessions } = await import("./reap-terminal-sessions-D7f3zSE9.js");
+		const { selectAwaitingTestWorkSessions } = await import("./reap-terminal-sessions-DgEIKMhH.js");
 		const candidates = selectAwaitingTestWorkSessions(loadReviewStatuses(), [...await Effect.runPromise(listSessionNames())]);
 		const now = Date.now();
 		for (const session of candidates) {
@@ -6764,7 +8323,7 @@ async function runPatrol() {
 		hasLoggedGlobalPauseSkip = false;
 		addLog("info", `Patrol cycle ${state.patrolCycle} — checking per-project specialists`, state.patrolCycle);
 		console.log(`[deacon] Patrol cycle ${state.patrolCycle} - checking per-project specialists`);
-		for (const a of await (await import("./stale-task-claims-PzFee70R.js")).patrolStaleTaskClaims()) {
+		for (const a of await (await import("./stale-task-claims-DMRLb5R2.js")).patrolStaleTaskClaims()) {
 			actions.push(a);
 			addLog("action", a, state.patrolCycle);
 		}
@@ -6772,30 +8331,30 @@ async function runPatrol() {
 		actions.push(...stuckRemediationActions);
 		for (const a of stuckRemediationActions) addLog("action", a, state.patrolCycle);
 		try {
-			const sweepRecommendations = await (await import("./stall-sweeper-DOyIfeLR.js")).runStallSweeperPatrol();
+			const sweepRecommendations = await (await import("./stall-sweeper-CBWqSWV2.js")).runStallSweeperPatrol();
 			actions.push(...sweepRecommendations);
 			for (const recommendation of sweepRecommendations) addLog("info", recommendation, state.patrolCycle);
 		} catch (err) {
 			console.warn(`[deacon] stall sweeper patrol failed: ${err?.message ?? err}`);
 			addLog("warn", `Stall sweeper patrol failed: ${err?.message ?? err}`, state.patrolCycle);
 		}
-		const { reconcileInFlightJournals } = await import("./advancing-selfheal-BQiJ7mIH.js");
+		const { reconcileInFlightJournals } = await import("./advancing-selfheal-BJAfiY-C.js");
 		const reconciledJournalActions = await reconcileInFlightJournals();
 		actions.push(...reconciledJournalActions);
 		for (const a of reconciledJournalActions) addLog("action", a, state.patrolCycle);
-		for (const a of (await import("./feedback-stuck-retirement-B8-fX7NA.js")).retireResolvedFeedbackDeliveryStuckFlags()) {
+		for (const a of (await import("./feedback-stuck-retirement-CXAYe2rU.js")).retireResolvedFeedbackDeliveryStuckFlags()) {
 			actions.push(a);
 			addLog("action", a, state.patrolCycle);
 		}
 		try {
 			const pendingFile = join$1(OVERDECK_HOME, "pending-post-merge.json");
-			const { processPendingLifecycleForPatrol } = await import("./deacon-pending-lifecycle-DVHjOLje.js");
+			const { processPendingLifecycleForPatrol } = await import("./deacon-pending-lifecycle-BzaE76Xo.js");
 			const action = await processPendingLifecycleForPatrol(pendingFile);
 			if (action) actions.push(action);
 		} catch (err) {
 			console.warn(`[deacon] Failed to process pending lifecycle: ${err.message}`);
 		}
-		if (state.patrolCycle % 5 === 0) await (await import("./deploy-patrol-BXjlvoV3.js")).runScheduledDeployPatrol();
+		if (state.patrolCycle % 5 === 0) await (await import("./deploy-patrol-B8sKkA8h.js")).runScheduledDeployPatrol();
 		const livenessActions = await reconcileAgentLiveness();
 		actions.push(...livenessActions);
 		for (const a of livenessActions) addLog("action", a, state.patrolCycle);
@@ -6816,7 +8375,7 @@ async function runPatrol() {
 		const idleStackActions = await reconcileIdleWorkspaceStacks();
 		actions.push(...idleStackActions);
 		for (const a of idleStackActions) addLog("action", a, state.patrolCycle);
-		for (const a of await (await import("./bridge-pool-patrol-DiHEd13O.js")).patrolDockerBridgePool()) {
+		for (const a of await (await import("./bridge-pool-patrol-BDohuMRt.js")).patrolDockerBridgePool()) {
 			actions.push(a);
 			addLog("action", a, state.patrolCycle);
 		}
@@ -6836,7 +8395,7 @@ async function runPatrol() {
 		actions.push(...suspendActions);
 		for (const a of suspendActions) addLog("action", a, state.patrolCycle);
 		try {
-			const { resolveProjectFromIssueSync } = await import("./projects-DvPEAP18.js");
+			const { resolveProjectFromIssueSync } = await import("./projects-BMuEf14J.js");
 			const allStatuses = loadReviewStatuses();
 			for (const [issueId, status] of Object.entries(allStatuses)) {
 				if (!status.readyForMerge || status.mergeStatus === "merged") continue;
@@ -6856,7 +8415,7 @@ async function runPatrol() {
 		} catch (err) {
 			console.warn(`[deacon] Failed to check workspace existence: ${err.message}`);
 		}
-		const { checkMergedAdvancingSessions } = await import("./advancing-selfheal-BQiJ7mIH.js");
+		const { checkMergedAdvancingSessions } = await import("./advancing-selfheal-BJAfiY-C.js");
 		const reapedWorkActions = await checkMergedWorkSessions();
 		actions.push(...reapedWorkActions);
 		for (const a of reapedWorkActions) addLog("action", a, state.patrolCycle);
@@ -6864,7 +8423,7 @@ async function runPatrol() {
 		actions.push(...reapedMergedAdvancingActions);
 		for (const a of reapedMergedAdvancingActions) addLog("action", a, state.patrolCycle);
 		try {
-			const { refreshClaudeCredentialsForActiveRemoteAgents } = await import("./remote-completion-DxUJ5HKR.js");
+			const { refreshClaudeCredentialsForActiveRemoteAgents } = await import("./remote-completion-LcWCpAm2.js");
 			const remoteCredentialActions = await refreshClaudeCredentialsForActiveRemoteAgents();
 			actions.push(...remoteCredentialActions);
 			for (const a of remoteCredentialActions) addLog(a.includes("failed") ? "warn" : "action", a, state.patrolCycle);
@@ -6872,7 +8431,7 @@ async function runPatrol() {
 			addLog("warn", `Remote credential refresh patrol failed: ${err.message}`, state.patrolCycle);
 		}
 		try {
-			const { refreshHostHeartbeatForEphemeralVms } = await import("./remote-agents-DQVGZVQ9.js");
+			const { refreshHostHeartbeatForEphemeralVms } = await import("./remote-agents-MuXx2gWm.js");
 			const heartbeatActions = await refreshHostHeartbeatForEphemeralVms();
 			actions.push(...heartbeatActions);
 			for (const a of heartbeatActions) addLog(a.includes("failed") ? "warn" : "action", a, state.patrolCycle);
@@ -6880,7 +8439,7 @@ async function runPatrol() {
 			addLog("warn", `Remote heartbeat refresh patrol failed: ${err.message}`, state.patrolCycle);
 		}
 		try {
-			const { reapCompletedRemoteAgents } = await import("./remote-completion-DxUJ5HKR.js");
+			const { reapCompletedRemoteAgents } = await import("./remote-completion-LcWCpAm2.js");
 			const remoteReap = await reapCompletedRemoteAgents();
 			for (const r of remoteReap) if (r.status === "handed-off" || r.status === "error") {
 				const msg = `Remote reap ${r.issueId}: ${r.status} (${r.details.join("; ")})`;
@@ -6963,7 +8522,7 @@ async function runPatrol() {
 			actions.push(a);
 			addLog("action", a, state.patrolCycle);
 		}
-		const swarmActions = await coordinateSwarmSlots();
+		const swarmActions = await swarmJanitorPass();
 		actions.push(...swarmActions);
 		for (const a of swarmActions) addLog("action", a, state.patrolCycle);
 		const staleMergeActions = await reconcileStaleMergeStatus();
@@ -6989,7 +8548,7 @@ async function runPatrol() {
 		const staleMergeBlockerActions = await reconcileStaleMergeBlockers();
 		actions.push(...staleMergeBlockerActions);
 		for (const a of staleMergeBlockerActions) addLog("action", a, state.patrolCycle);
-		const stuckReadyActions = reconcileStuckReadyForMerge();
+		const stuckReadyActions = await reconcileStuckReadyForMerge();
 		actions.push(...stuckReadyActions);
 		for (const a of stuckReadyActions) addLog("action", a, state.patrolCycle);
 		const deadEndActions = await checkDeadEndAgents();
@@ -7027,6 +8586,10 @@ async function runPatrol() {
 			actions.push(result.message);
 			addLog(result.level, result.message, state.patrolCycle);
 		}
+		if (state.patrolCycle % statePlaneReconcileEveryCycles(config.patrolIntervalMs) === 0) for (const result of await reconcileTerminalIssueResidue(projectConfigs)) {
+			actions.push(result.message);
+			addLog(result.level, result.message, state.patrolCycle);
+		}
 		for (const warning of await recreatedStateWarnings(projectConfigs)) addLog(warning.level, warning.message, state.patrolCycle);
 		const divergenceWarnings = await recordMainDivergenceHealth(state, projectConfigs);
 		for (const warning of divergenceWarnings) addLog("warn", warning, state.patrolCycle);
@@ -7076,7 +8639,7 @@ async function runPatrol() {
 							const issueId = runtimeState.currentIssue;
 							try {
 								if (getReviewStatusSync(issueId)?.mergeStatus === "merging") {
-									const { resolveProjectFromIssueSync } = await import("./projects-DvPEAP18.js");
+									const { resolveProjectFromIssueSync } = await import("./projects-BMuEf14J.js");
 									const resolved = resolveProjectFromIssueSync(issueId);
 									if (resolved) {
 										const branch = `feature/${issueId.toLowerCase()}`;
@@ -7090,7 +8653,7 @@ async function runPatrol() {
 												mergeStatus: "merged",
 												readyForMerge: false
 											});
-											const { postMergeLifecycle } = await import("./merge-agent-BRSz26Oh.js");
+											const { postMergeLifecycle } = await import("./merge-agent-D-4_iQgy.js");
 											postMergeLifecycle(issueId, resolved.projectPath).catch((err) => console.warn(`[deacon] postMergeLifecycle failed for ${issueId}: ${err}`));
 											actions.push(`Auto-completed stale merge for ${issueId}`);
 										} else {
@@ -7270,7 +8833,7 @@ function startDeacon() {
 	logDeaconEventSync(`startDeacon: health monitor starting (patrol every ${config.patrolIntervalMs / 1e3}s)`);
 	(async () => {
 		await reconcileAgentLiveness();
-		const { runBootAdvancingSelfHeal } = await import("./advancing-selfheal-BQiJ7mIH.js");
+		const { runBootAdvancingSelfHeal } = await import("./advancing-selfheal-BJAfiY-C.js");
 		await runBootAdvancingSelfHeal();
 		runScheduledPatrol("startup");
 	})().catch((err) => {
@@ -7283,7 +8846,7 @@ function startDeacon() {
 	}, config.patrolIntervalMs);
 	memoryPatrolInterval = setInterval(() => {
 		(async () => {
-			const { patrolMemoryPressure } = await import("./memory-pressure-patrol-BWlWywmA.js");
+			const { patrolMemoryPressure } = await import("./memory-pressure-patrol-C6DJJQRA.js");
 			for (const action of await patrolMemoryPressure()) logDeaconEventSync(`memory-pressure-patrol: ${action}`);
 		})().catch((err) => {
 			logDeaconEventSync(`memory-pressure-patrol: error: ${err instanceof Error ? err.message : String(err)}`);
@@ -7353,6 +8916,6 @@ function assessDeaconPatrolFreshness(params) {
 	};
 }
 //#endregion
-export { synthesizeReviewFromReports as $, reconcileAgentLiveness as A, cleanupClosedIssueAgentDirectories as B, getLastPatrolResult as C, isDeaconRunning as D, handleAgentStoppedForOrphanReviewerSessions as E, setAgentStatusChangedNotifier as F, redeliverUndeliveredKickoffs as G, isRapidPostResumeDeath as H, setAgentStoppedNotifier as I, isBootReconciliationCandidate as J, extendBootReconciliationGrace as K, setMergeReadyNotifier as L, resetPatrolHeartbeatForStartup as M, runPatrol as N, loadConfig as O, saveState as P, monitorReviewConvoySignals as Q, startDeacon as R, getDeaconStatus as S, handleAgentStoppedEvent as T, nudgeIdleWorkAgentsWithOpenBeads as U, isPreKickoffLaunchDeath as V, nudgeStalledResumeWorkAgents as W, startBootReconciliation as X, listBootReconciliationCandidates as Y, cleanupOrphanedReviewSessions as Z, cleanupOrphanReviewerSessions as _, checkInspectAgentTimeouts as _t, checkAwaitingTestWorkSessions as a, checkOrphanedReviewStatuses as at, containerRestartBackoffMs as b, checkMassDeath as c, recoverStalledReviewConvoys as ct, checkPendingTestDispatch as d, checkPostReviewCommits as dt, checkCompletedButUnsignaledReviews as et, checkReadyForMergeStuck as f, checkApiErrorAgents as ft, cleanupAbandonedFeedback as g, INSPECT_TIMEOUT_MS as gt, checkWorkspaceContainerHealth as h, paneShowsClaudeBootBlockingScreen as ht, checkAndSuspendIdleAgents as i, checkMissingReviewStatuses as it, reconcileTestStatusFromGreenCi as j, loadState as k, checkMergedWorkSessions as l, reviewConvoyLiveness as lt, checkVerificationReviewContradiction as m, stuckOverflowNativeRecoveryState as mt, applyBootReconciliationDecision as n, isSynthesisForActiveReviewRun as nt, checkCompletedButUnsignaledTests as o, handleReviewCoordinatorDied as ot, checkStuckWorkAgents as p, contextOverflowRecoveryState as pt, isAutoResumableRole as q, assessDeaconPatrolFreshness as r, reconcileUnappliedReviewVerdicts as rt, checkDeadEndAgents as s, handleWorkCompleted as st, MEMORY_PATROL_INTERVAL_MS as t, checkStuckReviewing as tt, checkOrphanedCompletions as u, stalledReviewConvoyRecoveryState as ut, cleanupOrphanedPlanningSessions as v, WORK_LAUNCHER_GRACE_MS as vt, handleAgentHeartbeatDeadEvent as w, getDeaconLogs as x, cleanupStaleAgentState as y, stopDeacon as z };
+export { monitorReviewConvoySignals as $, reconcileAgentLiveness as A, cleanupClosedIssueAgentDirectories as B, getLastPatrolResult as C, isDeaconRunning as D, handleAgentStoppedForOrphanReviewerSessions as E, setAgentStatusChangedNotifier as F, redeliverUndeliveredKickoffs as G, isRapidPostResumeDeath as H, setAgentStoppedNotifier as I, isBootReconciliationCandidate as J, extendBootReconciliationGrace as K, setMergeReadyNotifier as L, resetPatrolHeartbeatForStartup as M, runPatrol as N, loadConfig as O, saveState as P, cleanupOrphanedReviewSessions as Q, startDeacon as R, getDeaconStatus as S, handleAgentStoppedEvent as T, nudgeIdleWorkAgentsWithOpenBeads as U, isPreKickoffLaunchDeath as V, nudgeStalledResumeWorkAgents as W, startBootReconciliation as X, listBootReconciliationCandidates as Y, resolveSwarmPolicy as Z, cleanupOrphanReviewerSessions as _, INSPECT_TIMEOUT_MS as _t, checkAwaitingTestWorkSessions as a, checkMissingReviewStatuses as at, containerRestartBackoffMs as b, checkMassDeath as c, handleWorkCompleted as ct, checkPendingTestDispatch as d, stalledReviewConvoyRecoveryState as dt, synthesizeReviewFromReports as et, checkReadyForMergeStuck as f, checkPostReviewCommits as ft, cleanupAbandonedFeedback as g, paneShowsClaudeBootBlockingScreen as gt, checkWorkspaceContainerHealth as h, stuckOverflowNativeRecoveryState as ht, checkAndSuspendIdleAgents as i, reconcileUnappliedReviewVerdicts as it, reconcileTestStatusFromGreenCi as j, loadState as k, checkMergedWorkSessions as l, recoverStalledReviewConvoys as lt, checkVerificationReviewContradiction as m, contextOverflowRecoveryState as mt, applyBootReconciliationDecision as n, checkStuckReviewing as nt, checkCompletedButUnsignaledTests as o, checkOrphanedReviewStatuses as ot, checkStuckWorkAgents as p, checkApiErrorAgents as pt, isAutoResumableRole as q, assessDeaconPatrolFreshness as r, isSynthesisForActiveReviewRun as rt, checkDeadEndAgents as s, handleReviewCoordinatorDied as st, MEMORY_PATROL_INTERVAL_MS as t, checkCompletedButUnsignaledReviews as tt, checkOrphanedCompletions as u, reviewConvoyLiveness as ut, cleanupOrphanedPlanningSessions as v, checkInspectAgentTimeouts as vt, handleAgentHeartbeatDeadEvent as w, getDeaconLogs as x, cleanupStaleAgentState as y, WORK_LAUNCHER_GRACE_MS as yt, stopDeacon as z };
 
-//# sourceMappingURL=deacon-TPYssFYt.js.map
+//# sourceMappingURL=deacon-CsisLmPt.js.map