guardplane 0.1.0 → 0.2.0

package/README.md

@@ -7,7 +7,7 @@
 
 A minimal, framework-agnostic **control plane for AI agent fleets**: a signal plane, a confidence gate, and a kill switch. Zero runtime dependencies.
 
-AI agents have started causing the production incidents they were built to resolve. In April 2026 a coding agent deleted a company's production database and its backups in about nine seconds. The pattern is not rare, and it has the same shape every time: an agent takes a real action on an incomplete view of the world, and nothing stands between its intent and the damage.
+AI agents have started causing the production incidents they were built to resolve. In April 2026 a coding agent [deleted a company's production database and its backups](https://www.theregister.com/2026/04/27/cursoropus_agent_snuffs_out_pocketos/) in about nine seconds. The pattern is not rare, and it has the same shape every time: an agent takes a real action on an incomplete view of the world, and nothing stands between its intent and the damage.
 
 This is a small reference implementation of the thing that stands in between. It is the companion to the write-up [**Who Operates the Operators?**](https://mkadri85.github.io/blog/agentic-sre-agent-fleets/).
 
@@ -148,6 +148,49 @@ The gate is the only interesting decision in the system, so it is worth stating
 
 The default threshold is `0.8` and the default auto-allowed actions are `reroute` and `pause`. Both are configurable per plane.
 
+## The burn-rate breaker (new in 0.2)
+
+Per-action gates catch the bad call in front of you. They do not catch an
+agent whose judgment is slowly degrading. The `BurnRateMonitor` alarms on the
+derivative, not the level: each agent is compared to its OWN trailing
+baseline, and when its current failure rate burns past that baseline (default
+2x), the agent is latched into `propose_only` - it may keep producing, but its
+outputs are proposals for a human, not actions.
+
+```ts
+import { controlPlane } from "guardplane";
+
+const plane = controlPlane({
+  detectors: [],
+  actions,
+  onEscalate: (ctx) => notifyHuman(ctx),
+  burnRate: { tripRatio: 2, cooldownMs: 10 * 60_000 },
+  onDemote: ({ agentId, snapshot }) =>
+    page(`agent ${agentId} demoted: ${snapshot.reason}`),
+});
+
+const obs = plane.wrap("billing-agent").observe({ type: "tool_call", ok: false });
+obs.mode; // "active" | "propose_only"
+plane.fleet(); // one BurnSnapshot per agent + kill-switch state
+```
+
+Three guards keep a degrading agent from teaching the baseline that failure
+is normal:
+
+- **learning freeze** - while burn rate is elevated, the baseline stops
+  absorbing events, so an active incident cannot poison it
+- **asymmetric learning** - the baseline learns improvement fast and
+  degradation slowly
+- **absolute ceiling** - a level backstop (default 60% failure rate) that
+  catches the slow boil the ratio can never see, including during cold start
+
+The design follows the multi-window burn-rate alerting practice from the
+[Google SRE Workbook, ch. 5](https://sre.google/workbook/alerting-on-slos/),
+pointed at agents instead of services. `BurnRateMonitor` is the kill switch's
+softer sibling: `demote(agentId)` / `reset(agentId)` mirror `trip` / `reset`,
+and `burnRateDetector(monitor)` adapts the latch into a standard `Detector`
+for custom stacks.
+
 ## What this is, and is not
 
 - It **is** a dependency-free skeleton you can read in one sitting and wire into an existing agent runtime in an afternoon.

package/dist/burn-rate.d.ts

@@ -0,0 +1,97 @@
+import type { AgentEvent, AgentId, Detector } from "./types.js";
+export type AgentMode = "active" | "propose_only";
+/** One agent's burn-rate picture at a point in time. */
+export interface BurnSnapshot {
+    agentId: AgentId;
+    /** Trailing baseline failure rate, 0..1 (EWMA over the agent's own history). */
+    baseline: number;
+    /** Failure rate over the current short window, 0..1. Null below minCurrentSamples. */
+    current: number | null;
+    /** current / max(baseline, baselineFloor). Null while still learning. */
+    burnRate: number | null;
+    samples: {
+        baseline: number;
+        current: number;
+    };
+    mode: AgentMode;
+    demotedAt?: number;
+    reason?: string;
+}
+export interface BurnRateOptions {
+    /** Burn ratio (current/baseline) that latches demotion. Default 2. */
+    tripRatio?: number;
+    /** Current-window length in ms. Default 60_000. */
+    currentWindowMs?: number;
+    /** Half-life of the trailing baseline EWMA, in ms. Default 30 minutes. */
+    baselineHalfLifeMs?: number;
+    /** Minimum events in the current window before a burn rate is computed. Default 8. */
+    minCurrentSamples?: number;
+    /** Minimum lifetime events before the baseline is trusted (cold start). Default 30. */
+    minBaselineSamples?: number;
+    /** Baseline is clamped up to this before dividing (avoids 0-baseline infinities). Default 0.02. */
+    baselineFloor?: number;
+    /** Level backstop: absolute current failure rate that trips regardless of ratio. Default 0.6. */
+    absoluteCeiling?: number;
+    /** Stop folding events into the baseline while burnRate exceeds this (poisoning guard). Default 1.25. */
+    freezeLearningAbove?: number;
+    /** Sustained-recovery ms before auto-promotion back to "active". Omit for manual-reset-only. */
+    cooldownMs?: number;
+}
+/**
+ * Per-agent trailing-baseline burn-rate breaker: alarm on the derivative, not
+ * the level. Each agent is compared to its OWN history; when its current
+ * failure rate burns past its baseline (or past an absolute ceiling), the
+ * agent is latched into "propose_only" until cooldown or manual reset.
+ *
+ * Poisoning guards, so a degrading agent cannot teach the baseline that
+ * failure is normal:
+ *  - learning freezes while burn rate exceeds `freezeLearningAbove`
+ *  - the baseline learns improvement fast and degradation slowly
+ *    (asymmetric EWMA half-life)
+ *  - `absoluteCeiling` is a level backstop that catches the slow boil the
+ *    ratio can never see
+ *
+ * Clock discipline matches SignalPlane: learning uses event.ts, reads take
+ * `now` as a parameter. Never calls Date.now(). Zero dependencies, no Node
+ * APIs, runs in the browser.
+ */
+export declare class BurnRateMonitor {
+    private readonly agents;
+    private readonly demoteListeners;
+    private readonly promoteListeners;
+    private readonly tripRatio;
+    private readonly currentWindowMs;
+    private readonly baselineHalfLifeMs;
+    private readonly minCurrentSamples;
+    private readonly minBaselineSamples;
+    private readonly baselineFloor;
+    private readonly absoluteCeiling;
+    private readonly freezeLearningAbove;
+    private readonly cooldownMs?;
+    constructor(opts?: BurnRateOptions);
+    /** Feed one event. Uses event.ts as the clock; never Date.now(). */
+    record(event: AgentEvent): void;
+    /** Current picture for one agent. Pure read; pass the clock in. */
+    snapshot(agentId: AgentId, now: number): BurnSnapshot;
+    /** Fleet-level aggregated view: one snapshot per known agent. */
+    fleet(now: number): BurnSnapshot[];
+    mode(agentId: AgentId): AgentMode;
+    /** Manual demote, mirroring KillSwitch.trip. */
+    demote(agentId: AgentId, reason?: string, now?: number): void;
+    /** Manual reset back to active, mirroring KillSwitch.reset. */
+    reset(agentId: AgentId): void;
+    onDemote(fn: (snapshot: BurnSnapshot) => void): void;
+    onPromote(fn: (agentId: AgentId) => void): void;
+    private state;
+    private trim;
+    private rates;
+    private evaluate;
+    private latch;
+    private maybePromote;
+}
+/**
+ * Wraps a BurnRateMonitor as a standard Detector so it composes with the rest
+ * of the reasoning stack. Read-only view: feed the monitor via record();
+ * the adapter only reads the latch, keyed off the last event in the window.
+ */
+export declare function burnRateDetector(monitor: BurnRateMonitor): Detector;

package/dist/burn-rate.js

@@ -0,0 +1,214 @@
+/**
+ * Per-agent trailing-baseline burn-rate breaker: alarm on the derivative, not
+ * the level. Each agent is compared to its OWN history; when its current
+ * failure rate burns past its baseline (or past an absolute ceiling), the
+ * agent is latched into "propose_only" until cooldown or manual reset.
+ *
+ * Poisoning guards, so a degrading agent cannot teach the baseline that
+ * failure is normal:
+ *  - learning freezes while burn rate exceeds `freezeLearningAbove`
+ *  - the baseline learns improvement fast and degradation slowly
+ *    (asymmetric EWMA half-life)
+ *  - `absoluteCeiling` is a level backstop that catches the slow boil the
+ *    ratio can never see
+ *
+ * Clock discipline matches SignalPlane: learning uses event.ts, reads take
+ * `now` as a parameter. Never calls Date.now(). Zero dependencies, no Node
+ * APIs, runs in the browser.
+ */
+export class BurnRateMonitor {
+    agents = new Map();
+    demoteListeners = [];
+    promoteListeners = [];
+    tripRatio;
+    currentWindowMs;
+    baselineHalfLifeMs;
+    minCurrentSamples;
+    minBaselineSamples;
+    baselineFloor;
+    absoluteCeiling;
+    freezeLearningAbove;
+    cooldownMs;
+    constructor(opts = {}) {
+        this.tripRatio = opts.tripRatio ?? 2;
+        this.currentWindowMs = opts.currentWindowMs ?? 60_000;
+        this.baselineHalfLifeMs = opts.baselineHalfLifeMs ?? 30 * 60_000;
+        this.minCurrentSamples = opts.minCurrentSamples ?? 8;
+        this.minBaselineSamples = opts.minBaselineSamples ?? 30;
+        this.baselineFloor = opts.baselineFloor ?? 0.02;
+        this.absoluteCeiling = opts.absoluteCeiling ?? 0.6;
+        this.freezeLearningAbove = opts.freezeLearningAbove ?? 1.25;
+        this.cooldownMs = opts.cooldownMs;
+    }
+    /** Feed one event. Uses event.ts as the clock; never Date.now(). */
+    record(event) {
+        const s = this.state(event.agentId);
+        const dt = s.baselineSamples === 0 ? this.baselineHalfLifeMs : Math.max(0, event.ts - s.lastTs);
+        s.lastTs = Math.max(s.lastTs, event.ts);
+        // current window first, so the freeze guard sees the incident forming
+        s.window.push({ ts: event.ts, ok: event.ok });
+        this.trim(s, event.ts);
+        const { current, burnRate } = this.rates(s);
+        const frozen = burnRate !== null && burnRate > this.freezeLearningAbove;
+        if (!frozen) {
+            const value = event.ok ? 0 : 1;
+            let alpha;
+            if (s.baselineSamples < this.minBaselineSamples) {
+                // warm-up: plain running mean, so early ordering cannot skew the start
+                alpha = 1 / (s.baselineSamples + 1);
+            }
+            else {
+                // asymmetric EWMA: improvements are learned fast, degradation slowly
+                const halfLife = value < s.baseline ? this.baselineHalfLifeMs / 6 : this.baselineHalfLifeMs;
+                alpha = 1 - Math.pow(0.5, dt / halfLife);
+            }
+            s.baseline = s.baseline + alpha * (value - s.baseline);
+            s.baselineSamples += 1;
+        }
+        this.evaluate(event.agentId, s, current, burnRate, event.ts);
+    }
+    /** Current picture for one agent. Pure read; pass the clock in. */
+    snapshot(agentId, now) {
+        const s = this.state(agentId);
+        this.trim(s, now);
+        const { current, burnRate } = this.rates(s);
+        this.maybePromote(agentId, s, burnRate, now);
+        return {
+            agentId,
+            baseline: s.baseline,
+            current,
+            burnRate,
+            samples: { baseline: s.baselineSamples, current: s.window.length },
+            mode: s.mode,
+            ...(s.demotedAt !== undefined ? { demotedAt: s.demotedAt } : {}),
+            ...(s.reason !== undefined ? { reason: s.reason } : {}),
+        };
+    }
+    /** Fleet-level aggregated view: one snapshot per known agent. */
+    fleet(now) {
+        return [...this.agents.keys()].map((id) => this.snapshot(id, now));
+    }
+    mode(agentId) {
+        return this.agents.get(agentId)?.mode ?? "active";
+    }
+    /** Manual demote, mirroring KillSwitch.trip. */
+    demote(agentId, reason = "manually demoted", now) {
+        const s = this.state(agentId);
+        if (s.mode === "propose_only")
+            return;
+        s.mode = "propose_only";
+        s.demotedAt = now ?? s.lastTs;
+        s.reason = reason;
+        const snap = this.snapshot(agentId, s.demotedAt);
+        for (const l of this.demoteListeners)
+            l(snap);
+    }
+    /** Manual reset back to active, mirroring KillSwitch.reset. */
+    reset(agentId) {
+        const s = this.state(agentId);
+        if (s.mode === "active")
+            return;
+        s.mode = "active";
+        delete s.demotedAt;
+        delete s.reason;
+        for (const l of this.promoteListeners)
+            l(agentId);
+    }
+    onDemote(fn) {
+        this.demoteListeners.push(fn);
+    }
+    onPromote(fn) {
+        this.promoteListeners.push(fn);
+    }
+    // ---- internals ----
+    state(agentId) {
+        let s = this.agents.get(agentId);
+        if (!s) {
+            s = { baseline: 0, baselineSamples: 0, lastTs: 0, window: [], mode: "active" };
+            this.agents.set(agentId, s);
+        }
+        return s;
+    }
+    trim(s, now) {
+        while (s.window.length > 0 && now - s.window[0].ts > this.currentWindowMs) {
+            s.window.shift();
+        }
+    }
+    rates(s) {
+        if (s.window.length < this.minCurrentSamples)
+            return { current: null, burnRate: null };
+        const failures = s.window.filter((e) => !e.ok).length;
+        const current = failures / s.window.length;
+        if (s.baselineSamples < this.minBaselineSamples)
+            return { current, burnRate: null };
+        const burnRate = current / Math.max(s.baseline, this.baselineFloor);
+        return { current, burnRate };
+    }
+    evaluate(agentId, s, current, burnRate, now) {
+        if (s.mode === "propose_only") {
+            this.maybePromote(agentId, s, burnRate, now);
+            return;
+        }
+        if (current === null)
+            return;
+        // level backstop applies even during baseline cold start
+        if (current >= this.absoluteCeiling) {
+            this.latch(agentId, s, now, `failure rate ${(current * 100).toFixed(0)}% >= ceiling ${(this.absoluteCeiling * 100).toFixed(0)}%`);
+            return;
+        }
+        if (burnRate !== null && burnRate >= this.tripRatio) {
+            this.latch(agentId, s, now, `burn rate ${burnRate.toFixed(1)}x own baseline (${(s.baseline * 100).toFixed(1)}% -> ${(current * 100).toFixed(0)}%)`);
+        }
+    }
+    latch(agentId, s, now, reason) {
+        s.mode = "propose_only";
+        s.demotedAt = now;
+        s.reason = reason;
+        const snap = {
+            agentId,
+            baseline: s.baseline,
+            current: this.rates(s).current,
+            burnRate: this.rates(s).burnRate,
+            samples: { baseline: s.baselineSamples, current: s.window.length },
+            mode: s.mode,
+            demotedAt: now,
+            reason,
+        };
+        for (const l of this.demoteListeners)
+            l(snap);
+    }
+    maybePromote(agentId, s, burnRate, now) {
+        if (s.mode !== "propose_only" || this.cooldownMs === undefined || s.demotedAt === undefined)
+            return;
+        if (now - s.demotedAt < this.cooldownMs)
+            return;
+        if (burnRate !== null && burnRate >= 1)
+            return; // still burning; wait
+        s.mode = "active";
+        delete s.demotedAt;
+        delete s.reason;
+        for (const l of this.promoteListeners)
+            l(agentId);
+    }
+}
+/**
+ * Wraps a BurnRateMonitor as a standard Detector so it composes with the rest
+ * of the reasoning stack. Read-only view: feed the monitor via record();
+ * the adapter only reads the latch, keyed off the last event in the window.
+ */
+export function burnRateDetector(monitor) {
+    return (events) => {
+        const last = events[events.length - 1];
+        if (!last)
+            return null;
+        const snap = monitor.snapshot(last.agentId, last.ts);
+        if (snap.mode === "propose_only") {
+            return {
+                status: "failing",
+                confidence: 0.9,
+                reason: snap.reason ?? "burn-rate breaker latched: propose-only",
+            };
+        }
+        return null;
+    };
+}

package/dist/control-plane.d.ts

@@ -3,6 +3,7 @@ import { SignalPlane, type SignalSink } from "./signal-plane.js";
 import { KillSwitch } from "./kill-switch.js";
 import { type GatePolicy } from "./confidence-gate.js";
 import type { Actions } from "./actions.js";
+import { BurnRateMonitor, type AgentMode, type BurnRateOptions, type BurnSnapshot } from "./burn-rate.js";
 /** Everything the control plane hands a human when it decides to escalate. */
 export interface EscalationContext {
     agentId: AgentId;
@@ -27,11 +28,35 @@ export interface ControlPlaneConfig {
     now?: () => number;
     /** Map a diagnosis to a proposed remediation. Default: pause. */
     planRemediation?: (health: Health, agentId: AgentId) => Remediation;
+    /**
+     * Enable the baseline-relative burn-rate breaker: alarm on the derivative,
+     * not the level. Pass options, or a prebuilt monitor to share/inspect it.
+     */
+    burnRate?: BurnRateOptions | BurnRateMonitor;
+    /** Called when the breaker latches an agent into propose-only. */
+    onDemote?: (ctx: {
+        agentId: AgentId;
+        snapshot: BurnSnapshot;
+        replay: AgentEvent[];
+    }) => void;
 }
 /** What `observe` tells the caller: may the agent proceed, and why. */
 export interface Observation {
     allowed: boolean;
     decision: Decision;
+    /**
+     * "propose_only" while the burn-rate breaker has this agent demoted: the
+     * agent may keep producing, but its outputs are proposals for a human, not
+     * actions. "active" otherwise (and always, when burnRate is not configured).
+     */
+    mode: AgentMode;
+}
+/** Fleet-level health view: burn snapshots plus kill-switch state per agent. */
+export interface FleetView {
+    agents: Array<BurnSnapshot & {
+        killed: boolean;
+    }>;
+    generatedAt: number;
 }
 /** A per-agent handle onto the control plane. */
 export interface WrappedAgent {
@@ -51,9 +76,13 @@ export declare class ControlPlane {
     private readonly cfg;
     readonly signals: SignalPlane;
     readonly killSwitch: KillSwitch;
+    /** The burn-rate breaker, exposed like killSwitch. Undefined unless configured. */
+    readonly burnRate?: BurnRateMonitor;
     private readonly gate;
     private readonly now;
     constructor(cfg: ControlPlaneConfig);
+    /** Fleet-level health view across every agent the plane has seen. */
+    fleet(): FleetView;
     /** Get a handle for one agent in the fleet. */
     wrap(agentId: AgentId): WrappedAgent;
     private observe;

package/dist/control-plane.js

@@ -1,6 +1,7 @@
 import { SignalPlane } from "./signal-plane.js";
 import { KillSwitch } from "./kill-switch.js";
 import { confidenceGate } from "./confidence-gate.js";
+import { BurnRateMonitor } from "./burn-rate.js";
 /**
  * The control plane. Wraps a fleet of agents so that every decision is recorded
  * (signal plane), diagnosed (reasoning), gated (confidence gate), and either
@@ -10,6 +11,8 @@ export class ControlPlane {
     cfg;
     signals;
     killSwitch;
+    /** The burn-rate breaker, exposed like killSwitch. Undefined unless configured. */
+    burnRate;
     gate;
     now;
     constructor(cfg) {
@@ -18,6 +21,44 @@ export class ControlPlane {
         this.killSwitch = new KillSwitch();
         this.gate = confidenceGate(cfg.gate);
         this.now = cfg.now ?? (() => Date.now());
+        if (cfg.burnRate) {
+            this.burnRate = cfg.burnRate instanceof BurnRateMonitor
+                ? cfg.burnRate
+                : new BurnRateMonitor(cfg.burnRate);
+            if (cfg.onDemote) {
+                this.burnRate.onDemote((snapshot) => {
+                    cfg.onDemote?.({ agentId: snapshot.agentId, snapshot, replay: this.signals.replay(snapshot.agentId) });
+                });
+            }
+        }
+    }
+    /** Fleet-level health view across every agent the plane has seen. */
+    fleet() {
+        const now = this.now();
+        const killed = (id) => this.killSwitch.isTripped(id);
+        if (this.burnRate) {
+            const seen = new Set();
+            const agents = this.burnRate.fleet(now).map((s) => {
+                seen.add(s.agentId);
+                return { ...s, killed: killed(s.agentId) };
+            });
+            for (const e of this.signals.all()) {
+                if (!seen.has(e.agentId)) {
+                    seen.add(e.agentId);
+                    agents.push({ ...this.burnRate.snapshot(e.agentId, now), killed: killed(e.agentId) });
+                }
+            }
+            return { agents, generatedAt: now };
+        }
+        const ids = [...new Set(this.signals.all().map((e) => e.agentId))];
+        return {
+            agents: ids.map((agentId) => ({
+                agentId, baseline: 0, current: null, burnRate: null,
+                samples: { baseline: 0, current: 0 }, mode: "active",
+                killed: killed(agentId),
+            })),
+            generatedAt: now,
+        };
     }
     /** Get a handle for one agent in the fleet. */
     wrap(agentId) {
@@ -26,7 +67,11 @@ export class ControlPlane {
     observe(agentId, raw) {
         // 1. Kill switch: a hard stop that beats everything else.
         if (this.killSwitch.isTripped(agentId)) {
-            return { allowed: false, decision: { action: "blocked", reason: "kill switch tripped" } };
+            return {
+                allowed: false,
+                decision: { action: "blocked", reason: "kill switch tripped" },
+                mode: this.burnRate?.mode(agentId) ?? "active",
+            };
         }
         // 2. Signal plane: record the decision as one replayable event.
         const event = {
@@ -39,12 +84,25 @@ export class ControlPlane {
             detail: raw.detail,
         };
         this.signals.record(event);
+        this.burnRate?.record(event);
+        // 2b. Burn-rate breaker: while demoted, everything is a proposal.
+        if (this.burnRate && this.burnRate.mode(agentId) === "propose_only") {
+            const snap = this.burnRate.snapshot(agentId, event.ts);
+            return {
+                allowed: true,
+                mode: "propose_only",
+                decision: {
+                    action: "escalate",
+                    reason: snap.reason ?? "burn-rate breaker latched: propose-only until reset or cooldown",
+                },
+            };
+        }
         // 3. Reasoning layer: is this agent actually broken?
         const windowMs = this.cfg.windowMs ?? 60_000;
         const window = this.signals.recent(agentId, windowMs, this.now());
         const health = this.diagnose(window);
         if (health.status === "healthy") {
-            return { allowed: true, decision: { action: "allow", reason: "healthy" } };
+            return { allowed: true, decision: { action: "allow", reason: "healthy" }, mode: "active" };
         }
         // 4. Confidence gate: act or escalate.
         const remediation = (this.cfg.planRemediation ?? defaultPlan)(health, agentId);
@@ -53,15 +111,15 @@ export class ControlPlane {
         if (decision.action === "auto_remediate" && decision.remediation) {
             void this.apply(agentId, decision.remediation);
             // a reroute lets the agent keep working; a pause/rollback stops this step
-            return { allowed: decision.remediation.kind === "reroute", decision };
+            return { allowed: decision.remediation.kind === "reroute", decision, mode: "active" };
         }
         if (decision.action === "escalate") {
             // contain first, then hand the full replay to a human
             void this.cfg.actions.pause(agentId, "containing before human review");
             this.cfg.onEscalate({ agentId, health, decision, replay: this.signals.replay(agentId) });
-            return { allowed: false, decision };
+            return { allowed: false, decision, mode: "active" };
         }
-        return { allowed: true, decision };
+        return { allowed: true, decision, mode: "active" };
     }
     diagnose(events) {
         const findings = this.cfg.detectors

package/dist/index.d.ts

@@ -6,9 +6,11 @@ export type { KillScope } from "./kill-switch.js";
 export { confidenceGate } from "./confidence-gate.js";
 export type { GatePolicy } from "./confidence-gate.js";
 export { loopDetector, costRunawayDetector, errorRateDetector, driftDetector } from "./detector.js";
+export { BurnRateMonitor, burnRateDetector } from "./burn-rate.js";
+export type { AgentMode, BurnRateOptions, BurnSnapshot } from "./burn-rate.js";
 export type { Actions } from "./actions.js";
 export { ControlPlane } from "./control-plane.js";
-export type { ControlPlaneConfig, WrappedAgent, Observation, ObservableEvent, EscalationContext, } from "./control-plane.js";
+export type { ControlPlaneConfig, WrappedAgent, Observation, ObservableEvent, EscalationContext, FleetView, } from "./control-plane.js";
 import { ControlPlane, type ControlPlaneConfig } from "./control-plane.js";
 /** Convenience factory. `const plane = controlPlane({ ... })`. */
 export declare function controlPlane(cfg: ControlPlaneConfig): ControlPlane;

package/dist/index.js

@@ -2,6 +2,7 @@ export { SignalPlane } from "./signal-plane.js";
 export { KillSwitch } from "./kill-switch.js";
 export { confidenceGate } from "./confidence-gate.js";
 export { loopDetector, costRunawayDetector, errorRateDetector, driftDetector } from "./detector.js";
+export { BurnRateMonitor, burnRateDetector } from "./burn-rate.js";
 export { ControlPlane } from "./control-plane.js";
 import { ControlPlane } from "./control-plane.js";
 /** Convenience factory. `const plane = controlPlane({ ... })`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "guardplane",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A minimal, framework-agnostic control plane for AI agent fleets: signal plane, confidence gate, and kill switch.",
   "type": "module",
   "license": "MIT",
@@ -43,5 +43,9 @@
     "tsx": "^4.19.2",
     "typescript": "^5.7.2",
     "vitest": "^2.1.8"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
   }
 }