@overdeck/desktop 0.45.21 → 0.45.22

package/server/{deacon-1s7bM5zn.js → deacon-CkT_kznS.js}

@@ -1,47 +1,49 @@
 import { i as __require, t as __commonJSMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { $n as resolveProjectFromIssueSync, At as init_record, Ft as readIssueRecordSync, Nn as getProjectSync, Or as init_errors, Rr as OVERDECK_HOME, Un as listProjectsSync, ai as sessionFilePath, an as init_auto_commit, dn as init_state_plane, f as loadConfigSync, kr as AGENTS_DIR, ln as STATE_PLANE_PATHS, pn as isStatePlanePath, s as init_load, sn as reconcileStatePlaneDrift, ti as init_paths, un as getMainDivergence, zn as init_projects } from "./config-yaml-Ciyp2mYe.js";
-import { n as init_build_info, t as getBuildInfo } from "./build-info-27NlbKhV.js";
-import { n as getDashboardIdentity, t as recordDeaconNudge } from "./deacon-nudge-log-C5VCKtyi.js";
+import { Hn as init_projects, In as getProjectSync, Kn as listProjectsSync, Mr as AGENTS_DIR, Nt as init_record, Rt as readIssueRecordSync, Vr as OVERDECK_HOME, b as DEFAULT_CONFIG$1, ci as sessionFilePath, cn as init_auto_commit, f as loadConfigSync, fn as STATE_PLANE_PATHS, gn as isStatePlanePath, ii as init_paths, jr as init_errors, mn as init_state_plane, nr as resolveProjectFromIssueSync, pn as getMainDivergence, s as init_load, un as reconcileStatePlaneDrift, x as init_defaults } from "./config-yaml-ig8Nwtiw.js";
+import { n as init_build_info, t as getBuildInfo } from "./build-info-NU3KbXYw.js";
+import { n as getDashboardIdentity, t as recordDeaconNudge } from "./deacon-nudge-log-D6K9K-rE.js";
 import { a as init_activity_logger, n as emitActivityEntrySync, r as emitActivityTtsSync } from "./activity-logger-DDlOIAML.js";
-import { n as updateIssueRecord, t as init_record_update } from "./record-update-RviRDSNs.js";
-import { D as killSession, E as isPaneDead, F as querySessionSync, H as sessionExistsSync, M as listSessions, R as sendKeys, V as sessionExists, i as capturePane, j as listSessionNames, k as listPaneValues, w as init_tmux, z as sendKeysAsync } from "./tmux-y1blSxks.js";
-import { a as init_event_store, i as initEventStore } from "./event-store-BVnON3vf.js";
-import { S as needsReviewDispatch, c as init_review_status, h as reviewGatesPassedSync, s as getReviewStatusSync, u as loadReviewStatuses, x as init_review_dispatch_decision, y as setReviewStatusSync } from "./review-status-CCgPVK1h.js";
-import { c as listAllAgentsSync, d as isTerminalIssueStage, o as init_agents, u as getIssueStageSync } from "./agents-DbrHWunF.js";
-import { $ as stopAgent, Bn as recordAgentFailure, Dn as getAgentDir, F as isContextOverflowTail, Gn as saveAgentStateSync, I as init_messaging, Jn as setAgentYieldedSync, L as messageAgent, Ln as markAgentRunningState, M as resumeAgent, Mn as init_agent_state, N as init_context_overflow, Q as init_termination, St as init_transcript_landing, Tn as clearYieldForResumeSync, Un as resetAgentFailureCount, Wn as saveAgentState, _r as init_codex_auth, a as listRunningAgentsSync, at as getConcurrencyLimits, dr as init_runtime_state, fr as saveAgentRuntimeState, ft as workResumeSlotsAvailable, hr as applyCodexAuthBurnFlag, ht as setCachedMemoryVerdict, i as listRunningAgents, jn as getAgentStateSync, kn as getAgentState, lr as getAgentRuntimeState, lt as resetPatrolDispatchBudget, mt as init_memory_verdict_cache, n as init_queries, ot as init_concurrency, pn as buildDefaultResumeContinueMessage, qn as setAgentPausedSync, r as listAgentStates, rt as describeRunningAgents, s as init_agents$1, st as releaseAdvancingSlot, tt as countRunningAgents, ur as getAgentRuntimeStateSync, ut as tryReserveAdvancingSlot, vr as paneShowsCodexAuthBurn, vt as deliverInitialPromptWithRetry, wn as clearAgentTroubledSync, xt as captureTranscriptUserRecordSnapshot } from "./queries-B5hl7lMQ.js";
-import { c as logDeaconEventSync, o as init_persistent_logger, s as logAgentLifecycleSync } from "./session-history-DUehL3KN.js";
-import { i as resolveGitHubIssueSync, n as init_tracker_utils } from "./tracker-utils-DiceZN3a.js";
-import { i as ensureInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-DhfFiwW7.js";
-import { c as init_review_status_sync, l as markWorkspaceStuck } from "./review-status-sync-jnLgd04F.js";
-import { m as readWorkspacePlanSync, o as init_io } from "./io-BiM-7Zsx.js";
-import { f as init_config, m as loadConfigSync$1, p as loadConfig$1 } from "./config-CrduXs4a.js";
-import { T as stampBootReconciliation, h as setBootReconciliationDecision, l as isDeaconGloballyPaused, r as getBootReconciliationState, s as init_control_settings } from "./control-settings-D_79A6gp.js";
-import { c as init_docker_stats, s as DockerStatsCollector } from "./stack-health-DV_f-lK0.js";
-import { l as init_dag, o as getDispatchableItems } from "./dag-DIji6O2b.js";
-import { a as loadCloisterConfigSync, i as loadCloisterConfig, r as init_config$1 } from "./config-G1TOMJZA.js";
-import { a as findRecreatedLegacyStatePaths, o as init_state_home } from "./state-home-DixkE-up.js";
-import { a as isAgentIdleForNudge, t as checkStuckAgentRemediation } from "./stuck-remediation-BWkK_O7A.js";
-import { n as __filename, r as init_esm_shims } from "./esm-shims-BZw-fTQ6.js";
-import { i as init_staleness, r as computeBuildStaleness } from "./staleness-BbsGxmF2.js";
-import { a as pidsWithCwdUnder, i as sweepAutoCloseOutCache, n as pruneTerminalStoppedAgents, r as getAutoCloseOutCanonicalState } from "./agent-gc-D6PUckBB.js";
-import { a as writeFeedbackFile, i as init_feedback_writer } from "./feedback-writer-Wlq5-qgS.js";
-import { r as surfaceIssueFeedbackNeedsYou, t as init_feedback_target } from "./feedback-target-Dqik2WTe.js";
-import { a as init_review_convoy_liveness, c as init_review_monitor, i as evaluateReviewConvoyLiveness, o as reviewTimestampMs, r as init_in_flight_guard, s as REVIEW_SUB_ROLES, t as createInFlightGuard } from "./in-flight-guard-tVGiI5ee.js";
-import { H as getTmuxSessionName, J as parseReviewerSessionName, _ as getAllProjectSpecialistStatuses, t as init_specialists } from "./specialists-CYRwELzc.js";
-import { a as inferBranchFromWorkspace, i as findWorkspacePath, o as init_archive_planning } from "./archive-planning-BOnwJq8M.js";
-import { A as withConcurrencyLimit, k as init_concurrency$1 } from "./github-app-B3yfECo8.js";
-import { n as init_issue_closed, r as isIssueClosed } from "./issue-closed-Dfw3QDyZ.js";
-import { n as shouldSkipDispatchAsMerged, t as init_merge_verification } from "./merge-verification-B3meGcXF.js";
-import { n as init_review_verdict_feedback, t as deliverReviewVerdictFeedback } from "./review-verdict-feedback-CMsIpTpy.js";
-import { n as reconcileTraefikNetworks, t as init_traefik_connect } from "./traefik-connect-BXqfOP4-.js";
-import { g as decideAgentAutonomousRedrive, r as coordinateSwarmSlots, y as listFeatureWorkspaces } from "./deacon-swarm-DmA3rJ7k.js";
-import { t as recordRecoveryFailure } from "./recovery-trip-l1Hsi37x.js";
-import { n as isExplicitNoResumeRequest, t as init_no_resume_mode } from "./no-resume-mode-BnInAFKs.js";
-import { n as reconcileClosedIssueAgents } from "./closed-issue-reaper-BaYQYF6w.js";
-import { n as init_label_reconciler, r as reconcilePipelineLabelsPatrol } from "./label-reconciler-CNf3Ylm3.js";
-import { a as spawnWorkAgentThroughAgentsEndpoint, i as reconcileOrphanProposedSpecs, o as triggerRebuildAndStart } from "./orphan-proposed-reconciler-AxAGUouN.js";
-import { n as reconcileIdleWorkspaceStacks } from "./idle-stack-reaper-BfL8HqYy.js";
-import { i as readTestVerdictArtifact, n as decideUnsignaledTestAction, r as init_test_verdict } from "./test-verdict-BRiSu7eW.js";
+import { n as updateIssueRecord, t as init_record_update } from "./record-update-Crz74r-6.js";
+import { D as killSession, E as isPaneDead, F as querySessionSync, H as sessionExistsSync, M as listSessions, R as sendKeys, V as sessionExists, i as capturePane, j as listSessionNames, k as listPaneValues, w as init_tmux, z as sendKeysAsync } from "./tmux-L5LgvGLp.js";
+import { a as init_event_store, i as initEventStore } from "./event-store-TnWdydfB.js";
+import { C as projectLegacySystemHealthSummary, t as init_src } from "./src-k039WVYY.js";
+import { S as needsReviewDispatch, c as init_review_status, h as reviewGatesPassedSync, s as getReviewStatusSync, u as loadReviewStatuses, x as init_review_dispatch_decision, y as setReviewStatusSync } from "./review-status-DFRjDFef.js";
+import { c as listAllAgentsSync, d as isTerminalIssueStage, o as init_agents, u as getIssueStageSync } from "./agents-DXdHmRTC.js";
+import { $ as stopAgent, Bn as recordAgentFailure, Dn as getAgentDir, F as isContextOverflowTail, Gn as saveAgentStateSync, I as init_messaging, Jn as setAgentYieldedSync, L as messageAgent, Ln as markAgentRunningState, M as resumeAgent, Mn as init_agent_state, N as init_context_overflow, Q as init_termination, St as init_transcript_landing, Tn as clearYieldForResumeSync, Un as resetAgentFailureCount, Wn as saveAgentState, _r as init_codex_auth, a as listRunningAgentsSync, at as getConcurrencyLimits, dr as init_runtime_state, fr as saveAgentRuntimeState, ft as workResumeSlotsAvailable, hr as applyCodexAuthBurnFlag, ht as setCachedMemoryVerdict, i as listRunningAgents, jn as getAgentStateSync, kn as getAgentState, lr as getAgentRuntimeState, lt as resetPatrolDispatchBudget, mt as init_memory_verdict_cache, n as init_queries, ot as init_concurrency, pn as buildDefaultResumeContinueMessage, qn as setAgentPausedSync, r as listAgentStates, rt as describeRunningAgents, s as init_agents$1, st as releaseAdvancingSlot, tt as countRunningAgents, ur as getAgentRuntimeStateSync, ut as tryReserveAdvancingSlot, vr as paneShowsCodexAuthBurn, vt as deliverInitialPromptWithRetry, wn as clearAgentTroubledSync, xt as captureTranscriptUserRecordSnapshot } from "./queries-ZABd5aXP.js";
+import { c as logDeaconEventSync, l as getRuntimeSnapshot, o as init_persistent_logger, s as logAgentLifecycleSync, u as init_agent_runtime_mirror } from "./session-history-XdS0JKp3.js";
+import { i as resolveGitHubIssueSync, n as init_tracker_utils } from "./tracker-utils-CawsPSS2.js";
+import { i as ensureInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-CXsfxslp.js";
+import { c as init_review_status_sync, l as markWorkspaceStuck } from "./review-status-sync-DpAMD_WO.js";
+import { i as readReviewStatusMap, n as init_review_status_source, t as classifyAdvancingSessionLifecycle } from "./review-status-source-CxuEjLGg.js";
+import { m as readWorkspacePlanSync, o as init_io } from "./io-DQR9PMgS.js";
+import { f as init_config, m as loadConfigSync$1, p as loadConfig$1 } from "./config-q4Gvd8dq.js";
+import { T as stampBootReconciliation, h as setBootReconciliationDecision, l as isDeaconGloballyPaused, r as getBootReconciliationState, s as init_control_settings } from "./control-settings-D_odMIaC.js";
+import { c as init_docker_stats, s as DockerStatsCollector } from "./stack-health-C-ifC7b0.js";
+import { l as init_dag, o as getDispatchableItems } from "./dag-CJpgf9A3.js";
+import { a as loadCloisterConfigSync, i as loadCloisterConfig, r as init_config$1 } from "./config-DeTsoZdR.js";
+import { a as findRecreatedLegacyStatePaths, o as init_state_home } from "./state-home-CONQvZR0.js";
+import { a as isAgentIdleForNudge, t as checkStuckAgentRemediation } from "./stuck-remediation-CKnIryGT.js";
+import { n as __filename, r as init_esm_shims } from "./esm-shims-dTeNdq7X.js";
+import { i as init_staleness, r as computeBuildStaleness } from "./staleness-BID1BKdr.js";
+import { a as pidsWithCwdUnder, i as sweepAutoCloseOutCache, n as pruneTerminalStoppedAgents, r as getAutoCloseOutCanonicalState } from "./agent-gc-Dj2gncak.js";
+import { a as writeFeedbackFile, i as init_feedback_writer } from "./feedback-writer-BXP6g75N.js";
+import { r as surfaceIssueFeedbackNeedsYou, t as init_feedback_target } from "./feedback-target-DZ-iAnAa.js";
+import { a as init_review_convoy_liveness, c as init_review_monitor, i as evaluateReviewConvoyLiveness, o as reviewTimestampMs, r as init_in_flight_guard, s as REVIEW_SUB_ROLES, t as createInFlightGuard } from "./in-flight-guard-BoWm66Kh.js";
+import { H as getTmuxSessionName, J as parseReviewerSessionName, _ as getAllProjectSpecialistStatuses, t as init_specialists } from "./specialists-CwZHb5cb.js";
+import { a as inferBranchFromWorkspace, i as findWorkspacePath, o as init_archive_planning } from "./archive-planning-BvDuWNMo.js";
+import { A as withConcurrencyLimit, k as init_concurrency$1 } from "./github-app-CDPtGF7J.js";
+import { n as init_issue_closed, r as isIssueClosed } from "./issue-closed-DtmJM0D0.js";
+import { n as shouldSkipDispatchAsMerged, t as init_merge_verification } from "./merge-verification-CqnUzGEK.js";
+import { n as init_review_verdict_feedback, t as deliverReviewVerdictFeedback } from "./review-verdict-feedback-CpUZl5aE.js";
+import { n as reconcileTraefikNetworks, t as init_traefik_connect } from "./traefik-connect-C6mJckNs.js";
+import { g as decideAgentAutonomousRedrive, r as coordinateSwarmSlots, y as listFeatureWorkspaces } from "./deacon-swarm-BryRr6AO.js";
+import { t as recordRecoveryFailure } from "./recovery-trip-DkzJSej9.js";
+import { n as isExplicitNoResumeRequest, t as init_no_resume_mode } from "./no-resume-mode-BWOSZjWd.js";
+import { n as reconcileClosedIssueAgents } from "./closed-issue-reaper-CQ3kqha7.js";
+import { n as init_label_reconciler, r as reconcilePipelineLabelsPatrol } from "./label-reconciler-Df1ZduPH.js";
+import { a as spawnWorkAgentThroughAgentsEndpoint, i as reconcileOrphanProposedSpecs, o as triggerRebuildAndStart } from "./orphan-proposed-reconciler-xklgvNA7.js";
+import { n as reconcileIdleWorkspaceStacks } from "./idle-stack-reaper-Yf34xXxY.js";
+import { i as readTestVerdictArtifact, n as decideUnsignaledTestAction, r as init_test_verdict } from "./test-verdict-Cp5tljlJ.js";
 import { createRequire } from "node:module";
 import { join } from "node:path";
 import { Effect } from "effect";
@@ -50,13 +52,128 @@ import { dirname as dirname$1, join as join$1 } from "path";
 import { cpus, loadavg } from "os";
 import { cpus as cpus$1, freemem as freemem$1, homedir as homedir$1, loadavg as loadavg$1, platform as platform$1, totalmem as totalmem$1 } from "node:os";
 import { closeSync as closeSync$1, existsSync as existsSync$1, openSync as openSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, unlinkSync as unlinkSync$1, writeFileSync as writeFileSync$1 } from "node:fs";
-import { access, readFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { readFile as readFile$1, readdir as readdir$1, writeFile as writeFile$1 } from "fs/promises";
 import { exec, execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { exec as exec$1, execFile as execFile$1, spawn as spawn$1 } from "child_process";
 import { promisify as promisify$1 } from "util";
 import { layer } from "@effect/platform-node/NodeServices";
+//#region ../../lib/agents/health.ts
+init_paths();
+init_errors();
+init_activity_logger();
+init_projects();
+init_state_plane();
+init_auto_commit();
+init_record();
+init_record_update();
+init_tmux();
+init_src();
+init_agents();
+init_agent_runtime_mirror();
+init_persistent_logger();
+init_internal_token();
+init_review_status_sync();
+init_review_status_source();
+init_review_dispatch_decision();
+init_review_status();
+init_codex_auth();
+init_runtime_state();
+init_agent_state();
+init_transcript_landing();
+init_config$1();
+init_memory_verdict_cache();
+init_concurrency();
+init_termination();
+init_messaging();
+init_context_overflow();
+init_agents$1();
+init_queries();
+const STARTUP_GRACE_MS = 300 * 1e3;
+const ACTIVITY_WARNING_MS = 900 * 1e3;
+const ACTIVITY_STALLED_MS = 1800 * 1e3;
+function reason$1(code, severity, message) {
+	return {
+		code,
+		domain: "agent",
+		severity,
+		message
+	};
+}
+function validTimestamp(value) {
+	if (!value) return null;
+	const timestamp = Date.parse(value);
+	return Number.isFinite(timestamp) ? timestamp : null;
+}
+function latestActivity(persisted, runtime) {
+	const candidates = [persisted.lastActivity, runtime?.lastActivity].map((value) => ({
+		value,
+		timestamp: validTimestamp(value)
+	})).filter((entry) => entry.value !== void 0 && entry.timestamp !== null);
+	if (candidates.length === 0) return void 0;
+	return candidates.reduce((latest, entry) => entry.timestamp > latest.timestamp ? entry : latest).value;
+}
+function agentKind(role) {
+	if (role === "work") return "work";
+	if (role === "plan") return "planning";
+	if (role === "review" || role === "test" || role === "ship") return "specialist";
+	return "other";
+}
+function intentionalInactive(state) {
+	return state.status === "stopped" || state.status === "completed" || state.paused === true || state.stoppedByUser === true || state.stoppedByPause === true;
+}
+function lifecycleFor(input, state) {
+	if (input.reviewLifecycle === "warm" || input.reviewLifecycle === "orphaned") return input.reviewLifecycle;
+	if (input.liveSessions.has(input.agentId) && !intentionalInactive(state)) return "active";
+	return input.reviewLifecycle ?? "unknown";
+}
+function buildSnapshot(input, state, status, reasons) {
+	const lastActivityAt = latestActivity(state, input.runtime);
+	const observations = input.observations;
+	return {
+		id: input.agentId,
+		...state.issueId ? { issueId: state.issueId } : {},
+		...state.role ? { role: state.role } : {},
+		kind: agentKind(state.role),
+		status,
+		lifecycle: lifecycleFor(input, state),
+		tmuxActive: input.liveSessions.has(input.agentId),
+		...lastActivityAt ? { lastActivityAt } : {},
+		...observations?.consecutiveFailures !== void 0 ? { consecutiveFailures: observations.consecutiveFailures } : state.consecutiveFailures !== void 0 ? { consecutiveFailures: state.consecutiveFailures } : {},
+		...observations?.killCount !== void 0 ? { killCount: observations.killCount } : {},
+		...observations && Object.prototype.hasOwnProperty.call(observations, "contextPercent") ? { contextPercent: observations.contextPercent ?? null } : {},
+		reasons
+	};
+}
+/**
+* Classifies one resolved agent snapshot. The function is intentionally free of
+* filesystem, tmux, review-status, and runtime-store imports so every caller
+* supplies one coherent set of evidence and cycle-prone dashboard code remains
+* a thin resolver adapter.
+*/
+function classifyAgentHealth(input) {
+	if (input.persisted.status === "unavailable") return buildSnapshot(input, {}, "unavailable", [reason$1("agent.persisted_state.unavailable", "warning", input.persisted.reason)]);
+	const state = input.persisted.value;
+	if (input.runtime?.contextSaturatedAt) return buildSnapshot(input, state, "wedged", [reason$1("agent.context.saturated", "critical", "Context window exhausted; recovery is required.")]);
+	const startedAt = validTimestamp(state.startedAt);
+	const startupGraceElapsed = startedAt !== null && input.nowMs - startedAt >= STARTUP_GRACE_MS;
+	const expectsLiveSession = state.status === "running" || state.status === "starting";
+	if (!input.liveSessions.has(input.agentId) && expectsLiveSession && startupGraceElapsed) return buildSnapshot(input, state, "dead", [reason$1("agent.tmux.missing", "critical", "The persisted agent is running but its tmux session is missing.")]);
+	if (state.role === "work" && state.status === "running" && state.kickoffDelivered === false && startupGraceElapsed) return buildSnapshot(input, state, "stalled", [reason$1("agent.kickoff.not_delivered", "warning", "Work agent running with no kickoff delivered since spawn")]);
+	if (input.runtime?.state === "waiting-on-human") return buildSnapshot(input, state, "waiting", [reason$1("agent.runtime.waiting_on_human", "info", "The agent is waiting for operator input.")]);
+	if (input.reviewLifecycle === "warm" || input.reviewLifecycle === "orphaned" || input.runtime?.state === "idle" || input.runtime?.state === "suspended" || input.runtime?.state === "stopped" || intentionalInactive(state)) return buildSnapshot(input, state, "idle", []);
+	if (input.runtime?.state === "active") {
+		const lastActivityMs = validTimestamp(latestActivity(state, input.runtime));
+		if (lastActivityMs !== null) {
+			const inactivityMs = Math.max(0, input.nowMs - lastActivityMs);
+			if (inactivityMs >= ACTIVITY_STALLED_MS) return buildSnapshot(input, state, "stalled", [reason$1("agent.runtime.inactive.stalled", "warning", `The active agent has produced no activity for ${Math.round(inactivityMs / 6e4)} minutes.`)]);
+			if (inactivityMs >= ACTIVITY_WARNING_MS) return buildSnapshot(input, state, "warning", [reason$1("agent.runtime.inactive.warning", "warning", `The active agent has produced no activity for ${Math.round(inactivityMs / 6e4)} minutes.`)]);
+		}
+	}
+	return buildSnapshot(input, state, "healthy", []);
+}
+//#endregion
 //#region ../../../node_modules/.bun/undici@7.25.0/node_modules/undici/lib/core/symbols.js
 var require_symbols = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = {
@@ -21468,9 +21585,7 @@ var require_eventsource = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		defaultReconnectionTime
 	};
 }));
-//#endregion
-//#region ../../../node_modules/.bun/undici@7.25.0/node_modules/undici/index.js
-var require_undici = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+new ((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	init_esm_shims();
 	const Client = require_client();
 	const Dispatcher = require_dispatcher();
@@ -21636,37 +21751,7 @@ var require_undici = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		globalThis.EventSource = module.exports.EventSource;
 	}
 	module.exports.install = install;
-}));
-//#endregion
-//#region ../../../node_modules/.bun/smee-client@5.0.0/node_modules/smee-client/index.js
-init_paths();
-init_errors();
-init_activity_logger();
-init_projects();
-init_state_plane();
-init_auto_commit();
-init_record();
-init_record_update();
-init_tmux();
-init_agents();
-init_persistent_logger();
-init_internal_token();
-init_review_status_sync();
-init_review_dispatch_decision();
-init_review_status();
-init_codex_auth();
-init_runtime_state();
-init_agent_state();
-init_transcript_landing();
-init_config$1();
-init_memory_verdict_cache();
-init_concurrency();
-init_termination();
-init_messaging();
-init_context_overflow();
-init_agents$1();
-init_queries();
-new (require_undici()).EnvHttpProxyAgent();
+})))()).EnvHttpProxyAgent();
 //#endregion
 //#region ../../lib/smee.ts
 /**
@@ -21849,35 +21934,881 @@ function startSmeeProcessSync() {
 	console.log(`[smee] Started process (PID ${child.pid}) relaying to ${target}`);
 }
 //#endregion
-//#region services/system-health-service.ts
-init_docker_stats();
+//#region ../../lib/system-health/config.ts
 init_build_info();
-init_staleness();
+init_docker_stats();
+init_defaults();
+init_load();
+const GIB$2 = 1024 ** 3;
+const SYSTEM_HEALTH_DEFAULTS = Object.freeze({
+	pollSeconds: 15,
+	memoryWarnGb: DEFAULT_CONFIG$1.resources.memoryWarnGb,
+	memoryBlockGb: DEFAULT_CONFIG$1.resources.memoryBlockGb,
+	agentWarnCount: DEFAULT_CONFIG$1.resources.agentWarnCount,
+	agentBlockCount: DEFAULT_CONFIG$1.resources.agentBlockCount,
+	swapUsedWarningPercent: 20,
+	swapUsedCriticalPercent: 50,
+	cpuLoadWarningPerCore: 1,
+	cpuLoadCriticalPerCore: 1.5,
+	overcommitWarningPercent: 150,
+	overcommitCriticalPercent: 200
+});
+function finiteNonnegative(value) {
+	if (value === "" || value == null) return null;
+	const parsed = typeof value === "number" ? value : Number(value);
+	return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+/**
+* Normalizes every health threshold in one pass. Any invalid value or reversed
+* pair falls back to its named defaults, and the caller receives one warning
+* describing the complete fallback rather than one warning per field.
+*/
+function normalizeSystemHealthThresholds(input, warn = console.warn) {
+	const invalid = [];
+	const scalar = (name, fallback, minimum = 0) => {
+		const value = finiteNonnegative(input[name]);
+		if (value == null || value < minimum) {
+			invalid.push(String(name));
+			return fallback;
+		}
+		return value;
+	};
+	const increasingPair = (warningName, criticalName, warningDefault, criticalDefault) => {
+		const warning = finiteNonnegative(input[warningName]);
+		const critical = finiteNonnegative(input[criticalName]);
+		if (warning == null || critical == null || warning > critical) {
+			invalid.push(`${String(warningName)}/${String(criticalName)}`);
+			return [warningDefault, criticalDefault];
+		}
+		return [warning, critical];
+	};
+	const decreasingPair = (warningName, criticalName, warningDefault, criticalDefault) => {
+		const warning = finiteNonnegative(input[warningName]);
+		const critical = finiteNonnegative(input[criticalName]);
+		if (warning == null || critical == null || warning < critical) {
+			invalid.push(`${String(warningName)}/${String(criticalName)}`);
+			return [warningDefault, criticalDefault];
+		}
+		return [warning, critical];
+	};
+	const [memoryWarnGb, memoryBlockGb] = decreasingPair("memoryWarnGb", "memoryBlockGb", SYSTEM_HEALTH_DEFAULTS.memoryWarnGb, SYSTEM_HEALTH_DEFAULTS.memoryBlockGb);
+	const [agentWarnCountValue, agentBlockCountValue] = increasingPair("agentWarnCount", "agentBlockCount", SYSTEM_HEALTH_DEFAULTS.agentWarnCount, SYSTEM_HEALTH_DEFAULTS.agentBlockCount);
+	const [swapUsedWarningPercent, swapUsedCriticalPercent] = increasingPair("swapUsedWarningPercent", "swapUsedCriticalPercent", SYSTEM_HEALTH_DEFAULTS.swapUsedWarningPercent, SYSTEM_HEALTH_DEFAULTS.swapUsedCriticalPercent);
+	const [cpuLoadWarningPerCore, cpuLoadCriticalPerCore] = increasingPair("cpuLoadWarningPerCore", "cpuLoadCriticalPerCore", SYSTEM_HEALTH_DEFAULTS.cpuLoadWarningPerCore, SYSTEM_HEALTH_DEFAULTS.cpuLoadCriticalPerCore);
+	const [overcommitWarningPercent, overcommitCriticalPercent] = increasingPair("overcommitWarningPercent", "overcommitCriticalPercent", SYSTEM_HEALTH_DEFAULTS.overcommitWarningPercent, SYSTEM_HEALTH_DEFAULTS.overcommitCriticalPercent);
+	const pollSeconds = scalar("pollSeconds", SYSTEM_HEALTH_DEFAULTS.pollSeconds, 1);
+	const agentWarnCount = Math.max(1, Math.floor(agentWarnCountValue));
+	const agentBlockCount = Math.max(1, Math.floor(agentBlockCountValue));
+	if (invalid.length > 0) warn(`[system-health] Invalid thresholds (${invalid.join(", ")}); using named defaults.`);
+	return {
+		pollSeconds: Math.max(1, Math.floor(pollSeconds)),
+		resources: {
+			memoryWarnGb,
+			memoryBlockGb,
+			agentWarnCount,
+			agentBlockCount
+		},
+		thresholds: {
+			memoryAvailableWarningBytes: memoryWarnGb * GIB$2,
+			memoryAvailableCriticalBytes: memoryBlockGb * GIB$2,
+			swapUsedWarningPercent,
+			swapUsedCriticalPercent,
+			cpuLoadWarningPerCore,
+			cpuLoadCriticalPerCore,
+			overcommitWarningPercent,
+			overcommitCriticalPercent
+		}
+	};
+}
+function resolveSystemHealthConfig(options = {}) {
+	const resources = options.resources ?? loadConfigSync().config.resources;
+	const env = options.env ?? process.env;
+	return normalizeSystemHealthThresholds({
+		pollSeconds: env["PAN_HEALTH_POLL_SECONDS"] ?? SYSTEM_HEALTH_DEFAULTS.pollSeconds,
+		memoryWarnGb: env["PAN_MEMORY_WARN_GB"] ?? resources.memoryWarnGb,
+		memoryBlockGb: env["PAN_MEMORY_BLOCK_GB"] ?? resources.memoryBlockGb,
+		agentWarnCount: env["PAN_AGENT_WARN_COUNT"] ?? resources.agentWarnCount,
+		agentBlockCount: env["PAN_AGENT_BLOCK_COUNT"] ?? resources.agentBlockCount,
+		swapUsedWarningPercent: env["PAN_HEALTH_SWAP_WARN_PERCENT"] ?? SYSTEM_HEALTH_DEFAULTS.swapUsedWarningPercent,
+		swapUsedCriticalPercent: env["PAN_HEALTH_SWAP_CRITICAL_PERCENT"] ?? SYSTEM_HEALTH_DEFAULTS.swapUsedCriticalPercent,
+		cpuLoadWarningPerCore: env["PAN_HEALTH_LOAD_WARN_PER_CORE"] ?? SYSTEM_HEALTH_DEFAULTS.cpuLoadWarningPerCore,
+		cpuLoadCriticalPerCore: env["PAN_HEALTH_LOAD_CRITICAL_PER_CORE"] ?? SYSTEM_HEALTH_DEFAULTS.cpuLoadCriticalPerCore,
+		overcommitWarningPercent: env["PAN_HEALTH_OVERCOMMIT_WARN_PERCENT"] ?? SYSTEM_HEALTH_DEFAULTS.overcommitWarningPercent,
+		overcommitCriticalPercent: env["PAN_HEALTH_OVERCOMMIT_CRITICAL_PERCENT"] ?? SYSTEM_HEALTH_DEFAULTS.overcommitCriticalPercent
+	}, options.warn);
+}
+//#endregion
+//#region ../../lib/system-health/types.ts
+function available(value) {
+	return {
+		status: "available",
+		value
+	};
+}
+function unavailable(reason) {
+	return {
+		status: "unavailable",
+		reason
+	};
+}
+//#endregion
+//#region ../../lib/system-health/darwin.ts
+const execFileAsync$8 = promisify(execFile);
+const COMMAND_TIMEOUT_MS = 5e3;
+const MIB = 1024 ** 2;
+const DARWIN_MEMORY_PRESSURE_DEFAULTS = Object.freeze({
+	warningFreePercent: 10,
+	criticalFreePercent: 5,
+	swapActivityWarningBytesPerMinute: 64 * MIB,
+	swapActivityCriticalBytesPerMinute: 256 * MIB
+});
+function parseDarwinMemoryPressure(content) {
+	for (const pattern of [/System-wide memory free percentage:\s*([\d.]+)\s*%/i, /System-wide memory free percentage\s*=\s*([\d.]+)\s*%?/i]) {
+		const match = content.match(pattern);
+		if (!match) continue;
+		const value = Number(match[1]);
+		if (Number.isFinite(value) && value >= 0 && value <= 100) return value;
+	}
+	return null;
+}
+function parseDarwinVmStat(content) {
+	const pageSizeMatch = content.match(/page size of\s+(\d+)\s+bytes/i);
+	if (!pageSizeMatch) return null;
+	const pageSizeBytes = Number(pageSizeMatch[1]);
+	if (!Number.isFinite(pageSizeBytes) || pageSizeBytes <= 0) return null;
+	const pages = /* @__PURE__ */ new Map();
+	for (const line of content.split("\n")) {
+		const match = line.match(/^([^:]+):\s+(\d+)\.?$/);
+		if (!match) continue;
+		const value = Number(match[2]);
+		if (Number.isFinite(value)) pages.set(match[1].trim(), value);
+	}
+	const availablePageNames = [
+		"Pages free",
+		"Pages inactive",
+		"Pages speculative"
+	];
+	const availablePages = availablePageNames.every((name) => pages.has(name)) ? availablePageNames.reduce((sum, name) => sum + pages.get(name), 0) : void 0;
+	const swapIn = pages.get("Swapins");
+	const swapOut = pages.get("Swapouts");
+	return {
+		pageSizeBytes,
+		availableMemoryBytes: availablePages == null ? void 0 : availablePages * pageSizeBytes,
+		swap: swapIn == null || swapOut == null ? void 0 : {
+			pagesIn: swapIn,
+			pagesOut: swapOut
+		}
+	};
+}
+function unitBytes(value, unit) {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed < 0) return null;
+	const multiplier = unit.toUpperCase() === "G" ? 1024 ** 3 : unit.toUpperCase() === "K" ? 1024 : MIB;
+	return Math.round(parsed * multiplier);
+}
+function parseDarwinSwapUsage(content) {
+	const total = content.match(/total\s*=\s*([\d.]+)([KMG])/i);
+	const used = content.match(/used\s*=\s*([\d.]+)([KMG])/i);
+	const free = content.match(/free\s*=\s*([\d.]+)([KMG])/i);
+	if (!total || !used || !free) return null;
+	const totalBytes = unitBytes(total[1], total[2]);
+	const usedBytes = unitBytes(used[1], used[2]);
+	const freeBytes = unitBytes(free[1], free[2]);
+	return totalBytes == null || usedBytes == null || freeBytes == null ? null : {
+		totalBytes,
+		usedBytes,
+		freeBytes
+	};
+}
+function aggregateDarwinCpuCounters(cpuInfo) {
+	if (cpuInfo.length === 0) return null;
+	let idle = 0;
+	let total = 0;
+	for (const cpu of cpuInfo) {
+		const values = Object.values(cpu.times);
+		if (values.some((value) => !Number.isFinite(value) || value < 0)) return null;
+		idle += cpu.times.idle;
+		total += values.reduce((sum, value) => sum + value, 0);
+	}
+	return {
+		idle,
+		total
+	};
+}
+function computeCpuPercent$1(current, previous) {
+	if (!previous) return unavailable("A previous CPU time sample is required.");
+	const totalDelta = current.total - previous.total;
+	const idleDelta = current.idle - previous.idle;
+	if (totalDelta <= 0 || idleDelta < 0 || idleDelta > totalDelta) return unavailable("CPU times did not advance monotonically.");
+	return available(Math.round((totalDelta - idleDelta) / totalDelta * 1e3) / 10);
+}
+function computeSwapActivity(current, previous, elapsedMs, pageSizeBytes) {
+	if (!previous) return unavailable("A previous swap counter sample is required.");
+	const pages = current.pagesIn - previous.pagesIn + current.pagesOut - previous.pagesOut;
+	if (pages < 0 || elapsedMs <= 0) return unavailable("Swap counters or sample timing were invalid.");
+	return available(Math.round(pages * pageSizeBytes * 6e4 / elapsedMs));
+}
+function percent$1(part, total) {
+	if (total <= 0) return 0;
+	return Math.round(part / total * 1e3) / 10;
+}
+const defaultAdapters$1 = {
+	execFile: async (command, args, timeoutMs) => {
+		const { stdout } = await execFileAsync$8(command, [...args], {
+			encoding: "utf-8",
+			timeout: timeoutMs
+		});
+		return stdout;
+	},
+	cpus: cpus$1,
+	loadAverage1m: () => loadavg$1()[0] ?? 0,
+	totalMemoryBytes: totalmem$1,
+	now: () => Date.now()
+};
+async function command(adapters, executable, args) {
+	try {
+		return await adapters.execFile(executable, args, COMMAND_TIMEOUT_MS);
+	} catch {
+		return null;
+	}
+}
+function createDarwinHostHealthCollector(adapters = defaultAdapters$1) {
+	return {
+		platform: "darwin",
+		async sample(previous) {
+			const sampledAtMs = adapters.now();
+			const [pressureOutput, vmStatOutput, swapOutput] = await Promise.all([
+				command(adapters, "memory_pressure", ["-Q"]),
+				command(adapters, "vm_stat", []),
+				command(adapters, "sysctl", ["-n", "vm.swapusage"])
+			]);
+			const pressureFreePercent = pressureOutput == null ? null : parseDarwinMemoryPressure(pressureOutput);
+			const vmStat = vmStatOutput == null ? null : parseDarwinVmStat(vmStatOutput);
+			const swapUsage = swapOutput == null ? null : parseDarwinSwapUsage(swapOutput);
+			const cpuInfo = adapters.cpus();
+			const cpuCounters = aggregateDarwinCpuCounters(cpuInfo);
+			const totalMemoryBytes = adapters.totalMemoryBytes();
+			const availableMemoryBytes = pressureFreePercent != null ? Math.round(totalMemoryBytes * pressureFreePercent / 100) : vmStat?.availableMemoryBytes ?? null;
+			const usedMemoryBytes = Number.isFinite(totalMemoryBytes) && availableMemoryBytes != null ? Math.max(totalMemoryBytes - availableMemoryBytes, 0) : null;
+			const loadAverage1m = adapters.loadAverage1m();
+			const elapsedMs = previous ? sampledAtMs - previous.sampledAtMs : 0;
+			return {
+				platform: "darwin",
+				sampledAtMs,
+				cpuPercent: cpuCounters ? computeCpuPercent$1(cpuCounters, previous?.counters.cpu) : unavailable("macOS CPU times are unavailable."),
+				loadAverage1m: Number.isFinite(loadAverage1m) && loadAverage1m >= 0 ? available(loadAverage1m) : unavailable("The one-minute load average is unavailable."),
+				loadPerCore1m: Number.isFinite(loadAverage1m) && loadAverage1m >= 0 && cpuInfo.length > 0 ? available(Math.round(loadAverage1m / cpuInfo.length * 100) / 100) : unavailable("Load average or CPU core count is unavailable."),
+				totalMemoryBytes: Number.isFinite(totalMemoryBytes) && totalMemoryBytes > 0 ? available(totalMemoryBytes) : unavailable("Total memory is unavailable."),
+				usedMemoryBytes: usedMemoryBytes == null ? unavailable("Used memory cannot be derived.") : available(usedMemoryBytes),
+				availableMemoryBytes: availableMemoryBytes == null ? unavailable("Available memory is unavailable.") : available(availableMemoryBytes),
+				memoryUsedPercent: usedMemoryBytes == null ? unavailable("Memory utilization cannot be derived.") : available(percent$1(usedMemoryBytes, totalMemoryBytes)),
+				memoryPressureSomeAvg10: unavailable("macOS does not expose Linux memory PSI."),
+				memoryPressureFullAvg10: unavailable("macOS does not expose Linux memory PSI."),
+				memoryPressureFreePercent: pressureFreePercent == null ? unavailable("memory_pressure did not report a recognized free percentage.") : available(pressureFreePercent),
+				swapTotalBytes: swapUsage ? available(swapUsage.totalBytes) : unavailable("vm.swapusage is unavailable."),
+				swapUsedBytes: swapUsage ? available(swapUsage.usedBytes) : unavailable("vm.swapusage is unavailable."),
+				swapUsedPercent: swapUsage ? available(percent$1(swapUsage.usedBytes, swapUsage.totalBytes)) : unavailable("vm.swapusage is unavailable."),
+				swapActivityBytesPerMinute: vmStat?.swap ? computeSwapActivity(vmStat.swap, previous?.counters.swap, elapsedMs, vmStat.pageSizeBytes) : unavailable("vm_stat swap activity counters are unavailable."),
+				committedMemoryBytes: unavailable("macOS does not expose Linux Committed_AS."),
+				commitLimitBytes: unavailable("macOS does not expose Linux CommitLimit."),
+				virtualCommitmentPercent: unavailable("macOS virtual commitment is unavailable."),
+				counters: {
+					cpu: cpuCounters,
+					swap: vmStat?.swap ?? null
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region ../../lib/system-health/linux.ts
+const execFileAsync$7 = promisify(execFile);
+const KB$1 = 1024;
+const LINUX_MEMORY_PRESSURE_DEFAULTS = Object.freeze({
+	someWarningAvg10: 5,
+	fullCriticalAvg10: 1,
+	swapActivityWarningBytesPerMinute: 64 * 1024 ** 2,
+	swapActivityCriticalBytesPerMinute: 256 * 1024 ** 2
+});
+function parseMemInfo(content) {
+	const values = /* @__PURE__ */ new Map();
+	for (const line of content.split("\n")) {
+		const match = line.match(/^(\w+):\s+(\d+)\s+kB$/);
+		if (!match) continue;
+		const value = Number(match[2]);
+		if (Number.isFinite(value)) values.set(match[1], value * KB$1);
+	}
+	return {
+		memTotalBytes: values.get("MemTotal"),
+		memAvailableBytes: values.get("MemAvailable"),
+		swapTotalBytes: values.get("SwapTotal"),
+		swapFreeBytes: values.get("SwapFree"),
+		committedMemoryBytes: values.get("Committed_AS"),
+		commitLimitBytes: values.get("CommitLimit")
+	};
+}
+function parseProcStat(content) {
+	const lines = content.split("\n");
+	const cpuLine = lines.find((line) => line.startsWith("cpu "));
+	if (!cpuLine) return null;
+	const values = cpuLine.trim().split(/\s+/).slice(1).map(Number);
+	if (values.length < 4 || values.some((value) => !Number.isFinite(value))) return null;
+	const idle = values[3] + (values[4] ?? 0);
+	const total = values.reduce((sum, value) => sum + value, 0);
+	const coreCount = lines.filter((line) => /^cpu\d+\s/.test(line)).length;
+	if (total < 0 || idle < 0) return null;
+	return {
+		cpu: {
+			idle,
+			total
+		},
+		coreCount: Math.max(coreCount, 1)
+	};
+}
+function parseMemoryPressure(content) {
+	const result = {};
+	for (const line of content.split("\n")) {
+		const match = line.match(/^(some|full)\s+.*\bavg10=([^\s]+)/);
+		if (!match) continue;
+		const value = Number(match[2]);
+		if (!Number.isFinite(value) || value < 0) continue;
+		if (match[1] === "some") result.someAvg10 = value;
+		if (match[1] === "full") result.fullAvg10 = value;
+	}
+	return result;
+}
+function parseVmstat(content) {
+	let pagesIn = null;
+	let pagesOut = null;
+	for (const line of content.split("\n")) {
+		const match = line.match(/^(pswpin|pswpout)\s+(\d+)$/);
+		if (!match) continue;
+		const value = Number(match[2]);
+		if (!Number.isFinite(value)) continue;
+		if (match[1] === "pswpin") pagesIn = value;
+		if (match[1] === "pswpout") pagesOut = value;
+	}
+	return pagesIn == null || pagesOut == null ? null : {
+		pagesIn,
+		pagesOut
+	};
+}
+function parseLoadAverage(content) {
+	const value = Number(content.trim().split(/\s+/)[0]);
+	return Number.isFinite(value) && value >= 0 ? value : null;
+}
+function computeCpuPercent(current, previous) {
+	if (!previous) return unavailable("A previous CPU counter sample is required.");
+	const totalDelta = current.total - previous.total;
+	const idleDelta = current.idle - previous.idle;
+	if (totalDelta <= 0 || idleDelta < 0 || idleDelta > totalDelta) return unavailable("CPU counters did not advance monotonically.");
+	return available(Math.round((totalDelta - idleDelta) / totalDelta * 1e3) / 10);
+}
+function computeSwapActivityBytesPerMinute(current, previous, elapsedMs, pageSizeBytes) {
+	if (!previous) return unavailable("A previous swap counter sample is required.");
+	const pageDelta = current.pagesIn - previous.pagesIn + current.pagesOut - previous.pagesOut;
+	if (pageDelta < 0 || elapsedMs <= 0 || !Number.isFinite(pageSizeBytes) || pageSizeBytes <= 0) return unavailable("Swap counters or sample timing were invalid.");
+	return available(Math.round(pageDelta * pageSizeBytes * 6e4 / elapsedMs));
+}
+const defaultAdapters = {
+	readFile: (path) => readFile(path, "utf-8"),
+	readPageSizeBytes: async () => {
+		const { stdout } = await execFileAsync$7("getconf", ["PAGESIZE"], {
+			encoding: "utf-8",
+			timeout: 5e3
+		});
+		const value = Number(stdout.trim());
+		if (!Number.isFinite(value) || value <= 0) throw new Error("getconf returned an invalid page size");
+		return value;
+	},
+	now: () => Date.now()
+};
+async function readParsed(adapters, path, parse) {
+	try {
+		return parse(await adapters.readFile(path));
+	} catch {
+		return null;
+	}
+}
+function percent(part, total) {
+	if (total <= 0) return 0;
+	return Math.round(part / total * 1e3) / 10;
+}
+function createLinuxHostHealthCollector(adapters = defaultAdapters) {
+	return {
+		platform: "linux",
+		async sample(previous) {
+			const sampledAtMs = adapters.now();
+			const [memInfo, procStat, pressure, vmstat, loadAverage, pageSizeBytes] = await Promise.all([
+				readParsed(adapters, "/proc/meminfo", parseMemInfo),
+				readParsed(adapters, "/proc/stat", parseProcStat),
+				readParsed(adapters, "/proc/pressure/memory", parseMemoryPressure),
+				readParsed(adapters, "/proc/vmstat", parseVmstat),
+				readParsed(adapters, "/proc/loadavg", parseLoadAverage),
+				adapters.readPageSizeBytes().catch(() => null)
+			]);
+			const totalMemoryBytes = memInfo?.memTotalBytes;
+			const availableMemoryBytes = memInfo?.memAvailableBytes;
+			const usedMemoryBytes = totalMemoryBytes != null && availableMemoryBytes != null ? Math.max(totalMemoryBytes - availableMemoryBytes, 0) : null;
+			const swapTotalBytes = memInfo?.swapTotalBytes;
+			const swapFreeBytes = memInfo?.swapFreeBytes;
+			const swapUsedBytes = swapTotalBytes != null && swapFreeBytes != null ? Math.max(swapTotalBytes - swapFreeBytes, 0) : null;
+			const committedMemoryBytes = memInfo?.committedMemoryBytes;
+			const commitLimitBytes = memInfo?.commitLimitBytes;
+			const cpuCounters = procStat?.cpu ?? null;
+			const swapCounters = vmstat ?? null;
+			const elapsedMs = previous ? sampledAtMs - previous.sampledAtMs : 0;
+			return {
+				platform: "linux",
+				sampledAtMs,
+				cpuPercent: cpuCounters ? computeCpuPercent(cpuCounters, previous?.counters.cpu) : unavailable("The aggregate CPU counters are unavailable."),
+				loadAverage1m: loadAverage == null ? unavailable("The one-minute load average is unavailable.") : available(loadAverage),
+				loadPerCore1m: loadAverage == null || !procStat ? unavailable("Load average or CPU core count is unavailable.") : available(Math.round(loadAverage / procStat.coreCount * 100) / 100),
+				totalMemoryBytes: totalMemoryBytes == null ? unavailable("MemTotal is unavailable.") : available(totalMemoryBytes),
+				usedMemoryBytes: usedMemoryBytes == null ? unavailable("Used memory cannot be derived without MemTotal and MemAvailable.") : available(usedMemoryBytes),
+				availableMemoryBytes: availableMemoryBytes == null ? unavailable("MemAvailable is unavailable.") : available(availableMemoryBytes),
+				memoryUsedPercent: usedMemoryBytes == null || totalMemoryBytes == null ? unavailable("Memory utilization cannot be derived.") : available(percent(usedMemoryBytes, totalMemoryBytes)),
+				memoryPressureSomeAvg10: pressure?.someAvg10 == null ? unavailable("Linux memory PSI some.avg10 is unavailable.") : available(pressure.someAvg10),
+				memoryPressureFullAvg10: pressure?.fullAvg10 == null ? unavailable("Linux memory PSI full.avg10 is unavailable.") : available(pressure.fullAvg10),
+				memoryPressureFreePercent: unavailable("Linux reports memory pressure through PSI."),
+				swapTotalBytes: swapTotalBytes == null ? unavailable("SwapTotal is unavailable.") : available(swapTotalBytes),
+				swapUsedBytes: swapUsedBytes == null ? unavailable("Swap usage cannot be derived without SwapTotal and SwapFree.") : available(swapUsedBytes),
+				swapUsedPercent: swapUsedBytes == null || swapTotalBytes == null ? unavailable("Swap utilization cannot be derived.") : available(percent(swapUsedBytes, swapTotalBytes)),
+				swapActivityBytesPerMinute: swapCounters && pageSizeBytes != null ? computeSwapActivityBytesPerMinute(swapCounters, previous?.counters.swap, elapsedMs, pageSizeBytes) : unavailable("Linux swap activity counters are unavailable."),
+				committedMemoryBytes: committedMemoryBytes == null ? unavailable("Committed_AS is unavailable.") : available(committedMemoryBytes),
+				commitLimitBytes: commitLimitBytes == null ? unavailable("CommitLimit is unavailable.") : available(commitLimitBytes),
+				virtualCommitmentPercent: committedMemoryBytes == null || commitLimitBytes == null ? unavailable("Virtual commitment cannot be derived.") : available(percent(committedMemoryBytes, commitLimitBytes)),
+				counters: {
+					cpu: cpuCounters,
+					swap: swapCounters
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region ../../lib/system-health/collector.ts
+/**
+* Selects the platform host-health collector. Linux and macOS expose native
+* current-pressure signals; unsupported platforms return unavailable signals
+* so callers never mistake missing measurements for measured zeroes.
+*/
+function createUnsupportedCollector(platform = "unsupported") {
+	const signal = () => unavailable("Host health collection is unsupported on this platform.");
+	return {
+		platform,
+		async sample() {
+			return {
+				platform,
+				sampledAtMs: Date.now(),
+				cpuPercent: signal(),
+				loadAverage1m: signal(),
+				loadPerCore1m: signal(),
+				totalMemoryBytes: signal(),
+				usedMemoryBytes: signal(),
+				availableMemoryBytes: signal(),
+				memoryUsedPercent: signal(),
+				memoryPressureSomeAvg10: signal(),
+				memoryPressureFullAvg10: signal(),
+				memoryPressureFreePercent: signal(),
+				swapTotalBytes: signal(),
+				swapUsedBytes: signal(),
+				swapUsedPercent: signal(),
+				swapActivityBytesPerMinute: signal(),
+				committedMemoryBytes: signal(),
+				commitLimitBytes: signal(),
+				virtualCommitmentPercent: signal(),
+				counters: {
+					cpu: null,
+					swap: null
+				}
+			};
+		}
+	};
+}
+function createHostHealthCollector(selection = {}) {
+	const platform = selection.platform ?? platform$1();
+	if (platform === "linux") return selection.linux ?? createLinuxHostHealthCollector();
+	if (platform === "darwin") return selection.darwin ?? createDarwinHostHealthCollector();
+	return createUnsupportedCollector();
+}
+//#endregion
+//#region ../../lib/system-health/evaluate.ts
+function value(signal) {
+	return signal.status === "available" ? signal.value : null;
+}
+function reason(code, domain, severity, message, metric, observed, threshold) {
+	return {
+		code,
+		domain,
+		severity,
+		message,
+		metric,
+		observed,
+		threshold
+	};
+}
+function evaluateAdmission(sample, thresholds) {
+	const availableMemoryBytes = value(sample.availableMemoryBytes);
+	if (availableMemoryBytes == null) return {
+		state: "unavailable",
+		availableMemoryBytes: null,
+		reasons: [{
+			code: "admission.memory_available.unavailable",
+			domain: "admission",
+			severity: "info",
+			message: "Available memory could not be measured, so admission capacity is unavailable.",
+			metric: "availableMemoryBytes"
+		}]
+	};
+	if (availableMemoryBytes <= thresholds.memoryAvailableCriticalBytes) return {
+		state: "blocked",
+		availableMemoryBytes,
+		reasons: [reason("admission.memory_available.blocked", "admission", "critical", "Available memory is at or below the critical admission reserve.", "availableMemoryBytes", availableMemoryBytes, thresholds.memoryAvailableCriticalBytes)]
+	};
+	if (availableMemoryBytes <= thresholds.memoryAvailableWarningBytes) return {
+		state: "soft",
+		availableMemoryBytes,
+		reasons: [reason("admission.memory_available.soft", "admission", "warning", "Available memory is at or below the warning admission reserve.", "availableMemoryBytes", availableMemoryBytes, thresholds.memoryAvailableWarningBytes)]
+	};
+	return {
+		state: "open",
+		availableMemoryBytes,
+		reasons: []
+	};
+}
+function diagnostics(sample, thresholds) {
+	const results = [];
+	const swapUsedPercent = value(sample.swapUsedPercent);
+	if (swapUsedPercent != null && swapUsedPercent > 0) results.push(reason("host.diagnostic.swap_occupancy", "host", "info", "Swap occupancy is historical context and does not represent current pressure.", "swapUsedPercent", swapUsedPercent, thresholds.swapUsedWarningPercent));
+	const virtualCommitmentPercent = value(sample.virtualCommitmentPercent);
+	if (virtualCommitmentPercent != null) results.push(reason("host.diagnostic.virtual_commitment", "host", "info", "Virtual memory commitment is diagnostic and does not represent current pressure.", "virtualCommitmentPercent", virtualCommitmentPercent, thresholds.overcommitWarningPercent));
+	return results;
+}
+function linuxPressureReasons(sample, admission) {
+	const results = [];
+	const some = value(sample.memoryPressureSomeAvg10);
+	const full = value(sample.memoryPressureFullAvg10);
+	const swapActivity = value(sample.swapActivityBytesPerMinute);
+	if (admission.state === "blocked") {
+		if (full != null && full >= LINUX_MEMORY_PRESSURE_DEFAULTS.fullCriticalAvg10) results.push(reason("host.linux.psi_full.critical", "host", "critical", "Linux memory PSI full stalls reached the critical band while memory was below reserve.", "memoryPressureFullAvg10", full, LINUX_MEMORY_PRESSURE_DEFAULTS.fullCriticalAvg10));
+		if (swapActivity != null && swapActivity >= LINUX_MEMORY_PRESSURE_DEFAULTS.swapActivityCriticalBytesPerMinute) results.push(reason("host.linux.swap_activity.critical", "host", "critical", "Linux swap activity reached the critical band while memory was below reserve.", "swapActivityBytesPerMinute", swapActivity, LINUX_MEMORY_PRESSURE_DEFAULTS.swapActivityCriticalBytesPerMinute));
+	}
+	if (admission.state === "soft" || admission.state === "blocked") {
+		if (some != null && some >= LINUX_MEMORY_PRESSURE_DEFAULTS.someWarningAvg10) results.push(reason("host.linux.psi_some.warning", "host", "warning", "Linux memory PSI some stalls reached the warning band while memory was below reserve.", "memoryPressureSomeAvg10", some, LINUX_MEMORY_PRESSURE_DEFAULTS.someWarningAvg10));
+		if (swapActivity != null && swapActivity >= LINUX_MEMORY_PRESSURE_DEFAULTS.swapActivityWarningBytesPerMinute && !(admission.state === "blocked" && swapActivity >= LINUX_MEMORY_PRESSURE_DEFAULTS.swapActivityCriticalBytesPerMinute)) results.push(reason("host.linux.swap_activity.warning", "host", "warning", "Linux swap activity reached the warning band while memory was below reserve.", "swapActivityBytesPerMinute", swapActivity, LINUX_MEMORY_PRESSURE_DEFAULTS.swapActivityWarningBytesPerMinute));
+	}
+	return results;
+}
+function darwinPressureReasons(sample) {
+	const freePercent = value(sample.memoryPressureFreePercent);
+	if (freePercent == null) return [];
+	if (freePercent <= DARWIN_MEMORY_PRESSURE_DEFAULTS.criticalFreePercent) return [reason("host.darwin.memory_pressure.critical", "host", "critical", "macOS memory pressure free percentage reached the critical band.", "memoryPressureFreePercent", freePercent, DARWIN_MEMORY_PRESSURE_DEFAULTS.criticalFreePercent)];
+	if (freePercent <= DARWIN_MEMORY_PRESSURE_DEFAULTS.warningFreePercent) return [reason("host.darwin.memory_pressure.warning", "host", "warning", "macOS memory pressure free percentage reached the warning band.", "memoryPressureFreePercent", freePercent, DARWIN_MEMORY_PRESSURE_DEFAULTS.warningFreePercent)];
+	return [];
+}
+function hasCurrentPressureSignal(sample) {
+	if (sample.platform === "linux") return value(sample.memoryPressureSomeAvg10) != null || value(sample.memoryPressureFullAvg10) != null || value(sample.swapActivityBytesPerMinute) != null;
+	if (sample.platform === "darwin") return value(sample.memoryPressureFreePercent) != null;
+	return false;
+}
+function evaluateHostPressure(sample, thresholds) {
+	const admission = evaluateAdmission(sample, thresholds);
+	const diagnosticReasons = diagnostics(sample, thresholds);
+	if (!hasCurrentPressureSignal(sample)) return {
+		state: "unavailable",
+		reasons: [{
+			code: "host.current_pressure.unavailable",
+			domain: "host",
+			severity: "info",
+			message: "The platform collector could not measure a current-pressure signal."
+		}, ...diagnosticReasons],
+		diagnostics: diagnosticReasons,
+		admission
+	};
+	const pressureReasons = sample.platform === "linux" ? linuxPressureReasons(sample, admission) : darwinPressureReasons(sample);
+	return {
+		state: pressureReasons.some((entry) => entry.severity === "critical") ? "critical" : pressureReasons.some((entry) => entry.severity === "warning") ? "warning" : "healthy",
+		reasons: [...pressureReasons, ...diagnosticReasons],
+		diagnostics: diagnosticReasons,
+		admission
+	};
+}
+//#endregion
+//#region ../../lib/system-health/sampler.ts
+const DEFAULT_WARMUP_INTERVAL_MS = 1e3;
+const DEFAULT_WARMUP_SAMPLES = 3;
+const REQUIRED_CONSECUTIVE_SAMPLES = 3;
+function createMeasuringState(metrics, observedAt) {
+	return {
+		accepted: {
+			state: "measuring",
+			reasons: [{
+				code: "host.sampler.measuring",
+				domain: "host",
+				severity: "info",
+				message: "System health is collecting the initial three samples."
+			}],
+			metrics,
+			sampledAt: observedAt,
+			freshness: {
+				status: "measuring",
+				observedAt
+			},
+			transitionVersion: 0
+		},
+		candidate: null,
+		candidateCount: 0
+	};
+}
+function accept(previous, assessment) {
+	const changed = previous.state !== assessment.state;
+	const transitionVersion = changed ? previous.transitionVersion + 1 : previous.transitionVersion;
+	return {
+		state: {
+			accepted: {
+				...assessment,
+				freshness: {
+					status: "fresh",
+					observedAt: assessment.sampledAt
+				},
+				transitionVersion
+			},
+			candidate: null,
+			candidateCount: 0
+		},
+		transition: changed ? {
+			version: transitionVersion,
+			previousState: previous.state,
+			state: assessment.state,
+			reasonCodes: assessment.reasons.map((entry) => entry.code),
+			acceptedAt: assessment.sampledAt
+		} : null
+	};
+}
+/**
+* Applies symmetric three-sample hysteresis to one atomic assessment. Metrics
+* and reasons move with their state only when that complete assessment is
+* accepted, so readers never observe a new state paired with old evidence.
+*/
+function transitionAcceptedAssessment(previous, raw) {
+	if (raw.status === "invalid") return {
+		state: {
+			accepted: {
+				...previous.accepted,
+				freshness: {
+					status: "stale",
+					observedAt: raw.sampledAt,
+					reason: raw.reason
+				}
+			},
+			candidate: null,
+			candidateCount: 0
+		},
+		transition: null
+	};
+	const assessment = raw.assessment;
+	if (assessment.state === previous.accepted.state) return accept(previous.accepted, assessment);
+	const candidateCount = previous.candidate?.state === assessment.state ? previous.candidateCount + 1 : 1;
+	if (candidateCount >= REQUIRED_CONSECUTIVE_SAMPLES) return accept(previous.accepted, assessment);
+	return {
+		state: {
+			accepted: previous.accepted,
+			candidate: assessment,
+			candidateCount
+		},
+		transition: null
+	};
+}
+function resolveMeasuringMetrics(value) {
+	return typeof value === "function" ? value() : value;
+}
+function createSystemHealthSampler(options) {
+	const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+	const warmupIntervalMs = options.warmupIntervalMs ?? DEFAULT_WARMUP_INTERVAL_MS;
+	const warmupSamples = options.warmupSamples ?? DEFAULT_WARMUP_SAMPLES;
+	let state = createMeasuringState(resolveMeasuringMetrics(options.measuringMetrics), now());
+	let timer = null;
+	let started = false;
+	let stopped = false;
+	let samplesAttempted = 0;
+	const schedule = () => {
+		if (stopped) return;
+		const delay = samplesAttempted < warmupSamples ? warmupIntervalMs : options.pollIntervalMs;
+		timer = setTimeout(() => {
+			collectOnce();
+		}, delay);
+	};
+	const collectOnce = async () => {
+		if (stopped) return;
+		let raw;
+		try {
+			raw = await options.collect();
+		} catch (error) {
+			raw = {
+				status: "invalid",
+				sampledAt: now(),
+				reason: {
+					code: "host.sampler.collection_failed",
+					domain: "host",
+					severity: "info",
+					message: error instanceof Error ? error.message : "System health collection failed."
+				}
+			};
+		}
+		samplesAttempted++;
+		const result = transitionAcceptedAssessment(state, raw);
+		state = result.state;
+		if (result.transition && options.onTransition) try {
+			await options.onTransition(result.transition);
+		} catch (error) {
+			console.error("[system-health] Failed to publish accepted transition:", error);
+		}
+		schedule();
+	};
+	const start = () => {
+		if (started || stopped) return;
+		started = true;
+		collectOnce();
+	};
+	return {
+		getSnapshot() {
+			start();
+			return state.accepted;
+		},
+		stop() {
+			stopped = true;
+			if (timer) clearTimeout(timer);
+			timer = null;
+		}
+	};
+}
+//#endregion
+//#region services/system-health-v2.ts
 init_event_store();
+init_staleness();
+function runtimeHealthState(runtime) {
+	if (!runtime) return null;
+	switch (runtime.activity) {
+		case "working":
+		case "thinking": return {
+			state: "active",
+			lastActivity: runtime.lastActivity,
+			contextSaturatedAt: runtime.contextSaturatedAt
+		};
+		case "waiting": return {
+			state: "waiting-on-human",
+			lastActivity: runtime.lastActivity,
+			contextSaturatedAt: runtime.contextSaturatedAt
+		};
+		case "idle": return {
+			state: "idle",
+			lastActivity: runtime.lastActivity,
+			contextSaturatedAt: runtime.contextSaturatedAt
+		};
+		case "stopped": return {
+			state: "stopped",
+			lastActivity: runtime.lastActivity,
+			contextSaturatedAt: runtime.contextSaturatedAt
+		};
+	}
+}
+function agentLifecycle(role, issueId, tmuxActive, statuses) {
+	if (role !== "review" && role !== "test" && role !== "ship") return "unknown";
+	return classifyAdvancingSessionLifecycle(role, statuses.get(issueId.toUpperCase()), tmuxActive);
+}
+function stateToLegacySeverity(state) {
+	return state === "critical" ? "critical" : state === "warning" ? "warning" : "normal";
+}
+function signalValue(signal) {
+	return signal.status === "available" ? signal.value : null;
+}
+function hostMetrics(sample) {
+	return {
+		cpuPercent: signalValue(sample.cpuPercent),
+		loadAverage1m: signalValue(sample.loadAverage1m),
+		loadPerCore1m: signalValue(sample.loadPerCore1m),
+		totalMemoryBytes: signalValue(sample.totalMemoryBytes),
+		usedMemoryBytes: signalValue(sample.usedMemoryBytes),
+		availableMemoryBytes: signalValue(sample.availableMemoryBytes),
+		memoryUsedPercent: signalValue(sample.memoryUsedPercent),
+		memoryPressureSomeAvg10: signalValue(sample.memoryPressureSomeAvg10),
+		memoryPressureFullAvg10: signalValue(sample.memoryPressureFullAvg10),
+		memoryPressureFreePercent: signalValue(sample.memoryPressureFreePercent),
+		swapTotalBytes: signalValue(sample.swapTotalBytes),
+		swapUsedBytes: signalValue(sample.swapUsedBytes),
+		swapUsedPercent: signalValue(sample.swapUsedPercent),
+		swapActivityBytesPerMinute: signalValue(sample.swapActivityBytesPerMinute),
+		committedMemoryBytes: signalValue(sample.committedMemoryBytes),
+		commitLimitBytes: signalValue(sample.commitLimitBytes),
+		virtualCommitmentPercent: signalValue(sample.virtualCommitmentPercent)
+	};
+}
+function serviceHealth(smeeRelay) {
+	if (smeeRelay.status === "running") return [{
+		id: "smee-relay",
+		label: "Webhook relay",
+		required: false,
+		status: "running",
+		message: smeeRelay.message,
+		reasons: []
+	}];
+	if (smeeRelay.status === "not_configured") return [{
+		id: "smee-relay",
+		label: "Webhook relay",
+		required: false,
+		status: "not_configured",
+		message: smeeRelay.message,
+		reasons: []
+	}];
+	const unavailable = smeeRelay.status === "unknown";
+	return [{
+		id: "smee-relay",
+		label: "Webhook relay",
+		required: false,
+		status: unavailable ? "unavailable" : "stopped",
+		message: smeeRelay.message,
+		reasons: [{
+			code: unavailable ? "service.smee_relay.unavailable" : "service.smee_relay.stopped",
+			domain: "service",
+			severity: unavailable ? "info" : "warning",
+			message: smeeRelay.message
+		}]
+	}];
+}
+function overallHealthState(hostState, agents, services) {
+	if (hostState === "critical" || agents.some((agent) => agent.status === "dead" || agent.status === "wedged")) return "critical";
+	if (hostState === "warning" || agents.some((agent) => agent.status === "warning" || agent.status === "stalled") || services.some((service) => service.status === "degraded" || service.status === "stopped")) return "warning";
+	if (hostState === "measuring") return "measuring";
+	if (hostState === "unavailable" || agents.some((agent) => agent.status === "unavailable") || services.some((service) => service.status === "unavailable")) return "unavailable";
+	return "healthy";
+}
+function acceptedReasons(state, hostReasons, agents, services) {
+	const reasons = [
+		...hostReasons,
+		...agents.flatMap((agent) => agent.reasons),
+		...services.flatMap((service) => service.reasons)
+	];
+	if (state === "measuring" && reasons.length === 0) return [{
+		code: "host.sampler.measuring",
+		domain: "host",
+		severity: "info",
+		message: "System health is collecting the initial three samples."
+	}];
+	return reasons;
+}
+//#endregion
+//#region services/system-health-service.ts
+init_review_status_source();
 const execAsync$4 = promisify(exec);
-const DEFAULT_HEALTH_POLL_SECONDS = 15;
-const DEFAULT_RESOURCE_CONFIG = {
-	memoryWarnGb: 4,
-	memoryBlockGb: 2,
-	agentWarnCount: 8,
-	agentBlockCount: 10
-};
 const KB = 1024;
 const GIB$1 = 1024 ** 3;
-const GLOBAL_CONFIG_PATH = join(homedir$1(), ".overdeck", "config.yaml");
 let dockerStatsCollector$1 = null;
-let previousCpuSample = null;
-let previousCpuSampleAt = 0;
-let cachedHealth = null;
-let cacheExpiresAt = 0;
-let inflightRefresh = null;
-let previousSeverity = null;
-let candidateSeverity = null;
-let candidateCount = 0;
-const HYSTERESIS_POLLS = 3;
+const hostHealthCollector = createHostHealthCollector();
+let previousHostMetricSample;
+let systemHealthSampler = null;
 let eventStorePromise = null;
-let cachedResourceConfig = DEFAULT_RESOURCE_CONFIG;
-let cachedPollSeconds = DEFAULT_HEALTH_POLL_SECONDS;
+let cachedSystemHealthConfig = null;
 let resourceConfigLoadedAt = 0;
 let resourceConfigInflight = null;
 let cachedDeployStaleness = null;
@@ -21911,9 +22842,17 @@ function getDockerStatsCollector() {
 function bytesToGb(bytes) {
 	return Math.round(bytes / GIB$1 * 100) / 100;
 }
-function toPercent(part, total) {
-	if (total <= 0) return 0;
-	return Math.round(part / total * 1e3) / 10;
+const AGENT_STARTUP_GRACE_MS = 300 * 1e3;
+function countAdmittedWorkAgents(agents, nowMs = Date.now()) {
+	return agents.filter((agent) => {
+		if (agent.role !== "work") return false;
+		if (agent.status !== "running" && agent.status !== "starting") return false;
+		if (agent.tmuxActive) return true;
+		if (agent.status !== "starting" || !agent.startedAt) return false;
+		const startedAtMs = Date.parse(agent.startedAt);
+		const ageMs = nowMs - startedAtMs;
+		return Number.isFinite(startedAtMs) && ageMs >= 0 && ageMs < AGENT_STARTUP_GRACE_MS;
+	}).length;
 }
 function classifyAgentKind(agentId, role) {
 	if (agentId.startsWith("planning-")) return "planning";
@@ -21925,41 +22864,13 @@ function classifyAgentKind(agentId, role) {
 	if (agentId.endsWith("-agent")) return "specialist";
 	return "other";
 }
-function resolveFiniteNumber(value, fallback) {
-	if (value == null || value.trim() === "") return fallback;
-	const parsed = Number(value);
-	return Number.isFinite(parsed) ? parsed : fallback;
-}
 async function readGlobalResourceConfig() {
-	let next = DEFAULT_RESOURCE_CONFIG;
-	try {
-		await access(GLOBAL_CONFIG_PATH);
-		const raw = await readFile(GLOBAL_CONFIG_PATH, "utf-8");
-		const memoryWarnMatch = raw.match(/^\s*memory_warn_gb:\s*(\d+(?:\.\d+)?)\s*$/m);
-		const memoryBlockMatch = raw.match(/^\s*memory_block_gb:\s*(\d+(?:\.\d+)?)\s*$/m);
-		const agentWarnMatch = raw.match(/^\s*agent_warn_count:\s*(\d+(?:\.\d+)?)\s*$/m);
-		const agentBlockMatch = raw.match(/^\s*agent_block_count:\s*(\d+(?:\.\d+)?)\s*$/m);
-		const pollSecondsMatch = raw.match(/^\s*poll_seconds:\s*(\d+(?:\.\d+)?)\s*$/m);
-		next = {
-			memoryWarnGb: resolveFiniteNumber(memoryWarnMatch?.[1], DEFAULT_RESOURCE_CONFIG.memoryWarnGb),
-			memoryBlockGb: resolveFiniteNumber(memoryBlockMatch?.[1], DEFAULT_RESOURCE_CONFIG.memoryBlockGb),
-			agentWarnCount: Math.max(1, Math.floor(resolveFiniteNumber(agentWarnMatch?.[1], DEFAULT_RESOURCE_CONFIG.agentWarnCount))),
-			agentBlockCount: Math.max(1, Math.floor(resolveFiniteNumber(agentBlockMatch?.[1], DEFAULT_RESOURCE_CONFIG.agentBlockCount)))
-		};
-		cachedPollSeconds = Math.max(1, Math.floor(resolveFiniteNumber(process.env["PAN_HEALTH_POLL_SECONDS"], resolveFiniteNumber(pollSecondsMatch?.[1], DEFAULT_HEALTH_POLL_SECONDS))));
-	} catch {
-		cachedPollSeconds = Math.max(1, Math.floor(resolveFiniteNumber(process.env["PAN_HEALTH_POLL_SECONDS"], DEFAULT_HEALTH_POLL_SECONDS)));
-	}
-	cachedResourceConfig = {
-		memoryWarnGb: resolveFiniteNumber(process.env["PAN_MEMORY_WARN_GB"], next.memoryWarnGb),
-		memoryBlockGb: resolveFiniteNumber(process.env["PAN_MEMORY_BLOCK_GB"], next.memoryBlockGb),
-		agentWarnCount: Math.max(1, Math.floor(resolveFiniteNumber(process.env["PAN_AGENT_WARN_COUNT"], next.agentWarnCount))),
-		agentBlockCount: Math.max(1, Math.floor(resolveFiniteNumber(process.env["PAN_AGENT_BLOCK_COUNT"], next.agentBlockCount)))
-	};
+	cachedSystemHealthConfig = resolveSystemHealthConfig();
 	resourceConfigLoadedAt = Date.now();
 }
 async function ensureResourceConfigLoaded() {
-	const ttl = Math.max(5e3, cachedPollSeconds * 1e3);
+	const pollSeconds = cachedSystemHealthConfig?.pollSeconds ?? SYSTEM_HEALTH_DEFAULTS.pollSeconds;
+	const ttl = Math.max(5e3, pollSeconds * 1e3);
 	if (resourceConfigLoadedAt > 0 && Date.now() - resourceConfigLoadedAt < ttl) return;
 	if (!resourceConfigInflight) resourceConfigInflight = readGlobalResourceConfig().finally(() => {
 		resourceConfigInflight = null;
@@ -21967,23 +22878,8 @@ async function ensureResourceConfigLoaded() {
 	await resourceConfigInflight;
 }
 function getResourceConfig() {
-	return cachedResourceConfig;
-}
-function getHealthPollTtlMs() {
-	return Math.max(1, cachedPollSeconds) * 1e3;
-}
-function defaultThresholds() {
-	const resources = getResourceConfig();
-	return {
-		memoryAvailableWarningBytes: resources.memoryWarnGb * GIB$1,
-		memoryAvailableCriticalBytes: resources.memoryBlockGb * GIB$1,
-		swapUsedWarningPercent: Number(process.env["PAN_HEALTH_SWAP_WARN_PERCENT"] ?? 20),
-		swapUsedCriticalPercent: Number(process.env["PAN_HEALTH_SWAP_CRITICAL_PERCENT"] ?? 50),
-		cpuLoadWarningPerCore: Number(process.env["PAN_HEALTH_LOAD_WARN_PER_CORE"] ?? 1),
-		cpuLoadCriticalPerCore: Number(process.env["PAN_HEALTH_LOAD_CRITICAL_PER_CORE"] ?? 1.5),
-		overcommitWarningPercent: Number(process.env["PAN_HEALTH_OVERCOMMIT_WARN_PERCENT"] ?? 150),
-		overcommitCriticalPercent: Number(process.env["PAN_HEALTH_OVERCOMMIT_CRITICAL_PERCENT"] ?? 200)
-	};
+	cachedSystemHealthConfig ??= resolveSystemHealthConfig();
+	return cachedSystemHealthConfig.resources;
 }
 async function readProcMemoryLinux() {
 	const content = await readFile("/proc/meminfo", "utf-8");
@@ -22049,43 +22945,6 @@ async function readProcMemoryDarwin() {
 async function readProcMemory() {
 	return platform$1() === "darwin" ? readProcMemoryDarwin() : readProcMemoryLinux();
 }
-async function readLoadAverage() {
-	if (platform$1() === "darwin") {
-		const load = loadavg$1()[0] ?? 0;
-		return Number.isFinite(load) ? load : 0;
-	}
-	const content = await readFile("/proc/loadavg", "utf-8");
-	const load = Number((content.trim().split(/\s+/)[0] ?? "0").trim());
-	return Number.isFinite(load) ? load : 0;
-}
-async function readCpuPercent() {
-	if (platform$1() === "darwin") {
-		const coreCount = Math.max(cpus$1().length, 1);
-		const load = loadavg$1()[0] ?? 0;
-		return Math.round(Math.min(load / coreCount, 1) * 1e3) / 10;
-	}
-	const cpuLine = (await readFile("/proc/stat", "utf-8")).split("\n").find((line) => line.startsWith("cpu "));
-	if (!cpuLine) return 0;
-	const values = cpuLine.trim().split(/\s+/).slice(1).map((value) => Number(value));
-	const current = {
-		idle: (values[3] ?? 0) + (values[4] ?? 0),
-		total: values.reduce((sum, value) => sum + value, 0)
-	};
-	const now = Date.now();
-	if (!previousCpuSample || previousCpuSampleAt > 0 && now - previousCpuSampleAt > getHealthPollTtlMs() * 2) {
-		previousCpuSample = current;
-		previousCpuSampleAt = now;
-		const coreCount = Math.max(cpus$1().length, 1);
-		const fallback = Math.min(await readLoadAverage() / coreCount, 1) * 100;
-		return Math.round(fallback * 10) / 10;
-	}
-	const totalDelta = current.total - previousCpuSample.total;
-	const idleDelta = current.idle - previousCpuSample.idle;
-	previousCpuSample = current;
-	previousCpuSampleAt = now;
-	if (totalDelta <= 0) return 0;
-	return Math.round((totalDelta - idleDelta) / totalDelta * 1e3) / 10;
-}
 async function readProcessTable() {
 	const { stdout } = await execAsync$4("ps -eo pid=,ppid=,rss=,args=", {
 		encoding: "utf-8",
@@ -22127,41 +22986,13 @@ function sumProcessMemory(descendants, processes) {
 	for (const pid of descendants) totalRssKb += processes.get(pid)?.rssKb ?? 0;
 	return totalRssKb * KB;
 }
-function buildLeakedSpecialists(snapshot, runningAgents) {
-	if (!snapshot) return [];
-	const activeWorkIssues = new Set(runningAgents.filter((agent) => agent.kind === "work" && agent.status !== "stopped" && agent.tmuxActive).map((agent) => agent.issueId.toUpperCase()));
-	return snapshot.specialists.filter((specialist) => specialist.isRunning && !!specialist.currentIssue).filter((specialist) => !activeWorkIssues.has((specialist.currentIssue ?? "").toUpperCase())).map((specialist) => ({
-		name: specialist.name ?? "",
-		currentIssue: specialist.currentIssue ?? "",
-		reason: `Specialist is active for ${specialist.currentIssue} but no running work agent exists for that issue.`
+function buildLeakedSpecialists(agents) {
+	return agents.filter((agent) => agent.kind === "specialist" && agent.lifecycle === "orphaned").map((agent) => ({
+		name: agent.id,
+		currentIssue: agent.currentIssue ?? agent.issueId,
+		reason: `Advancing session remains live after ${agent.issueId} merged.`
 	}));
 }
-function evaluateSeverity(thresholds, data) {
-	const criticalReasons = [];
-	const warningReasons = [];
-	if (data.availableMemoryBytes < thresholds.memoryAvailableCriticalBytes) criticalReasons.push(`Available RAM is low (${bytesToGb(data.availableMemoryBytes)} GB).`);
-	else if (data.availableMemoryBytes < thresholds.memoryAvailableWarningBytes) warningReasons.push(`Available RAM is tight (${bytesToGb(data.availableMemoryBytes)} GB).`);
-	if (data.swapUsedPercent >= thresholds.swapUsedCriticalPercent) criticalReasons.push(`Swap usage is high (${data.swapUsedPercent}%).`);
-	else if (data.swapUsedPercent >= thresholds.swapUsedWarningPercent) warningReasons.push(`Swap usage is elevated (${data.swapUsedPercent}%).`);
-	if (data.loadPerCore1m >= thresholds.cpuLoadCriticalPerCore) criticalReasons.push(`CPU load is high (${data.loadPerCore1m.toFixed(2)} per core).`);
-	else if (data.loadPerCore1m >= thresholds.cpuLoadWarningPerCore) warningReasons.push(`CPU load is elevated (${data.loadPerCore1m.toFixed(2)} per core).`);
-	if (data.overcommitPercent >= thresholds.overcommitCriticalPercent) criticalReasons.push(`Committed memory exceeds the safe limit (${data.overcommitPercent}%).`);
-	else if (data.overcommitPercent >= thresholds.overcommitWarningPercent) warningReasons.push(`Committed memory is near the limit (${data.overcommitPercent}%).`);
-	if (data.leakedSpecialistCount > 0) warningReasons.push(`${data.leakedSpecialistCount} leaked specialist session${data.leakedSpecialistCount === 1 ? "" : "s"} detected.`);
-	if (data.smeeRelay.configured && !data.smeeRelay.running) warningReasons.push("smee-client webhook relay is configured but not running.");
-	if (criticalReasons.length > 0) return {
-		severity: "critical",
-		reasons: criticalReasons.concat(warningReasons)
-	};
-	if (warningReasons.length > 0) return {
-		severity: "warning",
-		reasons: warningReasons
-	};
-	return {
-		severity: "normal",
-		reasons: []
-	};
-}
 function collectSmeeRelayHealth() {
 	try {
 		if (!isSmeeConfiguredSync()) return {
@@ -22190,32 +23021,77 @@ function collectSmeeRelayHealth() {
 		};
 	}
 }
+function reviewStatusMap() {
+	return new Map(Object.entries(readReviewStatusMap() ?? {}));
+}
 async function collectAgentProcesses() {
-	const activeAgents = (await Effect.runPromise(listRunningAgents())).filter((agent) => agent.status !== "stopped");
+	const registeredAgents = await Effect.runPromise(listRunningAgents());
+	const nowMs = Date.now();
+	const admittedWorkAgentCount = countAdmittedWorkAgents(registeredAgents, nowMs);
+	const activeAgents = registeredAgents.filter((agent) => agent.status !== "stopped");
+	const liveSessions = new Set(registeredAgents.filter((agent) => agent.tmuxActive).map((agent) => agent.id));
 	const processTable = await readProcessTable().catch(() => /* @__PURE__ */ new Map());
-	return Promise.all(activeAgents.map(async (agent) => {
-		const runtimeState = await Effect.runPromise(getAgentRuntimeState(agent.id)).catch(() => null);
+	const reviewStatuses = reviewStatusMap();
+	const collected = await Promise.all(activeAgents.map(async (agent) => {
+		const [runtimeState, runtimeSnapshot] = await Promise.all([Effect.runPromise(getAgentRuntimeState(agent.id)).catch(() => null), Effect.runPromise(getRuntimeSnapshot(agent.id)).catch(() => null)]);
 		const panePidValue = (await Effect.runPromise(listPaneValues(agent.id, "#{pane_pid}")))[0];
 		const panePid = Number(panePidValue ?? "0");
 		const descendants = Number.isFinite(panePid) && panePid > 0 ? getDescendantPids(panePid, processTable) : /* @__PURE__ */ new Set();
 		const memoryBytes = descendants.size > 0 ? sumProcessMemory(descendants, processTable) : 0;
+		const lifecycle = agentLifecycle(agent.role, agent.issueId, agent.tmuxActive, reviewStatuses);
 		return {
-			id: agent.id,
-			issueId: agent.issueId,
-			kind: classifyAgentKind(agent.id, agent.role),
-			status: agent.status,
-			tmuxActive: agent.tmuxActive,
-			memoryBytes,
-			memoryGb: bytesToGb(memoryBytes),
-			currentIssue: runtimeState?.currentIssue
+			process: {
+				id: agent.id,
+				issueId: agent.issueId,
+				role: agent.role,
+				kind: classifyAgentKind(agent.id, agent.role),
+				status: agent.status,
+				lifecycle,
+				tmuxActive: agent.tmuxActive,
+				memoryBytes,
+				memoryGb: bytesToGb(memoryBytes),
+				currentIssue: runtimeState?.currentIssue
+			},
+			health: {
+				...classifyAgentHealth({
+					agentId: agent.id,
+					persisted: {
+						status: "available",
+						value: {
+							id: agent.id,
+							issueId: agent.issueId,
+							role: agent.role,
+							status: agent.status,
+							startedAt: agent.startedAt,
+							lastActivity: agent.lastActivity,
+							kickoffDelivered: agent.kickoffDelivered,
+							paused: agent.paused,
+							stoppedByUser: agent.stoppedByUser,
+							stoppedByPause: agent.stoppedByPause,
+							consecutiveFailures: agent.consecutiveFailures
+						}
+					},
+					runtime: runtimeHealthState(runtimeSnapshot),
+					liveSessions,
+					reviewLifecycle: lifecycle,
+					nowMs
+				}),
+				memoryBytes,
+				memoryGb: bytesToGb(memoryBytes),
+				...runtimeState?.currentIssue ? { currentIssue: runtimeState.currentIssue } : {}
+			}
 		};
 	}));
+	return {
+		agents: collected.map((entry) => entry.process),
+		healthAgents: collected.map((entry) => entry.health),
+		admittedWorkAgentCount
+	};
 }
-function buildTopConsumers(agents, containers, leakedSpecialists) {
-	const leakedByName = new Map(leakedSpecialists.map((item) => [item.name, item]));
+function buildTopConsumers(agents, containers) {
 	const agentConsumers = agents.map((agent) => {
 		const isSpecialist = agent.kind === "specialist";
-		const leaked = leakedByName.has(agent.id.replace(/^specialist-/, "")) || leakedByName.has(agent.id);
+		const leaked = agent.lifecycle === "orphaned";
 		const currentIssue = agent.currentIssue ?? agent.issueId;
 		const resolved = currentIssue ? resolveProjectFromIssueSync(currentIssue) : null;
 		const specialistType = isSpecialist ? agent.id.startsWith("specialist-") ? agent.id.replace(/^specialist-/, "") : agent.id : void 0;
@@ -22251,122 +23127,215 @@ function buildTopConsumers(agents, containers, leakedSpecialists) {
 			containerId: container.id
 		}
 	}));
-	return [...agentConsumers, ...containerConsumers].sort((a, b) => b.memoryBytes - a.memoryBytes).slice(0, 10);
+	return [...agentConsumers, ...containerConsumers].sort((a, b) => b.memoryBytes - a.memoryBytes);
 }
-async function refreshSystemHealth(snapshot) {
+function createMeasuringSnapshot() {
+	cachedSystemHealthConfig ??= resolveSystemHealthConfig();
+	const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const smeeRelay = collectSmeeRelayHealth();
+	const services = serviceHealth(smeeRelay);
+	const base = {
+		version: 2,
+		state: "measuring",
+		updatedAt,
+		nextPollMs: cachedSystemHealthConfig.pollSeconds * 1e3,
+		host: {
+			state: "measuring",
+			platform: hostHealthCollector.platform,
+			reasons: [{
+				code: "host.sampler.measuring",
+				domain: "host",
+				severity: "info",
+				message: "System health is collecting the initial three samples."
+			}],
+			metrics: {
+				cpuPercent: null,
+				loadAverage1m: null,
+				loadPerCore1m: null,
+				totalMemoryBytes: null,
+				usedMemoryBytes: null,
+				availableMemoryBytes: null,
+				memoryUsedPercent: null,
+				memoryPressureSomeAvg10: null,
+				memoryPressureFullAvg10: null,
+				memoryPressureFreePercent: null,
+				swapTotalBytes: null,
+				swapUsedBytes: null,
+				swapUsedPercent: null,
+				swapActivityBytesPerMinute: null,
+				committedMemoryBytes: null,
+				commitLimitBytes: null,
+				virtualCommitmentPercent: null
+			}
+		},
+		admission: {
+			state: "unavailable",
+			availableMemoryBytes: null,
+			admittedWorkAgentCount: 0,
+			reasons: [{
+				code: "admission.sampler.measuring",
+				domain: "admission",
+				severity: "info",
+				message: "Admission capacity is unavailable until the initial health sample is accepted."
+			}]
+		},
+		agents: [],
+		services,
+		topConsumers: []
+	};
+	const accepted = {
+		...base,
+		summary: projectLegacySystemHealthSummary(base)
+	};
+	return {
+		accepted,
+		compatibility: {
+			severity: "normal",
+			updatedAt,
+			admission: { admittedWorkAgentCount: 0 },
+			summary: accepted.summary,
+			thresholds: cachedSystemHealthConfig.thresholds,
+			reasons: accepted.host.reasons.map((reason) => reason.message),
+			agents: [],
+			leakedSpecialists: [],
+			topConsumers: [],
+			smeeRelay,
+			deployStaleness: null
+		}
+	};
+}
+async function collectSystemHealth() {
 	await ensureResourceConfigLoaded();
-	const [memory, loadAverage1m, cpuPercent, agents, containers] = await Promise.all([
-		readProcMemory(),
-		readLoadAverage(),
-		readCpuPercent(),
+	const [sample, agentProcesses, containers, deployStaleness] = await Promise.all([
+		hostHealthCollector.sample(previousHostMetricSample),
 		collectAgentProcesses(),
-		Promise.resolve(getDockerStatsCollector().getStats())
+		Promise.resolve(getDockerStatsCollector().getStats()),
+		getDeployStaleness()
 	]);
-	const thresholds = defaultThresholds();
+	previousHostMetricSample = sample;
+	const config = cachedSystemHealthConfig;
+	const host = evaluateHostPressure(sample, config.thresholds);
 	const smeeRelay = collectSmeeRelayHealth();
-	const coreCount = Math.max(cpus$1().length, 1);
-	const loadPerCore1m = Math.round(loadAverage1m / coreCount * 100) / 100;
-	const usedMemoryBytes = Math.max(memory.memTotal - memory.memAvailable, 0);
-	const swapUsedBytes = Math.max(memory.swapTotal - memory.swapFree, 0);
-	const overcommitPercent = toPercent(memory.committedAs, memory.memTotal);
-	const leakedSpecialists = buildLeakedSpecialists(snapshot, agents);
-	const evaluation = evaluateSeverity(thresholds, {
-		availableMemoryBytes: memory.memAvailable,
-		swapUsedPercent: toPercent(swapUsedBytes, memory.swapTotal),
-		loadPerCore1m,
-		overcommitPercent,
-		leakedSpecialistCount: leakedSpecialists.length,
-		smeeRelay
-	});
-	const containerMemoryBytes = containers.reduce((sum, container) => sum + container.memoryUsage, 0);
-	const workAgentCount = agents.filter((agent) => agent.kind === "work").length;
-	const planningAgentCount = agents.filter((agent) => agent.kind === "planning").length;
-	const specialistSessionCount = agents.filter((agent) => agent.kind === "specialist").length;
-	const swapUsedPercent = toPercent(swapUsedBytes, memory.swapTotal);
-	const overdeckMemoryBytes = agents.reduce((sum, agent) => sum + agent.memoryBytes, 0) + containerMemoryBytes;
-	const overdeckMemoryPercent = toPercent(overdeckMemoryBytes, memory.memTotal);
-	const sortedAgents = [...agents].sort((a, b) => b.memoryBytes - a.memoryBytes);
-	const deployStaleness = await getDeployStaleness();
-	let effectiveSeverity;
-	if (previousSeverity == null) effectiveSeverity = evaluation.severity;
-	else if (evaluation.severity === previousSeverity) {
-		candidateSeverity = null;
-		candidateCount = 0;
-		effectiveSeverity = previousSeverity;
-	} else if (evaluation.severity === candidateSeverity) {
-		candidateCount++;
-		effectiveSeverity = candidateCount >= HYSTERESIS_POLLS ? evaluation.severity : previousSeverity;
-		if (effectiveSeverity !== previousSeverity) {
-			candidateSeverity = null;
-			candidateCount = 0;
-		}
-	} else {
-		candidateSeverity = evaluation.severity;
-		candidateCount = 1;
-		effectiveSeverity = previousSeverity;
-	}
-	const result = {
-		severity: effectiveSeverity,
-		updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		summary: {
-			cpuPercent,
-			loadAverage1m,
-			loadPerCore1m,
-			totalMemoryBytes: memory.memTotal,
-			usedMemoryBytes,
-			availableMemoryBytes: memory.memAvailable,
-			memoryUsedPercent: toPercent(usedMemoryBytes, memory.memTotal),
-			swapTotalBytes: memory.swapTotal,
-			swapUsedBytes,
-			swapUsedPercent,
-			overcommitPercent,
-			agentCount: agents.length,
-			workAgentCount,
-			planningAgentCount,
-			specialistSessionCount,
-			leakedSpecialistCount: leakedSpecialists.length,
-			containerCount: containers.length,
-			containerMemoryBytes,
-			overdeckMemoryBytes,
-			overdeckMemoryPercent
+	const services = serviceHealth(smeeRelay);
+	const consumers = buildTopConsumers(agentProcesses.agents, containers);
+	const state = overallHealthState(host.state, agentProcesses.healthAgents, services);
+	const reasons = acceptedReasons(state, host.reasons, agentProcesses.healthAgents, services);
+	const updatedAt = new Date(sample.sampledAtMs).toISOString();
+	const base = {
+		version: 2,
+		state,
+		updatedAt,
+		nextPollMs: config.pollSeconds * 1e3,
+		host: {
+			state: host.state,
+			platform: sample.platform,
+			reasons: host.reasons,
+			metrics: hostMetrics(sample)
+		},
+		admission: {
+			...host.admission,
+			admittedWorkAgentCount: agentProcesses.admittedWorkAgentCount
 		},
-		thresholds,
-		reasons: evaluation.reasons,
-		agents: sortedAgents,
-		leakedSpecialists,
-		topConsumers: buildTopConsumers(sortedAgents, containers, leakedSpecialists),
-		smeeRelay,
-		deployStaleness
-	};
-	if (previousSeverity && previousSeverity !== result.severity) try {
+		agents: agentProcesses.healthAgents,
+		services,
+		topConsumers: consumers
+	};
+	const accepted = {
+		...base,
+		summary: projectLegacySystemHealthSummary(base)
+	};
+	const sortedAgents = [...agentProcesses.agents].sort((left, right) => right.memoryBytes - left.memoryBytes);
+	const leakedSpecialists = buildLeakedSpecialists(sortedAgents);
+	return {
+		accepted,
+		compatibility: {
+			severity: stateToLegacySeverity(state),
+			updatedAt,
+			admission: { admittedWorkAgentCount: agentProcesses.admittedWorkAgentCount },
+			summary: accepted.summary,
+			thresholds: config.thresholds,
+			reasons: reasons.map((reason) => reason.message),
+			agents: sortedAgents,
+			leakedSpecialists,
+			topConsumers: consumers.slice(0, 10),
+			smeeRelay,
+			deployStaleness
+		}
+	};
+}
+async function collectRawSystemHealth() {
+	const bundle = await collectSystemHealth();
+	const reasons = acceptedReasons(bundle.accepted.state, bundle.accepted.host.reasons, bundle.accepted.agents, bundle.accepted.services);
+	return {
+		status: "valid",
+		assessment: {
+			state: bundle.accepted.state,
+			reasons,
+			metrics: bundle,
+			sampledAt: bundle.accepted.updatedAt
+		}
+	};
+}
+function buildSystemHealthTransitionPayload(transition, leakedSpecialistCount) {
+	return {
+		version: 2,
+		transitionVersion: transition.version,
+		previousSeverity: stateToLegacySeverity(transition.previousState),
+		severity: stateToLegacySeverity(transition.state),
+		previousState: transition.previousState,
+		state: transition.state,
+		reasons: transition.reasonCodes,
+		reasonCodes: transition.reasonCodes,
+		acceptedAt: transition.acceptedAt,
+		leakedSpecialistCount
+	};
+}
+async function publishSystemHealthTransition(transition) {
+	const accepted = systemHealthSampler?.getSnapshot();
+	try {
 		await (await (eventStorePromise ??= initEventStore())).appendAsync({
 			type: "system.health_severity_changed",
-			timestamp: result.updatedAt,
-			payload: {
-				previousSeverity,
-				severity: result.severity,
-				reasons: result.reasons,
-				leakedSpecialistCount: leakedSpecialists.length
-			}
+			timestamp: transition.acceptedAt,
+			payload: buildSystemHealthTransitionPayload(transition, accepted?.metrics.accepted.summary.leakedSpecialistCount ?? 0)
 		});
 	} catch (err) {
-		console.error("[system-health] Failed to append severity transition event:", err);
+		console.error("[system-health] Failed to append accepted transition event:", err);
 	}
-	previousSeverity = result.severity;
-	cachedHealth = result;
-	cacheExpiresAt = Date.now() + getHealthPollTtlMs();
-	return result;
 }
-async function getSystemHealthSnapshot(snapshot) {
-	if (cachedHealth && Date.now() < cacheExpiresAt) return cachedHealth;
-	if (!inflightRefresh) inflightRefresh = refreshSystemHealth(snapshot).finally(() => {
-		inflightRefresh = null;
-	});
-	return inflightRefresh;
+function getSystemHealthSampler() {
+	if (!systemHealthSampler) {
+		const config = cachedSystemHealthConfig ?? resolveSystemHealthConfig();
+		cachedSystemHealthConfig = config;
+		systemHealthSampler = createSystemHealthSampler({
+			collect: collectRawSystemHealth,
+			measuringMetrics: createMeasuringSnapshot,
+			pollIntervalMs: config.pollSeconds * 1e3,
+			onTransition: publishSystemHealthTransition
+		});
+	}
+	return systemHealthSampler;
+}
+async function getSystemHealthEvidenceSnapshot() {
+	const assessment = getSystemHealthSampler().getSnapshot();
+	return {
+		accepted: assessment.metrics.accepted,
+		compatibility: {
+			...assessment.metrics.compatibility,
+			state: assessment.state,
+			structuredReasons: assessment.reasons,
+			freshness: assessment.freshness,
+			transitionVersion: assessment.transitionVersion
+		}
+	};
+}
+async function getAcceptedSystemHealthSnapshot() {
+	return (await getSystemHealthEvidenceSnapshot()).accepted;
+}
+async function getSystemHealthSnapshot() {
+	return (await getSystemHealthEvidenceSnapshot()).compatibility;
 }
 //#endregion
 //#region routes/resources/shared.ts
-init_load();
 init_docker_stats();
 function getCurrentDockerStats() {
 	return [];
@@ -22467,6 +23436,7 @@ function roundOne(value) {
 }
 //#endregion
 //#region ../../lib/cloister/memory-governor.ts
+init_load();
 init_projects();
 promisify(execFile);
 const GIB = 1024 ** 3;
@@ -22578,7 +23548,7 @@ async function checkInspectAgentTimeouts(now = /* @__PURE__ */ new Date()) {
 			console.warn(`[deacon] Failed to kill inspect session ${sessionName}: ${msg}`);
 		});
 		try {
-			const { messageAgent } = await import("./agents-Czz6R57Z.js");
+			const { messageAgent } = await import("./agents-DyHKlq1I.js");
 			await messageAgent(`agent-${issueId.toLowerCase()}`, verdict, "deacon:inspect-watchdog");
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
@@ -22730,7 +23700,7 @@ async function maybeProactivelyCompactContext(sessionName, now) {
 	if (!agentState?.workspace || !sessionId || !agentState.model) return null;
 	let usage = null;
 	try {
-		const { computeContextUsage } = await import("./conversation-service-CWk8mEym.js");
+		const { computeContextUsage } = await import("./conversation-service-Dq33SYEj.js");
 		usage = await computeContextUsage(sessionFilePath(agentState.workspace, sessionId), agentState.model);
 	} catch {
 		return null;
@@ -22840,13 +23810,13 @@ async function checkApiErrorAgents() {
 							const st = getAgentStateSync(sessionName);
 							const sid = st?.sessionId ?? runtimeState?.claudeSessionId;
 							if (st?.workspace && sid && st.model) {
-								const { computeContextUsage } = await import("./conversation-service-CWk8mEym.js");
+								const { computeContextUsage } = await import("./conversation-service-Dq33SYEj.js");
 								const usage = await computeContextUsage(sessionFilePath(st.workspace, sid), st.model);
 								if (usage && usage.percentUsed < 85) recoveredPct = usage.percentUsed;
 							}
 						} catch {}
 						if (recoveredPct !== null) {
-							const { clearWorkspaceStuck } = await import("./review-status-sync-C792ksoJ.js");
+							const { clearWorkspaceStuck } = await import("./review-status-sync-D60PJWNL.js");
 							clearWorkspaceStuck(issueId);
 							stuckOverflowNativeRecoveryState.delete(sessionName);
 							actions.push(`Context overflow recovery: cleared stuck flag for ${sessionName} (context back to ${Math.round(recoveredPct)}%)`);
@@ -22862,7 +23832,7 @@ async function checkApiErrorAgents() {
 					rec.attempts += 1;
 					rec.lastAttempt = now;
 					stuckOverflowNativeRecoveryState.set(sessionName, rec);
-					const { resumeAgent } = await import("./agents-Czz6R57Z.js");
+					const { resumeAgent } = await import("./agents-DyHKlq1I.js");
 					const recovered = await resumeAgent(sessionName, void 0, { compact: true });
 					if (recovered.success) {
 						stuckOverflowNativeRecoveryState.delete(sessionName);
@@ -22910,7 +23880,7 @@ async function checkApiErrorAgents() {
 					}
 					const compactAttempts = (ov?.compactAttempts ?? 0) + 1;
 					if (issueId !== null) {
-						const { resumeAgent } = await import("./agents-Czz6R57Z.js");
+						const { resumeAgent } = await import("./agents-DyHKlq1I.js");
 						const resumeResult = await resumeAgent(sessionName, void 0, { compact: true });
 						contextOverflowRecoveryState.set(sessionName, {
 							lastAttempt: now,
@@ -23433,7 +24403,7 @@ function reviewConvoyLiveness(issueId) {
 */
 async function recoverUnhealthyTestStack(issueId, workspacePath) {
 	const key = issueId.toUpperCase();
-	const { getWorkspaceStackHealth } = await import("./stack-health-I713ELld.js");
+	const { getWorkspaceStackHealth } = await import("./stack-health-Bd06frFn.js");
 	const health = await Effect.runPromise(getWorkspaceStackHealth(issueId, { workspacePath }));
 	if (health.healthy) {
 		testStackRebuildState.delete(key);
@@ -23465,7 +24435,7 @@ async function recoverUnhealthyTestStack(issueId, workspacePath) {
 	record.attempts += 1;
 	testStackRebuildState.set(key, record);
 	console.log(`[deacon] Test stack for ${key} unhealthy (${health.reasons.join("; ")}) — rebuilding (attempt ${record.attempts}/${TEST_STACK_REBUILD_MAX_ATTEMPTS})`);
-	const { rebuildWorkspaceStack } = await import("./rebuild-stack-DjdpALr1.js");
+	const { rebuildWorkspaceStack } = await import("./rebuild-stack-CKjJAI8L.js");
 	const result = await Effect.runPromise(rebuildWorkspaceStack(issueId, { onProgress: (m) => console.log(`[deacon]   ${key} stack rebuild: ${m}`) }));
 	if (!result.success) {
 		console.warn(`[deacon] Test stack rebuild failed for ${key}: ${result.error}`);
@@ -23633,7 +24603,7 @@ async function handleReviewCoordinatorDied(issueId, _sessionName, _reason) {
 		return actions;
 	}
 	try {
-		const { spawnReviewRoleForIssue } = await import("./review-agent-CSswH985.js");
+		const { spawnReviewRoleForIssue } = await import("./review-agent-CCum8sGe.js");
 		const dispatchResult = await Effect.runPromise(spawnReviewRoleForIssue({
 			issueId,
 			workspace,
@@ -23785,7 +24755,7 @@ async function reconcileReviewStatusOrphan(issueId, rawStatus, options = {}) {
 		const workspace = agentState?.workspace || (resolved ? findWorkspacePath(resolved.projectPath, issueLower) : null);
 		if (workspace && resolved && !tryReserveAdvancingSlot() && !await tryYieldForAdvancingDispatch("review", issueId)) actions.push(`Deferred review re-dispatch for ${issueId} — advancing-role concurrency ceiling reached`);
 		else if (workspace && resolved) try {
-			const { spawnReviewRoleForIssue } = await import("./review-agent-CSswH985.js");
+			const { spawnReviewRoleForIssue } = await import("./review-agent-CCum8sGe.js");
 			const dispatchResult = await Effect.runPromise(spawnReviewRoleForIssue({
 				issueId,
 				workspace,
@@ -23810,8 +24780,8 @@ async function reconcileReviewStatusOrphan(issueId, rawStatus, options = {}) {
 		const workspace = agentState?.workspace || (resolved ? findWorkspacePath(resolved.projectPath, issueLower) : null);
 		if (workspace && resolved) {
 			const branch = `feature/${issueLower}`;
-			const { spawnRun } = await import("./agents-Czz6R57Z.js");
-			const { buildTestRolePrompt } = await import("./test-agent-queue-BwpUpu-o.js");
+			const { spawnRun } = await import("./agents-DyHKlq1I.js");
+			const { buildTestRolePrompt } = await import("./test-agent-queue-BJZ9Nfcc.js");
 			const stackRecovery = await recoverUnhealthyTestStack(issueId, workspace);
 			if (stackRecovery === "cooldown" || stackRecovery === "exhausted") {
 				setReviewStatusSync(issueId, { testStatus: "dispatch_failed" });
@@ -23949,7 +24919,7 @@ async function recoverStalledReviewConvoys(getCanonicalState = getAutoCloseOutCa
 		record.lastAttempt = now;
 		record.attempts += 1;
 		stalledReviewConvoyRecoveryState.set(key, record);
-		const { spawnReviewRoleForIssue } = await import("./review-agent-CSswH985.js");
+		const { spawnReviewRoleForIssue } = await import("./review-agent-CCum8sGe.js");
 		try {
 			const result = await Effect.runPromise(spawnReviewRoleForIssue({
 				issueId,
@@ -24020,7 +24990,7 @@ async function checkMissingReviewStatuses() {
 				continue;
 			}
 			try {
-				const { spawnReviewRoleForIssue } = await import("./review-agent-CSswH985.js");
+				const { spawnReviewRoleForIssue } = await import("./review-agent-CCum8sGe.js");
 				await Effect.runPromise(spawnReviewRoleForIssue({
 					issueId,
 					workspace,
@@ -24073,7 +25043,7 @@ async function checkStuckReviewing() {
 	const actions = [];
 	const REVIEW_STUCK_THRESHOLD_MS = 1800 * 1e3;
 	try {
-		const { loadReviewStatuses, setReviewStatusSync } = await import("./review-status-DXeqFpk5.js");
+		const { loadReviewStatuses, setReviewStatusSync } = await import("./review-status-Bnh-rdkY.js");
 		const statuses = loadReviewStatuses();
 		const now = Date.now();
 		const activeReviewIssues = /* @__PURE__ */ new Set();
@@ -24218,7 +25188,7 @@ async function checkCompletedButUnsignaledReviews() {
 				}
 				const nudge = `Your review synthesis is already written and saved. Your ONLY remaining task is to execute this Bash command immediately — do not analyze, do not summarize, do not ask questions, just run it:\n\n${`pan admin specialists done review ${issueId} --status ${verdict}${verdict === "blocked" || verdict === "failed" ? ` --notes "${topBlocker || "See synthesis.md"}"` : ""}`}\n\nRun this command NOW. Do not write any other response before executing it.`;
 				try {
-					const { messageAgent } = await import("./agents-Czz6R57Z.js");
+					const { messageAgent } = await import("./agents-DyHKlq1I.js");
 					await messageAgent(reviewSession, nudge);
 					unsignaledReviewNudges.set(latestDir, now);
 					actions.push(`Nudged ${reviewSession} to signal ${verdict} (synthesis written ${Math.round((now - latestMtime) / 6e4)}min ago)`);
@@ -24340,7 +25310,7 @@ async function respawnIdleReviewer(state, agentId) {
 		return false;
 	}
 	try {
-		const { spawnReviewSubRoleForIssue } = await import("./review-agent-CSswH985.js");
+		const { spawnReviewSubRoleForIssue } = await import("./review-agent-CCum8sGe.js");
 		const contextManifestPath = join$1(dirname$1(outputPath), "context.json");
 		const result = await Effect.runPromise(spawnReviewSubRoleForIssue({
 			issueId: state.issueId,
@@ -24469,7 +25439,7 @@ async function nudgeSynthesisForCompleteReviewerReports(states) {
 			"Read the four reports, write synthesis.md, then signal review status exactly as roles/review.md instructs."
 		].join("\n");
 		try {
-			const { messageAgent } = await import("./agents-Czz6R57Z.js");
+			const { messageAgent } = await import("./agents-DyHKlq1I.js");
 			await messageAgent(state.id, message);
 			reviewReportsPresentNudges.set(nudgeKey, now);
 			const action = `Nudged ${state.id} to synthesize from ${REVIEW_SUB_ROLES.length} reviewer reports`;
@@ -24555,7 +25525,7 @@ async function monitorReviewConvoySignals() {
 		if (!signal) continue;
 		const message = signal === "ready" ? `REVIEWER_READY ${state.reviewSubRole} ${outputPath}` : signal === "timeout" ? `REVIEWER_TIMEOUT ${state.reviewSubRole} ${reason}` : `REVIEWER_FAILED ${state.reviewSubRole} ${reason}`;
 		try {
-			const { messageAgent } = await import("./agents-Czz6R57Z.js");
+			const { messageAgent } = await import("./agents-DyHKlq1I.js");
 			await messageAgent(state.reviewSynthesisAgentId, message);
 			state.reviewMonitorSignaled = signal;
 			saveAgentStateSync(state);
@@ -24563,7 +25533,7 @@ async function monitorReviewConvoySignals() {
 			actions.push(action);
 			logDeaconEventSync(`monitorReviewConvoySignals: ${action}`);
 			if (signal === "ready") try {
-				const { notifyPipelineSync } = await import("./pipeline-notifier-dQ-U4NSb.js");
+				const { notifyPipelineSync } = await import("./pipeline-notifier-CZsrU_nj.js");
 				notifyPipelineSync({
 					type: "reviewer_completed",
 					issueId: state.issueId,
@@ -24571,7 +25541,7 @@ async function monitorReviewConvoySignals() {
 				});
 			} catch {}
 			else if (signal === "timeout") try {
-				const { notifyPipelineSync } = await import("./pipeline-notifier-dQ-U4NSb.js");
+				const { notifyPipelineSync } = await import("./pipeline-notifier-CZsrU_nj.js");
 				notifyPipelineSync({
 					type: "reviewer_timed_out",
 					issueId: state.issueId,
@@ -24671,7 +25641,7 @@ const FORK_CACHE_CHECK_DELAY_MS = 180 * 1e3;
 async function checkStalledReviewDiscovery() {
 	const actions = [];
 	try {
-		const { listAgentStates } = await import("./agents-Czz6R57Z.js");
+		const { listAgentStates } = await import("./agents-DyHKlq1I.js");
 		const states = listAgentStates();
 		const now = Date.now();
 		for (const state of states) {
@@ -24680,7 +25650,7 @@ async function checkStalledReviewDiscovery() {
 			const aged = Number.isFinite(startedMs) && now - startedMs > 48e4;
 			const dead = !await Effect.runPromise(sessionExists(state.id)).catch(() => false) || await Effect.runPromise(isPaneDead(state.id)).catch(() => true);
 			if (!aged && !dead) continue;
-			const { handleReviewDiscoveryReady } = await import("./review-agent-CSswH985.js");
+			const { handleReviewDiscoveryReady } = await import("./review-agent-CCum8sGe.js");
 			const result = await handleReviewDiscoveryReady(state.issueId, { source: dead ? "deacon-backstop (parent dead)" : "deacon-backstop (discovery timeout)" });
 			actions.push(result.message);
 			logDeaconEventSync(`checkStalledReviewDiscovery: ${result.message}`);
@@ -24703,8 +25673,8 @@ async function checkStalledReviewDiscovery() {
 async function checkStalledReviewParents() {
 	const actions = [];
 	try {
-		const { listAgentStates, markAgentStoppedState } = await import("./agents-Czz6R57Z.js");
-		const { PARENT_REVIEW_TIMEOUT_MS } = await import("./review-agent-CSswH985.js");
+		const { listAgentStates, markAgentStoppedState } = await import("./agents-DyHKlq1I.js");
+		const { PARENT_REVIEW_TIMEOUT_MS } = await import("./review-agent-CCum8sGe.js");
 		const states = listAgentStates();
 		const now = Date.now();
 		for (const state of states) {
@@ -24753,8 +25723,8 @@ async function checkStalledReviewParents() {
 async function checkReviewForkCacheMisses() {
 	const actions = [];
 	try {
-		const { listAgentStates, saveAgentState } = await import("./agents-Czz6R57Z.js");
-		const { readEventsSync } = await import("./events-LGeUehYW.js");
+		const { listAgentStates, saveAgentState } = await import("./agents-DyHKlq1I.js");
+		const { readEventsSync } = await import("./events-Dsuv6qyB.js");
 		const { emitActivityEntrySync } = await import("./activity-logger-OEUBdfZ8.js");
 		const states = listAgentStates();
 		const now = Date.now();
@@ -24890,7 +25860,7 @@ async function reconcileStaleMergeStatus() {
 			if (!project) continue;
 			let specStatus;
 			try {
-				const { findSpecByIssue } = await import("./specs-BsNcum0h.js");
+				const { findSpecByIssue } = await import("./specs-BhOKBzqk.js");
 				const spec = await Effect.runPromise(findSpecByIssue(project.projectPath, issueId));
 				specStatus = spec?.status;
 				if (spec && (spec.status === "completed" || spec.status === "cancelled")) {
@@ -24905,7 +25875,7 @@ async function reconcileStaleMergeStatus() {
 				if (branchTip.stdout.trim() === mainTip.stdout.trim()) console.log(`[deacon] ${issueId}: branch ${branch} points at main; not treating zero-commit branch as merged`);
 			} catch {}
 			if (!isMerged) {
-				const { resolveGitHubIssueSync: _resolveGitHubIssue } = await import("./tracker-utils-WtP_V-yn.js");
+				const { resolveGitHubIssueSync: _resolveGitHubIssue } = await import("./tracker-utils-DV3h1FYG.js");
 				const ghResolved = _resolveGitHubIssue(issueId);
 				if (ghResolved.isGitHub) try {
 					const { stdout } = await execFileAsync$4("gh", [
@@ -24942,7 +25912,7 @@ async function reconcileStaleMergeStatus() {
 				actions.push(msg);
 				console.log(`[deacon] ${msg}`);
 				try {
-					const { postMergeLifecycle } = await import("./merge-agent-CnORPiri.js");
+					const { postMergeLifecycle } = await import("./merge-agent-B-SnXOoc.js");
 					postMergeLifecycle(issueId, project.projectPath, branch, { skipDeploy: true }).catch((err) => console.warn(`[deacon] postMergeLifecycle (reconcile) failed for ${issueId}: ${err}`));
 				} catch (err) {
 					console.warn(`[deacon] Could not import postMergeLifecycle: ${err}`);
@@ -24967,7 +25937,7 @@ const falseMergedReset = /* @__PURE__ */ new Set();
 async function reconcileFalseMerged() {
 	const actions = [];
 	try {
-		const { getPullRequestState, isGitHubAppConfigured } = await import("./github-app-CeSVFL6C.js");
+		const { getPullRequestState, isGitHubAppConfigured } = await import("./github-app-CU14oYzP.js");
 		if (!isGitHubAppConfigured()) return actions;
 		const statuses = loadReviewStatuses();
 		for (const [issueId, status] of Object.entries(statuses)) {
@@ -25012,7 +25982,7 @@ const CLOSED_PR_RECONCILE_COOLDOWN_MS = 600 * 1e3;
 async function reconcileClosedPrReadyForMerge() {
 	const actions = [];
 	try {
-		const { getPullRequestState, isGitHubAppConfigured } = await import("./github-app-CeSVFL6C.js");
+		const { getPullRequestState, isGitHubAppConfigured } = await import("./github-app-CU14oYzP.js");
 		if (!isGitHubAppConfigured()) return actions;
 		const statuses = loadReviewStatuses();
 		const now = Date.now();
@@ -25084,7 +26054,7 @@ const STALE_MERGE_BLOCKER_COOLDOWN_MS = 120 * 1e3;
 async function reconcileStaleMergeBlockers() {
 	const actions = [];
 	try {
-		const { resolveConflictGate, buildRealConflictGateDeps } = await import("./conflict-gate-BKalpcjL.js");
+		const { resolveConflictGate, buildRealConflictGateDeps } = await import("./conflict-gate-CHU9K1vU.js");
 		const statuses = loadReviewStatuses();
 		const now = Date.now();
 		const deps = buildRealConflictGateDeps();
@@ -25227,7 +26197,7 @@ async function checkFailedMergeRetry() {
 					if (ciEntry.count === 5) {
 						console.log(`[deacon] CI check failure for ${issueId} — retries exhausted, notifying work agent`);
 						const ciNotes = status.mergeNotes || "CI checks are failing on the PR";
-						const { writeFeedbackFile } = await import("./feedback-writer-DDQNV8uc.js");
+						const { writeFeedbackFile } = await import("./feedback-writer-Bx5z11mF.js");
 						const ciFileResult = await Effect.runPromise(writeFeedbackFile({
 							issueId,
 							specialist: "merge-agent",
@@ -25259,7 +26229,7 @@ async function checkFailedMergeRetry() {
 				ciRetryMap.set(issueId, ciEntry);
 				console.log(`[deacon] CI check failure for ${issueId} — notifying agent to re-submit (attempt ${ciEntry.count}/5)`);
 				const ciNotes = status.mergeNotes || "CI checks are failing on the PR";
-				const { writeFeedbackFile } = await import("./feedback-writer-DDQNV8uc.js");
+				const { writeFeedbackFile } = await import("./feedback-writer-Bx5z11mF.js");
 				const ciFileResult2 = await Effect.runPromise(writeFeedbackFile({
 					issueId,
 					specialist: "merge-agent",
@@ -25287,7 +26257,7 @@ async function checkFailedMergeRetry() {
 				const lastNudge = timeoutNudgeCooldowns.get(issueIdForFb);
 				if (!lastNudge || now - lastNudge >= TIMEOUT_NUDGE_COOLDOWN_MS) {
 					const timeoutNotes = status.mergeNotes;
-					const { writeFeedbackFile } = await import("./feedback-writer-DDQNV8uc.js");
+					const { writeFeedbackFile } = await import("./feedback-writer-Bx5z11mF.js");
 					await Effect.runPromise(writeFeedbackFile({
 						issueId: issueIdForFb,
 						specialist: "merge-agent",
@@ -25392,7 +26362,7 @@ async function autoCloseOut(now = /* @__PURE__ */ new Date()) {
 				} } : {}
 			};
 			try {
-				const { closeOut } = await import("./workflows-C5c-RPsY.js");
+				const { closeOut } = await import("./workflows-C4mR0Reb.js");
 				const result = await Effect.runPromise(closeOut(ctx));
 				if (!result.success) {
 					const failed = result.steps.find((step) => !step.success && !step.skipped);
@@ -25990,7 +26960,7 @@ async function nudgeStalledResumeWorkAgents() {
 		const message = buildStalledResumePrompt(state);
 		if (!message) continue;
 		try {
-			const { messageAgent } = await import("./agents-Czz6R57Z.js");
+			const { messageAgent } = await import("./agents-DyHKlq1I.js");
 			await messageAgent(agentId, message);
 			recordCooldown(agentId, ".last-stalled-resume-nudge");
 			const action = `Re-sent stalled resume prompt to ${agentId} (${state.issueId})`;
@@ -26104,7 +27074,7 @@ async function nudgeIdleWorkAgentsWithOpenBeads() {
 			"Continue the per-item workflow without asking — claim it (`pan task claim <item-id>`), implement, commit, push, then complete it through `pan task done <item-id>`. Inspection is conditional on metadata.requiresInspection (default false; check the plan item before deciding to call `pan inspect`). Do NOT end your turn with a multi-paragraph summary; just advance to the next bead."
 		].join("\n");
 		try {
-			const { messageAgent } = await import("./agents-Czz6R57Z.js");
+			const { messageAgent } = await import("./agents-DyHKlq1I.js");
 			await messageAgent(agentId, message);
 			writeFileSync(join$1(getAgentDir(agentId), ".last-bead-nudge"), String(Date.now()), "utf-8");
 			const action = `Nudged idle ${agentId} (${state.issueId}) — ${openTasks.length} ready task(s)`;
@@ -27373,8 +28343,8 @@ async function cleanupStaleAgentState() {
 */
 async function cleanupAbandonedFeedback() {
 	const actions = [];
-	const { getReviewStatusSync } = await import("./review-status-DXeqFpk5.js");
-	const { clearFeedbackFiles } = await import("./feedback-writer-DDQNV8uc.js");
+	const { getReviewStatusSync } = await import("./review-status-Bnh-rdkY.js");
+	const { clearFeedbackFiles } = await import("./feedback-writer-Bx5z11mF.js");
 	for (const { issueId, workspacePath } of listFeatureWorkspaces()) {
 		const panFeedbackDir = join$1(workspacePath, ".pan", "feedback");
 		if (!existsSync(panFeedbackDir)) continue;
@@ -27445,7 +28415,7 @@ async function handleOrphanReviewerSession(sessionName, sessions, creationTimes,
 	if (!issueId) return null;
 	const agentSession = `agent-${issueId.toLowerCase()}`;
 	if (sessions.includes(agentSession)) return null;
-	const { getReviewStatusSync } = await import("./review-status-DXeqFpk5.js");
+	const { getReviewStatusSync } = await import("./review-status-Bnh-rdkY.js");
 	try {
 		if (getReviewStatusSync(issueId)?.reviewStatus === "reviewing") return null;
 	} catch {}
@@ -27567,7 +28537,7 @@ async function checkOrphanedCompletions() {
 async function checkPendingTestDispatch() {
 	const actions = [];
 	try {
-		const { loadReviewStatuses, setReviewStatusSync } = await import("./review-status-DXeqFpk5.js");
+		const { loadReviewStatuses, setReviewStatusSync } = await import("./review-status-Bnh-rdkY.js");
 		const statuses = loadReviewStatuses();
 		const now = Date.now();
 		for (const [issueId, status] of Object.entries(statuses)) {
@@ -27600,7 +28570,7 @@ async function checkPendingTestDispatch() {
 				console.log(`[deacon] ${issueId}: skipping test re-dispatch — issue is closed`);
 				continue;
 			}
-			const { resolveProjectFromIssueSync } = await import("./projects-IRHJIPYC.js");
+			const { resolveProjectFromIssueSync } = await import("./projects-BKkwpH6q.js");
 			const resolved = resolveProjectFromIssueSync(issueId);
 			if (!resolved) continue;
 			const issueLower = issueId.toLowerCase();
@@ -27615,8 +28585,8 @@ async function checkPendingTestDispatch() {
 				logDeaconEventSync(`checkPendingTestDispatch: deferred test for ${issueId} — advancing ceiling reached (PAN-1665) — ${describeRunningAgents()}`);
 				continue;
 			}
-			const { spawnRun } = await import("./agents-Czz6R57Z.js");
-			const { buildTestRolePrompt } = await import("./test-agent-queue-BwpUpu-o.js");
+			const { spawnRun } = await import("./agents-DyHKlq1I.js");
+			const { buildTestRolePrompt } = await import("./test-agent-queue-BJZ9Nfcc.js");
 			try {
 				const run = await spawnRun(issueId, "test", {
 					workspace,
@@ -27739,7 +28709,7 @@ async function checkCompletedButUnsignaledTests() {
 					const cmd = `pan admin specialists done test ${issueId} --status ${decision.status}${noteArg}`;
 					const nudge = `Your test verdict (${decision.status}) is already written to .pan/test/result.json. Your ONLY remaining task is to execute this Bash command immediately — do not analyze, do not summarize, do not ask questions, just run it:\n\n${cmd}\n\nRun this command NOW. Do not write any other response before executing it.`;
 					try {
-						const { messageAgent } = await import("./agents-Czz6R57Z.js");
+						const { messageAgent } = await import("./agents-DyHKlq1I.js");
 						await messageAgent(testSession, nudge);
 						unsignaledTestNudges.set(testSession, now);
 						const msg = `Nudged ${testSession} to signal ${decision.status} (verdict artifact present)`;
@@ -27753,7 +28723,7 @@ async function checkCompletedButUnsignaledTests() {
 				case "nudge-write": {
 					const nudge = `Your test run for ${issueId} looks finished but no verdict was recorded. Decide the verdict from the gates/UAT you ran, then do BOTH of these now: (1) write the workspace file .pan/test/result.json as {"status":"passed"|"failed","notes":"<evidence>"}, and (2) run: pan admin specialists done test ${issueId} --status passed|failed. Do this immediately — do not summarize or ask questions, just write the file and run the command.`;
 					try {
-						const { messageAgent } = await import("./agents-Czz6R57Z.js");
+						const { messageAgent } = await import("./agents-DyHKlq1I.js");
 						await messageAgent(testSession, nudge);
 						unsignaledTestNudges.set(testSession, now);
 						const msg = `Nudged ${testSession} to write+signal a test verdict (no artifact yet)`;
@@ -27776,8 +28746,8 @@ async function checkCompletedButUnsignaledTests() {
 async function checkVerificationReviewContradiction() {
 	const actions = [];
 	try {
-		const { loadReviewStatuses, setReviewStatusSync } = await import("./review-status-DXeqFpk5.js");
-		const { resolveProjectFromIssueSync } = await import("./projects-IRHJIPYC.js");
+		const { loadReviewStatuses, setReviewStatusSync } = await import("./review-status-Bnh-rdkY.js");
+		const { resolveProjectFromIssueSync } = await import("./projects-BKkwpH6q.js");
 		const statuses = loadReviewStatuses();
 		for (const [issueId, status] of Object.entries(statuses)) if (status.verificationStatus === "passed" && status.reviewStatus === "reviewing" && status.stuckReason === "review_infrastructure_failure") {
 			let reviewedAtCommit;
@@ -27826,7 +28796,7 @@ async function checkPostReviewCommits() {
 	const actions = [];
 	try {
 		const statuses = loadReviewStatuses();
-		const { resolveProjectFromIssueSync } = await import("./projects-IRHJIPYC.js");
+		const { resolveProjectFromIssueSync } = await import("./projects-BKkwpH6q.js");
 		for (const [issueId, status] of Object.entries(statuses)) {
 			if (status.mergeStatus === "merged") continue;
 			if (!status.reviewedAtCommit) continue;
@@ -27881,7 +28851,7 @@ async function checkPostReviewCommits() {
 				actions.push(`Deferred post-review re-dispatch for ${issueId} — advancing-role concurrency ceiling reached`);
 				logDeaconEventSync(`checkPostReviewCommits: deferred review for ${issueId} — advancing ceiling reached (PAN-1665) — ${describeRunningAgents()}`);
 			} else if (freshStatus?.reviewStatus === "pending") {
-				const { spawnReviewRoleForIssue } = await import("./review-agent-CSswH985.js");
+				const { spawnReviewRoleForIssue } = await import("./review-agent-CCum8sGe.js");
 				const branch = `feature/${issueId.toLowerCase()}`;
 				const dispatchResult = await Effect.runPromise(spawnReviewRoleForIssue({
 					issueId,
@@ -27981,7 +28951,7 @@ async function checkReadyForMergeStuck() {
 const testStatusGreenCiReconcileCooldowns = /* @__PURE__ */ new Map();
 const TEST_STATUS_GREEN_CI_RECONCILE_COOLDOWN_MS = 300 * 1e3;
 async function reconcileTestStatusFromGreenCi() {
-	const { getCiCheckRunsState, getPullRequestHeadState, isGitHubAppConfigured } = await import("./github-app-CeSVFL6C.js");
+	const { getCiCheckRunsState, getPullRequestHeadState, isGitHubAppConfigured } = await import("./github-app-CU14oYzP.js");
 	return reconcileTestStatusFromGreenCiWithDeps({
 		isGitHubAppConfigured,
 		loadReviewStatuses,
@@ -28002,7 +28972,7 @@ async function reconcileTestStatusFromGreenCi() {
 */
 async function clearStaleCiFeedback(issueId) {
 	const { readdir, rm } = await import("fs/promises");
-	const { resolveProjectFromIssueSync } = await import("./projects-IRHJIPYC.js");
+	const { resolveProjectFromIssueSync } = await import("./projects-BKkwpH6q.js");
 	const projectConfig = resolveProjectFromIssueSync(issueId);
 	if (!projectConfig) return;
 	const repoDir = projectConfig.projectPath;
@@ -28298,7 +29268,7 @@ async function checkWorkspaceContainerHealth(sharedState) {
 				}
 			}
 			try {
-				const { resolveProjectFromIssueSync } = await import("./projects-IRHJIPYC.js");
+				const { resolveProjectFromIssueSync } = await import("./projects-BKkwpH6q.js");
 				const resolved = resolveProjectFromIssueSync(issueLower.toUpperCase());
 				if (resolved) await killOrphanedWorkspaceProcesses(`${resolved.projectPath}/workspaces/feature-${issueLower}`);
 			} catch {}
@@ -28347,8 +29317,8 @@ async function checkWorkspaceContainerHealth(sharedState) {
 async function checkMergedWorkSessions() {
 	const actions = [];
 	try {
-		const { selectMergedWorkSessions } = await import("./reap-terminal-sessions-C1mfzoZo.js");
-		const { setAgentPaused } = await import("./agents-Czz6R57Z.js");
+		const { selectMergedWorkSessions } = await import("./reap-terminal-sessions-CaMkFOIH.js");
+		const { setAgentPaused } = await import("./agents-DyHKlq1I.js");
 		const toKill = selectMergedWorkSessions(loadReviewStatuses(), [...await Effect.runPromise(listSessionNames())]);
 		for (const session of toKill) try {
 			await Effect.runPromise(setAgentPaused(session, "merged — awaiting close-out (verify on main)", true));
@@ -28388,7 +29358,7 @@ const AWAITING_TEST_IDLE_REAP_MS = 600 * 1e3;
 async function checkAwaitingTestWorkSessions() {
 	const actions = [];
 	try {
-		const { selectAwaitingTestWorkSessions } = await import("./reap-terminal-sessions-C1mfzoZo.js");
+		const { selectAwaitingTestWorkSessions } = await import("./reap-terminal-sessions-CaMkFOIH.js");
 		const candidates = selectAwaitingTestWorkSessions(loadReviewStatuses(), [...await Effect.runPromise(listSessionNames())]);
 		const now = Date.now();
 		for (const session of candidates) {
@@ -28441,14 +29411,14 @@ async function runPatrol() {
 		hasLoggedGlobalPauseSkip = false;
 		addLog("info", `Patrol cycle ${state.patrolCycle} — checking per-project specialists`, state.patrolCycle);
 		console.log(`[deacon] Patrol cycle ${state.patrolCycle} - checking per-project specialists`);
-		for (const a of await (await import("./stale-task-claims-CQSKZVq0.js")).patrolStaleTaskClaims()) {
+		for (const a of await (await import("./stale-task-claims-L7pJkQFL.js")).patrolStaleTaskClaims()) {
 			actions.push(a);
 			addLog("action", a, state.patrolCycle);
 		}
 		const stuckRemediationActions = await checkStuckAgentRemediation();
 		actions.push(...stuckRemediationActions);
 		for (const a of stuckRemediationActions) addLog("action", a, state.patrolCycle);
-		const { reconcileInFlightJournals } = await import("./advancing-selfheal-CPOBO5ZS.js");
+		const { reconcileInFlightJournals } = await import("./advancing-selfheal-cSvXNZLZ.js");
 		const reconciledJournalActions = await reconcileInFlightJournals();
 		actions.push(...reconciledJournalActions);
 		for (const a of reconciledJournalActions) addLog("action", a, state.patrolCycle);
@@ -28460,7 +29430,7 @@ async function runPatrol() {
 				const age = Date.now() - (pending.timestamp ?? 0);
 				if (age < 3600 * 1e3) {
 					console.log(`[deacon] Processing pending post-merge lifecycle for ${pending.issueId} (age: ${Math.round(age / 1e3)}s)`);
-					const { postMergeLifecycle } = await import("./merge-agent-CnORPiri.js");
+					const { postMergeLifecycle } = await import("./merge-agent-B-SnXOoc.js");
 					const { unlinkSync } = await import("fs");
 					unlinkSync(pendingFile);
 					await postMergeLifecycle(pending.issueId, pending.projectPath, pending.sourceBranch, { skipDeploy: true });
@@ -28474,7 +29444,7 @@ async function runPatrol() {
 		} catch (err) {
 			console.warn(`[deacon] Failed to process pending lifecycle: ${err.message}`);
 		}
-		if (state.patrolCycle % 5 === 0) await (await import("./deploy-patrol-DmM6F-yw.js")).runScheduledDeployPatrol();
+		if (state.patrolCycle % 5 === 0) await (await import("./deploy-patrol-1IrZxicY.js")).runScheduledDeployPatrol();
 		const livenessActions = await reconcileAgentLiveness();
 		actions.push(...livenessActions);
 		for (const a of livenessActions) addLog("action", a, state.patrolCycle);
@@ -28506,7 +29476,7 @@ async function runPatrol() {
 		actions.push(...suspendActions);
 		for (const a of suspendActions) addLog("action", a, state.patrolCycle);
 		try {
-			const { resolveProjectFromIssueSync } = await import("./projects-IRHJIPYC.js");
+			const { resolveProjectFromIssueSync } = await import("./projects-BKkwpH6q.js");
 			const allStatuses = loadReviewStatuses();
 			for (const [issueId, status] of Object.entries(allStatuses)) {
 				if (!status.readyForMerge || status.mergeStatus === "merged") continue;
@@ -28526,7 +29496,7 @@ async function runPatrol() {
 		} catch (err) {
 			console.warn(`[deacon] Failed to check workspace existence: ${err.message}`);
 		}
-		const { checkMergedAdvancingSessions } = await import("./advancing-selfheal-CPOBO5ZS.js");
+		const { checkMergedAdvancingSessions } = await import("./advancing-selfheal-cSvXNZLZ.js");
 		const reapedWorkActions = await checkMergedWorkSessions();
 		actions.push(...reapedWorkActions);
 		for (const a of reapedWorkActions) addLog("action", a, state.patrolCycle);
@@ -28534,7 +29504,7 @@ async function runPatrol() {
 		actions.push(...reapedMergedAdvancingActions);
 		for (const a of reapedMergedAdvancingActions) addLog("action", a, state.patrolCycle);
 		try {
-			const { refreshClaudeCredentialsForActiveRemoteAgents } = await import("./remote-completion-W67FNQ-A.js");
+			const { refreshClaudeCredentialsForActiveRemoteAgents } = await import("./remote-completion-Dca3hAaa.js");
 			const remoteCredentialActions = await refreshClaudeCredentialsForActiveRemoteAgents();
 			actions.push(...remoteCredentialActions);
 			for (const a of remoteCredentialActions) addLog(a.includes("failed") ? "warn" : "action", a, state.patrolCycle);
@@ -28542,7 +29512,7 @@ async function runPatrol() {
 			addLog("warn", `Remote credential refresh patrol failed: ${err.message}`, state.patrolCycle);
 		}
 		try {
-			const { refreshHostHeartbeatForEphemeralVms } = await import("./remote-agents-BNORDWAX.js");
+			const { refreshHostHeartbeatForEphemeralVms } = await import("./remote-agents-D6O_zETW.js");
 			const heartbeatActions = await refreshHostHeartbeatForEphemeralVms();
 			actions.push(...heartbeatActions);
 			for (const a of heartbeatActions) addLog(a.includes("failed") ? "warn" : "action", a, state.patrolCycle);
@@ -28550,7 +29520,7 @@ async function runPatrol() {
 			addLog("warn", `Remote heartbeat refresh patrol failed: ${err.message}`, state.patrolCycle);
 		}
 		try {
-			const { reapCompletedRemoteAgents } = await import("./remote-completion-W67FNQ-A.js");
+			const { reapCompletedRemoteAgents } = await import("./remote-completion-Dca3hAaa.js");
 			const remoteReap = await reapCompletedRemoteAgents();
 			for (const r of remoteReap) if (r.status === "handed-off" || r.status === "error") {
 				const msg = `Remote reap ${r.issueId}: ${r.status} (${r.details.join("; ")})`;
@@ -28735,7 +29705,7 @@ async function runPatrol() {
 							const issueId = runtimeState.currentIssue;
 							try {
 								if (getReviewStatusSync(issueId)?.mergeStatus === "merging") {
-									const { resolveProjectFromIssueSync } = await import("./projects-IRHJIPYC.js");
+									const { resolveProjectFromIssueSync } = await import("./projects-BKkwpH6q.js");
 									const resolved = resolveProjectFromIssueSync(issueId);
 									if (resolved) {
 										const branch = `feature/${issueId.toLowerCase()}`;
@@ -28749,7 +29719,7 @@ async function runPatrol() {
 												mergeStatus: "merged",
 												readyForMerge: false
 											});
-											const { postMergeLifecycle } = await import("./merge-agent-CnORPiri.js");
+											const { postMergeLifecycle } = await import("./merge-agent-B-SnXOoc.js");
 											postMergeLifecycle(issueId, resolved.projectPath).catch((err) => console.warn(`[deacon] postMergeLifecycle failed for ${issueId}: ${err}`));
 											actions.push(`Auto-completed stale merge for ${issueId}`);
 										} else {
@@ -28929,7 +29899,7 @@ function startDeacon() {
 	logDeaconEventSync(`startDeacon: health monitor starting (patrol every ${config.patrolIntervalMs / 1e3}s)`);
 	(async () => {
 		await reconcileAgentLiveness();
-		const { runBootAdvancingSelfHeal } = await import("./advancing-selfheal-CPOBO5ZS.js");
+		const { runBootAdvancingSelfHeal } = await import("./advancing-selfheal-cSvXNZLZ.js");
 		await runBootAdvancingSelfHeal();
 		runScheduledPatrol("startup");
 	})().catch((err) => {
@@ -28999,6 +29969,6 @@ function assessDeaconPatrolFreshness(params) {
 	};
 }
 //#endregion
-export { reconcileFalseMerged as $, reconcileAgentLiveness as A, getSystemHealthSnapshot as At, isPreKickoffLaunchDeath as B, getLastPatrolResult as C, checkInspectAgentTimeouts as Ct, isDeaconRunning as D, getContainerHistory as Dt, handleAgentStoppedForOrphanReviewerSessions as E, formatUptime as Et, setAgentStatusChangedNotifier as F, isBootReconciliationCandidate as G, nudgeIdleWorkAgentsWithOpenBeads as H, setAgentStoppedNotifier as I, autoCloseOut as J, listBootReconciliationCandidates as K, setMergeReadyNotifier as L, resetPatrolHeartbeatForStartup as M, startSmeeProcessSync as Mt, runPatrol as N, loadConfig as O, getCurrentDockerStats as Ot, saveState as P, reconcileClosedPrReadyForMerge as Q, startDeacon as R, getDeaconStatus as S, INSPECT_TIMEOUT_MS as St, handleAgentStoppedEvent as T, getResourceStacks as Tt, nudgeStalledResumeWorkAgents as U, isRapidPostResumeDeath as V, redeliverUndeliveredKickoffs as W, checkFirstCompletionAgents as X, checkFailedMergeRetry as Y, ciRetryMap as Z, cleanupOrphanReviewerSessions as _, checkApiErrorAgents as _t, checkCompletedButUnsignaledTests as a, monitorReviewConvoySignals as at, containerRestartBackoffMs as b, stuckOverflowNativeRecoveryState as bt, checkMergedWorkSessions as c, checkStuckReviewing as ct, checkPostReviewCommits as d, checkOrphanedReviewStatuses as dt, reconcileMergedButReviewing as et, checkReadyForMergeStuck as f, handleReviewCoordinatorDied as ft, cleanupAbandonedFeedback as g, stalledReviewConvoyRecoveryState as gt, checkWorkspaceContainerHealth as h, reviewConvoyLiveness as ht, checkAwaitingTestWorkSessions as i, cleanupOrphanedReviewSessions as it, reconcileTestStatusFromGreenCi as j, isSmeeConfiguredSync as jt, loadState as k, getResourceConfig as kt, checkOrphanedCompletions as l, isSynthesisForActiveReviewRun as lt, checkVerificationReviewContradiction as m, recoverStalledReviewConvoys as mt, assessDeaconPatrolFreshness as n, reconcileStaleMergeStatus as nt, checkDeadEndAgents as o, synthesizeReviewFromReports as ot, checkStuckWorkAgents as p, handleWorkCompleted as pt, startBootReconciliation as q, checkAndSuspendIdleAgents as r, reconcileStuckReadyForMerge as rt, checkMassDeath as s, checkCompletedButUnsignaledReviews as st, applyBootReconciliationDecision as t, reconcileStaleMergeBlockers as tt, checkPendingTestDispatch as u, checkMissingReviewStatuses as ut, cleanupOrphanedPlanningSessions as v, contextOverflowRecoveryState as vt, handleAgentHeartbeatDeadEvent as w, classifyMemoryPressure as wt, getDeaconLogs as x, paneShowsClaudeBootBlockingScreen as xt, cleanupStaleAgentState as y, contextProactiveCompactState as yt, stopDeacon as z };
+export { reconcileClosedPrReadyForMerge as $, reconcileAgentLiveness as A, getAcceptedSystemHealthSnapshot as At, recordDeadEndNeedsYou as B, getLastPatrolResult as C, INSPECT_TIMEOUT_MS as Ct, isDeaconRunning as D, formatUptime as Dt, handleAgentStoppedForOrphanReviewerSessions as E, getResourceStacks as Et, setAgentStatusChangedNotifier as F, isSmeeConfiguredSync as Ft, redeliverUndeliveredKickoffs as G, isRapidPostResumeDeath as H, setAgentStoppedNotifier as I, startSmeeProcessSync as It, startBootReconciliation as J, isBootReconciliationCandidate as K, setMergeReadyNotifier as L, classifyAgentHealth as Lt, resetPatrolHeartbeatForStartup as M, getResourceConfig as Mt, runPatrol as N, getSystemHealthEvidenceSnapshot as Nt, loadConfig as O, getContainerHistory as Ot, saveState as P, getSystemHealthSnapshot as Pt, ciRetryMap as Q, startDeacon as R, getDeaconStatus as S, paneShowsClaudeBootBlockingScreen as St, handleAgentStoppedEvent as T, classifyMemoryPressure as Tt, nudgeIdleWorkAgentsWithOpenBeads as U, isPreKickoffLaunchDeath as V, nudgeStalledResumeWorkAgents as W, checkFailedMergeRetry as X, autoCloseOut as Y, checkFirstCompletionAgents as Z, cleanupOrphanReviewerSessions as _, stalledReviewConvoyRecoveryState as _t, checkCompletedButUnsignaledTests as a, cleanupOrphanedReviewSessions as at, containerRestartBackoffMs as b, contextProactiveCompactState as bt, checkMergedWorkSessions as c, checkCompletedButUnsignaledReviews as ct, checkPostReviewCommits as d, checkMissingReviewStatuses as dt, reconcileFalseMerged as et, checkReadyForMergeStuck as f, checkOrphanedReviewStatuses as ft, cleanupAbandonedFeedback as g, reviewConvoyLiveness as gt, checkWorkspaceContainerHealth as h, recoverStalledReviewConvoys as ht, checkAwaitingTestWorkSessions as i, reconcileStuckReadyForMerge as it, reconcileTestStatusFromGreenCi as j, getDeployStaleness as jt, loadState as k, getCurrentDockerStats as kt, checkOrphanedCompletions as l, checkStuckReviewing as lt, checkVerificationReviewContradiction as m, handleWorkCompleted as mt, assessDeaconPatrolFreshness as n, reconcileStaleMergeBlockers as nt, checkDeadEndAgents as o, monitorReviewConvoySignals as ot, checkStuckWorkAgents as p, handleReviewCoordinatorDied as pt, listBootReconciliationCandidates as q, checkAndSuspendIdleAgents as r, reconcileStaleMergeStatus as rt, checkMassDeath as s, synthesizeReviewFromReports as st, applyBootReconciliationDecision as t, reconcileMergedButReviewing as tt, checkPendingTestDispatch as u, isSynthesisForActiveReviewRun as ut, cleanupOrphanedPlanningSessions as v, checkApiErrorAgents as vt, handleAgentHeartbeatDeadEvent as w, checkInspectAgentTimeouts as wt, getDeaconLogs as x, stuckOverflowNativeRecoveryState as xt, cleanupStaleAgentState as y, contextOverflowRecoveryState as yt, stopDeacon as z };
 
-//# sourceMappingURL=deacon-1s7bM5zn.js.map
+//# sourceMappingURL=deacon-CkT_kznS.js.map