@renseiai/agentfactory-server 0.8.0

package/dist/src/env-validation.js

@@ -0,0 +1,134 @@
+/**
+ * Environment Variable Validation
+ *
+ * Validates required environment variables on startup.
+ * Fails fast if critical security variables are missing in production.
+ */
+import { createLogger } from './logger.js';
+const log = createLogger('env-validation');
+/**
+ * Default required environment variables for production
+ * These are critical for security and must be present
+ */
+const DEFAULT_REQUIRED_VARS = [
+    'LINEAR_WEBHOOK_SECRET',
+    'CRON_SECRET',
+    'WORKER_API_KEY',
+    'SESSION_HASH_SALT',
+];
+/**
+ * Default minimum length validations
+ */
+const DEFAULT_MIN_LENGTH_VARS = [
+    { name: 'SESSION_HASH_SALT', minLength: 32 },
+];
+/**
+ * Check if running in production environment
+ */
+function isProduction() {
+    return (process.env.NODE_ENV === 'production' ||
+        process.env.VERCEL_ENV === 'production');
+}
+/**
+ * Validate environment variables
+ *
+ * In production: All required vars must be present
+ * In development: Log warnings for missing vars but don't fail
+ *
+ * @param config - Optional configuration to override defaults
+ * @returns Validation result with missing vars
+ */
+export function validateEnv(config) {
+    const missing = [];
+    const warnings = [];
+    const requiredVars = config?.requiredVars ?? DEFAULT_REQUIRED_VARS;
+    const minLengthVars = config?.minLengthVars ?? DEFAULT_MIN_LENGTH_VARS;
+    for (const varName of requiredVars) {
+        if (!process.env[varName]) {
+            if (isProduction()) {
+                missing.push(varName);
+            }
+            else {
+                warnings.push(varName);
+            }
+        }
+    }
+    // Additional validation for minimum length variables
+    for (const { name, minLength } of minLengthVars) {
+        const value = process.env[name];
+        if (value && value.length < minLength) {
+            const msg = `${name} should be at least ${minLength} characters for security`;
+            if (isProduction()) {
+                missing.push(`${name} (too short)`);
+            }
+            else {
+                warnings.push(msg);
+            }
+        }
+    }
+    return {
+        valid: missing.length === 0,
+        missing,
+        warnings,
+    };
+}
+/**
+ * Validate and fail fast if critical vars are missing
+ *
+ * Call this at application startup to ensure required
+ * environment variables are configured.
+ *
+ * @param config - Optional configuration to override defaults
+ * @throws Error if required vars are missing in production
+ */
+export function validateEnvOrThrow(config) {
+    const result = validateEnv(config);
+    // Log warnings for development
+    if (result.warnings.length > 0) {
+        log.warn('Missing environment variables (development mode)', {
+            variables: result.warnings,
+            hint: 'These are required in production',
+        });
+    }
+    // Fail in production if required vars are missing
+    if (!result.valid) {
+        const errorMsg = `Missing required environment variables: ${result.missing.join(', ')}`;
+        log.error(errorMsg, {
+            missing: result.missing,
+            environment: process.env.NODE_ENV,
+        });
+        throw new Error(errorMsg);
+    }
+    log.debug('Environment validation passed');
+}
+/**
+ * Check if webhook signature verification is configured
+ */
+export function isWebhookSecretConfigured() {
+    return !!process.env.LINEAR_WEBHOOK_SECRET;
+}
+/**
+ * Check if cron authentication is configured
+ */
+export function isCronSecretConfigured() {
+    return !!process.env.CRON_SECRET;
+}
+/**
+ * Check if session hashing is configured
+ */
+export function isSessionHashConfigured() {
+    const salt = process.env.SESSION_HASH_SALT;
+    return !!salt && salt.length >= 32;
+}
+/**
+ * Get session hash salt
+ * @param saltEnvVar - Environment variable name for the salt (default: SESSION_HASH_SALT)
+ * @throws Error if not configured
+ */
+export function getSessionHashSalt(saltEnvVar = 'SESSION_HASH_SALT') {
+    const salt = process.env[saltEnvVar];
+    if (!salt) {
+        throw new Error(`${saltEnvVar} not configured`);
+    }
+    return salt;
+}

package/dist/src/governor-dedup.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Redis Event Deduplicator
+ *
+ * Production EventDeduplicator backed by Redis SETNX with TTL.
+ * Key pattern: `governor:dedup:{dedupKey}`
+ */
+import type { EventDeduplicator, EventDeduplicatorConfig } from '@renseiai/agentfactory';
+export declare class RedisEventDeduplicator implements EventDeduplicator {
+    private readonly windowMs;
+    private readonly keyPrefix;
+    constructor(config?: Partial<EventDeduplicatorConfig>, keyPrefix?: string);
+    isDuplicate(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+}
+//# sourceMappingURL=governor-dedup.d.ts.map

package/dist/src/governor-dedup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor-dedup.d.ts","sourceRoot":"","sources":["../../src/governor-dedup.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAA;AAQxF,qBAAa,sBAAuB,YAAW,iBAAiB;IAC9D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;gBAGhC,MAAM,GAAE,OAAO,CAAC,uBAAuB,CAAM,EAC7C,SAAS,SAAmB;IAMxB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAS1C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAK7B"}

package/dist/src/governor-dedup.js

@@ -0,0 +1,31 @@
+/**
+ * Redis Event Deduplicator
+ *
+ * Production EventDeduplicator backed by Redis SETNX with TTL.
+ * Key pattern: `governor:dedup:{dedupKey}`
+ */
+import { DEFAULT_DEDUP_CONFIG } from '@renseiai/agentfactory';
+import { redisSetNX } from './redis.js';
+// ---------------------------------------------------------------------------
+// RedisEventDeduplicator
+// ---------------------------------------------------------------------------
+export class RedisEventDeduplicator {
+    windowMs;
+    keyPrefix;
+    constructor(config = {}, keyPrefix = 'governor:dedup') {
+        this.windowMs = config.windowMs ?? DEFAULT_DEDUP_CONFIG.windowMs;
+        this.keyPrefix = keyPrefix;
+    }
+    async isDuplicate(key) {
+        const redisKey = `${this.keyPrefix}:${key}`;
+        const ttlSeconds = Math.max(1, Math.ceil(this.windowMs / 1000));
+        // SETNX returns true if key was newly set (not a duplicate)
+        const wasSet = await redisSetNX(redisKey, '1', ttlSeconds);
+        return !wasSet; // if we couldn't set, it's a duplicate
+    }
+    async clear() {
+        // In production, keys auto-expire via TTL.
+        // Explicit clear is mainly for testing — not implemented for Redis
+        // since test suites should use InMemoryEventDeduplicator.
+    }
+}

package/dist/src/governor-event-bus.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Redis Event Bus
+ *
+ * Production GovernorEventBus backed by Redis Streams.
+ * Uses a consumer group for reliable delivery and horizontal scaling.
+ *
+ * Stream: `governor:events`
+ * Consumer group: `governor-group`
+ * MAXLEN: 10,000 (approximate trim)
+ */
+import type { GovernorEvent, GovernorEventBus } from '@renseiai/agentfactory';
+export interface RedisEventBusConfig {
+    /** Redis stream key (default: 'governor:events') */
+    streamKey?: string;
+    /** Consumer group name (default: 'governor-group') */
+    groupName?: string;
+    /** Consumer name within the group (default: hostname or random) */
+    consumerName?: string;
+    /** Max stream length — approximate trim (default: 10000) */
+    maxLen?: number;
+    /** Block timeout in milliseconds for XREADGROUP (default: 5000) */
+    blockMs?: number;
+}
+export declare class RedisEventBus implements GovernorEventBus {
+    private readonly streamKey;
+    private readonly groupName;
+    private readonly consumerName;
+    private readonly maxLen;
+    private readonly blockMs;
+    private closed;
+    private groupCreated;
+    constructor(config?: RedisEventBusConfig);
+    /**
+     * Ensure the consumer group exists. Idempotent — safe to call multiple times.
+     */
+    private ensureGroup;
+    publish(event: GovernorEvent): Promise<string>;
+    subscribe(): AsyncGenerator<{
+        id: string;
+        event: GovernorEvent;
+    }>;
+    ack(eventId: string): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Re-deliver pending messages (claimed but not acked from a previous run).
+     */
+    private readPending;
+    /**
+     * Parse a Redis stream message fields array into a GovernorEvent.
+     * Fields come as [key1, val1, key2, val2, ...].
+     */
+    private parseEvent;
+}
+//# sourceMappingURL=governor-event-bus.d.ts.map

package/dist/src/governor-event-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor-event-bus.d.ts","sourceRoot":"","sources":["../../src/governor-event-bus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAO7E,MAAM,WAAW,mBAAmB;IAClC,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,mEAAmE;IACnE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAWD,qBAAa,aAAc,YAAW,gBAAgB;IACpD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAClC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAQ;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAChC,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,YAAY,CAAQ;gBAEhB,MAAM,GAAE,mBAAwB;IAQ5C;;OAEG;YACW,WAAW;IAenB,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IA0B7C,SAAS,IAAI,cAAc,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,aAAa,CAAA;KAAE,CAAC;IAiDlE,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B;;OAEG;YACY,WAAW;IAiC1B;;;OAGG;IACH,OAAO,CAAC,UAAU;CAanB"}

package/dist/src/governor-event-bus.js

@@ -0,0 +1,152 @@
+/**
+ * Redis Event Bus
+ *
+ * Production GovernorEventBus backed by Redis Streams.
+ * Uses a consumer group for reliable delivery and horizontal scaling.
+ *
+ * Stream: `governor:events`
+ * Consumer group: `governor-group`
+ * MAXLEN: 10,000 (approximate trim)
+ */
+import { getRedisClient } from './redis.js';
+const DEFAULT_STREAM_KEY = 'governor:events';
+const DEFAULT_GROUP_NAME = 'governor-group';
+const DEFAULT_MAX_LEN = 10_000;
+const DEFAULT_BLOCK_MS = 5_000;
+// ---------------------------------------------------------------------------
+// RedisEventBus
+// ---------------------------------------------------------------------------
+export class RedisEventBus {
+    streamKey;
+    groupName;
+    consumerName;
+    maxLen;
+    blockMs;
+    closed = false;
+    groupCreated = false;
+    constructor(config = {}) {
+        this.streamKey = config.streamKey ?? DEFAULT_STREAM_KEY;
+        this.groupName = config.groupName ?? DEFAULT_GROUP_NAME;
+        this.consumerName = config.consumerName ?? `governor-${process.pid}-${Date.now()}`;
+        this.maxLen = config.maxLen ?? DEFAULT_MAX_LEN;
+        this.blockMs = config.blockMs ?? DEFAULT_BLOCK_MS;
+    }
+    /**
+     * Ensure the consumer group exists. Idempotent — safe to call multiple times.
+     */
+    async ensureGroup() {
+        if (this.groupCreated)
+            return;
+        const redis = getRedisClient();
+        try {
+            await redis.xgroup('CREATE', this.streamKey, this.groupName, '0', 'MKSTREAM');
+        }
+        catch (err) {
+            // BUSYGROUP = group already exists, which is fine
+            if (err instanceof Error && !err.message.includes('BUSYGROUP')) {
+                throw err;
+            }
+        }
+        this.groupCreated = true;
+    }
+    async publish(event) {
+        if (this.closed) {
+            throw new Error('Event bus is closed');
+        }
+        const redis = getRedisClient();
+        const payload = JSON.stringify(event);
+        // XADD with approximate MAXLEN trim
+        const id = await redis.xadd(this.streamKey, 'MAXLEN', '~', String(this.maxLen), '*', 'data', payload);
+        if (!id) {
+            throw new Error('XADD returned null — stream write failed');
+        }
+        return id;
+    }
+    async *subscribe() {
+        await this.ensureGroup();
+        const redis = getRedisClient();
+        // First, re-deliver any pending messages (from previous crash)
+        yield* this.readPending(redis);
+        // Then read new messages
+        while (!this.closed) {
+            try {
+                const results = await redis.xreadgroup('GROUP', this.groupName, this.consumerName, 'COUNT', '1', 'BLOCK', this.blockMs, 'STREAMS', this.streamKey, '>');
+                if (!results || results.length === 0) {
+                    continue; // timeout, loop back
+                }
+                for (const [, messages] of results) {
+                    for (const [id, fields] of messages) {
+                        const event = this.parseEvent(fields);
+                        if (event) {
+                            yield { id, event };
+                        }
+                        else {
+                            // Malformed event — ack and skip
+                            await this.ack(id);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (this.closed)
+                    return;
+                // Log and continue on transient errors
+                console.error('[redis-event-bus] Error reading from stream:', err);
+                // Brief backoff before retry
+                await new Promise((r) => setTimeout(r, 1000));
+            }
+        }
+    }
+    async ack(eventId) {
+        const redis = getRedisClient();
+        await redis.xack(this.streamKey, this.groupName, eventId);
+    }
+    async close() {
+        this.closed = true;
+    }
+    // ---- Internal ----
+    /**
+     * Re-deliver pending messages (claimed but not acked from a previous run).
+     */
+    async *readPending(redis) {
+        try {
+            const results = await redis.xreadgroup('GROUP', this.groupName, this.consumerName, 'COUNT', '100', 'STREAMS', this.streamKey, '0');
+            if (!results || results.length === 0)
+                return;
+            for (const [, messages] of results) {
+                for (const [id, fields] of messages) {
+                    if (!fields || fields.length === 0)
+                        continue; // already acked
+                    const event = this.parseEvent(fields);
+                    if (event) {
+                        yield { id, event };
+                    }
+                    else {
+                        await this.ack(id);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error('[redis-event-bus] Error reading pending messages:', err);
+        }
+    }
+    /**
+     * Parse a Redis stream message fields array into a GovernorEvent.
+     * Fields come as [key1, val1, key2, val2, ...].
+     */
+    parseEvent(fields) {
+        try {
+            // Find the 'data' field
+            for (let i = 0; i < fields.length; i += 2) {
+                if (fields[i] === 'data') {
+                    return JSON.parse(fields[i + 1]);
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/src/governor-storage.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Governor Storage — Redis Implementation
+ *
+ * Redis-backed storage adapter for the human touchpoint override state.
+ * Implements the OverrideStorage interface from @renseiai/agentfactory (packages/core).
+ */
+import type { OverrideStorage, OverrideState } from '@renseiai/agentfactory';
+/**
+ * Redis-backed override storage for production use.
+ *
+ * Stores override state under `governor:override:{issueId}` keys
+ * with a 30-day TTL.
+ */
+export declare class RedisOverrideStorage implements OverrideStorage {
+    /**
+     * Get the override state for an issue from Redis
+     */
+    get(issueId: string): Promise<OverrideState | null>;
+    /**
+     * Persist override state for an issue to Redis
+     */
+    set(issueId: string, state: OverrideState): Promise<void>;
+    /**
+     * Remove override state for an issue from Redis
+     */
+    clear(issueId: string): Promise<void>;
+}
+//# sourceMappingURL=governor-storage.d.ts.map

package/dist/src/governor-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor-storage.d.ts","sourceRoot":"","sources":["../../src/governor-storage.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAgB5E;;;;;GAKG;AACH,qBAAa,oBAAqB,YAAW,eAAe;IAC1D;;OAEG;IACG,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAWzD;;OAEG;IACG,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAM/D;;OAEG;IACG,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAK5C"}

package/dist/src/governor-storage.js

@@ -0,0 +1,52 @@
+/**
+ * Governor Storage — Redis Implementation
+ *
+ * Redis-backed storage adapter for the human touchpoint override state.
+ * Implements the OverrideStorage interface from @renseiai/agentfactory (packages/core).
+ */
+import { redisSet, redisGet, redisDel } from './redis.js';
+const log = {
+    info: (msg, data) => console.log(`[governor-storage] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[governor-storage] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[governor-storage] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+/** Redis key prefix for governor override state */
+const GOVERNOR_OVERRIDE_PREFIX = 'governor:override:';
+/** TTL for override state: 30 days in seconds */
+const GOVERNOR_OVERRIDE_TTL = 30 * 24 * 60 * 60;
+/**
+ * Redis-backed override storage for production use.
+ *
+ * Stores override state under `governor:override:{issueId}` keys
+ * with a 30-day TTL.
+ */
+export class RedisOverrideStorage {
+    /**
+     * Get the override state for an issue from Redis
+     */
+    async get(issueId) {
+        const key = `${GOVERNOR_OVERRIDE_PREFIX}${issueId}`;
+        const state = await redisGet(key);
+        if (state) {
+            log.debug('Retrieved override state', { issueId, type: state.directive.type });
+        }
+        return state;
+    }
+    /**
+     * Persist override state for an issue to Redis
+     */
+    async set(issueId, state) {
+        const key = `${GOVERNOR_OVERRIDE_PREFIX}${issueId}`;
+        await redisSet(key, state, GOVERNOR_OVERRIDE_TTL);
+        log.info('Stored override state', { issueId, type: state.directive.type });
+    }
+    /**
+     * Remove override state for an issue from Redis
+     */
+    async clear(issueId) {
+        const key = `${GOVERNOR_OVERRIDE_PREFIX}${issueId}`;
+        await redisDel(key);
+        log.info('Cleared override state', { issueId });
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,26 @@
+export * from './logger.js';
+export * from './types.js';
+export * from './redis.js';
+export * from './session-storage.js';
+export * from './work-queue.js';
+export * from './worker-storage.js';
+export * from './issue-lock.js';
+export * from './agent-tracking.js';
+export * from './webhook-idempotency.js';
+export * from './pending-prompts.js';
+export * from './orphan-cleanup.js';
+export * from './worker-auth.js';
+export * from './session-hash.js';
+export * from './rate-limit.js';
+export * from './token-storage.js';
+export * from './env-validation.js';
+export * from './governor-storage.js';
+export * from './processing-state-storage.js';
+export * from './governor-event-bus.js';
+export * from './governor-dedup.js';
+export * from './redis-rate-limiter.js';
+export * from './redis-circuit-breaker.js';
+export * from './quota-tracker.js';
+export * from './a2a-types.js';
+export * from './a2a-server.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAG3B,cAAc,YAAY,CAAA;AAG1B,cAAc,YAAY,CAAA;AAG1B,cAAc,sBAAsB,CAAA;AAGpC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,0BAA0B,CAAA;AAGxC,cAAc,sBAAsB,CAAA;AAGpC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,kBAAkB,CAAA;AAGhC,cAAc,mBAAmB,CAAA;AAGjC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,oBAAoB,CAAA;AAGlC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,uBAAuB,CAAA;AAGrC,cAAc,+BAA+B,CAAA;AAG7C,cAAc,yBAAyB,CAAA;AAGvC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,yBAAyB,CAAA;AAGvC,cAAc,4BAA4B,CAAA;AAG1C,cAAc,oBAAoB,CAAA;AAGlC,cAAc,gBAAgB,CAAA;AAG9B,cAAc,iBAAiB,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,50 @@
+// Logger
+export * from './logger.js';
+// Types
+export * from './types.js';
+// Redis client
+export * from './redis.js';
+// Session management
+export * from './session-storage.js';
+// Work queue
+export * from './work-queue.js';
+// Worker pool
+export * from './worker-storage.js';
+// Issue locking
+export * from './issue-lock.js';
+// Agent tracking
+export * from './agent-tracking.js';
+// Webhook idempotency
+export * from './webhook-idempotency.js';
+// Pending prompts
+export * from './pending-prompts.js';
+// Orphan cleanup
+export * from './orphan-cleanup.js';
+// Worker authentication
+export * from './worker-auth.js';
+// Session hashing
+export * from './session-hash.js';
+// Rate limiting
+export * from './rate-limit.js';
+// Token storage
+export * from './token-storage.js';
+// Environment validation
+export * from './env-validation.js';
+// Governor storage (Redis-backed override state)
+export * from './governor-storage.js';
+// Processing state storage (Redis-backed top-of-funnel phase tracking)
+export * from './processing-state-storage.js';
+// Governor event bus (Redis Streams)
+export * from './governor-event-bus.js';
+// Governor event deduplicator (Redis SETNX)
+export * from './governor-dedup.js';
+// Redis-backed Linear API rate limiter (shared across processes)
+export * from './redis-rate-limiter.js';
+// Redis-backed circuit breaker (shared across processes)
+export * from './redis-circuit-breaker.js';
+// Linear API quota tracker (reads rate limit headers)
+export * from './quota-tracker.js';
+// A2A Protocol types
+export * from './a2a-types.js';
+// A2A Server (AgentCard + JSON-RPC handlers)
+export * from './a2a-server.js';