feat(alerts): renames carry their alerts — monitor and host renames move rules, windows and history (#5065)

#5065 "Renames carry their alerts". Alert rules, maintenance-window scopes
and metric history key a thing by (source, name), so a rename used to leave
the rules watching a name nothing reported under, and split the history.

- core/renames.carry_rename moves AlertRule.resource_name,
  MaintenanceWindow.scope_resource, plugin_metrics and plugin_metrics_hourly
  to the new name in the caller's transaction. A host rename also carries
  its parts: host_agent "<host>:…" and docker "<host>/…" (HOST_SOURCES).
  Matching is exact (a prefix compare, not LIKE or a collation range).
  History left under the new name by something deleted is dropped first
  rather than merged in.
- Web monitor edit, MCP update_monitor and web host edit call it; MCP
  answers with `carried` (it used to return a warning naming stranded rules).
- A name another monitor of the same type, or another host, already has is
  refused on create and rename: two would share one history.
- The rename is audited (monitor.updated / host.renamed) with what moved.

Tests: an integration test renames a firing monitor through the web route
and finds its rule still firing and cleared by a sample on the new name,
its window and raw+hourly history moved and an orphan's history dropped; a
host rename moves agent and container parts but not a longer-named host's
or another source's; a guard that every host_agent resource is "<host>" or
"<host>:…".

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

steward/mcp/tools/monitors.py

@@ -5,7 +5,7 @@ import json
 
 from sqlalchemy import select
 
-from steward.models.alerts import AlertRule
+from steward.core import renames
 from steward.models.hosts import Host
 from steward.models.monitors import MONITOR_TYPE_VALUES, Monitor
 from steward.models.users import UserRole
@@ -188,6 +188,7 @@ async def create_monitor(name: str, type: str, target: str, host: str = "",
     fields = monitor_svc.monitor_fields(type, target=target, name=name,
                                         check_interval_seconds=check_interval_s, opts=config or {})
     async with db_session() as db, db.begin():
+        await monitor_svc.check_name_free(db, fields["type"], fields["name"])
         m = Monitor(host_id=await _host_id(db, host), enabled=enabled, **fields)
         db.add(m)
         _monitors, host_names = await _load(db)
@@ -207,8 +208,9 @@ async def update_monitor(monitor: str, name: str | None = None, target: str | No
       create_monitor for the keys of each type). A monitor's type cannot
       change; delete it and create another.
 
-    Alert rules watch a monitor by its name, so a rename returns `warning`
-    naming the rules still on the old name.
+    A rename carries the monitor's alert rules, maintenance windows and
+    check history to the new name; `carried` says what moved. A name another
+    monitor of the same type has is refused.
 
     Recorded in the audit log.
     """
@@ -223,23 +225,23 @@ async def update_monitor(monitor: str, name: str | None = None, target: str | No
                                     else check_interval_s),
             opts={**current, **(config or {})})
         old_name = m.name
+        if fields["name"] != old_name:
+            await monitor_svc.check_name_free(db, m.type, fields["name"], exclude_id=m.id)
         for k, v in fields.items():
             setattr(m, k, v)
         if host is not None:
             m.host_id = await _host_id(db, host)
-        stranded = []
-        if m.name != old_name:
-            stranded = list((await db.execute(
-                select(AlertRule.name).where(AlertRule.source_module == m.type,
-                                             AlertRule.resource_name == old_name))).scalars())
+        moved = await renames.carry_rename(db, ((m.type, None),), old_name, m.name)
     changed = sorted(k for k, v in {"name": name, "target": target, "host": host, "config": config,
                                     "check_interval_s": check_interval_s}.items() if v is not None)
-    await audit_mcp("monitor.updated", "monitor", m.name, {"monitor_id": m.id, "changed": changed})
+    detail = {"monitor_id": m.id, "changed": changed}
+    if moved:
+        detail["renamed_from"] = old_name
+        detail["carried"] = moved
+    await audit_mcp("monitor.updated", "monitor", m.name, detail)
     out = _saved(m, host_names)
-    if stranded:
-        out["warning"] = (f"Alert rules watch this monitor by name and still watch {old_name!r}: "
-                          f"{', '.join(stranded)}. update_alert_rule(resource=\"{m.name}\") "
-                          "points each at the new name.")
+    if moved:
+        out["carried"] = {"from": old_name, **moved}
     return out