galvanize 0.2.0__py3-none-any.whl

galvanize/__init__.py

@@ -0,0 +1,7 @@
+"""Galvanize — event-driven activation points for AI agents.
+
+Wake a fresh agent session when something happens in the world:
+a file lands in a folder, a webhook fires, a script emits an event.
+"""
+
+__version__ = "0.2.0"

galvanize/__main__.py

@@ -0,0 +1,8 @@
+"""Allow ``python -m galvanize`` as an alias for the CLI entry point."""
+
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

galvanize/_plugins/galvanize/__init__.py

@@ -0,0 +1,306 @@
+"""Galvanize Hermes plugin — trigger management tools for the agent.
+
+Why this exists: the agent's tool list shapes its habits. cronjob sits in
+schema every turn, so "watch for X" becomes an hourly poller. These tools
+give event-driven activation the same prominence. Wake-up itself stays
+external (the galvanize daemon / the Hermes webhook lane); this plugin is
+the management surface only.
+
+Tool handlers try `import galvanize` (same interpreter when galvanize is
+installed into Hermes' venv) and fall back to the `galvanize` CLI on PATH,
+so the plugin degrades gracefully when the daemon lives elsewhere.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import shutil
+import subprocess
+import sys
+
+logger = logging.getLogger(__name__)
+
+
+def _run_op(op: str, **kwargs):
+    """Call a galvanize manage op, in-process if possible, CLI otherwise."""
+    try:
+        from galvanize import manage
+
+        fn = {
+            "add": manage.add_trigger,
+            "remove": manage.remove_trigger_op,
+            "test": manage.test_trigger,
+            "status": manage.status,
+            "list": None,
+        }[op]
+        if op == "list":
+            from galvanize.config import load_triggers
+
+            ts = load_triggers()
+            return {"ok": True, "triggers": {n: t.to_dict() for n, t in ts.items()}}
+        return fn(**kwargs)
+    except ImportError:
+        if not shutil.which("galvanize"):
+            return {"ok": False, "error":
+                    "galvanize is not installed in this interpreter and 'galvanize' "
+                    "is not on PATH. Fix:  <hermes-python> -m pip install "
+                    "\"git+https://github.com/jarvis959/galvanize.git\"   (or run: galvanize init)"}
+        cmd = ["galvanize"]
+        cmd += {"add": ["add"], "remove": ["remove"], "test": ["test"],
+                "status": ["status"], "list": ["status"]}[op]
+        # CLI fallback: reconstruct the arg vector so trigger_add still works
+        # when the package isn't importable in the gateway interpreter.
+        if op == "add":
+            kind = kwargs.get("kind", "")
+            target = kwargs.get("target", "")
+            if not kind:
+                return {"ok": False, "error": "trigger_add needs 'kind'"}
+            cmd += [kind] + ([target] if target else [])
+            for flag, key in (("--name", "name"), ("--wake", "wake"),
+                              ("--deliver", "deliver"), ("--prompt", "prompt"),
+                              ("--workdir", "workdir"), ("--command", "command")):
+                val = kwargs.get(key, "")
+                if val:
+                    cmd += [flag, str(val)]
+            if kwargs.get("patterns"):
+                cmd += ["--patterns", ",".join(kwargs["patterns"])]
+            if kwargs.get("events"):
+                cmd += ["--events", ",".join(kwargs["events"])]
+            if kwargs.get("cooldown_s"):
+                cmd += ["--cooldown", str(kwargs["cooldown_s"])]
+        elif op == "remove":
+            cmd += [kwargs.get("name", "")]
+        elif op == "test":
+            cmd += [kwargs.get("name", "")]
+            if kwargs.get("payload"):
+                cmd += ["--payload", json.dumps(kwargs["payload"])]
+        try:
+            proc = subprocess.run(cmd, capture_output=True, text=True, timeout=60,
+                                  encoding="utf-8", errors="replace")
+            return {"ok": proc.returncode == 0,
+                    "output": (proc.stdout or proc.stderr)[-3000:]}
+        except Exception as e:
+            return {"ok": False, "error": str(e)}
+
+
+# ---------------------------------------------------------------- schemas
+
+ADD_SCHEMA = {
+    "name": "trigger_add",
+    "description": (
+        "Create an event trigger that wakes a fresh Hermes session when something "
+        "happens. USE THIS INSTEAD OF a scheduled/polling cron job whenever the user "
+        "describes an EVENT: 'wake me when X lands/arrives/happens', 'notify me when "
+        "a file shows up', 'when GitHub pings me...'. Sources: "
+        "folder (files landing in a directory — {file} and {path} usable in prompt), "
+        "webhook (external service POSTs to a URL we host: GitHub, Stripe, monitoring), "
+        "emit (named event fired by scripts or other agents via `galvanize emit`). "
+        "Results deliver per-trigger (deliver='telegram'|'discord'|...|'log')."
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "kind": {"type": "string", "enum": ["folder", "webhook", "emit"]},
+            "name": {"type": "string", "description": "lowercase-kebab trigger name"},
+            "target": {"type": "string", "description": "folder path to watch (kind=folder)"},
+            "prompt": {"type": "string", "description": "instruction for the woken session; placeholders {file} {path} or webhook payload fields like {pull_request.title}"},
+            "patterns": {"type": "array", "items": {"type": "string"}, "description": "filename globs, e.g. ['*.step']"},
+            "deliver": {"type": "string", "description": "delivery target for results (telegram, discord, slack, log)"},
+            "events": {"type": "array", "items": {"type": "string"}, "description": "kind=webhook: event types to accept"},
+            "cooldown_s": {"type": "number", "description": "minimum seconds between wakes (default 0)"},
+        },
+        "required": ["kind", "name"],
+    },
+}
+
+LIST_SCHEMA = {
+    "name": "trigger_list",
+    "description": "List all galvanize triggers with their source, wake mode, and settings.",
+    "parameters": {"type": "object", "properties": {}},
+}
+
+REMOVE_SCHEMA = {
+    "name": "trigger_remove",
+    "description": "Remove a galvanize trigger (and its Hermes webhook route if it had one).",
+    "parameters": {
+        "type": "object",
+        "properties": {"name": {"type": "string"}},
+        "required": ["name"],
+    },
+}
+
+TEST_SCHEMA = {
+    "name": "trigger_test",
+    "description": (
+        "Inject a synthetic event through a trigger's real dispatch path and report "
+        "what happened. ALWAYS run this right after trigger_add so the user sees the "
+        "trigger work before relying on it."
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"},
+            "payload": {"type": "object", "description": "optional synthetic payload"},
+        },
+        "required": ["name"],
+    },
+}
+
+STATUS_SCHEMA = {
+    "name": "trigger_status",
+    "description": (
+        "Health of the trigger system: daemon alive?, Hermes webhook lane enabled and "
+        "reachable?, per-trigger last-fire time, fires today, last error. Use to answer "
+        "'is my trigger still watching?' honestly instead of guessing."
+    ),
+    "parameters": {"type": "object", "properties": {}},
+}
+
+
+# ---------------------------------------------------------------- handlers
+
+def _handle_trigger_add(args, **kw):
+    r = _run_op(
+        "add",
+        args.get("kind", ""),
+        args.get("target", "") or str(args.get("target_path", "")),
+        name=args.get("name", ""),
+        wake="hermes",
+        deliver=args.get("deliver", "") or "",
+        prompt=args.get("prompt", "") or "",
+        patterns=args.get("patterns") or None,
+        events=args.get("events") or None,
+        cooldown_s=float(args.get("cooldown_s", 0) or 0),
+    )
+    return json.dumps(r, ensure_ascii=False)
+
+
+def _handle_trigger_list(args, **kw):
+    return json.dumps(_run_op("list"), ensure_ascii=False)
+
+
+def _handle_trigger_remove(args, **kw):
+    return json.dumps(_run_op("remove", name=args.get("name", "")), ensure_ascii=False)
+
+
+def _handle_trigger_test(args, **kw):
+    return json.dumps(
+        _run_op("test", name=args.get("name", ""), payload=args.get("payload") or None),
+        ensure_ascii=False,
+    )
+
+
+def _handle_trigger_status(args, **kw):
+    return json.dumps(_run_op("status"), ensure_ascii=False)
+
+
+# ---------------------------------------------------------------- slash + CLI
+
+def _slash_triggers(raw_args: str) -> str:
+    """/triggers [list|status|test <name>] — zero-LLM trigger checks."""
+    parts = (raw_args or "").split()
+    verb = parts[0].lower() if parts else "list"
+    try:
+        from galvanize import manage
+    except ImportError:
+        return "galvanize is not installed in this interpreter."
+    if verb == "test" and len(parts) > 1:
+        r = manage.test_trigger(parts[1])
+        return ("✔ " + r.get("detail", "accepted")) if r.get("ok") else ("✖ " + r.get("error", "failed"))
+    s = manage.status()
+    lines = [f"daemon: {'up' if s['daemon_alive'] else 'DOWN'}  "
+             f"webhook lane: {'on' if s['webhook_enabled'] else 'off'}  "
+             f"gateway: {'up' if s['gateway_running'] else 'down'}", ""]
+    if not s["triggers"]:
+        lines.append("No triggers yet — describe the event you want watched.")
+    for row in s["triggers"]:
+        mark = "●" if row["watching"] else ("○" if row["enabled"] else "–")
+        err = f"  ERR: {str(row['last_error'])[:40]}" if row["last_error"] else ""
+        lines.append(f"{mark} {row['name']}  {row['source']}→{row['wake']}  "
+                     f"last: {row['last_fire']}  today: {row['fires_today']}{err}")
+    for n in s["notes"]:
+        lines.append(f"! {n}")
+    return "\n".join(lines)
+
+
+def _cli_setup_triggers(subparser) -> None:
+    subparser.add_argument("verb", nargs="?", default="status",
+                           choices=["status", "list", "test", "doctor"],
+                           help="what to show (default: status)")
+    subparser.add_argument("name", nargs="?", default="",
+                           help="trigger name (for test)")
+
+
+def _cli_handle_triggers(args) -> None:
+    """`hermes triggers ...` — thin wrapper over manage ops."""
+    from galvanize import manage
+    verb = getattr(args, "verb", "status")
+    if verb == "test":
+        r = manage.test_trigger(getattr(args, "name", "") or "")
+        print(r.get("detail") or r.get("error") or "done") if (r.get("ok") or r.get("error")) else print("done")
+        for ln in r.get("lines", []):
+            print(" ", ln)
+        return
+    if verb == "doctor":
+        r = manage.doctor()
+        for c in r["checks"]:
+            print(("✔ " if c["ok"] else "✖ ") + f"{c['name']:<28} {c['note']}")
+        return
+    s = manage.status() if verb in ("status", "list") else manage.status()
+    if not s["triggers"]:
+        print("No triggers yet — ask the agent to create one, or: galvanize add folder <path>")
+    for row in s["triggers"]:
+        print(f"{'●' if row['watching'] else '–'} {row['name']:<24} "
+              f"{row['source']:>8} → {row['wake']:<6} last: {row['last_fire']}  "
+              f"today: {row['fires_today']}")
+    for n in s["notes"]:
+        print(f"! {n}")
+
+
+def _galvanize_present() -> bool:
+    try:
+        import galvanize  # noqa: F401
+        return True
+    except ImportError:
+        return bool(shutil.which("galvanize"))
+
+
+def register(ctx):
+    for schema, handler in (
+        (ADD_SCHEMA, _handle_trigger_add),
+        (LIST_SCHEMA, _handle_trigger_list),
+        (REMOVE_SCHEMA, _handle_trigger_remove),
+        (TEST_SCHEMA, _handle_trigger_test),
+        (STATUS_SCHEMA, _handle_trigger_status),
+    ):
+        ctx.register_tool(
+            name=schema["name"],
+            toolset="galvanize",
+            schema=schema,
+            handler=handler,
+            description=schema["description"],
+            check_fn=_galvanize_present,
+        )
+
+    # Zero-LLM management surfaces (PLAN item 12b/12c): /triggers slash in
+    # chat sessions + `hermes triggers` terminal verb.
+    try:
+        ctx.register_command(
+            name="triggers",
+            handler=_slash_triggers,
+            description="List galvanize triggers and their health (no agent turn spent)",
+            args_hint="[list|status|test <name>]",
+        )
+    except Exception as e:  # older hosts without register_command: tool surface still works
+        logger.debug("galvanize: /triggers slash not registered: %s", e)
+    try:
+        ctx.register_cli_command(
+            name="triggers",
+            help="show or test galvanize event triggers",
+            setup_fn=_cli_setup_triggers,
+            handler_fn=_cli_handle_triggers,
+            description="Thin wrapper over galvanize manage ops (status/list/test/doctor).",
+        )
+    except Exception as e:
+        logger.debug("galvanize: hermes triggers CLI not registered: %s", e)

galvanize/_plugins/galvanize/dashboard/dist/index.js

@@ -0,0 +1,219 @@
+/**
+ * Galvanize — Triggers dashboard tab
+ *
+ * Job management for event triggers (the cron-page analogue): per-trigger
+ * watching state, last fire, fires today, last error, and row actions
+ * (test-fire / enable-toggle / remove). MANAGES ONLY — creating triggers
+ * stays agent/conversation-first by design.
+ *
+ * Plain IIFE, no build step. Uses window.__HERMES_PLUGIN_SDK__ (React +
+ * host components + authed fetchJSON). Talks to /api/plugins/galvanize/.
+ */
+(function () {
+  "use strict";
+
+  var SDK = window.__HERMES_PLUGIN_SDK__;
+  if (!SDK) return;
+
+  var React = SDK.React;
+  var h = React.createElement;
+  var useState = SDK.hooks.useState;
+  var useEffect = SDK.hooks.useEffect;
+  var useCallback = SDK.hooks.useCallback;
+  var Badge = SDK.components.Badge;
+  var Button = SDK.components.Button;
+  var Card = SDK.components.Card;
+  var CardContent = SDK.components.CardContent;
+  var cn = SDK.utils.cn || function () { return Array.prototype.slice.call(arguments).filter(Boolean).join(" "); };
+  var timeAgo = SDK.utils.timeAgo;
+
+  var API = "/api/plugins/galvanize";
+  var POLL_MS = 5000;
+
+  function errText(e) {
+    if (!e) return "unknown error";
+    if (e.detail && typeof e.detail === "string") return e.detail;
+    return String(e.message || e);
+  }
+
+  function HealthChip(props) {
+    var ok = props.ok, label = props.label, hint = props.note;
+    return h("span", {
+      className: cn("inline-flex items-center gap-1.5 text-xs",
+        ok ? "text-green-600" : "text-red-600"),
+      title: hint || "",
+    }, h("span", {
+      className: cn("inline-block w-2 h-2 rounded-full",
+        ok ? "bg-green-500" : "bg-red-500"),
+    }), label);
+  }
+
+  function Row(props) {
+    var t = props.trigger;
+    var busy = props.busy;
+    var onAction = props.onAction;
+
+    var wakeLabel = t.wake === "hermes" ? "Hermes" : t.wake;
+    var srcLabel = { folder: "folder", imap: "email", webhook: "webhook", emit: "emit" }[t.source] || t.source;
+    var detail = t.path || t.mailbox || "";
+
+    return h("tr", { className: "border-b border-border/40" },
+      h("td", { className: "py-2 pr-3 align-top" },
+        h("div", { className: "flex items-center gap-2" },
+          h("span", {
+            className: cn("inline-block w-2 h-2 rounded-full shrink-0",
+              !t.enabled ? "bg-muted-foreground/40"
+                : t.watching ? "bg-green-500" : "bg-amber-500"),
+            title: !t.enabled ? "disabled" : t.watching ? "watching" : "not watching",
+          }),
+          h("span", { className: "font-medium" }, t.name),
+          t.description ? h("span", { className: "text-muted-foreground text-xs truncate max-w-52" },
+            t.description) : null)),
+      h("td", { className: "py-2 pr-3 align-top text-xs" },
+        h(Badge, { variant: "outline" }, srcLabel),
+        detail ? h("div", { className: "text-muted-foreground mt-1 truncate max-w-64", title: detail },
+          detail) : null),
+      h("td", { className: "py-2 pr-3 align-top text-xs text-muted-foreground" }, wakeLabel),
+      h("td", { className: "py-2 pr-3 align-top text-xs" },
+        t.last_fire === "never" || !t.last_fire
+          ? h("span", { className: "text-muted-foreground" }, "never") : t.last_fire),
+      h("td", { className: "py-2 pr-3 align-top text-xs tabular-nums" }, String(t.fires_today || 0)),
+      h("td", { className: "py-2 pr-3 align-top text-xs" },
+        t.last_error
+          ? h("span", { className: "text-red-600", title: t.last_error },
+            String(t.last_error).slice(0, 60))
+          : h("span", { className: "text-muted-foreground" }, "—")),
+      h("td", { className: "py-2 align-top text-right whitespace-nowrap" },
+        h(Button, {
+          size: "sm", variant: "ghost", disabled: busy,
+          title: "Send a synthetic test event through the real dispatch path",
+          onClick: function () { onAction("test", t); },
+        }, "Test"),
+        h(Button, {
+          size: "sm", variant: "ghost", disabled: busy,
+          onClick: function () { onAction("toggle", t); },
+        }, t.enabled ? "Disable" : "Enable"),
+        h(Button, {
+          size: "sm", variant: "ghost", disabled: busy,
+          className: "text-red-600",
+          onClick: function () { onAction("remove", t); },
+        }, "Remove")));
+  }
+
+  function TriggersPage() {
+    var state = useState(null);  var data = state[0], setData = state[1];
+    var busyS = useState("");    var busy = busyS[0], setBusy = busyS[1];
+    var msgS = useState("");     var msg = msgS[0], setMsg = msgS[1];
+    var errS = useState("");     var err = errS[0], setErr = errS[1];
+
+    var refresh = useCallback(function () {
+      SDK.fetchJSON(API + "/status").then(function (r) {
+        setData(r);
+        setErr("");
+      }).catch(function (e) { setErr(errText(e)); });
+    }, []);
+
+    useEffect(function () {
+      refresh();
+      var iv = setInterval(refresh, POLL_MS);
+      return function () { clearInterval(iv); };
+    }, [refresh]);
+
+    var act = useCallback(function (kind, t) {
+      if (kind === "remove" &&
+          !window.confirm("Remove trigger '" + t.name +
+          "'?\nThis also removes its Hermes webhook route if it had one.")) {
+        return;
+      }
+      setBusy(t.name); setMsg(""); setErr("");
+      var url = API + "/" + (kind === "toggle" ? "toggle" : kind);
+      var body = kind === "toggle"
+        ? { name: t.name, enabled: !t.enabled }
+        : { name: t.name };
+      SDK.fetchJSON(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      }).then(function (r) {
+        if (kind === "test") {
+          setMsg(r && r.ok
+            ? "Test event fired: " + (r.detail || "accepted") + " \u2014 a fresh agent session is starting."
+            : "Test failed: " + (r && (r.error || r.detail) || "unknown"));
+        }
+        refresh();
+      }).catch(function (e) { setErr(errText(e)); });
+      // clear busy after the refresh settles (fetchJSON has no finally chain guarantee across hosts)
+      setTimeout(function () { setBusy(""); refresh(); }, 1200);
+    }, [refresh]);
+
+    if (!data) {
+      return h("div", { className: "p-6 text-sm text-muted-foreground" }, "Loading triggers…");
+    }
+
+    var notes = data.notes || [];
+    var triggers = data.triggers || [];
+
+    // --- header row ---
+    var header = h("div", { className: "flex items-center justify-between flex-wrap gap-2" },
+      h("div", null,
+        h("h2", { className: "text-lg font-semibold" }, "Triggers"),
+        h("div", { className: "text-xs text-muted-foreground" },
+          "Events that wake agent sessions. To create one, just tell the agent:",
+          " \u201cwatch my downloads folder and wake me when a CAD file lands.\u201d")),
+      h("div", { className: "flex items-center gap-3" },
+        h(HealthChip, { ok: !!data.daemon_alive, label: "daemon" }),
+        h(HealthChip, { ok: !!data.webhook_enabled, label: "webhook lane" }),
+        h(HealthChip, { ok: !!data.gateway_running, label: "gateway" }),
+        h(Button, { size: "sm", variant: "ghost", onClick: refresh }, "Refresh")));
+
+    // --- messages / notes card ---
+    var msgCard = null;
+    if (err || msg || notes.length) {
+      msgCard = h(Card, null,
+        h(CardContent, { className: "py-3 text-sm space-y-1" },
+          err ? h("div", { className: "text-red-600" }, err) : null,
+          msg ? h("div", { className: "text-green-600" }, msg) : null,
+          notes.map(function (n, i) {
+            return h("div", { key: i, className: "text-amber-600 text-xs" }, "! " + n);
+          })));
+    }
+
+    // --- table or empty state ---
+    var body;
+    if (triggers.length === 0) {
+      body = h("div", {
+        className: "border border-dashed border-border rounded-lg p-8 text-center text-sm text-muted-foreground space-y-2",
+      },
+        h("div", null, "No triggers yet."),
+        h("div", null, "Ask your agent:",
+          h("code", { className: "text-xs" }, " wake me when resumes land in my inbox "),
+          " or run ",
+          h("code", { className: "text-xs" }, "galvanize add folder ~/watch --wake hermes"), "."));
+    } else {
+      var headRow = h("tr", { className: "text-left text-xs text-muted-foreground" },
+        h("th", { className: "py-2 pr-3 font-medium" }, "Trigger"),
+        h("th", { className: "py-2 pr-3 font-medium" }, "Source"),
+        h("th", { className: "py-2 pr-3 font-medium" }, "Wake"),
+        h("th", { className: "py-2 pr-3 font-medium" }, "Last fire"),
+        h("th", { className: "py-2 pr-3 font-medium" }, "Today"),
+        h("th", { className: "py-2 pr-3 font-medium" }, "Last error"),
+        h("th", { className: "py-2 font-medium" }, ""));
+      var rows = triggers.map(function (t) {
+        return h(Row, { key: t.name, trigger: t, busy: busy === t.name, onAction: act });
+      });
+      body = h("div", { className: "overflow-x-auto" },
+        h("table", { className: "w-full text-sm" },
+          h("thead", null, headRow),
+          h("tbody", null, rows)));
+    }
+
+    var footer = h("div", { className: "text-xs text-muted-foreground" },
+      "Managed by galvanize \u00b7 status refreshes every " + (POLL_MS / 1000) + "s");
+
+    return h("div", { className: "p-4 space-y-4" }, header, msgCard, body, footer);
+  }
+
+  if (window.__HERMES_PLUGINS__ && typeof window.__HERMES_PLUGINS__.register === "function") {
+    window.__HERMES_PLUGINS__.register("galvanize", TriggersPage);
+  }
+})();

galvanize/_plugins/galvanize/dashboard/manifest.json

@@ -0,0 +1,13 @@
+{
+  "name": "galvanize",
+  "label": "Triggers",
+  "description": "Event triggers that wake agent sessions — watch status, last fire, test-fire, enable/disable, remove",
+  "icon": "Zap",
+  "version": "0.2.0",
+  "tab": {
+    "path": "/triggers",
+    "position": "after:cron"
+  },
+  "entry": "dist/index.js",
+  "api": "plugin_api.py"
+}

galvanize/_plugins/galvanize/dashboard/plugin_api.py

@@ -0,0 +1,66 @@
+"""Galvanize dashboard plugin — backend API routes.
+
+Mounted at /api/plugins/galvanize/ by the dashboard plugin system
+(auth: the dashboard's session-token middleware covers /api/plugins/*).
+
+Intentionally thin: every handler calls galvanize.manage directly — the
+same ops the CLI, the agent tools, and the serve API use, so the four
+surfaces cannot drift. This is IN-PROCESS (the dashboard does not go
+through `galvanize serve`; two doors, one lock).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from fastapi import APIRouter, Body, HTTPException
+
+router = APIRouter()
+
+
+def _manage():
+    try:
+        from galvanize import manage
+        return manage
+    except ImportError:
+        raise HTTPException(
+            status_code=503,
+            detail="galvanize is not installed in the Hermes interpreter: pip install galvanize",
+        )
+
+
+@router.get("/status")
+def status() -> Dict[str, Any]:
+    return _manage().status()
+
+
+@router.get("/doctor")
+def doctor() -> Dict[str, Any]:
+    return _manage().doctor()
+
+
+@router.post("/test")
+def test(body: Dict[str, Any] = Body(...)) -> Dict[str, Any]:
+    name = str(body.get("name", "")).strip()
+    if not name:
+        raise HTTPException(status_code=400, detail="name required")
+    return _manage().test_trigger(name, body.get("payload"))
+
+
+@router.post("/toggle")
+def toggle(body: Dict[str, Any] = Body(...)) -> Dict[str, Any]:
+    from galvanize.config import set_enabled
+    name = str(body.get("name", "")).strip()
+    enabled = bool(body.get("enabled", True))
+    if not set_enabled(name, enabled):
+        raise HTTPException(status_code=404, detail=f"no trigger '{name}'")
+    return {"ok": True, "name": name, "enabled": enabled}
+
+
+@router.post("/remove")
+def remove(body: Dict[str, Any] = Body(...)) -> Dict[str, Any]:
+    name = str(body.get("name", "")).strip()
+    r = _manage().remove_trigger_op(name)
+    if not r.get("ok"):
+        raise HTTPException(status_code=400, detail=r.get("error", "remove failed"))
+    return r

galvanize/_plugins/galvanize/plugin.yaml

@@ -0,0 +1,11 @@
+name: galvanize
+version: "0.2.0"
+description: "Event-driven triggers for Hermes: wake a fresh agent session when files land, webhooks fire, or events are emitted. Gives the agent trigger_add/list/remove/test/status tools so 'trigger me when X' never silently becomes a cron poller."
+author: Jarvis Lai
+kind: standalone
+provides_tools:
+  - trigger_add
+  - trigger_list
+  - trigger_remove
+  - trigger_test
+  - trigger_status