From 985ad4127c48e08db82700ea9c8b815fb1f9377d Mon Sep 17 00:00:00 2001 From: Prime Backup Bot Date: Wed, 11 Mar 2026 21:30:35 +0000 Subject: [PATCH] feat(control-v2): add blocked/approve/deny aliases and autonomy guardrails --- prime_core/autonomy_loop.py | 9 +++- prime_core/guardrails.py | 78 ++++++++++++++++++++++++++++++++++ prime_core/queue.py | 4 ++ prime_core/telegram_control.py | 36 +++++++++++++++- 4 files changed, 123 insertions(+), 4 deletions(-) create mode 100644 prime_core/guardrails.py diff --git a/prime_core/autonomy_loop.py b/prime_core/autonomy_loop.py index afd776b..cd739c5 100644 --- a/prime_core/autonomy_loop.py +++ b/prime_core/autonomy_loop.py @@ -3,6 +3,7 @@ import json import time from pathlib import Path from .queue import enqueue +from .guardrails import allowed_now, record_task AUTON_PATH = Path('/srv/prime-core/state/autonomous-mode.json') GOALS_PATH = Path('/srv/prime-core/state/goals.json') @@ -54,8 +55,12 @@ def tick(): prev = int(lm.get(gid, 0)) # seed one planning task per goal every 30m if now - prev >= 1800: - enqueue('planning', f"Advance goal: {g.get('text','')}") - lm[gid] = now + task = f"Advance goal: {g.get('text','')}" + ok, reason = allowed_now(task) + if ok: + enqueue('planning', task) + record_task(task) + lm[gid] = now save_last(lm) diff --git a/prime_core/guardrails.py b/prime_core/guardrails.py new file mode 100644 index 0000000..8c80baa --- /dev/null +++ b/prime_core/guardrails.py @@ -0,0 +1,78 @@ +from __future__ import annotations +import json +import time +from pathlib import Path + +STATE = Path('/srv/prime-core/state/autonomy-guardrails.json') +HISTORY = Path('/srv/prime-core/state/autonomy-history.json') + +DEFAULT = { + 'max_tasks_per_hour': 12, + 'quiet_hours_utc': {'start': 23, 'end': 8}, + 'urgent_keywords': ['urgent', 'critical', 'outage', 'down', 'security'], + 'duplicate_cooldown_sec': 1800, +} + + +def _load(path: Path, fallback): + if not path.exists(): + return fallback + try: + return json.loads(path.read_text()) + except Exception: + return fallback + + +def get_cfg() -> dict: + return _load(STATE, DEFAULT) + + +def set_cfg(cfg: dict): + STATE.parent.mkdir(parents=True, exist_ok=True) + STATE.write_text(json.dumps(cfg, indent=2)) + + +def _hist() -> dict: + return _load(HISTORY, {'events': []}) + + +def _save_hist(h: dict): + HISTORY.parent.mkdir(parents=True, exist_ok=True) + HISTORY.write_text(json.dumps(h, indent=2)) + + +def record_task(text: str): + h=_hist() + h['events'].append({'ts': int(time.time()), 'text': text}) + # retain 48h + cutoff=int(time.time())-172800 + h['events']=[e for e in h['events'] if e.get('ts',0)>=cutoff] + _save_hist(h) + + +def allowed_now(text: str) -> tuple[bool,str]: + cfg=get_cfg() + now=int(time.time()) + hr=int(time.strftime('%H', time.gmtime(now))) + + # quiet hours check unless urgent + q=cfg.get('quiet_hours_utc',{}) + s=int(q.get('start',23)); e=int(q.get('end',8)) + quiet = (hr >= s or hr < e) if s > e else (s <= hr < e) + urgent=any(k in text.lower() for k in cfg.get('urgent_keywords',[])) + if quiet and not urgent: + return False, 'quiet_hours' + + h=_hist().get('events',[]) + last_hr=now-3600 + per_hour=sum(1 for ev in h if ev.get('ts',0)>=last_hr) + if per_hour >= int(cfg.get('max_tasks_per_hour',12)): + return False, 'hourly_budget_exceeded' + + # duplicate suppression + cooldown=int(cfg.get('duplicate_cooldown_sec',1800)) + for ev in reversed(h): + if ev.get('text','').strip().lower()==text.strip().lower() and now-ev.get('ts',0) < cooldown: + return False, 'duplicate_cooldown' + + return True, 'ok' diff --git a/prime_core/queue.py b/prime_core/queue.py index 0129441..0d9eba1 100644 --- a/prime_core/queue.py +++ b/prime_core/queue.py @@ -85,3 +85,7 @@ def deny(item_id: str, reason: str = 'denied_by_operator') -> dict: _save(items) return it raise ValueError(f'unknown task id: {item_id}') + + +def list_blocked() -> list[dict]: + return [it for it in _load() if it.get('status') == 'blocked_approval'] diff --git a/prime_core/telegram_control.py b/prime_core/telegram_control.py index 845cede..9ddfc55 100644 --- a/prime_core/telegram_control.py +++ b/prime_core/telegram_control.py @@ -7,6 +7,8 @@ import time import urllib.parse import urllib.request from pathlib import Path +from .queue import list_blocked +from .guardrails import get_cfg, set_cfg from .risk import classify, needs_approval from .audit import log_event @@ -75,13 +77,16 @@ def help_text() -> str: "Prime control commands:\n" "- status\n" "- queue list\n" + "- blocked\n" "- queue add \n" - "- queue approve \n" - "- queue deny [reason]\n" + "- queue approve (or /approve )\n" + "- queue deny [reason] (or /deny [reason])\n" "- run once\n" "- mode autonomous on|off\n" "- goals show\n" "- goals add \n" + "- guardrails show\n" + "- guardrails set max_tasks_per_hour \n" "- help" ) @@ -169,6 +174,33 @@ def parse_and_handle(chat_id: int, msg_id: int, text: str) -> str: set_autonomous(enabled) return f"autonomous mode set to {parts[2]}" + + if parts[0] == 'blocked': + b = list_blocked() + return json.dumps(b, indent=2)[:3500] if b else 'No blocked tasks.' + + if parts[0] in {'approve','/approve'}: + if len(parts) != 2: + return 'Usage: approve ' + code, out = run_prime(['queue','approve',parts[1]]) + return f"approve (code={code})\n{out[:3500]}" + + if parts[0] in {'deny','/deny'}: + if len(parts) < 2: + return 'Usage: deny [reason]' + reason = ' '.join(parts[2:]) if len(parts)>2 else 'denied_by_operator' + code, out = run_prime(['queue','deny',parts[1],'--reason',reason]) + return f"deny (code={code})\n{out[:3500]}" + + if parts[:2] == ['guardrails','show']: + return json.dumps(get_cfg(), indent=2) + + if parts[:3] == ['guardrails','set','max_tasks_per_hour']: + if len(parts) != 4: + return 'Usage: guardrails set max_tasks_per_hour ' + cfg = get_cfg(); cfg['max_tasks_per_hour'] = int(parts[3]); set_cfg(cfg) + return 'guardrails updated' + if parts[:2] == ['goals', 'show']: goals = load_goals() return json.dumps(goals, indent=2)[:3500] if goals else 'No goals set.'