@overdeck/desktop 0.45.13 → 0.45.16

package/server/{service-C8jKYZ0w.js → service-DfTVoqJg.js}

@@ -1,25 +1,26 @@
-import { Dt as getProjectConfigFromWorkspacePath, Ft as resolveProjectForIssue, Gn as resolveProjectFromIssueSync, Hr as init_paths, Nn as init_projects, Ot as init_record, Pt as readRecordContinueViewSync, Vr as getOverdeckHome, br as AGENTS_DIR, kr as OVERDECK_HOME, yr as init_errors } from "./config-yaml-C_djSurJ.js";
+import { Fn as init_projects, Ft as readRecordContinueViewSync, It as resolveProjectForIssue, Jr as init_paths, Ot as getProjectConfigFromWorkspacePath, Sr as AGENTS_DIR, jr as OVERDECK_HOME, kt as init_record, qn as resolveProjectFromIssueSync, qr as getOverdeckHome, xr as init_errors } from "./config-yaml-cNOZcEww.js";
 import { a as init_activity_logger, n as emitActivityEntrySync } from "./activity-logger-pcbf-e30.js";
-import { D as sql, E as like, S as gte, _ as integer, a as EventBus, b as and, f as init_infra, g as real, h as text, i as DbLive, m as sqliteTable, n as CostArchiveLive, o as EventBusLive, p as init_sqlite_core, r as Db, t as CostArchive, v as init_drizzle_orm, x as eq, y as desc } from "./infra-Clew3DpF.js";
-import { L as sessionExists, R as sessionExistsSync, w as killSession, x as init_tmux } from "./tmux-BVc-NeKM.js";
-import { c as init_review_status, u as loadReviewStatuses, y as setReviewStatusSync } from "./review-status-BcfwcAcO.js";
-import { n as init_issues, t as IssueId } from "./issues-BPcqPqfV.js";
-import { a as getAllBudgetsSync, i as deleteBudgetSync, n as checkBudgetSync, r as createBudgetSync, s as init_cost } from "./cost-CaiG63FG.js";
-import { An as getAgentDir, D as init_context_overflow, Jn as saveAgentStateSync, Mn as getAgentState, Pn as getAgentStateSync, Q as listRunningAgentsSync, Sr as parseOhmypiSessionCostResultSync, U as spawnAgent, _t as init_config, gr as getAgentRuntimeStateSync, gt as getHealthThresholdsMs, k as isContextOverflowTail, q as stopAgentSync, t as init_agents, vr as saveAgentRuntimeState, xr as init_ohmypi_parser, yt as loadCloisterConfigSync } from "./agents-DqQa4Dq_.js";
-import { i as parseCodexSessionSync, n as init_codex_parser, r as parseCodexSessionCostEventsSync } from "./behavior-D3d2mVyD.js";
-import { _ as init_tier_metrics, c as getDailyTrendsSync, d as init_cost_sync, h as deriveTieredAgentCostRole, t as getAgentDailyCostSync } from "./cost-sync-D6AX8jv-.js";
-import { c as requireModelOverrideSync, o as init_model_validation } from "./state-home-CoyWsECg.js";
-import { _ as setDeaconGloballyPaused, c as isCloisterSpawnsPausedSync, g as setCloisterSpawnsPausedSync, s as init_control_settings, x as setFlywheelGloballyPaused } from "./control-settings-KyYNXZLv.js";
-import { n as checkHookSync, p as init_hooks } from "./hooks-D_6pAbuJ.js";
-import { r as isRoleTerminal, t as init_reap_terminal_sessions } from "./reap-terminal-sessions-CAmURC2h.js";
-import { C as getLastPatrolResult, D as isDeaconRunning, Lt as getRuntimeForAgent, N as runPatrol, R as startDeacon, S as getDeaconStatus, n as assessDeaconPatrolFreshness, x as getDeaconLogs, z as stopDeacon } from "./deacon-2EvA9Ci3.js";
-import "./flywheel-D9NKvWqb.js";
-import { n as renderPrompt, t as init_prompts } from "./prompts-CXbQvevY.js";
-import { r as writeHealthEvent } from "./health-events-D4E1DLN-.js";
-import { O as init_specialists, T as getTmuxSessionName } from "./specialists-BGNZ0_ZW.js";
-import { t as withBdMutex } from "./bd-mutex-BItGvLQ8.js";
-import { n as init_issue_closed, r as isIssueClosed } from "./issue-closed-BYC2TCk-.js";
-import { n as shouldSkipDispatchAsMerged, t as init_merge_verification } from "./merge-verification-BAbjxEd5.js";
+import { D as sql, E as like, S as gte, _ as integer, a as EventBus, b as and, f as init_infra, g as real, h as text, i as DbLive, m as sqliteTable, n as CostArchiveLive, o as EventBusLive, p as init_sqlite_core, r as Db, t as CostArchive, v as init_drizzle_orm, x as eq, y as desc } from "./infra-Ba9mS6e6.js";
+import { L as sessionExists, R as sessionExistsSync, d as exactPaneTarget, w as killSession, x as init_tmux } from "./tmux-C3g9VFcg.js";
+import { c as init_review_status, u as loadReviewStatuses, y as setReviewStatusSync } from "./review-status-Dc1l4dVz.js";
+import { n as init_issues, t as IssueId } from "./issues-CBAsuoAO.js";
+import { a as getAllBudgetsSync, i as deleteBudgetSync, n as checkBudgetSync, r as createBudgetSync, s as init_cost } from "./cost-D9kPIY_5.js";
+import { An as getAgentDir, D as init_context_overflow, Jn as saveAgentStateSync, Mn as getAgentState, Pn as getAgentStateSync, Q as listRunningAgentsSync, U as spawnAgent, _t as init_config, gt as getHealthThresholdsMs, hr as saveAgentRuntimeState, k as isContextOverflowTail, pr as getAgentRuntimeStateSync, q as stopAgentSync, t as init_agents, vr as init_ohmypi_parser, yr as parseOhmypiSessionCostResultSync, yt as loadCloisterConfigSync } from "./agents-B9GwfCyp.js";
+import { n as parseCodexSessionCostEventsSync, r as parseCodexSessionSync, t as init_codex_parser } from "./codex-parser-mFYZh8vR.js";
+import { _ as init_tier_metrics, c as getDailyTrendsSync, d as init_cost_sync, h as deriveTieredAgentCostRole, t as getAgentDailyCostSync } from "./cost-sync-DF6odxK9.js";
+import { c as requireModelOverrideSync, o as init_model_validation } from "./state-home-CEvD_v5F.js";
+import { _ as setDeaconGloballyPaused, c as isCloisterSpawnsPausedSync, g as setCloisterSpawnsPausedSync, s as init_control_settings, x as setFlywheelGloballyPaused } from "./control-settings-D4EFsRBd.js";
+import { n as init_resolver, t as createBeadsResolver } from "./resolver-C7dLn8OK.js";
+import { n as checkHookSync, p as init_hooks } from "./hooks-BCoOjL_R.js";
+import { r as isRoleTerminal, t as init_reap_terminal_sessions } from "./reap-terminal-sessions-2s-fvilz.js";
+import { o as getRuntimeForAgent } from "./stuck-remediation-CxsyxwFO.js";
+import "./flywheel-Dczmgchd.js";
+import { C as getLastPatrolResult, D as isDeaconRunning, N as runPatrol, R as startDeacon, S as getDeaconStatus, n as assessDeaconPatrolFreshness, x as getDeaconLogs, z as stopDeacon } from "./deacon-DdARMjZq.js";
+import { n as renderPrompt, t as init_prompts } from "./prompts-B3njaImU.js";
+import { O as init_specialists, T as getTmuxSessionName } from "./specialists-CwzFdapR.js";
+import { n as init_issue_closed, r as isIssueClosed } from "./issue-closed-BxcePXL-.js";
+import { n as shouldSkipDispatchAsMerged, t as init_merge_verification } from "./merge-verification-D4wTChdX.js";
+import { r as writeHealthEvent } from "./health-events-B4u-2a9m.js";
 import { join } from "node:path";
 import { Context, Data, Effect, Layer, Schema } from "effect";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
@@ -27,7 +28,7 @@ import { dirname as dirname$1, join as join$1 } from "path";
 import { existsSync as existsSync$1, readdirSync as readdirSync$1 } from "node:fs";
 import { createHash } from "crypto";
 import { rm } from "fs/promises";
-import { exec } from "node:child_process";
+import { exec, execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { exec as exec$1 } from "child_process";
 import { promisify as promisify$1 } from "util";
@@ -726,7 +727,10 @@ HttpApiGroup.make("costs").add(HttpApiEndpoint.get("summary", "/costs/summary",
 }));
 //#endregion
 //#region ../../lib/cloister/health.ts
-init_context_overflow();
+init_cost_sync();
+init_review_status();
+init_control_settings();
+init_hooks();
 init_agents();
 init_config();
 /**
@@ -831,9 +835,6 @@ function getAgentsNeedingAttention(agentHealths) {
 }
 //#endregion
 //#region ../../lib/cloister/handoff-context.ts
-init_review_status();
-init_control_settings();
-init_hooks();
 /**
 * Handoff Context Module
 *
@@ -1168,310 +1169,595 @@ const performHandoff = (agentId, options) => Effect.tryPromise({
 	})
 });
 //#endregion
-//#region ../../lib/cloister/triggers.ts
+//#region ../../lib/cloister/cost-monitor.ts
 /**
-* Handoff Triggers
+* Cost Monitor
 *
-* Detects conditions that should trigger model handoffs:
-* 1. Stuck escalation - Agent inactive for too long
-* 2. Planning complete - Planning phase finished, ready for implementation
-* 3. Test failure - Tests failing, need more powerful model
-* 4. Task completion - Implementation done, ready for specialist testing
+* Monitors agent costs against configured limits and emits alerts.
+* Does NOT automatically stop agents - just provides visibility and warnings.
 */
+init_paths();
 init_config();
-const execAsync$2 = promisify$1(exec$1);
-const taskCompletionCache = /* @__PURE__ */ new Map();
-const taskCompletionInflight = /* @__PURE__ */ new Map();
 /**
-* Check if agent should be handed off due to stuck escalation
-*
-* Model-specific thresholds:
-* - Haiku: Stuck after 10 minutes → escalate to Sonnet
-* - Sonnet: Stuck after 20 minutes → escalate to Opus
-* - Opus: Stuck after 30 minutes → alert user (no auto-escalation)
-*
-* @param health - Agent health state
-* @param currentModel - Current model
-* @param config - Cloister configuration
-* @returns Trigger detection result
+* Path to cost data file
 */
-function checkStuckEscalation(health, currentModel, config) {
-	const stuckConfig = (config || loadCloisterConfigSync()).handoffs?.auto_triggers?.stuck_escalation;
-	if (!stuckConfig?.enabled) return {
-		triggered: false,
-		type: "stuck_escalation",
-		reason: "Stuck escalation disabled in config",
-		confidence: "high"
-	};
-	if (health.state !== "stuck") return {
-		triggered: false,
-		type: "stuck_escalation",
-		reason: `Agent is ${health.state}, not stuck`,
-		confidence: "high"
-	};
-	if (!health.lastActivity) return {
-		triggered: false,
-		type: "stuck_escalation",
-		reason: "No last activity timestamp available",
-		confidence: "low"
-	};
-	const minutesSinceActivity = (Date.now() - health.lastActivity.getTime()) / (1e3 * 60);
-	if (currentModel === "haiku" && minutesSinceActivity >= stuckConfig.haiku_to_sonnet_minutes) return {
-		triggered: true,
-		type: "stuck_escalation",
-		reason: `Haiku agent stuck for ${Math.round(minutesSinceActivity)} minutes`,
-		suggestedModel: "sonnet",
-		confidence: "high"
-	};
-	if (currentModel === "sonnet" && minutesSinceActivity >= stuckConfig.sonnet_to_opus_minutes) return {
-		triggered: true,
-		type: "stuck_escalation",
-		reason: `Sonnet agent stuck for ${Math.round(minutesSinceActivity)} minutes`,
-		suggestedModel: "opus",
-		confidence: "high"
-	};
-	if (currentModel === "opus") return {
-		triggered: false,
-		type: "stuck_escalation",
-		reason: "Opus agent stuck - no higher model available, manual intervention needed",
-		confidence: "high"
-	};
-	return {
-		triggered: false,
-		type: "stuck_escalation",
-		reason: `Agent stuck but threshold not reached (${Math.round(minutesSinceActivity)} minutes)`,
-		confidence: "medium"
-	};
-}
+const COST_DATA_FILE = join$1(OVERDECK_HOME, "cost-data.json");
 /**
-* Check if test failures should trigger escalation
-*
-* Aggressive escalation: Any test failure from Haiku escalates to Sonnet
-* Reasoning: Haiku is for simple tasks - if tests fail, the task isn't simple
-*
-* @param workspace - Workspace path
-* @param currentModel - Current model
-* @param config - Cloister configuration
-* @returns Trigger detection result
+* Load cost data from file
 */
-function checkTestFailure(workspace, currentModel, config) {
-	const testConfig = (config || loadCloisterConfigSync()).handoffs?.auto_triggers?.test_failure;
-	if (!testConfig?.enabled) return {
-		triggered: false,
-		type: "test_failure",
-		reason: "Test failure escalation disabled in config",
-		confidence: "high"
-	};
-	if (currentModel !== testConfig.from_model) return {
-		triggered: false,
-		type: "test_failure",
-		reason: `Test failure escalation only applies to ${testConfig.from_model} model`,
-		confidence: "high"
-	};
-	const testFailure = detectTestFailure(workspace);
-	if (testFailure.failed) return {
-		triggered: true,
-		type: "test_failure",
-		reason: `Test failures detected: ${testFailure.reason}`,
-		suggestedModel: testConfig.to_model,
-		confidence: testFailure.confidence
-	};
-	return {
-		triggered: false,
-		type: "test_failure",
-		reason: "No test failures detected",
-		confidence: "medium"
+function loadCostData() {
+	if (!existsSync(COST_DATA_FILE)) return {
+		perAgent: /* @__PURE__ */ new Map(),
+		perIssue: /* @__PURE__ */ new Map(),
+		dailyTotal: 0,
+		lastResetDate: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
 	};
+	try {
+		const fileContent = readFileSync(COST_DATA_FILE, "utf-8");
+		const persisted = JSON.parse(fileContent);
+		return {
+			perAgent: new Map(Object.entries(persisted.perAgent || {})),
+			perIssue: new Map(Object.entries(persisted.perIssue || {})),
+			dailyTotal: persisted.dailyTotal || 0,
+			lastResetDate: persisted.lastResetDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+		};
+	} catch (error) {
+		console.error("Failed to load cost data, starting fresh:", error);
+		return {
+			perAgent: /* @__PURE__ */ new Map(),
+			perIssue: /* @__PURE__ */ new Map(),
+			dailyTotal: 0,
+			lastResetDate: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+		};
+	}
 }
 /**
-* Detect test failures in workspace
-*
-* Checks for:
-* - npm test output
-* - Jest results
-* - pytest results
-* - cargo test results
-*
-* @param workspace - Workspace path
-* @returns Test failure detection
+* Save cost data to file (atomic write)
 */
-function detectTestFailure(workspace) {
-	return {
-		failed: false,
-		reason: "Test result detection not yet implemented",
-		confidence: "low"
-	};
-}
-async function checkTaskCompletionPromise(issueId, config, workspace) {
-	const completionConfig = (config || loadCloisterConfigSync()).handoffs?.auto_triggers?.implementation_complete;
-	if (!completionConfig?.enabled) return {
-		triggered: false,
-		type: "task_complete",
-		reason: "Task completion detection disabled in config",
-		confidence: "high"
-	};
-	const cacheKey = `${workspace ?? ""}::${issueId.toLowerCase()}`;
-	let mtimeMs = 0;
-	if (workspace) {
-		const beadsFile = join$1(workspace, ".beads", "issues.jsonl");
-		try {
-			mtimeMs = statSync(beadsFile).mtimeMs;
-		} catch {}
-		if (mtimeMs > 0) {
-			const cached = taskCompletionCache.get(cacheKey);
-			if (cached && cached.mtimeMs === mtimeMs) return cached.result;
-			const inflight = taskCompletionInflight.get(cacheKey);
-			if (inflight) return inflight;
-		}
-	}
-	const computePromise = (async () => {
-		if (!workspace) return {
-			triggered: false,
-			type: "task_complete",
-			reason: "No workspace available to check task completion",
-			confidence: "high"
-		};
-		const bdOptions = {
-			encoding: "utf-8",
-			cwd: workspace
-		};
-		const issueLower = issueId.toLowerCase();
-		try {
-			const { stdout: output } = await Effect.runPromise(withBdMutex(() => Effect.tryPromise({
-				try: () => execAsync$2(`bd list --json --title-contains ${issueLower} --status closed`, bdOptions),
-				catch: (cause) => cause
-			})));
-			if (JSON.parse(output).find((t) => t.title.toLowerCase().includes("implement") || t.labels?.includes("implementation"))) {
-				const { stdout: openOutput } = await execAsync$2(`bd list --json --title-contains ${issueLower} --status open`, bdOptions);
-				const openTasks = JSON.parse(openOutput);
-				if (openTasks.length === 0) return {
-					triggered: true,
-					type: "task_complete",
-					reason: "Implementation task closed, no remaining tasks",
-					suggestedModel: completionConfig.to_specialist,
-					confidence: "high"
-				};
-				return {
-					triggered: false,
-					type: "task_complete",
-					reason: `Implementation task closed but ${openTasks.length} tasks remain`,
-					confidence: "medium"
-				};
-			}
-		} catch {}
-		return {
-			triggered: false,
-			type: "task_complete",
-			reason: "No implementation completion signals detected",
-			confidence: "high"
+function saveCostData(data) {
+	try {
+		const dir = dirname$1(COST_DATA_FILE);
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		const persisted = {
+			perAgent: Object.fromEntries(data.perAgent),
+			perIssue: Object.fromEntries(data.perIssue),
+			dailyTotal: data.dailyTotal,
+			lastResetDate: data.lastResetDate
 		};
-	})();
-	if (workspace && mtimeMs > 0) {
-		taskCompletionInflight.set(cacheKey, computePromise);
+		const tempFile = `${COST_DATA_FILE}.tmp`;
+		writeFileSync(tempFile, JSON.stringify(persisted, null, 2));
+		writeFileSync(COST_DATA_FILE, readFileSync(tempFile));
 		try {
-			const result = await computePromise;
-			taskCompletionCache.set(cacheKey, {
-				mtimeMs,
-				result
-			});
-			return result;
-		} finally {
-			taskCompletionInflight.delete(cacheKey);
+			unlinkSync(tempFile);
+		} catch (unlinkError) {
+			console.debug("Failed to cleanup temp file:", unlinkError instanceof Error ? unlinkError.message : unlinkError);
 		}
+	} catch (error) {
+		console.error("Failed to save cost data:", error);
 	}
-	return computePromise;
-}
-async function checkAllTriggersPromise(agentId, workspace, issueId, currentModel, health, config) {
-	const triggers = [];
-	const stuckCheck = checkStuckEscalation(health, currentModel, config);
-	if (stuckCheck.triggered) triggers.push(stuckCheck);
-	const testCheck = checkTestFailure(workspace, currentModel, config);
-	if (testCheck.triggered) triggers.push(testCheck);
-	const completionCheck = await Effect.runPromise(checkTaskCompletion(issueId, config, workspace));
-	if (completionCheck.triggered) triggers.push(completionCheck);
-	return triggers;
 }
+let costData = loadCostData();
 /**
-* Effect-typed variant of {@link checkTaskCompletion}. Wraps the Promise-based
-* implementation; never fails (the underlying function swallows errors and
-* returns a "not triggered" detection on failure).
+* Get today's date as ISO string (YYYY-MM-DD)
 */
-function checkTaskCompletion(issueId, config, workspace) {
-	return Effect.promise(() => checkTaskCompletionPromise(issueId, config, workspace));
+function getTodayDate() {
+	return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
 }
 /**
-* Effect-typed variant of {@link checkAllTriggers}. Never fails — uses
-* `Effect.promise` because the underlying async path absorbs bd / fs errors.
+* Reset daily totals if it's a new day
 */
-function checkAllTriggers(agentId, workspace, issueId, currentModel, health, config) {
-	return Effect.promise(() => checkAllTriggersPromise(agentId, workspace, issueId, currentModel, health, config));
+function checkDailyReset() {
+	const today = getTodayDate();
+	if (costData.lastResetDate !== today) {
+		costData.dailyTotal = 0;
+		costData.lastResetDate = today;
+		console.log(`🔔 Cost monitor: Daily totals reset for ${today}`);
+		saveCostData(costData);
+	}
 }
-//#endregion
-//#region ../../lib/cloister/handoff-logger.ts
 /**
-* Handoff Event Logger
+* Check if any cost limits are being approached or exceeded
 *
-* Logs handoff events to JSONL file for tracking and analysis.
-*/
-init_paths();
+* @param agentId - Agent ID to check
+* @param issueId - Optional issue ID to check
+* @param config - Cost limits configuration
+* @returns Array of alerts (empty if no limits exceeded)
+*/
+function checkCostLimits(agentId, issueId, config = loadCloisterConfigSync().cost_limits || {
+	per_agent_usd: 10,
+	per_issue_usd: 25,
+	daily_total_usd: 100,
+	alert_threshold: .8
+}) {
+	const alerts = [];
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	if (config.per_agent_usd > 0) {
+		const agentCost = getAgentDailyCostSync(agentId);
+		const agentPercent = agentCost / config.per_agent_usd;
+		if (agentPercent >= 1) alerts.push({
+			type: "per_agent",
+			level: "limit_reached",
+			agentId,
+			currentCost: agentCost,
+			limit: config.per_agent_usd,
+			percentUsed: agentPercent * 100,
+			timestamp: now
+		});
+		else if (agentPercent >= config.alert_threshold) alerts.push({
+			type: "per_agent",
+			level: "warning",
+			agentId,
+			currentCost: agentCost,
+			limit: config.per_agent_usd,
+			percentUsed: agentPercent * 100,
+			timestamp: now
+		});
+	}
+	if (issueId && config.per_issue_usd > 0) {
+		const issueCost = getDailyTrendsSync({
+			days: 1,
+			issueId
+		}).reduce((sum, t) => sum + t.totalCost, 0);
+		const issuePercent = issueCost / config.per_issue_usd;
+		if (issuePercent >= 1) alerts.push({
+			type: "per_issue",
+			level: "limit_reached",
+			issueId,
+			currentCost: issueCost,
+			limit: config.per_issue_usd,
+			percentUsed: issuePercent * 100,
+			timestamp: now
+		});
+		else if (issuePercent >= config.alert_threshold) alerts.push({
+			type: "per_issue",
+			level: "warning",
+			issueId,
+			currentCost: issueCost,
+			limit: config.per_issue_usd,
+			percentUsed: issuePercent * 100,
+			timestamp: now
+		});
+	}
+	if (config.daily_total_usd > 0) {
+		const dailyTotal = getDailyTrendsSync({ days: 1 }).reduce((sum, t) => sum + t.totalCost, 0);
+		const dailyPercent = dailyTotal / config.daily_total_usd;
+		if (dailyPercent >= 1) alerts.push({
+			type: "daily_total",
+			level: "limit_reached",
+			currentCost: dailyTotal,
+			limit: config.daily_total_usd,
+			percentUsed: dailyPercent * 100,
+			timestamp: now
+		});
+		else if (dailyPercent >= config.alert_threshold) alerts.push({
+			type: "daily_total",
+			level: "warning",
+			currentCost: dailyTotal,
+			limit: config.daily_total_usd,
+			percentUsed: dailyPercent * 100,
+			timestamp: now
+		});
+	}
+	return alerts;
+}
 /**
-* Handoff log file path
+* Get cost summary
+*
+* @returns Cost summary with top spenders
 */
-const HANDOFF_LOG_FILE = join$1(OVERDECK_HOME, "logs", "handoffs.jsonl");
+function getCostSummary() {
+	checkDailyReset();
+	const topAgents = Array.from(costData.perAgent.entries()).map(([agentId, cost]) => ({
+		agentId,
+		cost
+	})).sort((a, b) => b.cost - a.cost).slice(0, 10);
+	const topIssues = Array.from(costData.perIssue.entries()).map(([issueId, cost]) => ({
+		issueId,
+		cost
+	})).sort((a, b) => b.cost - a.cost).slice(0, 10);
+	return {
+		dailyTotal: costData.dailyTotal,
+		topAgents,
+		topIssues
+	};
+}
+//#endregion
+//#region ../../lib/cloister/service-reactive.ts
+/** Cloister reactive lifecycle scheduler. */
+init_agents();
+init_tmux();
+init_issue_closed();
+init_merge_verification();
+const execAsync$2 = promisify(exec);
+/** Return issues orphaned in reviewStatus='reviewing' with no active reviewer. */
+function identifyOrphanedReviewingIssues(statuses, activeReviewIssues) {
+	const orphaned = [];
+	for (const [issueId, status] of Object.entries(statuses)) {
+		if (status.reviewStatus !== "reviewing") continue;
+		if (status.history?.some((h) => h.type === "review" && h.status === "passed")) continue;
+		if (activeReviewIssues.has(issueId.toUpperCase())) continue;
+		orphaned.push(issueId);
+	}
+	return orphaned;
+}
+function parseSpecialistAgentSession(name) {
+	const issueScoped = name.match(/^specialist-(.+)-([A-Z]+-\d+)-(review-agent|test-agent|merge-agent)$/);
+	if (issueScoped) return {
+		projectKey: issueScoped[1],
+		issueId: issueScoped[2],
+		specialistType: issueScoped[3]
+	};
+	const legacy = name.match(/^specialist-(.+)-(review-agent|test-agent|merge-agent)$/);
+	if (legacy) return {
+		projectKey: legacy[1],
+		specialistType: legacy[2]
+	};
+	return null;
+}
+const ROLE_RUN_STATES = {
+	todo: null,
+	open: null,
+	in_planning: "plan",
+	in_progress: "work",
+	in_review: "review",
+	testing: "test",
+	shipping: null,
+	closed: null,
+	canceled: null
+};
 /**
-* Ensure log directory exists
+* Map issue lifecycle state to the role that should own that state.
 */
-function ensureLogDir() {
-	const logDir = join$1(OVERDECK_HOME, "logs");
-	if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+function stateToRole(state) {
+	return ROLE_RUN_STATES[state.toLowerCase().replace(/[ -]/g, "_")] ?? null;
+}
+function normalizeIssueId(issueId) {
+	return issueId.trim().toUpperCase();
+}
+function roleFromAgentId(agentId, issueId) {
+	const base = `agent-${issueId.toLowerCase()}`;
+	if (agentId === base) return "work";
+	const role = agentId.slice(base.length + 1);
+	return [
+		"plan",
+		"review",
+		"test"
+	].includes(role) ? role : null;
+}
+/**
+* Grace window for `starting` states without a tmux session yet. The
+* start-planning route deliberately writes state.json BEFORE the lifecycle
+* transition (PAN-1048) so this guard can see the planner coming — but the
+* tmux session is only created after the transition. Treating any
+* starting-without-session as dead (the original S1 unstick heuristic)
+* re-opened the PAN-1048 race and spawned a duplicate `agent-<issue>-plan`
+* twin on EVERY `pan plan` (PAN-2159, 100% repro). A fresh `starting` state
+* is a startup in progress; only a stale one is a crashed spawn to unstick.
+*/
+const STARTING_WITHOUT_SESSION_GRACE_MS = 12e4;
+function isFreshStarting(state) {
+	const startedAt = Date.parse(state.startedAt ?? "");
+	return Number.isFinite(startedAt) && Date.now() - startedAt < STARTING_WITHOUT_SESSION_GRACE_MS;
+}
+async function activeRoleRunExists(issueId, role, workspacePath) {
+	const issueLower = issueId.toLowerCase();
+	if (role === "plan") {
+		const legacyId = `planning-${issueLower}`;
+		const legacyState = await Effect.runPromise(getAgentState(legacyId));
+		if (legacyState?.role === "plan" && legacyState.status !== "stopped" && legacyState.status !== "error") {
+			if (legacyState.status === "starting" && !await Effect.runPromise(sessionExists(legacyId))) return isFreshStarting(legacyState);
+			return true;
+		}
+	}
+	const candidateId = role === "work" ? `agent-${issueLower}` : `agent-${issueLower}-${role}`;
+	const state = await Effect.runPromise(getAgentState(candidateId));
+	if (!state) return false;
+	const stateRole = state.role ?? roleFromAgentId(candidateId, issueId);
+	if (stateRole === role && state.status === "starting" && !await Effect.runPromise(sessionExists(candidateId))) return isFreshStarting(state);
+	if (!(stateRole === role && state.status !== "stopped" && state.status !== "error")) return false;
+	if (workspacePath && state.roleRunHead) try {
+		const { stdout } = await execAsync$2("git rev-parse --short=8 HEAD", { cwd: workspacePath });
+		const currentHead = stdout.trim();
+		if (currentHead && currentHead !== state.roleRunHead) {
+			console.log(`[cloister] ${issueId}: ${role} session ${candidateId} is stale (ran against ${state.roleRunHead}, HEAD is now ${currentHead}) — not active`);
+			return false;
+		}
+	} catch {}
+	return true;
+}
+function buildReactiveRolePrompt(issueId, state, role) {
+	return `${role.toUpperCase()} TASK for ${issueId}:
+
+The issue lifecycle transitioned to ${state}. Run the ${role} role for this issue.
+
+Required steps:
+1. Work only in the workspace configured for ${issueId}.
+2. Read .pan/continue.json, .pan/spec.vbrief.json, project instructions, and issue context.
+3. Follow the boundaries and success criteria in roles/${role}.md exactly.
+4. Report the role-specific terminal status when done.`;
+}
+/**
+* Resolve the workspace path for an issue from agent state, then fall back
+* to the canonical `<projectPath>/workspaces/feature-<issueLower>` layout.
+* Mirrors the resolution used by startup recovery (service.ts:583-609) so
+* the reactive scheduler dispatches review/test wrappers with the same
+* workspace contract those wrappers receive on the manual code path.
+*/
+async function resolveWorkspaceForIssue(issueId) {
+	const issueLower = issueId.toLowerCase();
+	const agentState = await Effect.runPromise(getAgentState(`agent-${issueLower}`));
+	if (agentState?.workspace) return agentState.workspace;
+	const resolved = resolveProjectFromIssueSync(issueId);
+	if (!resolved) return null;
+	return `${resolved.projectPath}/workspaces/feature-${issueLower}`;
+}
+async function onIssueStateChangePromise(issueId, newState) {
+	const normalizedIssueId = normalizeIssueId(issueId);
+	const role = stateToRole(newState);
+	if (!role) {
+		console.log(`[cloister] ${normalizedIssueId}: no role for issue state '${newState}'`);
+		return;
+	}
+	if (await isIssueClosed(normalizedIssueId)) {
+		const message = `${normalizedIssueId}: skipping ${role} dispatch — issue is closed`;
+		console.log(`[cloister] ${message}`);
+		emitActivityEntrySync({
+			source: "cloister",
+			level: "info",
+			message,
+			issueId: normalizedIssueId
+		});
+		return;
+	}
+	const { getReviewStatusSync } = await import("./review-status-CG0iDuWa.js");
+	if (getReviewStatusSync(normalizedIssueId)?.mergeStatus === "merged") {
+		const message = `${normalizedIssueId}: skipping ${role} dispatch — merge already landed (merge_status='merged' is terminal)`;
+		console.log(`[cloister] ${message}`);
+		emitActivityEntrySync({
+			source: "cloister",
+			level: "info",
+			message,
+			issueId: normalizedIssueId
+		});
+		return;
+	}
+	const mergedGuard = await shouldSkipDispatchAsMerged(normalizedIssueId);
+	if (mergedGuard.skip) {
+		const message = `${normalizedIssueId}: skipping ${role} dispatch — ${mergedGuard.reason}`;
+		console.log(`[cloister] ${message}`);
+		emitActivityEntrySync({
+			source: "cloister",
+			level: "info",
+			message,
+			issueId: normalizedIssueId
+		});
+		return;
+	}
+	const workspace = await resolveWorkspaceForIssue(normalizedIssueId);
+	if (await activeRoleRunExists(normalizedIssueId, role, workspace ?? void 0)) {
+		const message = `${normalizedIssueId}: ${role} role already active; skipping lifecycle spawn`;
+		console.log(`[cloister] ${message}`);
+		emitActivityEntrySync({
+			source: "cloister",
+			level: "info",
+			message,
+			issueId: normalizedIssueId
+		});
+		return;
+	}
+	const issueLower = normalizedIssueId.toLowerCase();
+	const roleSessionId = role === "work" ? `agent-${issueLower}` : `agent-${issueLower}-${role}`;
+	if (await Effect.runPromise(sessionExists(roleSessionId))) {
+		const message = `${normalizedIssueId}: killing stale ${role} session ${roleSessionId} before re-dispatch`;
+		console.log(`[cloister] ${message}`);
+		emitActivityEntrySync({
+			source: "cloister",
+			level: "info",
+			message,
+			issueId: normalizedIssueId
+		});
+		try {
+			await Effect.runPromise(killSession(roleSessionId));
+		} catch (err) {
+			console.error(`[cloister] failed to kill stale session ${roleSessionId}:`, err instanceof Error ? err.message : String(err));
+		}
+	}
+	try {
+		if (role === "review") {
+			if (!workspace) {
+				const failure = `${normalizedIssueId}: cannot dispatch review role — no workspace or project resolved`;
+				console.error(`[cloister] ${failure}`);
+				emitActivityEntrySync({
+					source: "cloister",
+					level: "error",
+					message: failure,
+					issueId: normalizedIssueId
+				});
+				return;
+			}
+			const branch = `feature/${normalizedIssueId.toLowerCase()}`;
+			const { spawnReviewRoleForIssue } = await import("./review-agent-u5q3ip7H.js");
+			const result = await Effect.runPromise(spawnReviewRoleForIssue({
+				issueId: normalizedIssueId,
+				workspace,
+				branch
+			}));
+			const message = `${normalizedIssueId}: review role dispatched from lifecycle state '${newState}' (${result.message})`;
+			console.log(`[cloister] ${message}`);
+			emitActivityEntrySync({
+				source: "cloister",
+				level: result.success ? "info" : "error",
+				message,
+				issueId: normalizedIssueId
+			});
+			return;
+		}
+		if (role === "test") {
+			const branch = `feature/${normalizedIssueId.toLowerCase()}`;
+			const { dispatchTestAgentAndNotify } = await import("./test-agent-queue-CnuYku4B.js");
+			await Effect.runPromise(dispatchTestAgentAndNotify(normalizedIssueId, workspace ?? void 0, branch));
+			const message = `${normalizedIssueId}: test role dispatched from lifecycle state '${newState}'`;
+			console.log(`[cloister] ${message}`);
+			emitActivityEntrySync({
+				source: "cloister",
+				level: "info",
+				message,
+				issueId: normalizedIssueId
+			});
+			return;
+		}
+		const { spawnRun } = await import("./agents-CEcaxSkR.js");
+		const message = `${normalizedIssueId}: ${role} role started from lifecycle state '${newState}' as ${(await spawnRun(normalizedIssueId, role, { prompt: buildReactiveRolePrompt(normalizedIssueId, newState, role) })).id}`;
+		console.log(`[cloister] ${message}`);
+		emitActivityEntrySync({
+			source: "cloister",
+			level: "info",
+			message,
+			issueId: normalizedIssueId
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (message.includes("already running")) {
+			const skipMessage = `${normalizedIssueId}: ${role} role already running; skipping lifecycle spawn`;
+			console.log(`[cloister] ${skipMessage}`);
+			emitActivityEntrySync({
+				source: "cloister",
+				level: "info",
+				message: skipMessage,
+				issueId: normalizedIssueId
+			});
+			return;
+		}
+		console.error(`[cloister] Failed to start ${role} role for ${normalizedIssueId}:`, error);
+		emitActivityEntrySync({
+			source: "cloister",
+			level: "error",
+			message: `${normalizedIssueId}: failed to start ${role} role: ${message}`,
+			issueId: normalizedIssueId
+		});
+	}
+}
+function payloadRecord(event) {
+	return event.payload && typeof event.payload === "object" ? event.payload : {};
+}
+function issueStateChangeFromDomainEvent(event) {
+	const payload = payloadRecord(event);
+	const issueId = typeof payload.issueId === "string" ? payload.issueId : null;
+	if (!issueId) return null;
+	switch (event.type) {
+		case "issue.transitioned": return typeof payload.state === "string" ? {
+			issueId,
+			state: payload.state
+		} : null;
+		case "issue.statusChanged": return typeof payload.canonicalStatus === "string" ? {
+			issueId,
+			state: payload.canonicalStatus
+		} : null;
+		case "issue.closed": return {
+			issueId,
+			state: "closed"
+		};
+		case "agent.completed": {
+			const role = typeof payload.role === "string" ? payload.role : void 0;
+			if (role === void 0 || role === "work") return {
+				issueId,
+				state: "in_review"
+			};
+			return null;
+		}
+		case "work.completed": return {
+			issueId,
+			state: "in_review"
+		};
+		case "review.approved": return {
+			issueId,
+			state: "testing"
+		};
+		case "test.passed": return {
+			issueId,
+			state: "shipping"
+		};
+		default: return null;
+	}
+}
+async function handleCloisterDomainEventPromise(event) {
+	if (event.type === "agent.stopped") {
+		const agentId = event.payload?.agentId;
+		if (agentId) {
+			const { handleAgentStoppedEvent, handleAgentStoppedForOrphanReviewerSessions } = await import("./deacon-DONuopff.js");
+			const { handleAgentLifecycleEventForIdleStack } = await import("./idle-stack-reaper-H0W6XtHh.js");
+			handleAgentLifecycleEventForIdleStack(agentId);
+			const slotMatch = /^agent-(.+)-slot-\d+$/.exec(agentId);
+			await Promise.all([
+				handleAgentStoppedEvent(agentId),
+				handleAgentStoppedForOrphanReviewerSessions(agentId),
+				slotMatch ? (await import("./deacon-swarm-CvdFekIO.js")).coordinateSwarmSlots({ issueId: slotMatch[1].toUpperCase() }) : Promise.resolve([])
+			]);
+		}
+		return;
+	}
+	if (event.type === "agent.started") {
+		const agentId = event.payload?.agentId;
+		if (agentId) (await import("./idle-stack-reaper-H0W6XtHh.js")).handleAgentLifecycleEventForIdleStack(agentId);
+		return;
+	}
+	if (event.type === "agent.heartbeat_dead") {
+		const agentId = event.payload?.agentId;
+		if (agentId) {
+			const { handleAgentHeartbeatDeadEvent } = await import("./deacon-DONuopff.js");
+			await handleAgentHeartbeatDeadEvent(agentId, "event");
+		}
+		return;
+	}
+	if (event.type === "review.coordinator.died") {
+		const payload = event.payload;
+		const issueId = payload?.issueId;
+		if (issueId) {
+			const { handleReviewCoordinatorDied } = await import("./deacon-DONuopff.js");
+			await handleReviewCoordinatorDied(issueId, payload?.sessionName ?? "", payload?.reason ?? "");
+		}
+		return;
+	}
+	if (event.type === "work.completed") {
+		const issueId = event.payload?.issueId;
+		if (issueId) {
+			const { handleWorkCompleted } = await import("./deacon-DONuopff.js");
+			await handleWorkCompleted(issueId);
+		}
+	}
+	if (event.type === "issue.statusChanged") {
+		const payload = event.payload;
+		const issueId = payload?.issueId;
+		const canonicalStatus = payload?.canonicalStatus?.toLowerCase();
+		const status = payload?.status?.toLowerCase();
+		if (issueId) {
+			if (canonicalStatus === "closed" || status === "closed") {
+				const { handleIssueStatusChangedClosed } = await import("./closed-issue-reaper-CksfuiFD.js");
+				await handleIssueStatusChangedClosed(issueId);
+				return;
+			}
+			if (canonicalStatus === "todo" || status === "planned" || status === "todo") {
+				const { handleOrphanProposedSpec } = await import("./orphan-proposed-reconciler-BIcNu4tl.js");
+				await handleOrphanProposedSpec(issueId);
+			}
+		}
+	}
+	const change = issueStateChangeFromDomainEvent(event);
+	if (!change) return;
+	await Effect.runPromise(onIssueStateChange(change.issueId, change.state));
 }
 /**
-* Log a handoff event
-*
-* @param event - Handoff event to log
+* Effect-typed variant of {@link onIssueStateChange}. Never fails — failures
+* surface through `emitActivityEntry` inside the legacy implementation.
 */
-function logHandoffEventSync(event) {
-	ensureLogDir();
-	appendFileSync(HANDOFF_LOG_FILE, JSON.stringify(event) + "\n", "utf-8");
+function onIssueStateChange(issueId, newState) {
+	return Effect.promise(() => onIssueStateChangePromise(issueId, newState));
 }
 /**
-* Create a handoff event from handoff result
-*
-* @param agentId - Agent ID
-* @param issueId - Issue ID
-* @param context - Handoff context
-* @param trigger - Trigger type
-* @param success - Whether handoff succeeded
-* @param errorMessage - Error message if failed
-* @returns Handoff event
+* Effect-typed variant of {@link handleCloisterDomainEvent}. Never fails.
 */
-function createHandoffEvent(agentId, issueId, context, trigger, success, errorMessage) {
-	let stuckMinutes;
-	if (trigger === "stuck_escalation") {}
-	return {
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		agentId,
-		issueId,
-		from: {
-			model: context.previousModel,
-			runtime: context.previousRuntime,
-			sessionId: context.previousSessionId
-		},
-		to: {
-			model: context.targetModel,
-			runtime: context.previousRuntime,
-			sessionId: void 0
-		},
-		trigger,
-		reason: context.reason,
-		context: {
-			costAtHandoff: context.costSoFar,
-			handoffCount: context.handoffCount,
-			stuckMinutes
-		},
-		success,
-		errorMessage
-	};
+function handleCloisterDomainEvent(event) {
+	return Effect.promise(() => handleCloisterDomainEventPromise(event));
 }
 //#endregion
 //#region ../../lib/cloister/fpp-violations.ts
@@ -1633,198 +1919,71 @@ function clearOldViolationsSync(hoursOld = 24) {
 	if (changed) saveViolations(activeViolations);
 }
 //#endregion
-//#region ../../lib/cloister/cost-monitor.ts
+//#region ../../lib/cloister/handoff-logger.ts
 /**
-* Cost Monitor
+* Handoff Event Logger
 *
-* Monitors agent costs against configured limits and emits alerts.
-* Does NOT automatically stop agents - just provides visibility and warnings.
+* Logs handoff events to JSONL file for tracking and analysis.
 */
 init_errors();
-init_paths();
-init_config();
-init_cost_sync();
-/**
-* Path to cost data file
-*/
-const COST_DATA_FILE = join$1(OVERDECK_HOME, "cost-data.json");
-/**
-* Load cost data from file
-*/
-function loadCostData() {
-	if (!existsSync(COST_DATA_FILE)) return {
-		perAgent: /* @__PURE__ */ new Map(),
-		perIssue: /* @__PURE__ */ new Map(),
-		dailyTotal: 0,
-		lastResetDate: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
-	};
-	try {
-		const fileContent = readFileSync(COST_DATA_FILE, "utf-8");
-		const persisted = JSON.parse(fileContent);
-		return {
-			perAgent: new Map(Object.entries(persisted.perAgent || {})),
-			perIssue: new Map(Object.entries(persisted.perIssue || {})),
-			dailyTotal: persisted.dailyTotal || 0,
-			lastResetDate: persisted.lastResetDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
-		};
-	} catch (error) {
-		console.error("Failed to load cost data, starting fresh:", error);
-		return {
-			perAgent: /* @__PURE__ */ new Map(),
-			perIssue: /* @__PURE__ */ new Map(),
-			dailyTotal: 0,
-			lastResetDate: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
-		};
-	}
-}
-/**
-* Save cost data to file (atomic write)
-*/
-function saveCostData(data) {
-	try {
-		const dir = dirname$1(COST_DATA_FILE);
-		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-		const persisted = {
-			perAgent: Object.fromEntries(data.perAgent),
-			perIssue: Object.fromEntries(data.perIssue),
-			dailyTotal: data.dailyTotal,
-			lastResetDate: data.lastResetDate
-		};
-		const tempFile = `${COST_DATA_FILE}.tmp`;
-		writeFileSync(tempFile, JSON.stringify(persisted, null, 2));
-		writeFileSync(COST_DATA_FILE, readFileSync(tempFile));
-		try {
-			unlinkSync(tempFile);
-		} catch (unlinkError) {
-			console.debug("Failed to cleanup temp file:", unlinkError instanceof Error ? unlinkError.message : unlinkError);
-		}
-	} catch (error) {
-		console.error("Failed to save cost data:", error);
-	}
-}
-let costData = loadCostData();
-/**
-* Get today's date as ISO string (YYYY-MM-DD)
-*/
-function getTodayDate() {
-	return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-}
-/**
-* Reset daily totals if it's a new day
-*/
-function checkDailyReset() {
-	const today = getTodayDate();
-	if (costData.lastResetDate !== today) {
-		costData.dailyTotal = 0;
-		costData.lastResetDate = today;
-		console.log(`🔔 Cost monitor: Daily totals reset for ${today}`);
-		saveCostData(costData);
-	}
-}
-/**
-* Check if any cost limits are being approached or exceeded
-*
-* @param agentId - Agent ID to check
-* @param issueId - Optional issue ID to check
-* @param config - Cost limits configuration
-* @returns Array of alerts (empty if no limits exceeded)
-*/
-function checkCostLimits(agentId, issueId, config = loadCloisterConfigSync().cost_limits || {
-	per_agent_usd: 10,
-	per_issue_usd: 25,
-	daily_total_usd: 100,
-	alert_threshold: .8
-}) {
-	const alerts = [];
-	const now = (/* @__PURE__ */ new Date()).toISOString();
-	if (config.per_agent_usd > 0) {
-		const agentCost = getAgentDailyCostSync(agentId);
-		const agentPercent = agentCost / config.per_agent_usd;
-		if (agentPercent >= 1) alerts.push({
-			type: "per_agent",
-			level: "limit_reached",
-			agentId,
-			currentCost: agentCost,
-			limit: config.per_agent_usd,
-			percentUsed: agentPercent * 100,
-			timestamp: now
-		});
-		else if (agentPercent >= config.alert_threshold) alerts.push({
-			type: "per_agent",
-			level: "warning",
-			agentId,
-			currentCost: agentCost,
-			limit: config.per_agent_usd,
-			percentUsed: agentPercent * 100,
-			timestamp: now
-		});
-	}
-	if (issueId && config.per_issue_usd > 0) {
-		const issueCost = getDailyTrendsSync({
-			days: 1,
-			issueId
-		}).reduce((sum, t) => sum + t.totalCost, 0);
-		const issuePercent = issueCost / config.per_issue_usd;
-		if (issuePercent >= 1) alerts.push({
-			type: "per_issue",
-			level: "limit_reached",
-			issueId,
-			currentCost: issueCost,
-			limit: config.per_issue_usd,
-			percentUsed: issuePercent * 100,
-			timestamp: now
-		});
-		else if (issuePercent >= config.alert_threshold) alerts.push({
-			type: "per_issue",
-			level: "warning",
-			issueId,
-			currentCost: issueCost,
-			limit: config.per_issue_usd,
-			percentUsed: issuePercent * 100,
-			timestamp: now
-		});
-	}
-	if (config.daily_total_usd > 0) {
-		const dailyTotal = getDailyTrendsSync({ days: 1 }).reduce((sum, t) => sum + t.totalCost, 0);
-		const dailyPercent = dailyTotal / config.daily_total_usd;
-		if (dailyPercent >= 1) alerts.push({
-			type: "daily_total",
-			level: "limit_reached",
-			currentCost: dailyTotal,
-			limit: config.daily_total_usd,
-			percentUsed: dailyPercent * 100,
-			timestamp: now
-		});
-		else if (dailyPercent >= config.alert_threshold) alerts.push({
-			type: "daily_total",
-			level: "warning",
-			currentCost: dailyTotal,
-			limit: config.daily_total_usd,
-			percentUsed: dailyPercent * 100,
-			timestamp: now
-		});
-	}
-	return alerts;
+init_paths();
+/**
+* Handoff log file path
+*/
+const HANDOFF_LOG_FILE = join$1(OVERDECK_HOME, "logs", "handoffs.jsonl");
+/**
+* Ensure log directory exists
+*/
+function ensureLogDir() {
+	const logDir = join$1(OVERDECK_HOME, "logs");
+	if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
 }
 /**
-* Get cost summary
+* Log a handoff event
 *
-* @returns Cost summary with top spenders
+* @param event - Handoff event to log
 */
-function getCostSummary() {
-	checkDailyReset();
-	const topAgents = Array.from(costData.perAgent.entries()).map(([agentId, cost]) => ({
+function logHandoffEventSync(event) {
+	ensureLogDir();
+	appendFileSync(HANDOFF_LOG_FILE, JSON.stringify(event) + "\n", "utf-8");
+}
+/**
+* Create a handoff event from handoff result
+*
+* @param agentId - Agent ID
+* @param issueId - Issue ID
+* @param context - Handoff context
+* @param trigger - Trigger type
+* @param success - Whether handoff succeeded
+* @param errorMessage - Error message if failed
+* @returns Handoff event
+*/
+function createHandoffEvent(agentId, issueId, context, trigger, success, errorMessage) {
+	let stuckMinutes;
+	if (trigger === "stuck_escalation") {}
+	return {
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 		agentId,
-		cost
-	})).sort((a, b) => b.cost - a.cost).slice(0, 10);
-	const topIssues = Array.from(costData.perIssue.entries()).map(([issueId, cost]) => ({
 		issueId,
-		cost
-	})).sort((a, b) => b.cost - a.cost).slice(0, 10);
-	return {
-		dailyTotal: costData.dailyTotal,
-		topAgents,
-		topIssues
+		from: {
+			model: context.previousModel,
+			runtime: context.previousRuntime,
+			sessionId: context.previousSessionId
+		},
+		to: {
+			model: context.targetModel,
+			runtime: context.previousRuntime,
+			sessionId: void 0
+		},
+		trigger,
+		reason: context.reason,
+		context: {
+			costAtHandoff: context.costSoFar,
+			handoffCount: context.handoffCount,
+			stuckMinutes
+		},
+		success,
+		errorMessage
 	};
 }
 //#endregion
@@ -2032,404 +2191,944 @@ function checkAndRotateIfNeeded(specialistName, workingDir) {
 	return Effect.promise(() => checkAndRotateIfNeededPromise(specialistName, workingDir));
 }
 //#endregion
-//#region ../../lib/cloister/service.ts
-/** Cloister service: core monitoring for all running agents. */
+//#region ../../lib/cloister/triggers.ts
 init_config();
-init_agents();
-init_paths();
-init_reap_terminal_sessions();
-init_tmux();
-init_issue_closed();
-init_merge_verification();
-const execAsync = promisify(exec);
-const CLOISTER_STATE_FILE = join$1(OVERDECK_HOME, "cloister.state");
-const LEGACY_SPECIALISTS_DIR = join$1(OVERDECK_HOME, "specialists");
-async function cleanupLegacySpecialistsDirectory() {
-	await rm(LEGACY_SPECIALISTS_DIR, {
-		recursive: true,
-		force: true
-	});
+init_resolver();
+/** Single-flight prevents concurrent dashboard polls from duplicating the canonical read. */
+const taskCompletionInflight = /* @__PURE__ */ new Map();
+/**
+* Check if agent should be handed off due to stuck escalation
+*
+* Model-specific thresholds:
+* - Haiku: Stuck after 10 minutes → escalate to Sonnet
+* - Sonnet: Stuck after 20 minutes → escalate to Opus
+* - Opus: Stuck after 30 minutes → alert user (no auto-escalation)
+*
+* @param health - Agent health state
+* @param currentModel - Current model
+* @param config - Cloister configuration
+* @returns Trigger detection result
+*/
+function checkStuckEscalation(health, currentModel, config) {
+	const stuckConfig = (config || loadCloisterConfigSync()).handoffs?.auto_triggers?.stuck_escalation;
+	if (!stuckConfig?.enabled) return {
+		triggered: false,
+		type: "stuck_escalation",
+		reason: "Stuck escalation disabled in config",
+		confidence: "high"
+	};
+	if (health.state !== "stuck") return {
+		triggered: false,
+		type: "stuck_escalation",
+		reason: `Agent is ${health.state}, not stuck`,
+		confidence: "high"
+	};
+	if (!health.lastActivity) return {
+		triggered: false,
+		type: "stuck_escalation",
+		reason: "No last activity timestamp available",
+		confidence: "low"
+	};
+	const minutesSinceActivity = (Date.now() - health.lastActivity.getTime()) / (1e3 * 60);
+	if (currentModel === "haiku" && minutesSinceActivity >= stuckConfig.haiku_to_sonnet_minutes) return {
+		triggered: true,
+		type: "stuck_escalation",
+		reason: `Haiku agent stuck for ${Math.round(minutesSinceActivity)} minutes`,
+		suggestedModel: "sonnet",
+		confidence: "high"
+	};
+	if (currentModel === "sonnet" && minutesSinceActivity >= stuckConfig.sonnet_to_opus_minutes) return {
+		triggered: true,
+		type: "stuck_escalation",
+		reason: `Sonnet agent stuck for ${Math.round(minutesSinceActivity)} minutes`,
+		suggestedModel: "opus",
+		confidence: "high"
+	};
+	if (currentModel === "opus") return {
+		triggered: false,
+		type: "stuck_escalation",
+		reason: "Opus agent stuck - no higher model available, manual intervention needed",
+		confidence: "high"
+	};
+	return {
+		triggered: false,
+		type: "stuck_escalation",
+		reason: `Agent stuck but threshold not reached (${Math.round(minutesSinceActivity)} minutes)`,
+		confidence: "medium"
+	};
 }
-/** Return issues orphaned in reviewStatus='reviewing' with no active reviewer. */
-function identifyOrphanedReviewingIssues(statuses, activeReviewIssues) {
-	const orphaned = [];
-	for (const [issueId, status] of Object.entries(statuses)) {
-		if (status.reviewStatus !== "reviewing") continue;
-		if (status.history?.some((h) => h.type === "review" && h.status === "passed")) continue;
-		if (activeReviewIssues.has(issueId.toUpperCase())) continue;
-		orphaned.push(issueId);
-	}
-	return orphaned;
+/**
+* Check if test failures should trigger escalation
+*
+* Aggressive escalation: Any test failure from Haiku escalates to Sonnet
+* Reasoning: Haiku is for simple tasks - if tests fail, the task isn't simple
+*
+* @param workspace - Workspace path
+* @param currentModel - Current model
+* @param config - Cloister configuration
+* @returns Trigger detection result
+*/
+function checkTestFailure(workspace, currentModel, config) {
+	const testConfig = (config || loadCloisterConfigSync()).handoffs?.auto_triggers?.test_failure;
+	if (!testConfig?.enabled) return {
+		triggered: false,
+		type: "test_failure",
+		reason: "Test failure escalation disabled in config",
+		confidence: "high"
+	};
+	if (currentModel !== testConfig.from_model) return {
+		triggered: false,
+		type: "test_failure",
+		reason: `Test failure escalation only applies to ${testConfig.from_model} model`,
+		confidence: "high"
+	};
+	const testFailure = detectTestFailure(workspace);
+	if (testFailure.failed) return {
+		triggered: true,
+		type: "test_failure",
+		reason: `Test failures detected: ${testFailure.reason}`,
+		suggestedModel: testConfig.to_model,
+		confidence: testFailure.confidence
+	};
+	return {
+		triggered: false,
+		type: "test_failure",
+		reason: "No test failures detected",
+		confidence: "medium"
+	};
 }
-function parseSpecialistAgentSession(name) {
-	const issueScoped = name.match(/^specialist-(.+)-([A-Z]+-\d+)-(review-agent|test-agent|merge-agent)$/);
-	if (issueScoped) return {
-		projectKey: issueScoped[1],
-		issueId: issueScoped[2],
-		specialistType: issueScoped[3]
+/**
+* Detect test failures in workspace
+*
+* Checks for:
+* - npm test output
+* - Jest results
+* - pytest results
+* - cargo test results
+*
+* @param workspace - Workspace path
+* @returns Test failure detection
+*/
+function detectTestFailure(workspace) {
+	return {
+		failed: false,
+		reason: "Test result detection not yet implemented",
+		confidence: "low"
 	};
-	const legacy = name.match(/^specialist-(.+)-(review-agent|test-agent|merge-agent)$/);
-	if (legacy) return {
-		projectKey: legacy[1],
-		specialistType: legacy[2]
+}
+async function checkTaskCompletionPromise(issueId, config, workspace) {
+	const completionConfig = (config || loadCloisterConfigSync()).handoffs?.auto_triggers?.implementation_complete;
+	if (!completionConfig?.enabled) return {
+		triggered: false,
+		type: "task_complete",
+		reason: "Task completion detection disabled in config",
+		confidence: "high"
 	};
-	return null;
+	const cacheKey = `${workspace ?? ""}::${issueId.toLowerCase()}`;
+	const inflight = taskCompletionInflight.get(cacheKey);
+	if (inflight) return inflight;
+	const computePromise = (async () => {
+		if (!workspace) return {
+			triggered: false,
+			type: "task_complete",
+			reason: "No workspace available to check task completion",
+			confidence: "high"
+		};
+		try {
+			const result = await createBeadsResolver(workspace).getBeadsForIssue(issueId);
+			if (!result.ok) throw result.error;
+			if (result.value.filter((task) => task.status === "closed").find((t) => t.title.toLowerCase().includes("implement") || t.labels?.includes("implementation"))) {
+				const openTasks = result.value.filter((task) => task.status === "open");
+				if (openTasks.length === 0) return {
+					triggered: true,
+					type: "task_complete",
+					reason: "Implementation task closed, no remaining tasks",
+					suggestedModel: completionConfig.to_specialist,
+					confidence: "high"
+				};
+				return {
+					triggered: false,
+					type: "task_complete",
+					reason: `Implementation task closed but ${openTasks.length} tasks remain`,
+					confidence: "medium"
+				};
+			}
+		} catch {}
+		return {
+			triggered: false,
+			type: "task_complete",
+			reason: "No implementation completion signals detected",
+			confidence: "high"
+		};
+	})();
+	taskCompletionInflight.set(cacheKey, computePromise);
+	try {
+		return await computePromise;
+	} finally {
+		taskCompletionInflight.delete(cacheKey);
+	}
 }
-let cloisterEventStoreProvider = null;
-function setCloisterEventStoreProvider(provider) {
-	cloisterEventStoreProvider = provider;
+async function checkAllTriggersPromise(agentId, workspace, issueId, currentModel, health, config) {
+	const triggers = [];
+	const stuckCheck = checkStuckEscalation(health, currentModel, config);
+	if (stuckCheck.triggered) triggers.push(stuckCheck);
+	const testCheck = checkTestFailure(workspace, currentModel, config);
+	if (testCheck.triggered) triggers.push(testCheck);
+	const completionCheck = await Effect.runPromise(checkTaskCompletion(issueId, config, workspace));
+	if (completionCheck.triggered) triggers.push(completionCheck);
+	return triggers;
 }
-const ROLE_RUN_STATES = {
-	todo: null,
-	open: null,
-	in_planning: "plan",
-	in_progress: "work",
-	in_review: "review",
-	testing: "test",
-	shipping: null,
-	closed: null,
-	canceled: null
-};
 /**
-* Map issue lifecycle state to the role that should own that state.
+* Effect-typed variant of {@link checkTaskCompletion}. Wraps the Promise-based
+* implementation; never fails (the underlying function swallows errors and
+* returns a "not triggered" detection on failure).
 */
-function stateToRole(state) {
-	return ROLE_RUN_STATES[state.toLowerCase().replace(/[ -]/g, "_")] ?? null;
-}
-function normalizeIssueId(issueId) {
-	return issueId.trim().toUpperCase();
-}
-function roleFromAgentId(agentId, issueId) {
-	const base = `agent-${issueId.toLowerCase()}`;
-	if (agentId === base) return "work";
-	const role = agentId.slice(base.length + 1);
-	return [
-		"plan",
-		"review",
-		"test"
-	].includes(role) ? role : null;
+function checkTaskCompletion(issueId, config, workspace) {
+	return Effect.promise(() => checkTaskCompletionPromise(issueId, config, workspace));
 }
 /**
-* Grace window for `starting` states without a tmux session yet. The
-* start-planning route deliberately writes state.json BEFORE the lifecycle
-* transition (PAN-1048) so this guard can see the planner coming — but the
-* tmux session is only created after the transition. Treating any
-* starting-without-session as dead (the original S1 unstick heuristic)
-* re-opened the PAN-1048 race and spawned a duplicate `agent-<issue>-plan`
-* twin on EVERY `pan plan` (PAN-2159, 100% repro). A fresh `starting` state
-* is a startup in progress; only a stale one is a crashed spawn to unstick.
+* Effect-typed variant of {@link checkAllTriggers}. Never fails — uses
+* `Effect.promise` because the underlying async path absorbs bd / fs errors.
 */
-const STARTING_WITHOUT_SESSION_GRACE_MS = 12e4;
-function isFreshStarting(state) {
-	const startedAt = Date.parse(state.startedAt ?? "");
-	return Number.isFinite(startedAt) && Date.now() - startedAt < STARTING_WITHOUT_SESSION_GRACE_MS;
-}
-async function activeRoleRunExists(issueId, role, workspacePath) {
-	const issueLower = issueId.toLowerCase();
-	if (role === "plan") {
-		const legacyId = `planning-${issueLower}`;
-		const legacyState = await Effect.runPromise(getAgentState(legacyId));
-		if (legacyState?.role === "plan" && legacyState.status !== "stopped" && legacyState.status !== "error") {
-			if (legacyState.status === "starting" && !await Effect.runPromise(sessionExists(legacyId))) return isFreshStarting(legacyState);
-			return true;
-		}
-	}
-	const candidateId = role === "work" ? `agent-${issueLower}` : `agent-${issueLower}-${role}`;
-	const state = await Effect.runPromise(getAgentState(candidateId));
-	if (!state) return false;
-	const stateRole = state.role ?? roleFromAgentId(candidateId, issueId);
-	if (stateRole === role && state.status === "starting" && !await Effect.runPromise(sessionExists(candidateId))) return isFreshStarting(state);
-	if (!(stateRole === role && state.status !== "stopped" && state.status !== "error")) return false;
-	if (workspacePath && state.roleRunHead) try {
-		const { stdout } = await execAsync("git rev-parse --short=8 HEAD", { cwd: workspacePath });
-		const currentHead = stdout.trim();
-		if (currentHead && currentHead !== state.roleRunHead) {
-			console.log(`[cloister] ${issueId}: ${role} session ${candidateId} is stale (ran against ${state.roleRunHead}, HEAD is now ${currentHead}) — not active`);
-			return false;
-		}
-	} catch {}
-	return true;
-}
-function buildReactiveRolePrompt(issueId, state, role) {
-	return `${role.toUpperCase()} TASK for ${issueId}:
-
-The issue lifecycle transitioned to ${state}. Run the ${role} role for this issue.
-
-Required steps:
-1. Work only in the workspace configured for ${issueId}.
-2. Read .pan/continue.json, .pan/spec.vbrief.json, project instructions, and issue context.
-3. Follow the boundaries and success criteria in roles/${role}.md exactly.
-4. Report the role-specific terminal status when done.`;
+function checkAllTriggers(agentId, workspace, issueId, currentModel, health, config) {
+	return Effect.promise(() => checkAllTriggersPromise(agentId, workspace, issueId, currentModel, health, config));
 }
+//#endregion
+//#region ../../lib/cloister/service-health.ts
+/** Cloister health monitoring seam. */
+init_agents();
 /**
-* Resolve the workspace path for an issue from agent state, then fall back
-* to the canonical `<projectPath>/workspaces/feature-<issueLower>` layout.
-* Mirrors the resolution used by startup recovery (service.ts:583-609) so
-* the reactive scheduler dispatches review/test wrappers with the same
-* workspace contract those wrappers receive on the manual code path.
+* Perform a health check on all running agents
 */
-async function resolveWorkspaceForIssue(issueId) {
-	const issueLower = issueId.toLowerCase();
-	const agentState = await Effect.runPromise(getAgentState(`agent-${issueLower}`));
-	if (agentState?.workspace) return agentState.workspace;
-	const resolved = resolveProjectFromIssueSync(issueId);
-	if (!resolved) return null;
-	return `${resolved.projectPath}/workspaces/feature-${issueLower}`;
-}
-async function onIssueStateChangePromise(issueId, newState) {
-	const normalizedIssueId = normalizeIssueId(issueId);
-	const role = stateToRole(newState);
-	if (!role) {
-		console.log(`[cloister] ${normalizedIssueId}: no role for issue state '${newState}'`);
-		return;
-	}
-	if (await isIssueClosed(normalizedIssueId)) {
-		const message = `${normalizedIssueId}: skipping ${role} dispatch — issue is closed`;
-		console.log(`[cloister] ${message}`);
-		emitActivityEntrySync({
-			source: "cloister",
-			level: "info",
-			message,
-			issueId: normalizedIssueId
-		});
-		return;
-	}
-	const { getReviewStatusSync } = await import("./review-status-B0Axo-Ma.js");
-	if (getReviewStatusSync(normalizedIssueId)?.mergeStatus === "merged") {
-		const message = `${normalizedIssueId}: skipping ${role} dispatch — merge already landed (merge_status='merged' is terminal)`;
-		console.log(`[cloister] ${message}`);
-		emitActivityEntrySync({
-			source: "cloister",
-			level: "info",
-			message,
-			issueId: normalizedIssueId
+async function performHealthCheck(host) {
+	try {
+		const runningAgents = listRunningAgentsSync().filter((a) => a.tmuxActive);
+		const agentIds = runningAgents.map((a) => a.id);
+		const currentRunningSet = new Set(agentIds);
+		if (host.previousRunningAgents.size > 0 && host.config.auto_restart?.enabled) {
+			for (const previousAgentId of host.previousRunningAgents) if (!currentRunningSet.has(previousAgentId)) await host.handleAgentCrash(previousAgentId);
+		}
+		host.previousRunningAgents = currentRunningSet;
+		host.healthCheckCount++;
+		if (host.healthCheckCount % 4 === 0) host.checkCompletionMarkers();
+		if (agentIds.length === 0) {
+			host.lastCheck = /* @__PURE__ */ new Date();
+			return;
+		}
+		const agentHealths = [];
+		for (const agentId of agentIds) {
+			const runtime = getRuntimeForAgent(agentId);
+			if (runtime) {
+				const health = getAgentHealth(agentId, runtime);
+				agentHealths.push(health);
+				host.recordHealthEvent(health);
+			}
+		}
+		host.lastCheck = /* @__PURE__ */ new Date();
+		host.emit({
+			type: "health_check",
+			agentHealths
 		});
-		return;
-	}
-	const mergedGuard = await shouldSkipDispatchAsMerged(normalizedIssueId);
-	if (mergedGuard.skip) {
-		const message = `${normalizedIssueId}: skipping ${role} dispatch — ${mergedGuard.reason}`;
-		console.log(`[cloister] ${message}`);
-		emitActivityEntrySync({
-			source: "cloister",
-			level: "info",
-			message,
-			issueId: normalizedIssueId
+		const needsAttention = getAgentsNeedingAttention(agentHealths);
+		const pokeCooldownMs = host.config.auto_actions.poke_cooldown_ms ?? 1800 * 1e3;
+		const now = Date.now();
+		for (const health of needsAttention) {
+			const idleAgentState = getAgentStateSync(health.agentId);
+			if (idleAgentState?.role === "sequencer") continue;
+			const { shouldSkipIdlePokeForAgent } = await import("./stuck-remediation-nTIvhGOR.js");
+			if (shouldSkipIdlePokeForAgent(idleAgentState)) {
+				host.pokeProgress.delete(health.agentId);
+				continue;
+			}
+			const cooledDown = now - (host.lastPokeTimestamps.get(health.agentId) ?? 0) >= pokeCooldownMs;
+			if (health.state === "warning") {
+				host.emit({
+					type: "agent_warning",
+					agentId: health.agentId,
+					health
+				});
+				if (host.config.auto_actions.poke_on_warning && cooledDown) {
+					host.pokeAgent(health.agentId);
+					host.lastPokeTimestamps.set(health.agentId, now);
+				}
+			} else if (health.state === "stuck") {
+				host.emit({
+					type: "agent_stuck",
+					agentId: health.agentId,
+					health
+				});
+				if ((host.config.auto_actions.poke_on_stuck ?? true) && cooledDown) {
+					host.pokeAgent(health.agentId);
+					host.lastPokeTimestamps.set(health.agentId, now);
+				}
+				if (host.config.auto_actions.kill_on_stuck) host.killAgent(health.agentId);
+			}
+		}
+		host.checkHandoffTriggers(agentHealths);
+		host.checkFPPViolations(agentIds);
+		await reconcilePiCostEventsForRunningAgents(runningAgents);
+		host.checkCostAlerts(agentIds);
+		if (Math.random() < .1) host.checkSpecialistRotations();
+		if (Math.random() < .01) clearOldViolationsSync(24);
+	} catch (error) {
+		console.error("Cloister health check failed:", error);
+		host.emit({
+			type: "error",
+			error
 		});
-		return;
 	}
-	const workspace = await resolveWorkspaceForIssue(normalizedIssueId);
-	if (await activeRoleRunExists(normalizedIssueId, role, workspace ?? void 0)) {
-		const message = `${normalizedIssueId}: ${role} role already active; skipping lifecycle spawn`;
-		console.log(`[cloister] ${message}`);
-		emitActivityEntrySync({
-			source: "cloister",
-			level: "info",
-			message,
-			issueId: normalizedIssueId
+}
+/**
+* Check if any specialists need session rotation
+*/
+async function checkSpecialistRotations(host) {
+	const mergeAgentResult = await Effect.runPromise(checkAndRotateIfNeeded("merge-agent", process.cwd()));
+	if (mergeAgentResult) {
+		host.emit({
+			type: "session_rotated",
+			specialistName: "merge-agent",
+			result: mergeAgentResult
 		});
-		return;
+		if (mergeAgentResult.success) console.log(`🔔 Rotated merge-agent session: ${mergeAgentResult.oldSessionId.substring(0, 8)} → ${mergeAgentResult.newSessionId?.substring(0, 8)}`);
+		else console.error(`🔔 Failed to rotate merge-agent: ${mergeAgentResult.error}`);
 	}
-	const issueLower = normalizedIssueId.toLowerCase();
-	const roleSessionId = role === "work" ? `agent-${issueLower}` : `agent-${issueLower}-${role}`;
-	if (await Effect.runPromise(sessionExists(roleSessionId))) {
-		const message = `${normalizedIssueId}: killing stale ${role} session ${roleSessionId} before re-dispatch`;
-		console.log(`[cloister] ${message}`);
-		emitActivityEntrySync({
-			source: "cloister",
-			level: "info",
-			message,
-			issueId: normalizedIssueId
-		});
-		try {
-			await Effect.runPromise(killSession(roleSessionId));
-		} catch (err) {
-			console.error(`[cloister] failed to kill stale session ${roleSessionId}:`, err instanceof Error ? err.message : String(err));
+}
+/**
+* Record health event to database
+*
+* Only writes events when state changes or on first check.
+*/
+function recordHealthEvent(host, health) {
+	try {
+		const currentState = health.state;
+		const previousState = host.previousStates.get(health.agentId);
+		if (previousState === void 0 || previousState !== currentState) {
+			const source = health.heartbeat?.source ? host.mapHeartbeatSource(health.heartbeat.source) : "unknown";
+			writeHealthEvent({
+				agentId: health.agentId,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				state: currentState,
+				source,
+				metadata: health.heartbeat ? JSON.stringify({
+					confidence: health.heartbeat.confidence,
+					lastAction: health.heartbeat.lastAction,
+					toolName: health.heartbeat.toolName,
+					timeSinceActivity: health.timeSinceActivity
+				}) : void 0
+			});
+			host.previousStates.set(health.agentId, currentState);
 		}
+	} catch (error) {
+		console.error(`Failed to record health event for ${health.agentId}:`, error);
 	}
-	try {
-		if (role === "review") {
-			if (!workspace) {
-				const failure = `${normalizedIssueId}: cannot dispatch review role — no workspace or project resolved`;
-				console.error(`[cloister] ${failure}`);
-				emitActivityEntrySync({
-					source: "cloister",
-					level: "error",
-					message: failure,
-					issueId: normalizedIssueId
-				});
-				return;
+}
+/**
+* Check for handoff triggers and execute handoffs (Phase 4)
+*
+* Checks all triggers for each agent and performs handoffs when triggered.
+*/
+async function checkHandoffTriggers(host, agentHealths) {
+	for (const health of agentHealths) try {
+		const agentState = getAgentStateSync(health.agentId);
+		if (!agentState) continue;
+		if (!agentState.workspace) continue;
+		const triggers = await Effect.runPromise(checkAllTriggers(health.agentId, agentState.workspace, agentState.issueId, agentState.model, health, host.config));
+		if (triggers.length > 0) {
+			const trigger = triggers[0];
+			if (trigger.type === "task_complete" && [
+				"review-agent",
+				"test-agent",
+				"merge-agent",
+				"inspect-agent",
+				"uat-agent"
+			].includes(trigger.suggestedModel || "")) {
+				console.log(`[cloister] Skipping handoff for ${health.agentId}: task_complete triggers specialist dispatch via completion marker, not model swap`);
+				continue;
 			}
-			const branch = `feature/${normalizedIssueId.toLowerCase()}`;
-			const { spawnReviewRoleForIssue } = await import("./review-agent-Bf9XjLnl.js");
-			const result = await Effect.runPromise(spawnReviewRoleForIssue({
-				issueId: normalizedIssueId,
-				workspace,
-				branch
-			}));
-			const message = `${normalizedIssueId}: review role dispatched from lifecycle state '${newState}' (${result.message})`;
-			console.log(`[cloister] ${message}`);
-			emitActivityEntrySync({
-				source: "cloister",
-				level: result.success ? "info" : "error",
-				message,
-				issueId: normalizedIssueId
+			host.emit({
+				type: "handoff_triggered",
+				agentId: health.agentId,
+				trigger
 			});
-			return;
-		}
-		if (role === "test") {
-			const branch = `feature/${normalizedIssueId.toLowerCase()}`;
-			const { dispatchTestAgentAndNotify } = await import("./test-agent-queue-Bq298zZl.js");
-			await Effect.runPromise(dispatchTestAgentAndNotify(normalizedIssueId, workspace ?? void 0, branch));
-			const message = `${normalizedIssueId}: test role dispatched from lifecycle state '${newState}'`;
-			console.log(`[cloister] ${message}`);
-			emitActivityEntrySync({
-				source: "cloister",
-				level: "info",
-				message,
-				issueId: normalizedIssueId
+			console.log(`🔔 Handoff triggered for ${health.agentId}: ${trigger.reason}`);
+			const result = await Effect.runPromise(performHandoff(health.agentId, {
+				targetModel: trigger.suggestedModel || "sonnet",
+				reason: trigger.reason
+			}));
+			host.emit({
+				type: "handoff_completed",
+				agentId: health.agentId,
+				result
 			});
-			return;
+			if (result.context) logHandoffEventSync(createHandoffEvent(health.agentId, agentState.issueId, result.context, trigger.type, result.success, result.error));
+			if (result.success) console.log(`✓ Handoff completed: ${health.agentId} → ${result.newAgentId} (${trigger.suggestedModel})`);
+			else console.error(`✗ Handoff failed: ${result.error}`);
 		}
-		const { spawnRun } = await import("./agents-CxbuBjID.js");
-		const message = `${normalizedIssueId}: ${role} role started from lifecycle state '${newState}' as ${(await spawnRun(normalizedIssueId, role, { prompt: buildReactiveRolePrompt(normalizedIssueId, newState, role) })).id}`;
-		console.log(`[cloister] ${message}`);
-		emitActivityEntrySync({
-			source: "cloister",
-			level: "info",
-			message,
-			issueId: normalizedIssueId
-		});
 	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		if (message.includes("already running")) {
-			const skipMessage = `${normalizedIssueId}: ${role} role already running; skipping lifecycle spawn`;
-			console.log(`[cloister] ${skipMessage}`);
-			emitActivityEntrySync({
-				source: "cloister",
-				level: "info",
-				message: skipMessage,
-				issueId: normalizedIssueId
+		console.error(`Failed to check handoff triggers for ${health.agentId}:`, error);
+	}
+}
+/**
+* Check for FPP violations and send nudges
+*/
+function checkFPPViolations(host, agentIds) {
+	for (const agentId of agentIds) {
+		const violation = checkAgentForViolations(agentId);
+		if (!violation) continue;
+		if (violation.nudgeCount === 0) host.emit({
+			type: "fpp_violation_detected",
+			agentId,
+			violation
+		});
+		if ((violation.lastNudgeAt ? Date.now() - new Date(violation.lastNudgeAt).getTime() : Infinity) >= 300 * 1e3 || violation.nudgeCount === 0) {
+			if (hasExceededMaxNudges(violation)) {
+				host.emit({
+					type: "fpp_max_nudges_exceeded",
+					agentId,
+					violation
+				});
+				console.error(`🔔 Agent ${agentId} exceeded max nudges for ${violation.type} - manual intervention required`);
+			} else if (sendNudge(violation)) host.emit({
+				type: "fpp_nudge_sent",
+				agentId,
+				nudgeCount: violation.nudgeCount
 			});
-			return;
 		}
-		console.error(`[cloister] Failed to start ${role} role for ${normalizedIssueId}:`, error);
-		emitActivityEntrySync({
-			source: "cloister",
-			level: "error",
-			message: `${normalizedIssueId}: failed to start ${role} role: ${message}`,
-			issueId: normalizedIssueId
-		});
 	}
 }
-function payloadRecord(event) {
-	return event.payload && typeof event.payload === "object" ? event.payload : {};
-}
-function issueStateChangeFromDomainEvent(event) {
-	const payload = payloadRecord(event);
-	const issueId = typeof payload.issueId === "string" ? payload.issueId : null;
-	if (!issueId) return null;
-	switch (event.type) {
-		case "issue.transitioned": return typeof payload.state === "string" ? {
-			issueId,
-			state: payload.state
-		} : null;
-		case "issue.statusChanged": return typeof payload.canonicalStatus === "string" ? {
-			issueId,
-			state: payload.canonicalStatus
-		} : null;
-		case "issue.closed": return {
-			issueId,
-			state: "closed"
-		};
-		case "agent.completed": {
-			const role = typeof payload.role === "string" ? payload.role : void 0;
-			if (role === void 0 || role === "work") return {
-				issueId,
-				state: "in_review"
-			};
-			return null;
+/**
+* Check for cost limit alerts
+*/
+function checkCostAlerts(host, agentIds) {
+	const config = host.config.cost_limits;
+	if (!config) return;
+	for (const agentId of agentIds) {
+		const alerts = checkCostLimits(agentId, agentId.startsWith("agent-") ? agentId.replace(/^agent-/, "") : agentId, config);
+		for (const alert of alerts) {
+			host.emit({
+				type: "cost_alert",
+				alert
+			});
+			const entityLabel = alert.agentId || alert.issueId || "(unattributed)";
+			if (alert.level === "limit_reached") console.error(`🔔 COST LIMIT REACHED: ${alert.type} for ${entityLabel} - $${alert.currentCost.toFixed(2)} / $${alert.limit.toFixed(2)}`);
+			else console.warn(`🔔 Cost warning: ${alert.type} for ${entityLabel} at ${alert.percentUsed.toFixed(0)}% ($${alert.currentCost.toFixed(2)} / $${alert.limit.toFixed(2)})`);
 		}
-		case "work.completed": return {
-			issueId,
-			state: "in_review"
-		};
-		case "review.approved": return {
-			issueId,
-			state: "testing"
-		};
-		case "test.passed": return {
-			issueId,
-			state: "shipping"
-		};
-		default: return null;
 	}
 }
-async function handleCloisterDomainEventPromise(event) {
-	if (event.type === "agent.stopped") {
-		const agentId = event.payload?.agentId;
-		if (agentId) {
-			const { handleAgentStoppedEvent, handleAgentStoppedForOrphanReviewerSessions } = await import("./deacon-Bz-6Wjmn.js");
-			const { handleAgentLifecycleEventForIdleStack } = await import("./idle-stack-reaper-DNbV9-fj.js");
-			handleAgentLifecycleEventForIdleStack(agentId);
-			const slotMatch = /^agent-(.+)-slot-\d+$/.exec(agentId);
-			await Promise.all([
-				handleAgentStoppedEvent(agentId),
-				handleAgentStoppedForOrphanReviewerSessions(agentId),
-				slotMatch ? (await import("./deacon-swarm-B8pgK2a7.js")).coordinateSwarmSlots({ issueId: slotMatch[1].toUpperCase() }) : Promise.resolve([])
-			]);
+/**
+* Map heartbeat source to database source string
+*/
+function mapHeartbeatSource(_host, source) {
+	switch (source) {
+		case "jsonl": return "jsonl_mtime";
+		case "tmux": return "tmux_activity";
+		case "git": return "git_activity";
+		case "active-heartbeat": return "active_heartbeat";
+		default: return source;
+	}
+}
+//#endregion
+//#region ../../lib/cloister/service-completion.ts
+/** Cloister completion marker fallback seam. */
+init_paths();
+/** Fallback scan for completion markers when `pan done` did not reach the dashboard. */
+async function checkCompletionMarkers(host) {
+	try {
+		if (!existsSync(AGENTS_DIR)) return;
+		const agentDirs = readdirSync(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("agent-"));
+		for (const dir of agentDirs) {
+			const completedFile = join$1(AGENTS_DIR, dir.name, "completed");
+			const processedFile = join$1(AGENTS_DIR, dir.name, "completed.processed");
+			if (!existsSync(completedFile)) continue;
+			if (existsSync(processedFile)) try {
+				if (statSync(completedFile).mtimeMs > statSync(processedFile).mtimeMs) {
+					try {
+						unlinkSync(processedFile);
+					} catch {}
+					host.processedCompletions.delete(dir.name);
+					console.log(`🔔 Cloister: Detected re-completion for ${dir.name} (completed newer than .processed) — clearing stale marker`);
+				} else continue;
+			} catch {
+				continue;
+			}
+			try {
+				const content = JSON.parse(readFileSync(completedFile, "utf-8"));
+				const ageMs = Date.now() - new Date(content.timestamp).getTime();
+				if (ageMs > 1440 * 60 * 1e3) {
+					console.log(`🔔 Cloister: Skipping stale completion marker for ${dir.name} (${Math.floor(ageMs / 36e5)}h old)`);
+					host.processedCompletions.set(dir.name, Infinity);
+					try {
+						renameSync(completedFile, processedFile);
+					} catch {}
+					continue;
+				}
+			} catch (parseErr) {
+				console.warn(`  ⚠ Cloister: Could not parse completion marker for ${dir.name}, skipping`);
+				continue;
+			}
+			const retryCount = host.processedCompletions.get(dir.name) || 0;
+			if (retryCount === Infinity) host.processedCompletions.delete(dir.name);
+			else if (retryCount >= 3) continue;
+			const issueId = dir.name.replace("agent-", "").toUpperCase();
+			const { getReviewStatusSync } = await import("./review-status-CG0iDuWa.js");
+			const existingReview = getReviewStatusSync(issueId);
+			if (existingReview && ["reviewing", "passed"].includes(existingReview.reviewStatus || "")) {
+				console.log(`🔔 Cloister: Completion marker for ${issueId} — review already ${existingReview.reviewStatus}, marking processed`);
+				try {
+					renameSync(completedFile, processedFile);
+				} catch {}
+				host.processedCompletions.set(dir.name, Infinity);
+				continue;
+			}
+			console.log(`🔔 Cloister: Found completion marker for ${issueId}, triggering review...${retryCount > 0 ? ` (retry ${retryCount}/3)` : ""}`);
+			try {
+				const result = await (async () => {
+					const controller = new AbortController();
+					const timer = setTimeout(() => controller.abort(), 5e3);
+					try {
+						const res = await fetch(`${host.getDashboardApiUrl()}/api/review/${issueId}/trigger`, {
+							method: "POST",
+							headers: { "Content-Type": "application/json" },
+							body: JSON.stringify({}),
+							signal: controller.signal
+						});
+						clearTimeout(timer);
+						try {
+							return await res.json();
+						} catch {
+							return {
+								success: false,
+								error: `Invalid response (HTTP ${res.status})`
+							};
+						}
+					} catch (e) {
+						clearTimeout(timer);
+						if (e instanceof Error && e.name === "AbortError") return {
+							success: false,
+							error: "Timeout (5s)"
+						};
+						return {
+							success: false,
+							error: e instanceof Error ? e.message : String(e)
+						};
+					}
+				})();
+				if (result.success) {
+					console.log(`  ✓ Review triggered for ${issueId}`);
+					renameSync(completedFile, processedFile);
+					host.processedCompletions.set(dir.name, Infinity);
+				} else if (result.alreadyReviewed || result.alreadyMerged) {
+					console.log(`  ✓ ${issueId} already ${result.alreadyMerged ? "merged" : "reviewed"}, marking processed`);
+					renameSync(completedFile, processedFile);
+					host.processedCompletions.set(dir.name, Infinity);
+				} else {
+					host.processedCompletions.set(dir.name, retryCount + 1);
+					console.log(`  ⚠ Review trigger failed for ${issueId}: ${result.error || "unknown"} (will retry, ${2 - retryCount} attempts left)`);
+				}
+			} catch (err) {
+				host.processedCompletions.set(dir.name, retryCount + 1);
+				const message = err instanceof Error ? err.message : String(err);
+				console.error(`  ✗ Failed to trigger review for ${issueId}: ${message} (will retry, ${2 - retryCount} attempts left)`);
+			}
+		}
+	} catch (error) {}
+}
+//#endregion
+//#region ../../lib/cloister/service-crash.ts
+/** Cloister crash recovery and poke escalation seam. */
+init_context_overflow();
+init_agents();
+init_tmux();
+init_reap_terminal_sessions();
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+/**
+* One-shot convoy roles (PAN-1742). The review lenses + synthesis and the test
+* role are spawned fresh via `spawnRun` each cycle; they run once, write their
+* artifact, and exit. They never save a sessionId, so they cannot be resumed.
+*/
+const ONE_SHOT_ROLES = new Set(["review", "test"]);
+/**
+* Decide whether a vanished tmux session should be treated as a crash worth
+* auto-restarting (PAN-1742). Returns a human-readable reason to SKIP the
+* crash/restart machinery, or `null` when the agent is a genuine restart
+* candidate.
+*
+* Two cases are not crashes:
+*  - one-shot convoy roles, whose session-end is a normal completion; and
+*  - any agent without a saved session, which `restartAgent` cannot resume
+*    (it throws "No session ID found"), so counting a crash and scheduling a
+*    restart is pure noise.
+*
+* Pure and exported so the rule is unit-tested independent of the service's
+* private health-check plumbing.
+*/
+function nonRestartableReason(role, sessionId) {
+	if (ONE_SHOT_ROLES.has(role)) return `(${role}) finished its one-shot run — completion, not a crash`;
+	if (!sessionId) return "ended with no resumable session — not auto-restartable";
+	return null;
+}
+/**
+* Poke an agent (send "are you stuck?" message).
+*
+* NOTE: runtime.sendMessage() is async — both ClaudeCodeRuntime and PiRuntime
+* are declared `async sendMessage(): Promise<void>`. A `throw` inside an
+* async function before any await still returns a rejected Promise, so the
+* surrounding try/catch CANNOT catch it. Without explicit `.catch()`, the
+* rejection becomes an UnhandledPromiseRejection and crashes the dashboard
+* server. We hit this in production when the deacon health-check polled a
+* dead agent (PAN-1189 wedge sweep #12-13).
+*/
+function pokeAgent(host, agentId) {
+	host.pokeAgentWithEscalation(agentId).catch((error) => {
+		console.error(`Failed to poke ${agentId}:`, error);
+	});
+}
+/** PAN-2452: fingerprint of observable progress — workspace HEAD + pane tail.
+* Unchanged fingerprint across pokes = the poke did nothing. */
+async function progressFingerprint(_host, agentId) {
+	const state = getAgentStateSync(agentId);
+	let head = "";
+	if (state?.workspace) try {
+		const { stdout } = await execAsync("git rev-parse HEAD", {
+			cwd: state.workspace,
+			encoding: "utf-8"
+		});
+		head = stdout.trim();
+	} catch {}
+	let pane = "";
+	try {
+		const { stdout } = await execFileAsync("tmux", [
+			"-L",
+			"overdeck",
+			"capture-pane",
+			"-t",
+			exactPaneTarget(agentId),
+			"-p",
+			"-S",
+			`-40`
+		], { encoding: "utf-8" });
+		pane = stdout;
+	} catch {}
+	const paneHash = createHash("sha1").update(pane).digest("hex").slice(0, 12);
+	return `${head}:${paneHash}`;
+}
+async function pokeAgentWithEscalation(host, agentId) {
+	const runtime = getRuntimeForAgent(agentId);
+	if (!runtime) throw new Error(`No runtime found for agent ${agentId}`);
+	const fingerprint = await host.progressFingerprint(agentId);
+	const prior = host.pokeProgress.get(agentId);
+	const ineffective = prior && prior.fingerprint === fingerprint ? prior.ineffective + 1 : 0;
+	host.pokeProgress.set(agentId, {
+		fingerprint,
+		ineffective
+	});
+	if (ineffective >= 4) {
+		const { setAgentPausedSync } = await import("./agent-state-lGvgPP4m.js");
+		try {
+			setAgentPausedSync(agentId, `needs-you: idle-alive — no observable progress across ${ineffective + 1} pokes (idle-alive escalation)`);
+			host.emit({
+				type: "agent_stuck",
+				agentId,
+				health: void 0
+			});
+			console.log(`🛑 ${agentId} paused: idle-alive across ${ineffective + 1} pokes`);
+		} catch (pauseErr) {
+			console.error(`Failed to pause idle-alive ${agentId}:`, pauseErr);
 		}
 		return;
 	}
-	if (event.type === "agent.started") {
-		const agentId = event.payload?.agentId;
-		if (agentId) (await import("./idle-stack-reaper-DNbV9-fj.js")).handleAgentLifecycleEventForIdleStack(agentId);
+	let pokeMessage = "Hey, I noticed you haven't made progress in a while. Are you stuck? If you need help or clarification, please ask. Otherwise, please continue with your work.";
+	if (ineffective >= 2) {
+		let tail = "";
+		try {
+			const { stdout } = await execFileAsync("tmux", [
+				"-L",
+				"overdeck",
+				"capture-pane",
+				"-t",
+				exactPaneTarget(agentId),
+				"-p",
+				"-S",
+				`-40`
+			], { encoding: "utf-8" });
+			tail = stdout;
+		} catch {}
+		if (isContextOverflowTail(tail)) {
+			pokeMessage = "/compact";
+			console.log(`🔔 ${agentId}: overflow tail detected — delivering /compact instead of a poke`);
+		} else pokeMessage = "You appear active but have made no observable progress (no new commits, unchanged output) across multiple checks. Do exactly one of: (1) work is done — commit, push, and run pan done; (2) blocked — state the blocker in one sentence and commit what you have as WIP; (3) lost context — re-read your bead (bd show), your latest .pan/feedback/ file, and git status, then resume. Act now.";
+	}
+	await Promise.resolve(runtime.sendMessage(agentId, pokeMessage)).catch((sendErr) => {
+		console.error(`Failed to send poke to ${agentId}:`, sendErr);
+	});
+	host.emit({
+		type: "poked_agent",
+		agentId
+	});
+	console.log(`🔔 Poked ${agentId}${ineffective > 0 ? ` (ineffective streak: ${ineffective})` : ""}`);
+}
+/**
+* Kill an agent
+*
+* runtime.killAgent() is also async in some runtime implementations — apply
+* the same fire-and-forget guard as pokeAgent so async rejection cannot
+* crash the dashboard from a deacon health-check timer callback.
+*/
+function killAgent(host, agentId) {
+	try {
+		const runtime = getRuntimeForAgent(agentId);
+		if (!runtime) throw new Error(`No runtime found for agent ${agentId}`);
+		Promise.resolve(runtime.killAgent(agentId)).catch((killErr) => {
+			console.error(`Failed to kill ${agentId}:`, killErr);
+		});
+		host.emit({
+			type: "killed_agent",
+			agentId
+		});
+		console.log(`🔔 Killed ${agentId}`);
+	} catch (error) {
+		console.error(`Failed to kill ${agentId}:`, error);
+	}
+}
+/**
+* Handle agent crash with auto-restart logic
+*/
+async function handleAgentCrash(host, agentId) {
+	const config = host.config.auto_restart;
+	if (!config?.enabled) return;
+	const agentState = getAgentStateSync(agentId);
+	if (!agentState || agentState.status === "stopped") {
+		console.log(`🔔 Agent ${agentId} was intentionally stopped, skipping restart`);
 		return;
 	}
-	if (event.type === "agent.heartbeat_dead") {
-		const agentId = event.payload?.agentId;
-		if (agentId) {
-			const { handleAgentHeartbeatDeadEvent } = await import("./deacon-Bz-6Wjmn.js");
-			await handleAgentHeartbeatDeadEvent(agentId, "event");
-		}
+	const runtimeState = getAgentRuntimeStateSync(agentId);
+	if (runtimeState?.state === "suspended") {
+		console.log(`🔔 Agent ${agentId} is suspended, skipping restart`);
 		return;
 	}
-	if (event.type === "review.coordinator.died") {
-		const payload = event.payload;
-		const issueId = payload?.issueId;
-		if (issueId) {
-			const { handleReviewCoordinatorDied } = await import("./deacon-Bz-6Wjmn.js");
-			await handleReviewCoordinatorDied(issueId, payload?.sessionName ?? "", payload?.reason ?? "");
-		}
+	if (runtimeState?.state === "stopped") {
+		console.log(`🔔 Agent ${agentId} runtime is stopped, skipping restart`);
 		return;
 	}
-	if (event.type === "work.completed") {
-		const issueId = event.payload?.issueId;
-		if (issueId) {
-			const { handleWorkCompleted } = await import("./deacon-Bz-6Wjmn.js");
-			await handleWorkCompleted(issueId);
+	const skipReason = nonRestartableReason(agentState.role, agentState.sessionId);
+	if (skipReason) {
+		let recoverUnfinishedOneShot = false;
+		if (ONE_SHOT_ROLES.has(agentState.role) && agentState.sessionId && agentState.issueId) try {
+			const { getReviewStatusSync } = await import("./review-status-CG0iDuWa.js");
+			const status = getReviewStatusSync(agentState.issueId);
+			recoverUnfinishedOneShot = !(status ? isRoleTerminal(agentState.role, {
+				reviewStatus: status.reviewStatus,
+				testStatus: status.testStatus,
+				readyForMerge: status.readyForMerge,
+				mergeStatus: status.mergeStatus
+			}) : false);
+		} catch {
+			recoverUnfinishedOneShot = false;
+		}
+		if (!recoverUnfinishedOneShot) {
+			console.log(`🔔 Agent ${agentId} ${skipReason}; skipping restart`);
+			return;
 		}
+		console.log(`🔔 Agent ${agentId} (${agentState.role}) vanished before a terminal verdict — recovering instead of treating as a one-shot completion (PAN-2007)`);
 	}
-	if (event.type === "issue.statusChanged") {
-		const payload = event.payload;
-		const issueId = payload?.issueId;
-		const canonicalStatus = payload?.canonicalStatus?.toLowerCase();
-		const status = payload?.status?.toLowerCase();
-		if (issueId) {
-			if (canonicalStatus === "closed" || status === "closed") {
-				const { handleIssueStatusChangedClosed } = await import("./closed-issue-reaper-BRQBc7Xa.js");
-				await handleIssueStatusChangedClosed(issueId);
-				return;
-			}
-			if (canonicalStatus === "todo" || status === "planned" || status === "todo") {
-				const { handleOrphanProposedSpec } = await import("./orphan-proposed-reconciler-BqVGaOIj.js");
-				await handleOrphanProposedSpec(issueId);
+	const now = /* @__PURE__ */ new Date();
+	host.deathTimestamps.push(now);
+	host.checkForMassDeaths();
+	let tracker = host.crashTrackers.get(agentId);
+	if (!tracker) {
+		tracker = {
+			agentId,
+			crashCount: 0,
+			lastCrash: now,
+			gaveUp: false
+		};
+		host.crashTrackers.set(agentId, tracker);
+	}
+	if (tracker.gaveUp) return;
+	tracker.crashCount++;
+	tracker.lastCrash = now;
+	host.emit({
+		type: "agent_crashed",
+		agentId,
+		crashCount: tracker.crashCount
+	});
+	console.log(`🔔 Agent ${agentId} crashed (crash #${tracker.crashCount})`);
+	if (host.eventStore) try {
+		host.eventStore.append({
+			type: "agent.heartbeat_dead",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			payload: {
+				agentId,
+				issueId: agentState.issueId,
+				sessionId: agentState.sessionId
 			}
+		});
+	} catch (err) {
+		console.error(`[cloister] Failed to emit heartbeat_dead for ${agentId}:`, err);
+	}
+	if (tracker.crashCount > config.max_retries) {
+		tracker.gaveUp = true;
+		host.emit({
+			type: "agent_gave_up",
+			agentId,
+			maxRetries: config.max_retries
+		});
+		console.error(`🔔 Gave up on restarting ${agentId} after ${config.max_retries} attempts`);
+		return;
+	}
+	const backoffIndex = Math.min(tracker.crashCount - 1, config.backoff_seconds.length - 1);
+	const backoffSeconds = config.backoff_seconds[backoffIndex];
+	const nextRetryAt = new Date(Date.now() + backoffSeconds * 1e3);
+	tracker.nextRetryAt = nextRetryAt;
+	host.emit({
+		type: "agent_restarting",
+		agentId,
+		crashCount: tracker.crashCount,
+		backoffSeconds
+	});
+	console.log(`🔔 Deacon will recover ${agentId} via heartbeat_dead (attempt ${tracker.crashCount}/${config.max_retries}, backoff ${backoffSeconds}s)`);
+}
+/**
+* Restart an agent using its saved session
+*/
+async function restartAgent(_host, agentId) {
+	const runtime = getRuntimeForAgent(agentId);
+	if (!runtime) throw new Error(`No runtime found for agent ${agentId}`);
+	const agentState = getAgentStateSync(agentId);
+	if (!agentState?.sessionId) throw new Error(`No session ID found for agent ${agentId}`);
+	if (!agentState.workspace) throw new Error(`No workspace found for agent ${agentId}`);
+	console.log(`🔔 Restarting ${agentId} with session ${agentState.sessionId.substring(0, 8)}...`);
+	runtime.spawnAgent({
+		agentId,
+		workspace: agentState.workspace,
+		sessionId: agentState.sessionId,
+		runtime: runtime.name
+	});
+	console.log(`🔔 Successfully restarted ${agentId}`);
+}
+/**
+* Check for mass death events
+*
+* Detects when 3+ agents die within 30 seconds and pauses spawns.
+*/
+function checkForMassDeaths(host) {
+	const MASS_DEATH_THRESHOLD = 3;
+	const WINDOW_SECONDS = 30;
+	const windowStart = Date.now() - WINDOW_SECONDS * 1e3;
+	host.deathTimestamps = host.deathTimestamps.filter((timestamp) => timestamp.getTime() >= windowStart);
+	if (host.deathTimestamps.length >= MASS_DEATH_THRESHOLD) {
+		host.emit({
+			type: "mass_death_detected",
+			deathCount: host.deathTimestamps.length,
+			windowSeconds: WINDOW_SECONDS
+		});
+		if (!host.spawnsPaused) {
+			host.pauseSpawns("Mass death detected - system stability concern");
+			console.error(`🔔 MASS DEATH DETECTED: ${host.deathTimestamps.length} agents died in ${WINDOW_SECONDS}s - spawns paused`);
+		}
+	}
+}
+/**
+* Pause new agent spawns
+*/
+function pauseSpawns(host, reason) {
+	host.spawnsPaused = true;
+	setCloisterSpawnsPausedSync(true);
+	host.emit({
+		type: "spawn_paused",
+		reason
+	});
+	console.log(`🔔 Agent spawns paused: ${reason}`);
+}
+//#endregion
+//#region ../../lib/cloister/service-status.ts
+init_agents();
+/**
+* Get current status
+*
+* Uses a 3-second TTL cache to avoid blocking the event loop on repeated
+* dashboard polls. The underlying computation does sync file I/O and tmux
+* calls for every agent, which scales poorly with agent count.
+*/
+function getStatus(host) {
+	const now = Date.now();
+	if (host.statusCache && now - host.statusCacheAt < host.statusCacheTtlMs) return host.statusCache;
+	const agentIds = listRunningAgentsSync().filter((a) => a.tmuxActive).map((a) => a.id);
+	const agentHealths = [];
+	for (const agentId of agentIds) {
+		const runtime = getRuntimeForAgent(agentId);
+		if (runtime) {
+			const health = getAgentHealth(agentId, runtime);
+			agentHealths.push(health);
+		}
+	}
+	const summary = generateHealthSummary(agentHealths);
+	const needsAttention = getAgentsNeedingAttention(agentHealths).map((h) => h.agentId);
+	const deaconStatus = getDeaconStatus();
+	const patrol = assessDeaconPatrolFreshness({
+		isRunning: deaconStatus.isRunning,
+		lastPatrol: deaconStatus.state.lastPatrol,
+		patrolIntervalMs: deaconStatus.config.patrolIntervalMs
+	});
+	const status = {
+		running: host.isRunning(),
+		lastCheck: host.lastCheck,
+		config: host.config,
+		summary,
+		agentsNeedingAttention: needsAttention,
+		patrol: {
+			...patrol,
+			loopRunning: deaconStatus.isRunning,
+			patrolIntervalMs: deaconStatus.config.patrolIntervalMs
+		}
+	};
+	host.statusCache = status;
+	host.statusCacheAt = now;
+	return status;
+}
+/**
+* Get health for a specific agent
+*/
+function getServiceAgentHealth(_host, agentId) {
+	const runtime = getRuntimeForAgent(agentId);
+	if (!runtime) return null;
+	return getAgentHealth(agentId, runtime);
+}
+/**
+* Get health for all running agents
+*/
+function getAllAgentHealth(_host) {
+	const runningAgents = listRunningAgentsSync().filter((a) => a.tmuxActive);
+	const agentHealths = [];
+	for (const agent of runningAgents) {
+		const runtime = getRuntimeForAgent(agent.id);
+		if (runtime) {
+			const health = getAgentHealth(agent.id, runtime);
+			agentHealths.push(health);
 		}
 	}
-	const change = issueStateChangeFromDomainEvent(event);
-	if (!change) return;
-	await Effect.runPromise(onIssueStateChange(change.issueId, change.state));
+	return agentHealths;
+}
+//#endregion
+//#region ../../lib/cloister/service.ts
+init_config();
+init_agents();
+init_control_settings();
+init_paths();
+init_tmux();
+init_activity_logger();
+const CLOISTER_STATE_FILE = join$1(OVERDECK_HOME, "cloister.state");
+const LEGACY_SPECIALISTS_DIR = join$1(OVERDECK_HOME, "specialists");
+async function cleanupLegacySpecialistsDirectory() {
+	await rm(LEGACY_SPECIALISTS_DIR, {
+		recursive: true,
+		force: true
+	});
+}
+let cloisterEventStoreProvider = null;
+function setCloisterEventStoreProvider(provider) {
+	cloisterEventStoreProvider = provider;
 }
 /**
 * Write Cloister running state to file for cross-process visibility
@@ -2466,32 +3165,6 @@ function readCloisterStateFile() {
 	return { running: false };
 }
 /**
-* One-shot convoy roles (PAN-1742). The review lenses + synthesis and the test
-* role are spawned fresh via `spawnRun` each cycle; they run once, write their
-* artifact, and exit. They never save a sessionId, so they cannot be resumed.
-*/
-const ONE_SHOT_ROLES = new Set(["review", "test"]);
-/**
-* Decide whether a vanished tmux session should be treated as a crash worth
-* auto-restarting (PAN-1742). Returns a human-readable reason to SKIP the
-* crash/restart machinery, or `null` when the agent is a genuine restart
-* candidate.
-*
-* Two cases are not crashes:
-*  - one-shot convoy roles, whose session-end is a normal completion; and
-*  - any agent without a saved session, which `restartAgent` cannot resume
-*    (it throws "No session ID found"), so counting a crash and scheduling a
-*    restart is pure noise.
-*
-* Pure and exported so the rule is unit-tested independent of the service's
-* private health-check plumbing.
-*/
-function nonRestartableReason(role, sessionId) {
-	if (ONE_SHOT_ROLES.has(role)) return `(${role}) finished its one-shot run — completion, not a crash`;
-	if (!sessionId) return "ended with no resumable session — not auto-restartable";
-	return null;
-}
-/**
 * Cloister Service
 *
 * Monitors agent health and performs auto-actions.
@@ -2520,6 +3193,122 @@ var CloisterService = class {
 	constructor(config) {
 		this.config = config || loadCloisterConfigSync();
 	}
+	healthHost() {
+		const service = this;
+		return {
+			get previousRunningAgents() {
+				return service.previousRunningAgents;
+			},
+			set previousRunningAgents(value) {
+				service.previousRunningAgents = value;
+			},
+			get config() {
+				return service.config;
+			},
+			get healthCheckCount() {
+				return service.healthCheckCount;
+			},
+			set healthCheckCount(value) {
+				service.healthCheckCount = value;
+			},
+			get lastCheck() {
+				return service.lastCheck;
+			},
+			set lastCheck(value) {
+				service.lastCheck = value;
+			},
+			get lastPokeTimestamps() {
+				return service.lastPokeTimestamps;
+			},
+			get pokeProgress() {
+				return service.pokeProgress;
+			},
+			get previousStates() {
+				return service.previousStates;
+			},
+			handleAgentCrash: (agentId) => service.handleAgentCrash(agentId),
+			checkCompletionMarkers: () => service.checkCompletionMarkers(),
+			recordHealthEvent: (health) => service.recordHealthEvent(health),
+			emit: (event) => service.emit(event),
+			pokeAgent: (agentId) => service.pokeAgent(agentId),
+			killAgent: (agentId) => service.killAgent(agentId),
+			checkHandoffTriggers: (agentHealths) => service.checkHandoffTriggers(agentHealths),
+			checkFPPViolations: (agentIds) => service.checkFPPViolations(agentIds),
+			checkCostAlerts: (agentIds) => service.checkCostAlerts(agentIds),
+			checkSpecialistRotations: () => service.checkSpecialistRotations(),
+			mapHeartbeatSource: (source) => service.mapHeartbeatSource(source)
+		};
+	}
+	completionHost() {
+		const service = this;
+		return {
+			get processedCompletions() {
+				return service.processedCompletions;
+			},
+			getDashboardApiUrl: () => service.getDashboardApiUrl()
+		};
+	}
+	crashHost() {
+		const service = this;
+		return {
+			get config() {
+				return service.config;
+			},
+			get crashTrackers() {
+				return service.crashTrackers;
+			},
+			get deathTimestamps() {
+				return service.deathTimestamps;
+			},
+			set deathTimestamps(value) {
+				service.deathTimestamps = value;
+			},
+			get spawnsPaused() {
+				return service.spawnsPaused;
+			},
+			set spawnsPaused(value) {
+				service.spawnsPaused = value;
+			},
+			get pokeProgress() {
+				return service.pokeProgress;
+			},
+			get eventStore() {
+				return service.eventStore;
+			},
+			progressFingerprint: (agentId) => service.progressFingerprint(agentId),
+			pokeAgentWithEscalation: (agentId) => service.pokeAgentWithEscalation(agentId),
+			checkForMassDeaths: () => service.checkForMassDeaths(),
+			pauseSpawns: (reason) => service.pauseSpawns(reason),
+			emit: (event) => service.emit(event)
+		};
+	}
+	statusHost() {
+		const service = this;
+		return {
+			get statusCache() {
+				return service._statusCache;
+			},
+			set statusCache(value) {
+				service._statusCache = value;
+			},
+			get statusCacheAt() {
+				return service._statusCacheAt;
+			},
+			set statusCacheAt(value) {
+				service._statusCacheAt = value;
+			},
+			get statusCacheTtlMs() {
+				return service.STATUS_CACHE_TTL_MS;
+			},
+			get lastCheck() {
+				return service.lastCheck;
+			},
+			get config() {
+				return service.config;
+			},
+			isRunning: () => service.isRunning()
+		};
+	}
 	getDashboardApiUrl() {
 		return `http://127.0.0.1:${process.env.API_PORT || process.env.PORT || "3011"}`;
 	}
@@ -2558,7 +3347,7 @@ var CloisterService = class {
 		let clearedSpecialistCount = 0;
 		try {
 			if (existsSync(AGENTS_DIR)) {
-				const { isRunning: isSpecialistRunning } = await import("./specialists-Chvvwf5z.js");
+				const { isRunning: isSpecialistRunning } = await import("./specialists-k22_Btaq.js");
 				const entries = readdirSync(AGENTS_DIR, { withFileTypes: true });
 				for (const entry of entries) {
 					if (!entry.isDirectory()) continue;
@@ -2593,8 +3382,8 @@ var CloisterService = class {
 		}
 		try {
 			const reviewStatuses = loadReviewStatuses();
-			const { resolveProjectFromIssueSync } = await import("./projects-BqRMlDOv.js");
-			const { getTmuxSessionName, getAllProjectSpecialistStatuses } = await import("./specialists-Chvvwf5z.js");
+			const { resolveProjectFromIssueSync } = await import("./projects-CrBE6IhN.js");
+			const { getTmuxSessionName, getAllProjectSpecialistStatuses } = await import("./specialists-k22_Btaq.js");
 			const activeReviewIssues = /* @__PURE__ */ new Set();
 			try {
 				const projSpecs = await getAllProjectSpecialistStatuses();
@@ -2605,7 +3394,7 @@ var CloisterService = class {
 				}
 				const globalRs = getAgentRuntimeStateSync(getTmuxSessionName("review-agent"));
 				if (globalRs?.state === "active" && globalRs.currentIssue) activeReviewIssues.add(globalRs.currentIssue.toUpperCase());
-				const { listRunningAgents } = await import("./agents-CxbuBjID.js");
+				const { listRunningAgents } = await import("./agents-CEcaxSkR.js");
 				const agents = await Effect.runPromise(listRunningAgents());
 				for (const agent of agents) {
 					if (agent.status === "stopped" || agent.status === "error") continue;
@@ -2648,7 +3437,7 @@ var CloisterService = class {
 						continue;
 					}
 					const branch = `feature/${issueId.toLowerCase()}`;
-					const { spawnReviewRoleForIssue } = await import("./review-agent-Bf9XjLnl.js");
+					const { spawnReviewRoleForIssue } = await import("./review-agent-u5q3ip7H.js");
 					const dispatchResult = await Effect.runPromise(spawnReviewRoleForIssue({
 						issueId,
 						workspace,
@@ -2736,7 +3525,7 @@ var CloisterService = class {
 				console.log("  ✓ Cloister event store provider installed");
 				return;
 			}
-			const { initEventStore } = await import("./event-store-C02Gprug.js");
+			const { initEventStore } = await import("./event-store-CqDgfbAs.js");
 			const store = await initEventStore();
 			this.eventStore = store;
 			this.domainEventUnsubscribe = store.subscribe((event) => {
@@ -2837,177 +3626,11 @@ var CloisterService = class {
 	* Perform a health check on all running agents
 	*/
 	async performHealthCheck() {
-		try {
-			const runningAgents = listRunningAgentsSync().filter((a) => a.tmuxActive);
-			const agentIds = runningAgents.map((a) => a.id);
-			const currentRunningSet = new Set(agentIds);
-			if (this.previousRunningAgents.size > 0 && this.config.auto_restart?.enabled) {
-				for (const previousAgentId of this.previousRunningAgents) if (!currentRunningSet.has(previousAgentId)) await this.handleAgentCrash(previousAgentId);
-			}
-			this.previousRunningAgents = currentRunningSet;
-			this.healthCheckCount++;
-			if (this.healthCheckCount % 4 === 0) this.checkCompletionMarkers();
-			if (agentIds.length === 0) {
-				this.lastCheck = /* @__PURE__ */ new Date();
-				return;
-			}
-			const agentHealths = [];
-			for (const agentId of agentIds) {
-				const runtime = getRuntimeForAgent(agentId);
-				if (runtime) {
-					const health = getAgentHealth(agentId, runtime);
-					agentHealths.push(health);
-					this.recordHealthEvent(health);
-				}
-			}
-			this.lastCheck = /* @__PURE__ */ new Date();
-			this.emit({
-				type: "health_check",
-				agentHealths
-			});
-			const needsAttention = getAgentsNeedingAttention(agentHealths);
-			const pokeCooldownMs = this.config.auto_actions.poke_cooldown_ms ?? 1800 * 1e3;
-			const now = Date.now();
-			for (const health of needsAttention) {
-				if (getAgentStateSync(health.agentId)?.role === "sequencer") continue;
-				const cooledDown = now - (this.lastPokeTimestamps.get(health.agentId) ?? 0) >= pokeCooldownMs;
-				if (health.state === "warning") {
-					this.emit({
-						type: "agent_warning",
-						agentId: health.agentId,
-						health
-					});
-					if (this.config.auto_actions.poke_on_warning && cooledDown) {
-						this.pokeAgent(health.agentId);
-						this.lastPokeTimestamps.set(health.agentId, now);
-					}
-				} else if (health.state === "stuck") {
-					this.emit({
-						type: "agent_stuck",
-						agentId: health.agentId,
-						health
-					});
-					if ((this.config.auto_actions.poke_on_stuck ?? true) && cooledDown) {
-						this.pokeAgent(health.agentId);
-						this.lastPokeTimestamps.set(health.agentId, now);
-					}
-					if (this.config.auto_actions.kill_on_stuck) this.killAgent(health.agentId);
-				}
-			}
-			this.checkHandoffTriggers(agentHealths);
-			this.checkFPPViolations(agentIds);
-			await reconcilePiCostEventsForRunningAgents(runningAgents);
-			this.checkCostAlerts(agentIds);
-			if (Math.random() < .1) this.checkSpecialistRotations();
-			if (Math.random() < .01) clearOldViolationsSync(24);
-		} catch (error) {
-			console.error("Cloister health check failed:", error);
-			this.emit({
-				type: "error",
-				error
-			});
-		}
+		return performHealthCheck(this.healthHost());
 	}
 	/** Fallback scan for completion markers when `pan done` did not reach the dashboard. */
 	async checkCompletionMarkers() {
-		try {
-			if (!existsSync(AGENTS_DIR)) return;
-			const agentDirs = readdirSync(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("agent-"));
-			for (const dir of agentDirs) {
-				const completedFile = join$1(AGENTS_DIR, dir.name, "completed");
-				const processedFile = join$1(AGENTS_DIR, dir.name, "completed.processed");
-				if (!existsSync(completedFile)) continue;
-				if (existsSync(processedFile)) try {
-					if (statSync(completedFile).mtimeMs > statSync(processedFile).mtimeMs) {
-						try {
-							unlinkSync(processedFile);
-						} catch {}
-						this.processedCompletions.delete(dir.name);
-						console.log(`🔔 Cloister: Detected re-completion for ${dir.name} (completed newer than .processed) — clearing stale marker`);
-					} else continue;
-				} catch {
-					continue;
-				}
-				try {
-					const content = JSON.parse(readFileSync(completedFile, "utf-8"));
-					const ageMs = Date.now() - new Date(content.timestamp).getTime();
-					if (ageMs > 1440 * 60 * 1e3) {
-						console.log(`🔔 Cloister: Skipping stale completion marker for ${dir.name} (${Math.floor(ageMs / 36e5)}h old)`);
-						this.processedCompletions.set(dir.name, Infinity);
-						try {
-							renameSync(completedFile, processedFile);
-						} catch {}
-						continue;
-					}
-				} catch (parseErr) {
-					console.warn(`  ⚠ Cloister: Could not parse completion marker for ${dir.name}, skipping`);
-					continue;
-				}
-				const retryCount = this.processedCompletions.get(dir.name) || 0;
-				if (retryCount === Infinity) this.processedCompletions.delete(dir.name);
-				else if (retryCount >= 3) continue;
-				const issueId = dir.name.replace("agent-", "").toUpperCase();
-				const { getReviewStatusSync } = await import("./review-status-B0Axo-Ma.js");
-				const existingReview = getReviewStatusSync(issueId);
-				if (existingReview && ["reviewing", "passed"].includes(existingReview.reviewStatus || "")) {
-					console.log(`🔔 Cloister: Completion marker for ${issueId} — review already ${existingReview.reviewStatus}, marking processed`);
-					try {
-						renameSync(completedFile, processedFile);
-					} catch {}
-					this.processedCompletions.set(dir.name, Infinity);
-					continue;
-				}
-				console.log(`🔔 Cloister: Found completion marker for ${issueId}, triggering review...${retryCount > 0 ? ` (retry ${retryCount}/3)` : ""}`);
-				try {
-					const result = await (async () => {
-						const controller = new AbortController();
-						const timer = setTimeout(() => controller.abort(), 5e3);
-						try {
-							const res = await fetch(`${this.getDashboardApiUrl()}/api/review/${issueId}/trigger`, {
-								method: "POST",
-								headers: { "Content-Type": "application/json" },
-								body: JSON.stringify({}),
-								signal: controller.signal
-							});
-							clearTimeout(timer);
-							try {
-								return await res.json();
-							} catch {
-								return {
-									success: false,
-									error: `Invalid response (HTTP ${res.status})`
-								};
-							}
-						} catch (e) {
-							clearTimeout(timer);
-							if (e?.name === "AbortError") return {
-								success: false,
-								error: "Timeout (5s)"
-							};
-							return {
-								success: false,
-								error: e?.message || String(e)
-							};
-						}
-					})();
-					if (result.success) {
-						console.log(`  ✓ Review triggered for ${issueId}`);
-						renameSync(completedFile, processedFile);
-						this.processedCompletions.set(dir.name, Infinity);
-					} else if (result.alreadyReviewed || result.alreadyMerged) {
-						console.log(`  ✓ ${issueId} already ${result.alreadyMerged ? "merged" : "reviewed"}, marking processed`);
-						renameSync(completedFile, processedFile);
-						this.processedCompletions.set(dir.name, Infinity);
-					} else {
-						this.processedCompletions.set(dir.name, retryCount + 1);
-						console.log(`  ⚠ Review trigger failed for ${issueId}: ${result.error || "unknown"} (will retry, ${2 - retryCount} attempts left)`);
-					}
-				} catch (err) {
-					this.processedCompletions.set(dir.name, retryCount + 1);
-					console.error(`  ✗ Failed to trigger review for ${issueId}: ${err.message} (will retry, ${2 - retryCount} attempts left)`);
-				}
-			}
-		} catch (error) {}
+		return checkCompletionMarkers(this.completionHost());
 	}
 	/**
 	* Poke an agent (send "are you stuck?" message).
@@ -3021,75 +3644,15 @@ var CloisterService = class {
 	* dead agent (PAN-1189 wedge sweep #12-13).
 	*/
 	pokeAgent(agentId) {
-		this.pokeAgentWithEscalation(agentId).catch((error) => {
-			console.error(`Failed to poke ${agentId}:`, error);
-		});
+		return pokeAgent(this.crashHost(), agentId);
 	}
 	/** PAN-2452: fingerprint of observable progress — workspace HEAD + pane tail.
 	* Unchanged fingerprint across pokes = the poke did nothing. */
 	async progressFingerprint(agentId) {
-		const state = getAgentStateSync(agentId);
-		let head = "";
-		if (state?.workspace) try {
-			const { stdout } = await execAsync("git rev-parse HEAD", {
-				cwd: state.workspace,
-				encoding: "utf-8"
-			});
-			head = stdout.trim();
-		} catch {}
-		let pane = "";
-		try {
-			const { stdout } = await execAsync(`tmux -L overdeck capture-pane -t ${JSON.stringify(agentId)} -p -S -40`, { encoding: "utf-8" });
-			pane = stdout;
-		} catch {}
-		const paneHash = createHash("sha1").update(pane).digest("hex").slice(0, 12);
-		return `${head}:${paneHash}`;
+		return progressFingerprint(this.crashHost(), agentId);
 	}
 	async pokeAgentWithEscalation(agentId) {
-		const runtime = getRuntimeForAgent(agentId);
-		if (!runtime) throw new Error(`No runtime found for agent ${agentId}`);
-		const fingerprint = await this.progressFingerprint(agentId);
-		const prior = this.pokeProgress.get(agentId);
-		const ineffective = prior && prior.fingerprint === fingerprint ? prior.ineffective + 1 : 0;
-		this.pokeProgress.set(agentId, {
-			fingerprint,
-			ineffective
-		});
-		if (ineffective >= 4) {
-			const { setAgentPausedSync } = await import("./agent-state-C6Rm6FPR.js");
-			try {
-				setAgentPausedSync(agentId, `needs-you: idle-alive — no observable progress across ${ineffective + 1} pokes (idle-alive escalation)`);
-				this.emit({
-					type: "agent_stuck",
-					agentId,
-					health: void 0
-				});
-				console.log(`🛑 ${agentId} paused: idle-alive across ${ineffective + 1} pokes`);
-			} catch (pauseErr) {
-				console.error(`Failed to pause idle-alive ${agentId}:`, pauseErr);
-			}
-			return;
-		}
-		let pokeMessage = "Hey, I noticed you haven't made progress in a while. Are you stuck? If you need help or clarification, please ask. Otherwise, please continue with your work.";
-		if (ineffective >= 2) {
-			let tail = "";
-			try {
-				const { stdout } = await execAsync(`tmux -L overdeck capture-pane -t ${JSON.stringify(agentId)} -p -S -40`, { encoding: "utf-8" });
-				tail = stdout;
-			} catch {}
-			if (isContextOverflowTail(tail)) {
-				pokeMessage = "/compact";
-				console.log(`🔔 ${agentId}: overflow tail detected — delivering /compact instead of a poke`);
-			} else pokeMessage = "You appear active but have made no observable progress (no new commits, unchanged output) across multiple checks. Do exactly one of: (1) work is done — commit, push, and run pan done; (2) blocked — state the blocker in one sentence and commit what you have as WIP; (3) lost context — re-read your bead (bd show), your latest .pan/feedback/ file, and git status, then resume. Act now.";
-		}
-		await Promise.resolve(runtime.sendMessage(agentId, pokeMessage)).catch((sendErr) => {
-			console.error(`Failed to send poke to ${agentId}:`, sendErr);
-		});
-		this.emit({
-			type: "poked_agent",
-			agentId
-		});
-		console.log(`🔔 Poked ${agentId}${ineffective > 0 ? ` (ineffective streak: ${ineffective})` : ""}`);
+		return pokeAgentWithEscalation(this.crashHost(), agentId);
 	}
 	/**
 	* Kill an agent
@@ -3099,136 +3662,19 @@ var CloisterService = class {
 	* crash the dashboard from a deacon health-check timer callback.
 	*/
 	killAgent(agentId) {
-		try {
-			const runtime = getRuntimeForAgent(agentId);
-			if (!runtime) throw new Error(`No runtime found for agent ${agentId}`);
-			Promise.resolve(runtime.killAgent(agentId)).catch((killErr) => {
-				console.error(`Failed to kill ${agentId}:`, killErr);
-			});
-			this.emit({
-				type: "killed_agent",
-				agentId
-			});
-			console.log(`🔔 Killed ${agentId}`);
-		} catch (error) {
-			console.error(`Failed to kill ${agentId}:`, error);
-		}
+		return killAgent(this.crashHost(), agentId);
 	}
 	/**
 	* Handle agent crash with auto-restart logic
 	*/
 	async handleAgentCrash(agentId) {
-		const config = this.config.auto_restart;
-		if (!config?.enabled) return;
-		const agentState = getAgentStateSync(agentId);
-		if (!agentState || agentState.status === "stopped") {
-			console.log(`🔔 Agent ${agentId} was intentionally stopped, skipping restart`);
-			return;
-		}
-		const runtimeState = getAgentRuntimeStateSync(agentId);
-		if (runtimeState?.state === "suspended") {
-			console.log(`🔔 Agent ${agentId} is suspended, skipping restart`);
-			return;
-		}
-		if (runtimeState?.state === "stopped") {
-			console.log(`🔔 Agent ${agentId} runtime is stopped, skipping restart`);
-			return;
-		}
-		const skipReason = nonRestartableReason(agentState.role, agentState.sessionId);
-		if (skipReason) {
-			let recoverUnfinishedOneShot = false;
-			if (ONE_SHOT_ROLES.has(agentState.role) && agentState.sessionId && agentState.issueId) try {
-				const { getReviewStatusSync } = await import("./review-status-B0Axo-Ma.js");
-				const status = getReviewStatusSync(agentState.issueId);
-				recoverUnfinishedOneShot = !(status ? isRoleTerminal(agentState.role, {
-					reviewStatus: status.reviewStatus,
-					testStatus: status.testStatus,
-					readyForMerge: status.readyForMerge,
-					mergeStatus: status.mergeStatus
-				}) : false);
-			} catch {
-				recoverUnfinishedOneShot = false;
-			}
-			if (!recoverUnfinishedOneShot) {
-				console.log(`🔔 Agent ${agentId} ${skipReason}; skipping restart`);
-				return;
-			}
-			console.log(`🔔 Agent ${agentId} (${agentState.role}) vanished before a terminal verdict — recovering instead of treating as a one-shot completion (PAN-2007)`);
-		}
-		const now = /* @__PURE__ */ new Date();
-		this.deathTimestamps.push(now);
-		this.checkForMassDeaths();
-		let tracker = this.crashTrackers.get(agentId);
-		if (!tracker) {
-			tracker = {
-				agentId,
-				crashCount: 0,
-				lastCrash: now,
-				gaveUp: false
-			};
-			this.crashTrackers.set(agentId, tracker);
-		}
-		if (tracker.gaveUp) return;
-		tracker.crashCount++;
-		tracker.lastCrash = now;
-		this.emit({
-			type: "agent_crashed",
-			agentId,
-			crashCount: tracker.crashCount
-		});
-		console.log(`🔔 Agent ${agentId} crashed (crash #${tracker.crashCount})`);
-		if (this.eventStore) try {
-			this.eventStore.append({
-				type: "agent.heartbeat_dead",
-				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-				payload: {
-					agentId,
-					issueId: agentState.issueId,
-					sessionId: agentState.sessionId
-				}
-			});
-		} catch (err) {
-			console.error(`[cloister] Failed to emit heartbeat_dead for ${agentId}:`, err);
-		}
-		if (tracker.crashCount > config.max_retries) {
-			tracker.gaveUp = true;
-			this.emit({
-				type: "agent_gave_up",
-				agentId,
-				maxRetries: config.max_retries
-			});
-			console.error(`🔔 Gave up on restarting ${agentId} after ${config.max_retries} attempts`);
-			return;
-		}
-		const backoffIndex = Math.min(tracker.crashCount - 1, config.backoff_seconds.length - 1);
-		const backoffSeconds = config.backoff_seconds[backoffIndex];
-		const nextRetryAt = new Date(Date.now() + backoffSeconds * 1e3);
-		tracker.nextRetryAt = nextRetryAt;
-		this.emit({
-			type: "agent_restarting",
-			agentId,
-			crashCount: tracker.crashCount,
-			backoffSeconds
-		});
-		console.log(`🔔 Deacon will recover ${agentId} via heartbeat_dead (attempt ${tracker.crashCount}/${config.max_retries}, backoff ${backoffSeconds}s)`);
+		return handleAgentCrash(this.crashHost(), agentId);
 	}
 	/**
 	* Restart an agent using its saved session
 	*/
 	async restartAgent(agentId) {
-		const runtime = getRuntimeForAgent(agentId);
-		if (!runtime) throw new Error(`No runtime found for agent ${agentId}`);
-		const agentState = getAgentStateSync(agentId);
-		if (!agentState?.sessionId) throw new Error(`No session ID found for agent ${agentId}`);
-		if (!agentState.workspace) throw new Error(`No workspace found for agent ${agentId}`);
-		console.log(`🔔 Restarting ${agentId} with session ${agentState.sessionId.substring(0, 8)}...`);
-		runtime.spawnAgent({
-			agentId,
-			workspace: agentState.workspace,
-			sessionId: agentState.sessionId,
-			runtime: runtime.name
-		});
-		console.log(`🔔 Successfully restarted ${agentId}`);
+		return restartAgent(this.crashHost(), agentId);
 	}
 	/**
 	* Check for mass death events
@@ -3236,33 +3682,13 @@ var CloisterService = class {
 	* Detects when 3+ agents die within 30 seconds and pauses spawns.
 	*/
 	checkForMassDeaths() {
-		const MASS_DEATH_THRESHOLD = 3;
-		const WINDOW_SECONDS = 30;
-		const windowStart = Date.now() - WINDOW_SECONDS * 1e3;
-		this.deathTimestamps = this.deathTimestamps.filter((timestamp) => timestamp.getTime() >= windowStart);
-		if (this.deathTimestamps.length >= MASS_DEATH_THRESHOLD) {
-			this.emit({
-				type: "mass_death_detected",
-				deathCount: this.deathTimestamps.length,
-				windowSeconds: WINDOW_SECONDS
-			});
-			if (!this.spawnsPaused) {
-				this.pauseSpawns("Mass death detected - system stability concern");
-				console.error(`🔔 MASS DEATH DETECTED: ${this.deathTimestamps.length} agents died in ${WINDOW_SECONDS}s - spawns paused`);
-			}
-		}
+		return checkForMassDeaths(this.crashHost());
 	}
 	/**
 	* Pause new agent spawns
 	*/
 	pauseSpawns(reason) {
-		this.spawnsPaused = true;
-		setCloisterSpawnsPausedSync(true);
-		this.emit({
-			type: "spawn_paused",
-			reason
-		});
-		console.log(`🔔 Agent spawns paused: ${reason}`);
+		return pauseSpawns(this.crashHost(), reason);
 	}
 	/**
 	* Resume agent spawns
@@ -3286,48 +3712,13 @@ var CloisterService = class {
 	* Check for FPP violations and send nudges
 	*/
 	checkFPPViolations(agentIds) {
-		for (const agentId of agentIds) {
-			const violation = checkAgentForViolations(agentId);
-			if (!violation) continue;
-			if (violation.nudgeCount === 0) this.emit({
-				type: "fpp_violation_detected",
-				agentId,
-				violation
-			});
-			if ((violation.lastNudgeAt ? Date.now() - new Date(violation.lastNudgeAt).getTime() : Infinity) >= 300 * 1e3 || violation.nudgeCount === 0) {
-				if (hasExceededMaxNudges(violation)) {
-					this.emit({
-						type: "fpp_max_nudges_exceeded",
-						agentId,
-						violation
-					});
-					console.error(`🔔 Agent ${agentId} exceeded max nudges for ${violation.type} - manual intervention required`);
-				} else if (sendNudge(violation)) this.emit({
-					type: "fpp_nudge_sent",
-					agentId,
-					nudgeCount: violation.nudgeCount
-				});
-			}
-		}
+		return checkFPPViolations(this.healthHost(), agentIds);
 	}
 	/**
 	* Check for cost limit alerts
 	*/
 	checkCostAlerts(agentIds) {
-		const config = this.config.cost_limits;
-		if (!config) return;
-		for (const agentId of agentIds) {
-			const alerts = checkCostLimits(agentId, agentId.startsWith("agent-") ? agentId.replace(/^agent-/, "") : agentId, config);
-			for (const alert of alerts) {
-				this.emit({
-					type: "cost_alert",
-					alert
-				});
-				const entityLabel = alert.agentId || alert.issueId || "(unattributed)";
-				if (alert.level === "limit_reached") console.error(`🔔 COST LIMIT REACHED: ${alert.type} for ${entityLabel} - $${alert.currentCost.toFixed(2)} / $${alert.limit.toFixed(2)}`);
-				else console.warn(`🔔 Cost warning: ${alert.type} for ${entityLabel} at ${alert.percentUsed.toFixed(0)}% ($${alert.currentCost.toFixed(2)} / $${alert.limit.toFixed(2)})`);
-			}
-		}
+		return checkCostAlerts(this.healthHost(), agentIds);
 	}
 	/**
 	* Get cost summary
@@ -3339,16 +3730,7 @@ var CloisterService = class {
 	* Check if any specialists need session rotation
 	*/
 	async checkSpecialistRotations() {
-		const mergeAgentResult = await Effect.runPromise(checkAndRotateIfNeeded("merge-agent", process.cwd()));
-		if (mergeAgentResult) {
-			this.emit({
-				type: "session_rotated",
-				specialistName: "merge-agent",
-				result: mergeAgentResult
-			});
-			if (mergeAgentResult.success) console.log(`🔔 Rotated merge-agent session: ${mergeAgentResult.oldSessionId.substring(0, 8)} → ${mergeAgentResult.newSessionId?.substring(0, 8)}`);
-			else console.error(`🔔 Failed to rotate merge-agent: ${mergeAgentResult.error}`);
-		}
+		return checkSpecialistRotations(this.healthHost());
 	}
 	/**
 	* Record health event to database
@@ -3356,28 +3738,7 @@ var CloisterService = class {
 	* Only writes events when state changes or on first check.
 	*/
 	recordHealthEvent(health) {
-		try {
-			const currentState = health.state;
-			const previousState = this.previousStates.get(health.agentId);
-			if (previousState === void 0 || previousState !== currentState) {
-				const source = health.heartbeat?.source ? this.mapHeartbeatSource(health.heartbeat.source) : "unknown";
-				writeHealthEvent({
-					agentId: health.agentId,
-					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-					state: currentState,
-					source,
-					metadata: health.heartbeat ? JSON.stringify({
-						confidence: health.heartbeat.confidence,
-						lastAction: health.heartbeat.lastAction,
-						toolName: health.heartbeat.toolName,
-						timeSinceActivity: health.timeSinceActivity
-					}) : void 0
-				});
-				this.previousStates.set(health.agentId, currentState);
-			}
-		} catch (error) {
-			console.error(`Failed to record health event for ${health.agentId}:`, error);
-		}
+		return recordHealthEvent(this.healthHost(), health);
 	}
 	/**
 	* Check for handoff triggers and execute handoffs (Phase 4)
@@ -3385,57 +3746,13 @@ var CloisterService = class {
 	* Checks all triggers for each agent and performs handoffs when triggered.
 	*/
 	async checkHandoffTriggers(agentHealths) {
-		for (const health of agentHealths) try {
-			const agentState = getAgentStateSync(health.agentId);
-			if (!agentState) continue;
-			if (!agentState.workspace) continue;
-			const triggers = await Effect.runPromise(checkAllTriggers(health.agentId, agentState.workspace, agentState.issueId, agentState.model, health, this.config));
-			if (triggers.length > 0) {
-				const trigger = triggers[0];
-				if (trigger.type === "task_complete" && [
-					"review-agent",
-					"test-agent",
-					"merge-agent",
-					"inspect-agent",
-					"uat-agent"
-				].includes(trigger.suggestedModel || "")) {
-					console.log(`[cloister] Skipping handoff for ${health.agentId}: task_complete triggers specialist dispatch via completion marker, not model swap`);
-					continue;
-				}
-				this.emit({
-					type: "handoff_triggered",
-					agentId: health.agentId,
-					trigger
-				});
-				console.log(`🔔 Handoff triggered for ${health.agentId}: ${trigger.reason}`);
-				const result = await Effect.runPromise(performHandoff(health.agentId, {
-					targetModel: trigger.suggestedModel || "sonnet",
-					reason: trigger.reason
-				}));
-				this.emit({
-					type: "handoff_completed",
-					agentId: health.agentId,
-					result
-				});
-				if (result.context) logHandoffEventSync(createHandoffEvent(health.agentId, agentState.issueId, result.context, trigger.type, result.success, result.error));
-				if (result.success) console.log(`✓ Handoff completed: ${health.agentId} → ${result.newAgentId} (${trigger.suggestedModel})`);
-				else console.error(`✗ Handoff failed: ${result.error}`);
-			}
-		} catch (error) {
-			console.error(`Failed to check handoff triggers for ${health.agentId}:`, error);
-		}
+		return checkHandoffTriggers(this.healthHost(), agentHealths);
 	}
 	/**
 	* Map heartbeat source to database source string
 	*/
 	mapHeartbeatSource(source) {
-		switch (source) {
-			case "jsonl": return "jsonl_mtime";
-			case "tmux": return "tmux_activity";
-			case "git": return "git_activity";
-			case "active-heartbeat": return "active_heartbeat";
-			default: return source;
-		}
+		return mapHeartbeatSource(this.healthHost(), source);
 	}
 	/**
 	* Get current status
@@ -3445,63 +3762,19 @@ var CloisterService = class {
 	* calls for every agent, which scales poorly with agent count.
 	*/
 	getStatus() {
-		const now = Date.now();
-		if (this._statusCache && now - this._statusCacheAt < this.STATUS_CACHE_TTL_MS) return this._statusCache;
-		const agentIds = listRunningAgentsSync().filter((a) => a.tmuxActive).map((a) => a.id);
-		const agentHealths = [];
-		for (const agentId of agentIds) {
-			const runtime = getRuntimeForAgent(agentId);
-			if (runtime) {
-				const health = getAgentHealth(agentId, runtime);
-				agentHealths.push(health);
-			}
-		}
-		const summary = generateHealthSummary(agentHealths);
-		const needsAttention = getAgentsNeedingAttention(agentHealths).map((h) => h.agentId);
-		const deaconStatus = getDeaconStatus();
-		const patrol = assessDeaconPatrolFreshness({
-			isRunning: deaconStatus.isRunning,
-			lastPatrol: deaconStatus.state.lastPatrol,
-			patrolIntervalMs: deaconStatus.config.patrolIntervalMs
-		});
-		const status = {
-			running: this.isRunning(),
-			lastCheck: this.lastCheck,
-			config: this.config,
-			summary,
-			agentsNeedingAttention: needsAttention,
-			patrol: {
-				...patrol,
-				loopRunning: deaconStatus.isRunning,
-				patrolIntervalMs: deaconStatus.config.patrolIntervalMs
-			}
-		};
-		this._statusCache = status;
-		this._statusCacheAt = now;
-		return status;
+		return getStatus(this.statusHost());
 	}
 	/**
 	* Get health for a specific agent
 	*/
 	getAgentHealth(agentId) {
-		const runtime = getRuntimeForAgent(agentId);
-		if (!runtime) return null;
-		return getAgentHealth(agentId, runtime);
+		return getServiceAgentHealth(this.statusHost(), agentId);
 	}
 	/**
 	* Get health for all running agents
 	*/
 	getAllAgentHealth() {
-		const runningAgents = listRunningAgentsSync().filter((a) => a.tmuxActive);
-		const agentHealths = [];
-		for (const agent of runningAgents) {
-			const runtime = getRuntimeForAgent(agent.id);
-			if (runtime) {
-				const health = getAgentHealth(agent.id, runtime);
-				agentHealths.push(health);
-			}
-		}
-		return agentHealths;
+		return getAllAgentHealth(this.statusHost());
 	}
 	/**
 	* Get deacon (specialist health monitor) status
@@ -3599,20 +3872,7 @@ function getCloisterService() {
 	if (!globalService) globalService = new CloisterService();
 	return globalService;
 }
-/**
-* Effect-typed variant of {@link onIssueStateChange}. Never fails — failures
-* surface through `emitActivityEntry` inside the legacy implementation.
-*/
-function onIssueStateChange(issueId, newState) {
-	return Effect.promise(() => onIssueStateChangePromise(issueId, newState));
-}
-/**
-* Effect-typed variant of {@link handleCloisterDomainEvent}. Never fails.
-*/
-function handleCloisterDomainEvent(event) {
-	return Effect.promise(() => handleCloisterDomainEventPromise(event));
-}
 //#endregion
 export { performHandoff as a, getAgentsNeedingAttention as c, CostResolverLive as d, CostWriter as f, checkAllTriggers as i, CostDoorLive as l, readCloisterStateFile as n, generateHealthSummary as o, setCloisterEventStoreProvider as r, getAgentHealth as s, getCloisterService as t, CostResolver as u };
 
-//# sourceMappingURL=service-C8jKYZ0w.js.map
+//# sourceMappingURL=service-DfTVoqJg.js.map