agentdynamics 0.7.0__tar.gz → 0.8.0__tar.gz

{agentdynamics-0.7.0 → agentdynamics-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentdynamics
-Version: 0.7.0
+Version: 0.8.0
 Summary: Application performance monitoring for AI agents: flows, cost, reliability and process quality
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/Aditya31398/agentdynamics

{agentdynamics-0.7.0 → agentdynamics-0.8.0}/agentdynamics/__init__.py

@@ -5,7 +5,7 @@
 
 See agentdynamics.autotrace for @trace / @tool / span.
 """
-__version__ = "0.7.0"
+__version__ = "0.8.0"
 
 from .autotrace import flush, init, llm_call, outcome, record_llm, span, tool, trace  # noqa: E402,F401
 

{agentdynamics-0.7.0 → agentdynamics-0.8.0}/agentdynamics/__main__.py

@@ -187,6 +187,32 @@ def cmd_alerts(a, data):
     return 1 if failed else 0
 
 
+def cmd_revoke(a, data):
+    from . import config as cfgmod, store
+    con = store.connect(*store.target(cfgmod.load(data), data))
+    now = time.time()
+    if a.clear:
+        n = store.clear_revocation(con, a.clear, now)
+        print("cleared" if n else f"no active directive {a.clear}")
+        return 0 if n else 1
+    if a.list:
+        rows_ = store.revocations(con, now)
+        for d in rows_:
+            status = "cleared" if d["cleared"] else "expired" if d["expires"] <= now else "active"
+            print(f"{d['id']}  {status:<8} {d['project'] or '(all projects)':<18} {d['agent'] or '(all agents)':<18} "
+                  f"until {time.strftime('%Y-%m-%d %H:%M', time.localtime(d['expires']))}  [{d['source']}] {d['reason']}")
+        if not rows_:
+            print("no directives")
+        return 0
+    if not a.reason:
+        print("--reason is required: it goes into the kernel's audit log")
+        return 2
+    rid = store.add_revocation(con, a.project, a.agent, a.reason, "operator", now, now + a.minutes * 60)
+    print(f"{rid}: {'agent ' + a.agent if a.agent else 'every agent'} in {a.project or 'every project'} is revoked "
+          f"for {a.minutes:g} min, in processes using agentdynamics.integrations.aegis.instrument(..., revocations=True)")
+    return 0
+
+
 def cmd_keys(a, data):
     from .config import keys_path, load_keys, save_keys
     keys = load_keys(data)
@@ -373,6 +399,14 @@ def main(argv=None):
     al.add_argument("action", choices=["status", "test"],
                     help="status: destinations, queue and firing SLO alerts; test: send a test alert to each")
     al.add_argument("--to", metavar="NAME", help="test only this destination (its name, as status shows it)")
+    rv = sub.add_parser("revoke", help="revoke an agent's Aegis grants wherever it runs (applied in-process by "
+                                       "agentdynamics.integrations.aegis), or list/clear directives")
+    rv.add_argument("--agent", help="the agent (grant) name; omit to revoke every grant in the project")
+    rv.add_argument("--project", help="omit for every project")
+    rv.add_argument("--reason", help="why (it goes into the kernel's audit log)")
+    rv.add_argument("--minutes", type=float, default=60, help="how long new grants of that agent are refused too")
+    rv.add_argument("--list", action="store_true", help="list directives")
+    rv.add_argument("--clear", metavar="ID", help="stop a directive (grants it revoked stay revoked)")
     sub.add_parser("ingest", help="scan sources once and rebuild the database")
     rp = sub.add_parser("report", help="print a text summary")
     rp.add_argument("--project")
@@ -397,6 +431,8 @@ def main(argv=None):
         return cmd_keys(a, a.data)
     if cmd == "alerts":
         return cmd_alerts(a, a.data)
+    if cmd == "revoke":
+        return cmd_revoke(a, a.data)
 
     from .engine import Engine
     eng = Engine(a.data, a.claude_root or None)

{agentdynamics-0.7.0 → agentdynamics-0.8.0}/agentdynamics/alerts.py

@@ -10,7 +10,8 @@ Destinations are `[[alerts.webhooks]]` in agentdynamics.toml:
     format = "pagerduty"                 # json (default) | slack | pagerduty
     routing_key_env = "PD_ROUTING_KEY"   # PagerDuty Events API v2 integration key (or routing_key = "...")
     min_severity = "critical"            # info | warning (default) | critical
-    kinds = ["events", "slos"]           # default ["events"]; "slos" adds SLO burn-rate alerts
+    kinds = ["events", "slos"]           # default ["events"]; "slos" adds SLO burn-rate alerts,
+                                         # "revocations" the directives that stop an agent (server-side #8)
     projects = ["checkout"]              # optional: only these projects
     rules = ["run_failed"]               # optional: only these health rules
 
@@ -37,7 +38,7 @@ from collections import OrderedDict
 from urllib.parse import quote
 
 FORMATS = ("json", "slack", "pagerduty")
-KINDS = ("events", "slos")
+KINDS = ("events", "slos", "revocations")
 SEV = {"info": 1, "warning": 2, "critical": 3}
 # https://raw.githubusercontent.com/PagerDuty/api-schema/main/reference/events-v2/openapiv3.json
 PAGERDUTY_URL = "https://events.pagerduty.com/v2/enqueue"
@@ -135,6 +136,15 @@ def from_slo(key, c, action, now):
             "project": (c.get("scope") or {}).get("project") or None, "slo": c["slo"], "ts": now, "condition": c}
 
 
+def from_revocation(d):
+    who = f"agent {d['agent']}" if d.get("agent") else "every agent"
+    where = f" in project {d['project']}" if d.get("project") else ""
+    until = time.strftime("%Y-%m-%d %H:%M", time.localtime(d["expires"]))
+    return {"kind": "revocation", "action": "trigger", "key": f"revocation/{d['id']}", "severity": "critical",
+            "summary": f"Revoked {who}{where} until {until}: {d['reason']}", "project": d.get("project"),
+            "ts": d["created"], "revocation": d}
+
+
 # ---------------------------------------------------------------- formats
 
 def _dedup_key(key):
@@ -148,6 +158,8 @@ def link(console_url, alert):
     base = console_url.rstrip("/")
     if alert["kind"] == "event":
         return f"{base}/#/task/{quote(alert['event']['task_id'], safe='')}"
+    if alert["kind"] == "revocation":
+        return f"{base}/#/governance"
     return f"{base}/#/slos"
 
 
@@ -172,6 +184,9 @@ def render(dest, alerts, console_url=""):
                  "link": link(console_url, a), **a["condition"]} for a in alerts if a["kind"] == "slo"]
         if slos:
             bodies.append({"source": "agentdynamics", "slo_alerts": slos})
+        revs = [dict(a["revocation"], summary=a["summary"]) for a in alerts if a["kind"] == "revocation"]
+        if revs:
+            bodies.append({"source": "agentdynamics", "revocations": revs})
         return bodies
     # one line (Slack) or one alert (PagerDuty) per dedup key, so a burst of the same violation reads as one
     groups = OrderedDict()
@@ -185,6 +200,9 @@ def render(dest, alerts, console_url=""):
             where = " / ".join(_slack_escape(x) for x in (a.get("project"), a.get("task_type")) if x)
             url = link(console_url, a)
             ref = f" · <{url}|{'latest' if len(g) > 1 else 'open'}>" if url else ""
+            if a["kind"] == "revocation":
+                lines.append(f"*REVOKED* · {_slack_escape(a['summary'])}{ref}")
+                continue
             if a["kind"] == "event":
                 e = a["event"]
                 times = f" ×{len(g)}" if len(g) > 1 else ""
@@ -200,7 +218,10 @@ def render(dest, alerts, console_url=""):
         if a["action"] == "resolve":
             bodies.append({"event_action": "resolve", "dedup_key": _dedup_key(key)})
             continue
-        if a["kind"] == "event":
+        if a["kind"] == "revocation":
+            d = a["revocation"]
+            details, group, klass = dict(d), d.get("agent") or "all agents", "revocation"
+        elif a["kind"] == "event":
             e = a["event"]
             details = {"rule": e["rule"], "rule_id": e["rule_id"], "message": e["message"], "value": e.get("value"),
                        "task_id": e["task_id"], "run_id": e.get("run_id"), "project": e["project"],

{agentdynamics-0.7.0 → agentdynamics-0.8.0}/agentdynamics/api/governance.py

@@ -4,7 +4,7 @@ import time
 from collections import Counter, defaultdict
 
 from ..analysis import pct
-from ..store import rows
+from ..store import revocations as list_revocations, rows
 
 
 
@@ -23,6 +23,15 @@ class GovernanceMixin:
                                   "ORDER BY task_id, seq", chunk)
         return out
 
+    def revocations(self, q):
+        """Revocation directives (#8), newest first, each with its status. `active=1` and `project=` are what
+        the in-process poller asks for."""
+        now = time.time()
+        out = list_revocations(self.con, now, active=q.get("active") == "1", project=q.get("project"))
+        for d in out:
+            d["status"] = "cleared" if d["cleared"] else "expired" if d["expires"] <= now else "active"
+        return {"revocations": out, "now": now, "probing": (self.e.cfg.get("enforcement") or {}).get("probing")}
+
     def governance(self, q):
         ts = self._governed(q)
         ids = [t["id"] for t in ts]

{agentdynamics-0.7.0 → agentdynamics-0.8.0}/agentdynamics/config.py

@@ -24,6 +24,9 @@ Example agentdynamics.toml:
     url = "postgresql://agentdynamics@db.internal/agentdynamics"   # needs pip install "agentdynamics[postgres]"
     schema = "agentdynamics"
 
+    [enforcement]                   # server-side revocation (off unless set): an agent the policy keeps
+    probing = { denials = 10, runs = 3, window_minutes = 30, revoke_minutes = 60 }   # refusing across runs
+
     [retention]
     days = 90                       # spans/runs older than this are purged; daily totals are kept
 
@@ -78,6 +81,7 @@ DEFAULTS = {
     "retention": {"days": 0},
     "alerts": {"webhooks": [], "console_url": "", "slo_min_tasks": 10},
     "store": {"url": "", "schema": "agentdynamics"},
+    "enforcement": {},
     "analysis": {"interval": 15, "idle_cap_seconds": 300},
     "sources": [],
 }

{agentdynamics-0.7.0 → agentdynamics-0.8.0}/agentdynamics/engine.py

@@ -17,7 +17,7 @@ import sys
 import threading
 import time
 import traceback
-from collections import defaultdict
+from collections import Counter, defaultdict
 
 from . import alerts as alertmod, analysis, config as cfgmod, pricing, slo as slomod, store
 from .collectors import aegis_audit, claude_code, generic, inbox, langfuse, langsmith, otlp, spans as spanmod
@@ -105,6 +105,7 @@ class Engine:
         # ingest (both go through the store), and one of them takes over if the writer goes away.
         self.writer = store.claim_writer(self.con, self.db_schema)
         self._grades_sig = self._rules_sig = None
+        self._revocations_seen = None     # newest directive already alerted on (None: not looked yet)
         self._store_sdk_ids = set()           # ids of SDK runs read from the store, as _files holds file ones
         self._store_sdk_sig = {}              # run id -> hash of the payload last read
         self.lock = threading.RLock()
@@ -449,6 +450,86 @@ class Engine:
         self._wake.set()
         return len(items)
 
+    # ------------------------------------------------------------------ server-side revocation (#8)
+    # A directive says "revoke this agent's grants in this project until then". The in-process Aegis
+    # integration polls for directives and applies them through Kernel.revoke (integrations/aegis.py):
+    # the kernel enforces and audits, and a directive can only take privileges away (invariant 6).
+
+    def revoke(self, agent=None, project=None, reason="operator", minutes=60, source="operator"):
+        """Issue a directive. `agent` None revokes a process's whole grant tree; `project` None, every project."""
+        now = self._clock()
+        with self.lock:
+            rid = store.add_revocation(self.con, project, agent, reason, source, now, now + float(minutes) * 60)
+        self._wake.set()
+        return rid
+
+    def clear_revocation(self, rid):
+        """Stop a directive applying to new grants; ones it revoked stay revoked (Aegis can't un-revoke)."""
+        with self.lock:
+            return store.clear_revocation(self.con, rid, self._clock())
+
+    def _detect_probing(self):
+        """[enforcement] probing: an agent whose calls the policy keeps refusing across several runs is probing
+        it. The in-process Watchdog sees one run; this sees them all, and issues a directive. Off unless
+        configured: it acts on running agents."""
+        p = (self.cfg.get("enforcement") or {}).get("probing")
+        if not p:
+            return []
+        now = self._clock()
+        since = now - float(p.get("window_minutes", 30)) * 60
+        issued = store.revocations(self.con, now, limit=10000)
+        # a directive restarts the count: denials from before it were what it acted on
+        last = {}
+        for d in issued:
+            if d["source"] == "probing":
+                last[(d["project"], d["agent"])] = max(last.get((d["project"], d["agent"]), 0), d["created"])
+        active = {(d["project"], d["agent"]) for d in issued if d["cleared"] is None and d["expires"] > now}
+        seen = defaultdict(lambda: [0, set(), Counter()])
+        for run in self._runs.values():
+            if (run.get("ended") or run.get("started") or 0) < since:
+                continue                   # only recent runs: this runs every refresh
+            project = run.get("project") or "default"
+            for s in run["steps"]:
+                if not (s.get("denied") and s.get("governed") and s.get("agent")):
+                    continue
+                key = (project, s["agent"])
+                if (s.get("ts") or 0) < max(since, last.get(key, 0)):
+                    continue
+                c = seen[key]
+                c[0] += 1
+                c[1].add(run["id"])
+                c[2][s.get("rule") or "denied"] += 1
+        out = []
+        for (project, agent), (n, runs, rules) in seen.items():
+            if n < int(p.get("denials", 10)) or len(runs) < int(p.get("runs", 3)) or (project, agent) in active:
+                continue
+            top = ", ".join(f"{r} x{k}" for r, k in rules.most_common(3))
+            reason = (f"probing: {n} denied calls across {len(runs)} runs in "
+                      f"{float(p.get('window_minutes', 30)):g} min ({top})")
+            out.append(store.add_revocation(self.con, project, agent, reason, "probing", now,
+                                            now + float(p.get("revoke_minutes", 60)) * 60))
+        return out
+
+    def _alert_new_revocations(self):
+        """Alert on directives issued since the last look, from wherever they came (this process, another
+        instance, the CLI): an agent was stopped, and someone should know why. On the alert tick, so a
+        directive issued while no traffic arrives is still announced."""
+        if not self.writer:
+            return 0
+        with self.lock:
+            return self._alert_new_revocations_locked()
+
+    def _alert_new_revocations_locked(self):
+        now = self._clock()
+        recent = store.revocations(self.con, now, limit=500)
+        newest = max((d["created"] for d in recent), default=0)
+        if self._revocations_seen is None:     # a process's first look: that's history
+            self._revocations_seen = newest
+            return 0
+        new = [d for d in recent if d["created"] > self._revocations_seen]
+        self._revocations_seen = max(self._revocations_seen, newest)
+        return self._queue([alertmod.from_revocation(d) for d in reversed(new)], now) if new else 0
+
     # ------------------------------------------------------------------ settings saved from the console
     # Health rules and SLOs. With SQLite they are files in the data directory. On Postgres a saved one goes in
     # the store, where every instance reads it (a file in the data directory still works, as the default).
@@ -668,6 +749,7 @@ class Engine:
                                            gone - changed, events, baselines, meta, self.redactor)
             self.stats["tasks_rescored"] = len(self._cache.changed)
             self._queue_event_alerts(events)
+            self._detect_probing()
             self._first = False
             self.last_refresh = time.time()
             self.last_duration = round(self.last_refresh - t0, 2)
@@ -847,6 +929,7 @@ class Engine:
             self._alert_wake.clear()
             try:
                 self.check_slos()
+                self._alert_new_revocations()
                 self.deliver_alerts()
             except Exception:
                 traceback.print_exc()

{agentdynamics-0.7.0 → agentdynamics-0.8.0}/agentdynamics/integrations/aegis.py

@@ -29,6 +29,9 @@ import json
 import math
 import threading
 import time
+import urllib.parse
+import urllib.request
+import weakref
 from collections import Counter
 
 from .. import autotrace as at
@@ -115,7 +118,13 @@ def _wrap_kernel(kernel):
         return
     orig_invoke, orig_ainvoke, orig_spawn, orig_revoke = kernel.invoke, kernel.ainvoke, kernel.spawn, kernel.revoke
 
+    def check(grant):
+        rv = getattr(kernel, "_agentdynamics_revocations", None)    # this kernel's, not another's in-process
+        if rv is not None:
+            rv.check_use(grant)
+
     def invoke(grant, tool, /, **args):
+        check(grant)
         t0 = time.time()
         with bind(grant):
             try:
@@ -127,6 +136,7 @@ def _wrap_kernel(kernel):
             return r
 
     async def ainvoke(grant, tool, /, **args):
+        check(grant)
         t0 = time.time()
         tok = _grant.set(grant)
         try:
@@ -140,6 +150,7 @@ def _wrap_kernel(kernel):
         return r
 
     def spawn(parent, req):
+        check(parent)
         t0 = time.time()
         try:
             child = orig_spawn(parent, req)
@@ -151,6 +162,7 @@ def _wrap_kernel(kernel):
                     "start_ts": t0, "end_ts": time.time(), "agent": parent.agent_name, "governed": True,
                     "rule": "spawn.granted", "text": f"spawned {child.agent_name} (depth {child.depth}) "
                                                      f"with {sorted(req.tools)}"}, "aegis.spawn")
+        check(child)                     # a new grant for an agent a directive names is revoked before it acts
         return child
 
     def revoke(grant, reason="operator"):
@@ -292,27 +304,158 @@ class Watchdog:
 
 # ---------------------------------------------------------------- entry point
 
+# ---------------------------------------------------------------- 5. server-side revocation (#8)
+
+class Revocations:
+    """Directives from the AgentDynamics server to revoke an agent's grants, applied through Kernel.revoke.
+
+    The server issues one when an operator asks (`agentdynamics revoke`, POST /api/revocations) or when it sees
+    an agent probing its policy across runs ([enforcement] probing), which no single process can see. This polls
+    for the directives that apply to this process's project and revokes the grants they name: at once in every
+    grant tree it has seen (apps often make a root per conversation, not only the one given to instrument()),
+    and at the point of use -- before any governed call, and on spawn -- for a grant not seen yet. The kernel
+    enforces and audits each revocation.
+    A directive can only take privileges away (invariant 6), and clearing it restores nothing: Aegis revocation
+    is permanent. If the server can't be reached nothing is revoked and the agent carries on, as without this.
+
+    It uses the URL, key and project given to agentdynamics.init(). The key needs the ingest role.
+    """
+
+    def __init__(self, interval=10.0):
+        self.interval = interval
+        self.active = {}                 # directive id -> directive, as of the last successful poll
+        self.applied = []                # {"directive", "agent", "grant_id", "ts"} for each grant revoked here
+        self._done = set()               # (directive id, grant id)
+        self._roots = weakref.WeakValueDictionary()   # grant id -> root, for every tree seen (kept only while alive)
+        self._lock = threading.RLock()
+        self._stop = threading.Event()
+        self.kernel = self.root = None
+
+    def start(self, kernel, root):
+        self.kernel, self.root = kernel, root
+        if self.interval:
+            threading.Thread(target=self._loop, daemon=True, name="agentdynamics-revocations").start()
+
+    def stop(self):
+        self._stop.set()
+
+    def _loop(self):
+        while True:
+            try:
+                self.poll_once()
+            except Exception as ex:      # never into the agent
+                at._warn("revocations-err", f"revocation poll failed: {ex}")
+            if self._stop.wait(self.interval):
+                return
+
+    def poll_once(self):
+        """Fetch the active directives and apply them; returns the number of grants revoked."""
+        url = at._cfg.get("url")
+        if not url:
+            at._warn("revocations-nourl", "revocations=True needs agentdynamics.init(url=...); nothing is polled")
+            return 0
+        q = urllib.parse.urlencode({"active": "1", "project": at._cfg.get("project") or "default"})
+        headers = {"Authorization": f"Bearer {at._cfg['key']}"} if at._cfg.get("key") else {}
+        try:
+            with urllib.request.urlopen(urllib.request.Request(f"{url}/api/revocations?{q}", headers=headers),
+                                        timeout=5) as r:
+                data = json.loads(r.read())
+        except Exception as ex:
+            at._warn("revocations-down", f"could not fetch revocation directives from {url} ({ex}); "
+                                         "nothing is revoked until it answers")
+            return 0
+        with self._lock:
+            self.active = {d["id"]: d for d in data.get("revocations", [])}
+        return self.apply()
+
+    def _live(self):
+        now = time.time()
+        with self._lock:
+            return [d for d in self.active.values() if (d.get("expires") or 0) > now]
+
+    def apply(self):
+        """Revoke every live grant an active directive names; returns how many."""
+        if self.kernel is None or self.root is None:
+            return 0
+        return sum(self._revoke(d, g) for d in self._live() for g in self._targets(d))
+
+    def note(self, grant):
+        root = grant                     # up the parent chain (Grant.root is a constructor, not this)
+        while root.parent is not None:
+            root = root.parent
+        self._roots[root.grant_id] = root
+
+    def _all_roots(self):
+        return [self.root] + [r for r in list(self._roots.values()) if r is not self.root]
+
+    def _targets(self, d):
+        if not d.get("agent"):
+            return self._all_roots()     # every agent: every tree
+        out, stack = [], self._all_roots()
+        while stack:
+            g = stack.pop()
+            if g.agent_name == d["agent"]:
+                out.append(g)            # its subtree goes with it
+            else:
+                stack.extend(g.children)
+        return out
+
+    def _revoke(self, d, grant):
+        key = (d["id"], grant.grant_id)
+        with self._lock:
+            if key in self._done or not grant.is_active():
+                return 0
+            self._done.add(key)
+        self.kernel.revoke(grant, reason=f"agentdynamics directive {d['id']}: {d.get('reason')}")
+        self.applied.append({"directive": d["id"], "agent": grant.agent_name, "grant_id": grant.grant_id,
+                             "ts": time.time()})
+        return 1
+
+    def check_use(self, grant):
+        """Before a grant acts: if an active directive names its agent or an ancestor's (or every agent),
+        revoke first, so the call is refused. Free while no directive is active."""
+        try:
+            self.note(grant)             # so a later directive finds this tree even while it sits idle
+            if not self.active:
+                return
+            chain, g = [], grant
+            while g is not None:
+                chain.append(g)
+                g = g.parent
+            for d in self._live():
+                hit = chain[-1] if not d.get("agent") else next((g for g in chain if g.agent_name == d["agent"]), None)
+                if hit is not None:
+                    self._revoke(d, hit)
+                    return
+        except Exception as ex:          # the check itself must not break the agent
+            at._warn("revocations-check", f"could not check a grant against revocation directives: {ex}")
+
+
 class Governance:
-    def __init__(self, kernel, root, gate, watchdog, unregister):
+    def __init__(self, kernel, root, gate, watchdog, unregister, revocations=None):
         self.kernel, self.root, self.gate, self.watchdog, self._unregister = kernel, root, gate, watchdog, unregister
+        self.revocations = revocations
 
     def uninstall(self):
         self._unregister()
 
 
-def instrument(kernel, root=None, *, gate_models=True, watchdog=None, correlate=True, record_decisions=True):
+def instrument(kernel, root=None, *, gate_models=True, watchdog=None, correlate=True, record_decisions=True,
+               revocations=None):
     """Connect an Aegis kernel to AgentDynamics. Call after `agentdynamics.init()` and `build_kernel()`.
 
     kernel      the Aegis Kernel
     root        the root Grant (model calls outside a bound grant are charged to it)
     gate_models reserve model spend against the Aegis budget before each call
     watchdog    a Watchdog, or None
+    revocations True (or a Revocations) to apply the server's revocation directives: off by default, since it
+                lets the server stop agents in this process. Needs `root`.
     """
     _require_aegis()
     _state.update(kernel=kernel, root=root)
     undo = []
-    if record_decisions:
-        _wrap_kernel(kernel)
+    if record_decisions or revocations:
+        _wrap_kernel(kernel)             # the spawn hook applies directives to new grants
     if correlate:
         try:
             from aegis.observe import register_context_provider
@@ -356,10 +499,20 @@ def instrument(kernel, root=None, *, gate_models=True, watchdog=None, correlate=
     at._hooks["run_meta"].append(meta)
     undo.append(lambda: at._hooks["run_meta"].remove(meta))
 
+    rv = None
+    if revocations:
+        if root is None:
+            at._warn("revocations-noroot", "revocations need the root grant: instrument(kernel, root, revocations=True)")
+        else:
+            rv = revocations if isinstance(revocations, Revocations) else Revocations()
+            kernel._agentdynamics_revocations = rv
+            rv.start(kernel, root)
+            undo += [rv.stop, lambda: setattr(kernel, "_agentdynamics_revocations", None)]
+
     def unregister():
         for u in undo:
             try:
                 u()
             except ValueError:
                 pass
-    return Governance(kernel, root, gate, watchdog, unregister)
+    return Governance(kernel, root, gate, watchdog, unregister, rv)

{agentdynamics-0.7.0 → agentdynamics-0.8.0}/agentdynamics/pg.py

@@ -349,6 +349,8 @@ def ddl(schema_version, derived):
         f"CREATE TABLE IF NOT EXISTS alert_outbox (id BIGSERIAL PRIMARY KEY, dest TEXT, body TEXT, created {NUM}, "
         f"attempts {NUM} DEFAULT 0, next_try {NUM}, last_error TEXT)",
         f"CREATE TABLE IF NOT EXISTS alert_state (key TEXT PRIMARY KEY, since {NUM}, data TEXT)",
+        "CREATE TABLE IF NOT EXISTS revocations (id TEXT PRIMARY KEY, project TEXT, agent TEXT, reason TEXT, "
+        f"source TEXT, created {NUM}, expires {NUM}, cleared {NUM})",
         f"CREATE TABLE IF NOT EXISTS rollup_daily ({dims}, {', '.join(f'{c} {NUM}' for c in s.ROLLUP_SUMS)}, "
         f"PRIMARY KEY ({', '.join(s.ROLLUP_DIMS)}))",
     ]