nexo-brain 7.30.28 → 7.30.29

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.28",
+  "version": "7.30.29",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.28",
+  "version": "7.30.29",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/cli.py

@@ -1287,17 +1287,27 @@ def _agents_set_schedule(args):
 
     interval_seconds = None
     daily_at = None
+    schedule_freq = None
+    schedule_at = None
+    schedule_day = None
     if getattr(args, "every_minutes", None) is not None:
         interval_seconds = int(args.every_minutes) * 60
     elif getattr(args, "every_seconds", None) is not None:
         interval_seconds = int(args.every_seconds)
     elif getattr(args, "daily_at", None):
         daily_at = str(args.daily_at).strip()
+    elif getattr(args, "schedule_freq", None):
+        schedule_freq = str(args.schedule_freq).strip()
+        schedule_at = str(getattr(args, "schedule_at", "") or "").strip()
+        schedule_day = getattr(args, "schedule_day", None)
 
     result = set_agent_schedule(
         args.name,
         interval_seconds=interval_seconds,
         daily_at=daily_at,
+        schedule_freq=schedule_freq,
+        schedule_at=schedule_at,
+        schedule_day=schedule_day,
         clear=bool(getattr(args, "reset", False)),
     )
     if args.json:
@@ -4160,7 +4170,10 @@ def main():
     agents_schedule_group.add_argument("--every-minutes", type=int, help="Run the agent every N minutes")
     agents_schedule_group.add_argument("--every-seconds", type=int, help="Run the agent every N seconds")
     agents_schedule_group.add_argument("--daily-at", type=str, help="Run the agent every day at HH:MM or HH:MM:weekday")
+    agents_schedule_group.add_argument("--schedule-freq", choices=["daily", "weekly", "monthly", "every_n_days"], help="Run the agent on an anchored cadence")
     agents_schedule_group.add_argument("--reset", action="store_true", help="Clear the agent schedule")
+    agents_schedule_p.add_argument("--schedule-at", type=str, help="Anchored schedule time HH:MM")
+    agents_schedule_p.add_argument("--schedule-day", type=int, help="Weekday 0-6, month day 1-28, or every N days")
     agents_schedule_p.add_argument("--json", action="store_true", help="JSON output")
 
     agents_run_p = agents_sub.add_parser("run", help="Run an agent now")

package/src/local_context/api.py

@@ -43,6 +43,8 @@ DEFAULT_MAX_JOB_ATTEMPTS = int(os.environ.get("NEXO_LOCAL_INDEX_MAX_JOB_ATTEMPTS
 DEFAULT_SQLITE_BUSY_RETRY_ATTEMPTS = int(os.environ.get("NEXO_LOCAL_CONTEXT_BUSY_RETRY_ATTEMPTS", "5") or "5")
 DEFAULT_SQLITE_BUSY_RETRY_DELAY_SECONDS = float(os.environ.get("NEXO_LOCAL_CONTEXT_BUSY_RETRY_DELAY_SECONDS", "0.35") or "0.35")
 DEFAULT_HYGIENE_QUICK_SCAN_LIMIT = int(os.environ.get("NEXO_LOCAL_INDEX_HYGIENE_QUICK_SCAN_LIMIT", "5000") or "5000")
+LOCAL_CONTEXT_DEFAULT_MAX_DB_BYTES = 60 * 1024 ** 3
+LOCAL_CONTEXT_DEFAULT_MIN_FREE_BYTES = 5 * 1024 ** 3
 INITIAL_INDEX_COMPLETE_KEY = "initial_index_complete"
 INITIAL_INDEX_STARTED_AT_KEY = "initial_index_started_at"
 PERFORMANCE_PROFILE_KEY = "performance_profile"
@@ -1845,6 +1847,73 @@ def _is_paused_conn(conn) -> bool:
     return _get_state_conn(conn, "paused", "0") == "1"
 
 
+def _local_context_storage_bytes(db_path: Path | None = None) -> int:
+    db = Path(db_path or local_context_db_path())
+    total = 0
+    for candidate in (db, Path(str(db) + "-wal"), Path(str(db) + "-shm")):
+        try:
+            total += int(candidate.stat().st_size)
+        except OSError:
+            pass
+    return total
+
+
+def _local_context_disk_budget() -> dict:
+    db_path = Path(local_context_db_path())
+    max_bytes = paths.parse_size_bytes(
+        os.environ.get("NEXO_LOCAL_CONTEXT_MAX_DB_BYTES"),
+        default=LOCAL_CONTEXT_DEFAULT_MAX_DB_BYTES,
+    )
+    min_free_bytes = paths.parse_size_bytes(
+        os.environ.get("NEXO_LOCAL_CONTEXT_MIN_FREE_BYTES"),
+        default=LOCAL_CONTEXT_DEFAULT_MIN_FREE_BYTES,
+    )
+    db_bytes = _local_context_storage_bytes(db_path)
+    try:
+        probe = db_path.parent if db_path.parent.exists() else paths.memory_dir()
+        free_bytes = int(shutil.disk_usage(str(probe)).free)
+    except Exception:
+        free_bytes = None
+
+    reason = ""
+    if max_bytes > 0 and db_bytes > max_bytes:
+        reason = "local_context_db_too_large"
+    elif min_free_bytes > 0 and free_bytes is not None and free_bytes < min_free_bytes:
+        reason = "disk_free_below_floor"
+    return {
+        "ok": not reason,
+        "paused": bool(reason),
+        "reason": reason,
+        "db_path": str(db_path),
+        "db_bytes": db_bytes,
+        "max_bytes": max_bytes,
+        "free_bytes": free_bytes,
+        "min_free_bytes": min_free_bytes,
+    }
+
+
+def enforce_local_context_disk_budget() -> dict:
+    budget = _local_context_disk_budget()
+    if budget["ok"]:
+        return budget
+    try:
+        _set_state("paused", "1")
+        _set_state("pause_reason", str(budget["reason"]))
+        log_event(
+            "warn",
+            "index_paused_disk_budget",
+            "Local memory indexing paused to protect disk space",
+            reason=budget["reason"],
+            db_bytes=budget["db_bytes"],
+            max_bytes=budget["max_bytes"],
+            free_bytes=budget["free_bytes"],
+            min_free_bytes=budget["min_free_bytes"],
+        )
+    except Exception as exc:
+        budget["pause_error"] = type(exc).__name__
+    return budget
+
+
 def _allow_explicit_blocked_root(path: str) -> bool:
     # Test and controlled diagnostics may explicitly index a temporary fixture
     # root while production root discovery still skips temp/system trees.
@@ -3332,6 +3401,33 @@ def run_once(
     live_dir_limit: int | None = None,
     live_file_limit: int | None = None,
 ) -> dict:
+    disk_budget = enforce_local_context_disk_budget()
+    if disk_budget.get("paused"):
+        config = performance_config()
+        return {
+            "ok": True,
+            "paused": True,
+            "disk_budget": disk_budget,
+            "initial_scan": {
+                "complete": False,
+                "mode": "paused",
+                "pending_roots": 0,
+                "total_roots": 0,
+                "checkpoint_count": 0,
+            },
+            "initial_index_complete": False,
+            "live": {"ok": True, "paused": True, "assets": {}, "dirs": {}},
+            "scan": {"ok": True, "paused": True, "roots": 0, "seen": 0, "changed": 0, "errors": 0, "partial": False},
+            "jobs": {"ok": True, "paused": True, "processed": 0, "failed": 0},
+            "performance": {
+                "profile": config["profile"],
+                "scan_limit": 0,
+                "process_limit": 0,
+                "live_asset_limit": 0,
+                "live_dir_limit": 0,
+                "live_file_limit": 0,
+            },
+        }
     if _get_state("privacy_hygiene_v2", "0") != "1":
         local_index_privacy_hygiene(fix=True)
         _set_state("privacy_hygiene_v2", "1")
@@ -3832,6 +3928,21 @@ def _status_from_conn(conn, *, readonly: bool = False) -> dict:
     service["state"] = "paused" if paused else ("attention" if problem else ("idle" if active_jobs == 0 and initial_index_complete else "indexing"))
     performance = performance_config(conn=conn)
     problems = _problem_rows(conn)
+    disk_budget = _local_context_disk_budget()
+    if not disk_budget["ok"]:
+        problems.insert(0, {
+            "user_message": "Local memory indexing is paused to protect disk space",
+            "message_key": "local_context.disk_budget.paused",
+            "recommended_action": "Review local memory size and free disk space",
+            "recommended_action_key": "local_context.disk_budget.review",
+            "technical_detail": json_dumps(disk_budget),
+            "support_code": "LOCAL_CONTEXT_DISK_BUDGET",
+            "severity": "warning",
+            "retryable": True,
+            "path": disk_budget["db_path"],
+            "phase": "storage",
+            "created_at": now(),
+        })
     if problem:
         problems.insert(0, {
             "user_message": problem["user_message"],
@@ -3881,6 +3992,7 @@ def _status_from_conn(conn, *, readonly: bool = False) -> dict:
             "performance_profile": performance["profile"],
         },
         "performance": performance,
+        "disk_budget": disk_budget,
         "initial_scan": initial_scan,
         "initial_index_complete": bool(initial_index_complete),
         "volumes": volumes,

package/src/paths.py

@@ -515,8 +515,8 @@ def aggressive_runtime_backup_prune(
 ) -> dict:
     """Escalate NEXO-owned backup pruning before any user-facing disk alert.
 
-    Escalation never targets protected business/hourly backup classes; the
-    pruner enforces that policy.
+    Escalation never targets protected business/weekly restore classes. Hourly
+    DB dumps are pruned only down to their configured restore floor.
     """
     root = Path(backups_root or backups_dir())
     floor = int(min_free_bytes if min_free_bytes is not None else backup_min_free_bytes())

package/src/plugins/schedule.py

@@ -384,7 +384,71 @@ def _runtime_command(script_type: str) -> str:
     return "python3"
 
 
-def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds, description, script_type, label="", plist_path="", keep_alive: bool = False):
+def _declared_schedule_payload(declared: dict | None) -> dict:
+    declared = declared or {}
+    raw = str(declared.get("schedule_value") or "").strip()
+    if not raw.startswith("{"):
+        return {}
+    try:
+        payload = json.loads(raw)
+    except Exception:
+        return {}
+    return payload if isinstance(payload, dict) else {}
+
+
+def _calendar_from_schedule(schedule: str, declared: dict | None = None) -> dict:
+    payload = _declared_schedule_payload(declared)
+    if payload:
+        freq = str(payload.get("freq") or "")
+        cal = {"Hour": int(payload.get("hour")), "Minute": int(payload.get("minute"))}
+        if freq == "weekly":
+            cal["Weekday"] = int(payload.get("weekday"))
+        elif freq == "monthly":
+            cal["Day"] = int(payload.get("day"))
+        return cal
+
+    parts = str(schedule or "").split(":")
+    cal = {"Hour": int(parts[0]), "Minute": int(parts[1])}
+    if len(parts) > 2:
+        cal["Weekday"] = int(parts[2])
+    return cal
+
+
+def _systemd_calendar_from_schedule(schedule: str, declared: dict | None = None) -> str:
+    payload = _declared_schedule_payload(declared)
+    if payload:
+        freq = str(payload.get("freq") or "")
+        hour = int(payload.get("hour"))
+        minute = int(payload.get("minute"))
+        if freq == "weekly":
+            days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
+            return f"OnCalendar={days[int(payload.get('weekday'))]} *-*-* {hour:02d}:{minute:02d}:00"
+        if freq == "monthly":
+            return f"OnCalendar=*-*-{int(payload.get('day')):02d} {hour:02d}:{minute:02d}:00"
+        return f"OnCalendar=*-*-* {hour:02d}:{minute:02d}:00"
+
+    parts = str(schedule or "").split(":")
+    hour, minute = int(parts[0]), int(parts[1])
+    if len(parts) > 2:
+        days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
+        return f"OnCalendar={days[int(parts[2])]} *-*-* {hour:02d}:{minute:02d}:00"
+    return f"OnCalendar=*-*-* {hour:02d}:{minute:02d}:00"
+
+
+def _schedule_gate_env(declared: dict | None = None) -> dict:
+    payload = _declared_schedule_payload(declared)
+    if not payload:
+        return {}
+    env = {
+        "NEXO_SCHEDULE_FREQ": str(payload.get("freq") or ""),
+        "NEXO_SCHEDULE_AT": str(payload.get("at") or ""),
+    }
+    if payload.get("freq") == "every_n_days":
+        env["NEXO_SCHEDULE_EVERY_DAYS"] = str(int(payload.get("every_days") or 0))
+    return {key: value for key, value in env.items() if value}
+
+
+def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds, description, script_type, label="", plist_path="", keep_alive: bool = False, declared: dict | None = None):
     init_db()
     script_meta = parse_inline_metadata(Path(script_path))
     runtime = classify_runtime(Path(script_path), script_meta)
@@ -398,7 +462,12 @@ def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds
         source="filesystem",
         has_inline_metadata=bool(script_meta),
     )
-    if keep_alive:
+    declared = declared or {}
+    if declared.get("valid") and declared.get("schedule_type"):
+        schedule_type = str(declared.get("schedule_type") or "")
+        schedule_value = str(declared.get("schedule_value") or "")
+        schedule_label = str(declared.get("schedule_label") or "")
+    elif keep_alive:
         schedule_type = "keep_alive"
         schedule_value = "true"
         schedule_label = "keep alive"
@@ -452,6 +521,7 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
             "PATH": resolve_launchagent_path(),
             PERSONAL_SCHEDULE_MANAGED_ENV: "1",
             "NEXO_PERSONAL_CRON_ID": cron_id,
+            **_schedule_gate_env(declared),
         },
     }
 
@@ -460,11 +530,7 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
     elif interval_seconds:
         plist["StartInterval"] = interval_seconds
     elif schedule:
-        parts = schedule.split(":")
-        cal = {"Hour": int(parts[0]), "Minute": int(parts[1])}
-        if len(parts) > 2:
-            cal["Weekday"] = int(parts[2])
-        plist["StartCalendarInterval"] = cal
+        plist["StartCalendarInterval"] = _calendar_from_schedule(schedule, declared)
 
     declared = declared or {}
     if declared.get("run_on_boot") or (keep_alive and "run_on_boot" not in declared):
@@ -485,6 +551,7 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
         label=label,
         plist_path=str(plist_path),
         keep_alive=keep_alive,
+        declared=declared,
     )
 
     if keep_alive:
@@ -517,6 +584,8 @@ Environment=HOME={Path.home()}
 Environment={PERSONAL_SCHEDULE_MANAGED_ENV}=1
 Environment=NEXO_PERSONAL_CRON_ID={cron_id}
 """
+    for key, value in _schedule_gate_env(declared).items():
+        service_content += f"Environment={key}={value}\n"
     service_path = unit_dir / f"nexo-{cron_id}.service"
     service_path.write_text(service_content)
 
@@ -535,10 +604,10 @@ Environment=NEXO_HOME={nexo_home}
 Environment=HOME={Path.home()}
 Environment={PERSONAL_SCHEDULE_MANAGED_ENV}=1
 Environment=NEXO_PERSONAL_CRON_ID={cron_id}
-
-[Install]
-WantedBy=default.target
 """
+        for key, value in _schedule_gate_env(declared).items():
+            service_content += f"Environment={key}={value}\n"
+        service_content += "\n[Install]\nWantedBy=default.target\n"
         service_path = unit_dir / f"nexo-{cron_id}.service"
         service_path.write_text(service_content)
 
@@ -555,6 +624,7 @@ WantedBy=default.target
             label=f"nexo-{cron_id}",
             plist_path="",
             keep_alive=True,
+            declared=declared,
         )
 
         return f"Cron '{cron_id}' installed as KeepAlive systemd service and enabled. Service: {service_path}"
@@ -565,14 +635,7 @@ WantedBy=default.target
         if declared.get("run_on_boot") or not declared.get("required"):
             timer_spec += "\nOnBootSec=60s"
     elif schedule:
-        parts = schedule.split(":")
-        hour, minute = int(parts[0]), int(parts[1])
-        if len(parts) > 2:
-            days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
-            day = days[int(parts[2])]
-            timer_spec = f"OnCalendar={day} *-*-* {hour:02d}:{minute:02d}:00"
-        else:
-            timer_spec = f"OnCalendar=*-*-* {hour:02d}:{minute:02d}:00"
+        timer_spec = _systemd_calendar_from_schedule(schedule, declared)
     else:
         return "ERROR: no schedule or interval"
 
@@ -602,6 +665,7 @@ WantedBy=timers.target
         label=f"nexo-{cron_id}",
         plist_path="",
         keep_alive=False,
+        declared=declared,
     )
 
     return f"Cron '{cron_id}' installed as systemd timer and enabled. Service: {service_path}, Timer: {timer_path}"

package/src/script_registry.py

@@ -83,6 +83,9 @@ METADATA_KEYS = {
     "category",
     "cron_id",
     "schedule",
+    "schedule_freq",
+    "schedule_at",
+    "schedule_day",
     "interval_seconds",
     "schedule_required",
     "recovery_policy",
@@ -125,6 +128,9 @@ METADATA_WRITE_ORDER = [
     "cron_id",
     "schedule_required",
     "schedule",
+    "schedule_freq",
+    "schedule_at",
+    "schedule_day",
     "interval_seconds",
     "recovery_policy",
     "run_on_boot",
@@ -160,6 +166,8 @@ _SCHEDULE_WEEKDAY_PREFIX_RE = re.compile(
     r"^weekday\s*=\s*(?P<weekday>\d)\s+(?P<hour>\d{1,2}):(?P<minute>\d{2})$",
     re.IGNORECASE,
 )
+_SCHEDULE_AT_RE = re.compile(r"^(?P<hour>\d{1,2}):(?P<minute>\d{2})$")
+SUPPORTED_ANCHORED_SCHEDULE_FREQS = {"daily", "weekly", "monthly", "every_n_days"}
 _LEGACY_CORE_SCRIPT_ALIASES = {
     "nexo-postcompact.sh": "post-compact.sh",
     "nexo-memory-precompact.sh": "pre-compact.sh",
@@ -415,6 +423,12 @@ def _normalize_metadata_value(key: str, value: str) -> str:
         return _normalize_runtime_metadata(value)
     if key == "schedule":
         return _normalize_schedule_metadata(value)
+    if key == "schedule_freq":
+        return str(value or "").strip().lower().replace("-", "_")
+    if key == "schedule_at":
+        return _normalize_schedule_at_metadata(value)
+    if key == "schedule_day":
+        return str(value or "").strip()
     return value
 
 
@@ -440,6 +454,35 @@ def _normalize_schedule_metadata(value: str) -> str:
     return candidate
 
 
+def _normalize_schedule_at_metadata(value: str) -> str:
+    candidate = str(value or "").strip()
+    match = _SCHEDULE_AT_RE.match(candidate)
+    if not match:
+        return candidate
+    try:
+        hour = int(match.group("hour"))
+        minute = int(match.group("minute"))
+    except ValueError:
+        return candidate
+    if 0 <= hour <= 23 and 0 <= minute <= 59:
+        return f"{hour:02d}:{minute:02d}"
+    return candidate
+
+
+def _parse_schedule_at(value: str) -> tuple[int, int] | None:
+    match = _SCHEDULE_AT_RE.match(str(value or "").strip())
+    if not match:
+        return None
+    try:
+        hour = int(match.group("hour"))
+        minute = int(match.group("minute"))
+    except ValueError:
+        return None
+    if 0 <= hour <= 23 and 0 <= minute <= 59:
+        return hour, minute
+    return None
+
+
 def _detect_shebang(path: Path) -> str | None:
     """Read first line for shebang."""
     try:
@@ -563,13 +606,17 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
     cron_id = explicit_cron_id or _safe_slug(default_name or explicit_name or "script")
     interval_raw = metadata.get("interval_seconds", "").strip()
     schedule_raw = metadata.get("schedule", "").strip()
+    schedule_freq_raw = metadata.get("schedule_freq", "").strip().lower().replace("-", "_")
+    schedule_at_raw = metadata.get("schedule_at", "").strip()
+    schedule_day_raw = metadata.get("schedule_day", "").strip()
+    anchored_raw_present = bool(schedule_freq_raw or schedule_at_raw or schedule_day_raw)
     schedule_required = _truthy(metadata.get("schedule_required"))
     recovery_policy_raw = metadata.get("recovery_policy", "").strip().lower()
     run_on_boot = _truthy(metadata.get("run_on_boot"))
     run_on_wake = _truthy(metadata.get("run_on_wake"))
     idempotent = _truthy(metadata.get("idempotent"))
     max_catchup_age_raw = metadata.get("max_catchup_age", "").strip()
-    required = schedule_required or bool(interval_raw or schedule_raw)
+    required = schedule_required or bool(interval_raw or schedule_raw or anchored_raw_present)
 
     if recovery_policy_raw and recovery_policy_raw not in SUPPORTED_RECOVERY_POLICIES:
         return {
@@ -638,11 +685,12 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
             return idempotent
         return policy in {"catchup", "run_once_on_wake", "restart", "restart_daemon"}
 
-    if interval_raw and schedule_raw:
+    configured_modes = sum(bool(value) for value in (interval_raw, schedule_raw, anchored_raw_present))
+    if configured_modes > 1:
         return {
             "required": required,
             "valid": False,
-            "error": "Both schedule and interval_seconds are set; choose one.",
+            "error": "Choose only one schedule mode: schedule, interval_seconds, or schedule_freq/schedule_at.",
             "cron_id": cron_id,
         }
 
@@ -679,6 +727,101 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
             "max_catchup_age": max_catchup_age or max(interval * 4, interval + 900),
         }
 
+    if anchored_raw_present:
+        freq = schedule_freq_raw
+        if freq not in SUPPORTED_ANCHORED_SCHEDULE_FREQS:
+            return {
+                "required": required,
+                "valid": False,
+                "error": f"Invalid schedule_freq: {schedule_freq_raw or '(missing)'}",
+                "cron_id": cron_id,
+            }
+        parsed_at = _parse_schedule_at(schedule_at_raw)
+        if parsed_at is None:
+            return {
+                "required": required,
+                "valid": False,
+                "error": f"Invalid schedule_at: {schedule_at_raw or '(missing)'}",
+                "cron_id": cron_id,
+            }
+        hour, minute = parsed_at
+        day: int | None = None
+        if freq in {"weekly", "monthly", "every_n_days"}:
+            try:
+                day = int(schedule_day_raw)
+            except ValueError:
+                return {
+                    "required": required,
+                    "valid": False,
+                    "error": f"Invalid schedule_day: {schedule_day_raw or '(missing)'}",
+                    "cron_id": cron_id,
+                }
+        if freq == "weekly" and not (day is not None and 0 <= day <= 6):
+            return {
+                "required": required,
+                "valid": False,
+                "error": f"schedule_day for weekly schedules must be 0-6 (got {schedule_day_raw})",
+                "cron_id": cron_id,
+            }
+        if freq == "monthly" and not (day is not None and 1 <= day <= 28):
+            return {
+                "required": required,
+                "valid": False,
+                "error": f"schedule_day for monthly schedules must be 1-28 (got {schedule_day_raw})",
+                "cron_id": cron_id,
+            }
+        if freq == "every_n_days" and not (day is not None and 1 <= day <= 31):
+            return {
+                "required": required,
+                "valid": False,
+                "error": f"schedule_day for every_n_days schedules must be 1-31 (got {schedule_day_raw})",
+                "cron_id": cron_id,
+            }
+        at = f"{hour:02d}:{minute:02d}"
+        payload = {
+            "freq": freq,
+            "at": at,
+            "hour": hour,
+            "minute": minute,
+        }
+        if freq == "weekly":
+            payload["weekday"] = day
+            schedule = f"{at}:{day}"
+            label = f"weekly weekday={day} {at}"
+            max_age = 14 * 86400
+        elif freq == "monthly":
+            payload["day"] = day
+            schedule = at
+            label = f"monthly day={day} {at}"
+            max_age = 45 * 86400
+        elif freq == "every_n_days":
+            payload["every_days"] = day
+            schedule = at
+            label = f"every {day}d {at}"
+            max_age = max((day or 1) * 86400 + 48 * 3600, 72 * 3600)
+        else:
+            schedule = at
+            label = f"{at} daily"
+            max_age = 48 * 3600
+        return {
+            "required": required,
+            "valid": True,
+            "cron_id": cron_id,
+            "schedule_type": "calendar",
+            "schedule_value": json.dumps(payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False),
+            "schedule_label": label,
+            "schedule": schedule,
+            "schedule_freq": freq,
+            "schedule_at": at,
+            "schedule_day": day or 0,
+            "interval_seconds": 0,
+            "recovery_policy": recovery_policy_raw or "catchup",
+            "run_on_boot": _effective_run_on_boot(recovery_policy_raw or "catchup"),
+            "run_on_wake": _effective_run_on_wake(recovery_policy_raw or "catchup"),
+            "idempotent": _effective_idempotent(recovery_policy_raw or "catchup"),
+            "max_catchup_age": max_catchup_age or max_age,
+        }
+
     if schedule_raw:
         parts = schedule_raw.split(":")
         if len(parts) not in {2, 3}:
@@ -1122,6 +1265,9 @@ def _format_schedule_from_plist(plist_data: dict) -> tuple[str, str, str]:
         hour = cal.get("Hour")
         minute = cal.get("Minute")
         weekday = cal.get("Weekday")
+        day = cal.get("Day")
+        if day is not None and hour is not None and minute is not None:
+            return "calendar", json.dumps(cal, ensure_ascii=False), f"{hour:02d}:{minute:02d} day={day}"
         if weekday is not None and hour is not None and minute is not None:
             return "calendar", json.dumps(cal, ensure_ascii=False), f"{hour:02d}:{minute:02d} weekday={weekday}"
         if hour is not None and minute is not None:
@@ -1131,6 +1277,27 @@ def _format_schedule_from_plist(plist_data: dict) -> tuple[str, str, str]:
     return "manual", "", ""
 
 
+def _anchored_schedule_payload(schedule_value: str | dict | list | None) -> dict | None:
+    if isinstance(schedule_value, dict):
+        payload = schedule_value
+    elif isinstance(schedule_value, str) and schedule_value.lstrip().startswith("{"):
+        try:
+            payload = json.loads(schedule_value)
+        except Exception:
+            return None
+    else:
+        return None
+    if not isinstance(payload, dict):
+        return None
+    freq = str(payload.get("freq") or "").strip()
+    if freq not in SUPPORTED_ANCHORED_SCHEDULE_FREQS:
+        return None
+    at = str(payload.get("at") or "").strip()
+    if _parse_schedule_at(at) is None:
+        return None
+    return payload
+
+
 def _calendar_payload_from_declared(schedule_value: str) -> dict | list | None:
     if not schedule_value:
         return None
@@ -1178,6 +1345,9 @@ def _compact_schedule_from_record(record: dict) -> str:
     if raw.lstrip().startswith("{") or raw.lstrip().startswith("["):
         with contextlib.suppress(Exception):
             payload = json.loads(raw)
+    anchored = _anchored_schedule_payload(payload)
+    if anchored:
+        return str(anchored.get("at") or "")
     if isinstance(payload, list):
         if len(payload) == 1 and isinstance(payload[0], dict):
             payload = payload[0]
@@ -1243,10 +1413,25 @@ def _inferred_schedule_metadata_lines(path: Path, metadata: dict, record: dict)
         lines.append(f"{prefix} nexo: interval_seconds={interval}")
         lines.append(f"{prefix} nexo: recovery_policy=run_once_on_wake")
     elif schedule_type == "calendar":
-        compact_schedule = _compact_schedule_from_record(record)
-        if not compact_schedule:
-            return None
-        lines.append(f"{prefix} nexo: schedule={compact_schedule}")
+        anchored = _anchored_schedule_payload(record.get("schedule_value"))
+        if anchored:
+            freq = str(anchored.get("freq") or "")
+            at = str(anchored.get("at") or "")
+            if freq == "weekly":
+                day = anchored.get("weekday")
+            elif freq == "every_n_days":
+                day = anchored.get("every_days")
+            else:
+                day = anchored.get("day")
+            lines.append(f"{prefix} nexo: schedule_freq={freq}")
+            lines.append(f"{prefix} nexo: schedule_at={at}")
+            if freq in {"weekly", "monthly", "every_n_days"}:
+                lines.append(f"{prefix} nexo: schedule_day={day}")
+        else:
+            compact_schedule = _compact_schedule_from_record(record)
+            if not compact_schedule:
+                return None
+            lines.append(f"{prefix} nexo: schedule={compact_schedule}")
         lines.append(f"{prefix} nexo: recovery_policy=catchup")
     elif schedule_type == "keep_alive":
         lines.append(f"{prefix} nexo: recovery_policy=restart_daemon")
@@ -1336,6 +1521,18 @@ def _is_agent_archived(metadata: dict | None) -> bool:
 
 
 def _format_agent_calendar_value(raw: str) -> tuple[str, str]:
+    payload = _anchored_schedule_payload(raw)
+    if payload:
+        at = str(payload.get("at") or "")
+        freq = str(payload.get("freq") or "")
+        if freq == "weekly":
+            return at, f"weekly weekday={int(payload.get('weekday'))} {at}"
+        if freq == "monthly":
+            return at, f"monthly day={int(payload.get('day'))} {at}"
+        if freq == "every_n_days":
+            return at, f"every {int(payload.get('every_days'))}d {at}"
+        return at, f"{at} daily"
+
     compact = _compact_schedule_from_record({
         "schedule_type": "calendar",
         "schedule_value": raw,
@@ -1357,6 +1554,30 @@ def _format_agent_calendar_value(raw: str) -> tuple[str, str]:
     return compact, f"{hour:02d}:{minute:02d} daily"
 
 
+def _agent_anchored_schedule_fields(schedule_value: str | dict | list | None) -> dict:
+    payload = _anchored_schedule_payload(schedule_value)
+    if not payload:
+        return {
+            "schedule_freq": "",
+            "schedule_at": "",
+            "schedule_day": 0,
+        }
+    freq = str(payload.get("freq") or "")
+    if freq == "weekly":
+        day = int(payload.get("weekday"))
+    elif freq == "monthly":
+        day = int(payload.get("day"))
+    elif freq == "every_n_days":
+        day = int(payload.get("every_days"))
+    else:
+        day = 0
+    return {
+        "schedule_freq": freq,
+        "schedule_at": str(payload.get("at") or ""),
+        "schedule_day": day,
+    }
+
+
 def _agent_schedule_from_script(script: dict) -> dict:
     schedules = script.get("schedules") if isinstance(script.get("schedules"), list) else []
     if schedules:
@@ -1372,6 +1593,7 @@ def _agent_schedule_from_script(script: dict) -> dict:
         elif schedule_type == "calendar":
             daily_at, formatted = _format_agent_calendar_value(schedule_value)
             label = formatted or label
+        anchored_fields = _agent_anchored_schedule_fields(schedule_value)
         return {
             "schedule_type": schedule_type,
             "schedule_value": schedule_value,
@@ -1379,6 +1601,7 @@ def _agent_schedule_from_script(script: dict) -> dict:
             "effective_schedule_label": label,
             "interval_seconds": interval_seconds,
             "daily_at": daily_at,
+            **anchored_fields,
             "cron_id": str(schedule.get("cron_id") or ""),
             "schedule_source": "runtime",
             "schedules": schedules,
@@ -1394,6 +1617,9 @@ def _agent_schedule_from_script(script: dict) -> dict:
             "effective_schedule_label": str(declared.get("schedule_label") or ""),
             "interval_seconds": int(declared.get("interval_seconds", 0) or 0),
             "daily_at": str(declared.get("schedule") or ""),
+            "schedule_freq": str(declared.get("schedule_freq") or ""),
+            "schedule_at": str(declared.get("schedule_at") or ""),
+            "schedule_day": int(declared.get("schedule_day", 0) or 0),
             "cron_id": str(declared.get("cron_id") or ""),
             "schedule_source": "metadata",
             "schedules": [],
@@ -1406,6 +1632,9 @@ def _agent_schedule_from_script(script: dict) -> dict:
         "effective_schedule_label": "",
         "interval_seconds": 0,
         "daily_at": "",
+        "schedule_freq": "",
+        "schedule_at": "",
+        "schedule_day": 0,
         "cron_id": str(metadata.get("cron_id") or script.get("name") or ""),
         "schedule_source": "",
         "schedules": [],
@@ -1579,6 +1808,9 @@ def set_agent_schedule(
     *,
     interval_seconds: int | None = None,
     daily_at: str | None = None,
+    schedule_freq: str | None = None,
+    schedule_at: str | None = None,
+    schedule_day: int | str | None = None,
     clear: bool = False,
 ) -> dict:
     status = get_agent_status(name_or_path)
@@ -1592,7 +1824,18 @@ def set_agent_schedule(
     if runtime == "unknown":
         runtime = "shell" if path.suffix.lower() == ".sh" else "python"
 
-    remove = {"schedule", "interval_seconds", "recovery_policy", "run_on_boot", "run_on_wake", "idempotent", "max_catchup_age"}
+    remove = {
+        "schedule",
+        "schedule_freq",
+        "schedule_at",
+        "schedule_day",
+        "interval_seconds",
+        "recovery_policy",
+        "run_on_boot",
+        "run_on_wake",
+        "idempotent",
+        "max_catchup_age",
+    }
     updates = {
         "agent": "true",
         "name": metadata.get("name") or agent.get("name") or _logical_personal_script_name(path.stem),
@@ -1615,6 +1858,11 @@ def set_agent_schedule(
             "agent": refreshed.get("agent") if refreshed.get("ok") else agent,
         }
 
+    anchored_requested = bool(schedule_freq or schedule_at or schedule_day is not None)
+    mode_count = sum(bool(value) for value in (interval_seconds is not None, bool(daily_at), anchored_requested))
+    if mode_count > 1:
+        return {"ok": False, "error": "Choose interval_seconds, daily_at, or schedule_freq/schedule_at."}
+
     if interval_seconds is not None:
         try:
             interval = int(interval_seconds)
@@ -1627,6 +1875,17 @@ def set_agent_schedule(
             "interval_seconds": str(interval),
             "recovery_policy": "run_once_on_wake",
         })
+    elif anchored_requested:
+        freq = str(schedule_freq or "").strip().lower().replace("-", "_")
+        at = _normalize_schedule_at_metadata(str(schedule_at or "").strip())
+        updates.update({
+            "schedule_required": "true",
+            "schedule_freq": freq,
+            "schedule_at": at,
+            "recovery_policy": "catchup",
+        })
+        if schedule_day is not None:
+            updates["schedule_day"] = str(schedule_day)
     elif daily_at:
         schedule_value = _normalize_schedule_metadata(str(daily_at).strip())
         updates.update({
@@ -1635,7 +1894,7 @@ def set_agent_schedule(
             "recovery_policy": "catchup",
         })
     else:
-        return {"ok": False, "error": "Choose interval_seconds, daily_at, or clear=true"}
+        return {"ok": False, "error": "Choose interval_seconds, daily_at, schedule_freq/schedule_at, or clear=true"}
 
     candidate_metadata = dict(metadata)
     for key in remove:
@@ -1660,6 +1919,7 @@ def set_agent_schedule(
         "ok": not ensure_error,
         "name": agent["name"],
         "cron_id": cron_id,
+        "declared_schedule": declared,
         "error": ensure_error,
         "removed": removed,
         "ensure_schedules": ensured,
@@ -1860,6 +2120,15 @@ def _discover_personal_schedule_records() -> list[dict]:
             continue
 
         schedule_type, schedule_value, schedule_label = _format_schedule_from_plist(plist_data)
+        managed_marker = env.get(PERSONAL_SCHEDULE_MANAGED_ENV) == "1"
+        if managed_marker and exists and script_path is not None:
+            with contextlib.suppress(Exception):
+                meta = parse_inline_metadata(script_path)
+                declared = get_declared_schedule(meta, meta.get("name", script_path.stem))
+                if declared.get("valid") and declared.get("cron_id") == cron_id:
+                    schedule_type = str(declared.get("schedule_type") or schedule_type)
+                    schedule_value = str(declared.get("schedule_value") or schedule_value)
+                    schedule_label = str(declared.get("schedule_label") or schedule_label)
         results.append({
             "cron_id": cron_id,
             "script_path": str(script_path) if script_path else "",
@@ -1871,7 +2140,7 @@ def _discover_personal_schedule_records() -> list[dict]:
             "plist_path": str(plist_path),
             "enabled": True,
             "description": "",
-            "managed_marker": env.get(PERSONAL_SCHEDULE_MANAGED_ENV) == "1",
+            "managed_marker": managed_marker,
             "script_exists": exists,
             "script_within_scripts_dir": in_scripts_dir,
         })

package/src/scripts/nexo-backup.sh

@@ -59,7 +59,12 @@ cleanup_backups() {
         PRUNER="$(dirname "$0")/prune_runtime_backups.py"
     fi
     if [ -f "$PRUNER" ]; then
-        python3 "$PRUNER" --root "$BACKUP_DIR" --apply --max-bytes "$BACKUP_MAX_BYTES" >/dev/null 2>&1 || true
+        python3 "$PRUNER" \
+            --root "$BACKUP_DIR" \
+            --apply \
+            --max-bytes "$BACKUP_MAX_BYTES" \
+            --hourly-keep "$KEEP_LAST" \
+            --local-context-keep "$LOCAL_CONTEXT_KEEP_LAST" >/dev/null 2>&1 || true
     fi
 
     python3 - "$BACKUP_DIR" "$RETENTION_HOURS" "$KEEP_LAST" "$FAMILY_KEEP_LAST" "$LOCAL_CONTEXT_RETENTION_HOURS" "$LOCAL_CONTEXT_KEEP_LAST" <<'PY'

package/src/scripts/nexo-cron-wrapper.sh

@@ -331,6 +331,73 @@ if [ "$DISABLED_GATE_OUTPUT" = "disabled" ]; then
     exit 0
 fi
 
+if [ "${NEXO_SCHEDULE_FREQ:-}" = "every_n_days" ] && [ -n "${NEXO_SCHEDULE_EVERY_DAYS:-}" ]; then
+    EVERY_N_DAYS_GATE_OUTPUT=$(python3 - "$DB" "$CRON_ID" "$NEXO_SCHEDULE_EVERY_DAYS" <<'PYGATE' 2>/dev/null || true
+from __future__ import annotations
+from datetime import datetime, timezone
+import sqlite3
+import sys
+
+db_path, cron_id, every_days_raw = sys.argv[1:]
+try:
+    every_days = int(every_days_raw)
+except ValueError:
+    sys.exit(0)
+if every_days <= 1:
+    sys.exit(0)
+try:
+    row = None
+    conn = sqlite3.connect(db_path)
+    row = conn.execute(
+        """
+        SELECT started_at
+          FROM cron_runs
+         WHERE cron_id = ?
+           AND ended_at IS NOT NULL
+           AND exit_code = 0
+           AND COALESCE(summary, '') NOT LIKE '[schedule-gate]%'
+           AND COALESCE(summary, '') NOT LIKE '[disabled]%'
+         ORDER BY started_at DESC, id DESC
+         LIMIT 1
+        """,
+        (cron_id,),
+    ).fetchone()
+except Exception:
+    sys.exit(0)
+finally:
+    try:
+        conn.close()
+    except Exception:
+        pass
+if row is None or not row[0]:
+    sys.exit(0)
+raw = str(row[0])
+try:
+    last = datetime.strptime(raw[:19], "%Y-%m-%d %H:%M:%S").replace(tzinfo=timezone.utc)
+except ValueError:
+    try:
+        last = datetime.fromisoformat(raw.replace("Z", "+00:00"))
+    except ValueError:
+        sys.exit(0)
+    if last.tzinfo is None:
+        last = last.replace(tzinfo=timezone.utc)
+elapsed = (datetime.now(timezone.utc) - last.astimezone(timezone.utc)).total_seconds()
+if elapsed < every_days * 86400:
+    remaining_hours = max(1, int(((every_days * 86400) - elapsed + 3599) // 3600))
+    print(f"skip\tlast={raw}\tremaining_hours={remaining_hours}")
+PYGATE
+)
+    if [ -n "$EVERY_N_DAYS_GATE_OUTPUT" ]; then
+        EXIT_CODE=0
+        SIGNAL_NAME=""
+        : > "$OUTPUT_FILE"
+        echo "[schedule-gate] $CRON_ID skipped - every ${NEXO_SCHEDULE_EVERY_DAYS} days (${EVERY_N_DAYS_GATE_OUTPUT})" > "$OUTPUT_FILE"
+        finalize_row
+        cleanup
+        exit 0
+    fi
+fi
+
 "$@" > "$OUTPUT_FILE" 2>&1 &
 CHILD_PID=$!
 

package/src/scripts/prune_runtime_backups.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # nexo: name=prune-runtime-backups
-# nexo: description=Rotate technical rollback snapshots under runtime/backups by family. Never touches business (shopify-backups) or hourly_db (nexo-backup.sh) artifacts.
+# nexo: description=Rotate runtime/backups by class, including hourly DB dumps under a bounded restore policy.
 # nexo: category=maintenance
 # nexo: runtime=python
 # nexo: timeout=300
@@ -10,9 +10,9 @@
 prune_runtime_backups.py — NEXO backup retention by class.
 
 Separates *technical* rollback snapshots (throwaway, produced by the installer,
-updater and backfills) from *operational* snapshots (shopify-backups, hourly
-DB dumps, weekly archives) so the former can be rotated without risk to the
-latter.
+updater and backfills) from protected business/weekly restore points. Hourly
+DB dumps and local memory DB dumps are product-generated runtime artifacts and
+are rotated here with explicit minimum restore counts plus a global cap.
 
 Target: $NEXO_HOME/runtime/backups/ (default ~/.nexo/runtime/backups)
 
@@ -38,8 +38,8 @@ Class taxonomy (prefix-based) and retention policy:
 
   HOURLY_DB (sqlite dumps, managed by nexo-backup.sh):
     Prefix: nexo-YYYY-MM-DD-HHMM.db in runtime/backups/ root
-    These are already rotated by nexo-backup.sh (48h retention). We skip
-    them here to avoid double-rotation logic.
+    Retention: keep --hourly-keep newest unconditionally; older dumps are
+    pruned and may also be budget-pruned down to the same minimum.
 
   WEEKLY_DB (weekly/ directory):
     Already rotated by nexo-backup.sh (90d retention). Skip.
@@ -109,7 +109,7 @@ TECHNICAL_PREFIXES = (
 
 # Entries that must never be considered for pruning.
 PROTECTED_NAMES = {"shopify-backups", "weekly"}
-# Hourly DB dumps at the root of runtime/backups — managed by nexo-backup.sh.
+# Hourly DB dumps at the root of runtime/backups.
 HOURLY_DB_RE = re.compile(r"^nexo-\d{4}-\d{2}-\d{2}-\d{4}\.db$")
 LOCAL_CONTEXT_DB_RE = re.compile(r"^local-context-\d{4}-\d{2}-\d{2}-\d{4}(\d{2})?\.db$")
 TEMPORARY_RE = re.compile(r"(^|.*[.])tmp([.-].*)?$|.*\.tmp\..*|.*-journal$|.*\.db-(wal|shm)$")
@@ -328,7 +328,7 @@ def plan_prunes(
         else:
             to_keep.append(it)
 
-    for klass, keep_count in (("LOCAL_CONTEXT_DB", local_context_keep),):
+    for klass, keep_count in (("LOCAL_CONTEXT_DB", local_context_keep), ("HOURLY_DB", hourly_keep)):
         group = [it for it in items if it["class"] == klass]
         group.sort(key=lambda x: (x["ts"] or datetime.min.replace(tzinfo=timezone.utc)), reverse=True)
         for it in group[:max(0, keep_count)]:
@@ -346,11 +346,13 @@ def plan_prunes(
             for it in items:
                 by_budget_family.setdefault((it["class"], it["family"]), []).append(it)
             for (klass, _family), group in by_budget_family.items():
-                if klass not in {"TECHNICAL", "LOCAL_CONTEXT_DB", "TEMPORARY"}:
+                if klass not in {"TECHNICAL", "LOCAL_CONTEXT_DB", "HOURLY_DB", "TEMPORARY"}:
                     continue
                 min_keep = 0
                 if klass == "LOCAL_CONTEXT_DB":
                     min_keep = max(0, local_context_keep)
+                elif klass == "HOURLY_DB":
+                    min_keep = max(0, hourly_keep)
                 group.sort(key=lambda x: (x["ts"] or datetime.min.replace(tzinfo=timezone.utc)), reverse=True)
                 for it in group[:min_keep]:
                     protected_keep_ids.add(id(it))
@@ -359,7 +361,7 @@ def plan_prunes(
                 it for it in items
                 if id(it) not in delete_ids
                 and id(it) not in protected_keep_ids
-                and it["class"] in {"TECHNICAL", "LOCAL_CONTEXT_DB", "TEMPORARY"}
+                and it["class"] in {"TECHNICAL", "LOCAL_CONTEXT_DB", "HOURLY_DB", "TEMPORARY"}
             ]
             budget_candidates.sort(
                 key=lambda x: (
@@ -381,10 +383,10 @@ def plan_prunes(
     return to_delete, to_keep
 
 
-def restore_point_guard(items: list[dict], to_delete: list[dict]) -> tuple[bool, list[str], dict]:
+def restore_point_guard(items: list[dict], to_delete: list[dict], *, hourly_keep: int) -> tuple[bool, list[str], dict]:
     """Validate that apply mode never removes protected restore classes."""
     delete_ids = {id(item) for item in to_delete}
-    protected_classes = {"BUSINESS", "HOURLY_DB", "ROOT_DB", "UNKNOWN"}
+    protected_classes = {"BUSINESS", "ROOT_DB", "UNKNOWN"}
     protected_names = set(PROTECTED_NAMES)
     violations: list[str] = []
     for item in items:
@@ -393,10 +395,17 @@ def restore_point_guard(items: list[dict], to_delete: list[dict]) -> tuple[bool,
         if item["class"] in protected_classes or item["name"] in protected_names:
             violations.append(f"{item['name']} ({item['class']})")
     hourly_count = sum(1 for item in items if item["class"] == "HOURLY_DB")
+    hourly_delete_count = sum(1 for item in items if item["class"] == "HOURLY_DB" and id(item) in delete_ids)
+    hourly_after_prune = hourly_count - hourly_delete_count
+    hourly_floor = min(hourly_count, max(0, hourly_keep))
+    if hourly_after_prune < hourly_floor:
+        violations.append(f"hourly_db_floor ({hourly_after_prune} < {hourly_floor})")
     weekly_present = any(item["name"] == "weekly" for item in items)
     business_count = sum(1 for item in items if item["class"] == "BUSINESS")
     return not violations, violations, {
         "hourly_db_present": hourly_count,
+        "hourly_db_after_prune": hourly_after_prune,
+        "hourly_keep_floor": hourly_floor,
         "weekly_present": weekly_present,
         "business_protected": business_count,
         "protected_delete_violations": violations,
@@ -450,7 +459,11 @@ def run(args: argparse.Namespace) -> int:
                 delete_ids.add(id(item))
         to_keep = [item for item in items if id(item) not in delete_ids]
 
-    restore_guard_ok, restore_guard_violations, restore_guard = restore_point_guard(items, to_delete)
+    restore_guard_ok, restore_guard_violations, restore_guard = restore_point_guard(
+        items,
+        to_delete,
+        hourly_keep=max(0, args.hourly_keep),
+    )
 
     total_all = sum(i["size"] for i in items)
     total_del = sum(i["size"] for i in to_delete)
@@ -505,7 +518,7 @@ def run(args: argparse.Namespace) -> int:
         print(f"  total on disk:   {human_size(total_all)}  ({len(items)} entries)")
         print(f"    technical:     {len(tech_items)}")
         print(f"    business:      {len(biz_items)} (protected)")
-        print(f"    hourly_db:     {len(hourly_items)} (managed by nexo-backup.sh)")
+        print(f"    hourly_db:     {len(hourly_items)} (bounded; keep {args.hourly_keep})")
         print(f"    local_context: {len(local_context_items)}")
         print(f"    temporary:     {len(temporary_items)}")
         print(f"    root_db:       {len(root_db_items)} (never auto-pruned)")
@@ -578,7 +591,7 @@ def main() -> int:
     ap.add_argument("--window-days", type=int, default=90, help="month-spaced retention window (default: 90)")
     ap.add_argument("--only", help="restrict to one technical family (e.g. 'pre-backfill-owner')")
     ap.add_argument("--max-bytes", default=os.environ.get("NEXO_BACKUP_MAX_BYTES", str(DEFAULT_MAX_BYTES)), help="global product-generated backup hard cap, bytes or K/M/G/T (default: 50G)")
-    ap.add_argument("--delete-all-technical", action="store_true", help="emergency mode: delete all technical rollback snapshots; protected business/weekly/hourly DB backups remain untouched")
+    ap.add_argument("--delete-all-technical", action="store_true", help="emergency mode: delete all technical rollback snapshots; protected business/weekly backups remain untouched")
     ap.add_argument("--tmp-ttl-minutes", type=int, default=int(os.environ.get("NEXO_BACKUP_TMP_TTL_MINUTES", "30")), help="delete orphan temporary backup files older than this (default: 30)")
     ap.add_argument("--local-context-keep", type=int, default=int(os.environ.get("NEXO_LOCAL_CONTEXT_BACKUP_KEEP_LAST", "1")), help="local-context backup files to keep under the global cap (default: 1)")
     ap.add_argument("--hourly-keep", type=int, default=int(os.environ.get("NEXO_BACKUP_KEEP_LAST", "3")), help="hourly nexo DB backups to keep under the global cap (default: 3)")