@renseiai/agentfactory-server 0.8.0

package/dist/src/processing-state-storage.js

@@ -0,0 +1,61 @@
+/**
+ * Redis-backed Processing State Storage
+ *
+ * Implements the `ProcessingStateStorage` interface from `@renseiai/agentfactory`
+ * using Redis for persistence. Used by the top-of-funnel governor to track
+ * which processing phases (research, backlog-creation) have been completed
+ * for each issue.
+ *
+ * Key format: `governor:processing:{issueId}:{phase}`
+ * TTL: 30 days (matches workflow state TTL)
+ */
+import { redisSet, redisGet, redisDel, redisExists } from './redis.js';
+// Redis key prefix for processing state records
+const PROCESSING_STATE_PREFIX = 'governor:processing:';
+// 30-day TTL in seconds
+const PROCESSING_STATE_TTL = 30 * 24 * 60 * 60;
+/**
+ * Build the Redis key for a specific issue + phase combination.
+ */
+function redisKey(issueId, phase) {
+    return `${PROCESSING_STATE_PREFIX}${issueId}:${phase}`;
+}
+/**
+ * Redis-backed implementation of `ProcessingStateStorage`.
+ *
+ * Each phase completion is stored as an independent key so that phases
+ * can be checked and cleared independently without affecting each other.
+ */
+export class RedisProcessingStateStorage {
+    /**
+     * Check whether a given phase has already been completed for an issue.
+     */
+    async isPhaseCompleted(issueId, phase) {
+        return redisExists(redisKey(issueId, phase));
+    }
+    /**
+     * Mark a phase as completed for an issue.
+     * Stores a `ProcessingRecord` JSON object with a 30-day TTL.
+     */
+    async markPhaseCompleted(issueId, phase, sessionId) {
+        const record = {
+            issueId,
+            phase,
+            completedAt: Date.now(),
+            sessionId,
+        };
+        await redisSet(redisKey(issueId, phase), record, PROCESSING_STATE_TTL);
+    }
+    /**
+     * Clear a phase completion record for an issue.
+     */
+    async clearPhase(issueId, phase) {
+        await redisDel(redisKey(issueId, phase));
+    }
+    /**
+     * Retrieve the processing record for a phase, if it exists.
+     */
+    async getPhaseRecord(issueId, phase) {
+        return redisGet(redisKey(issueId, phase));
+    }
+}

package/dist/src/quota-tracker.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Linear API Quota Tracker
+ *
+ * Stores Linear's rate limit response headers in Redis so any component
+ * can check the remaining budget before making a call.
+ *
+ * Redis keys:
+ * - `linear:quota:{workspaceId}:requests_remaining`
+ * - `linear:quota:{workspaceId}:complexity_remaining`
+ * - `linear:quota:{workspaceId}:requests_reset`  (timestamp)
+ * - `linear:quota:{workspaceId}:updated_at`       (timestamp)
+ *
+ * Usage:
+ * - After every Linear API call, call `recordQuota()` with response headers
+ * - Before making a call, check `getQuota()` to see remaining budget
+ * - If `requestsRemaining < LOW_QUOTA_THRESHOLD`, the rate limiter
+ *   should proactively throttle
+ */
+/** Threshold below which we should proactively throttle */
+export declare const LOW_QUOTA_THRESHOLD = 500;
+export interface LinearQuotaSnapshot {
+    /** Remaining request quota (from X-RateLimit-Requests-Remaining) */
+    requestsRemaining: number | null;
+    /** Remaining complexity quota (from X-RateLimit-Complexity-Remaining) */
+    complexityRemaining: number | null;
+    /** Timestamp when request quota resets (from X-RateLimit-Requests-Reset) */
+    requestsReset: number | null;
+    /** When this snapshot was last updated */
+    updatedAt: number;
+}
+/**
+ * Record quota information from Linear API response headers.
+ *
+ * Call this after every successful Linear API response.
+ */
+export declare function recordQuota(workspaceId: string, headers: {
+    requestsRemaining?: string | number | null;
+    complexityRemaining?: string | number | null;
+    requestsReset?: string | number | null;
+}): Promise<void>;
+/**
+ * Get the current quota snapshot for a workspace.
+ */
+export declare function getQuota(workspaceId: string): Promise<LinearQuotaSnapshot>;
+/**
+ * Check if quota is critically low for a workspace.
+ *
+ * Returns true if we know the quota is below the threshold.
+ * Returns false if quota is healthy or unknown (fail open).
+ */
+export declare function isQuotaLow(workspaceId: string): Promise<boolean>;
+/**
+ * Extract quota headers from a Linear API response.
+ *
+ * Works with both fetch Response objects and plain header objects.
+ */
+export declare function extractQuotaHeaders(response: unknown): {
+    requestsRemaining?: string;
+    complexityRemaining?: string;
+    requestsReset?: string;
+};
+//# sourceMappingURL=quota-tracker.d.ts.map

package/dist/src/quota-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quota-tracker.d.ts","sourceRoot":"","sources":["../../src/quota-tracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAOH,2DAA2D;AAC3D,eAAO,MAAM,mBAAmB,MAAM,CAAA;AAKtC,MAAM,WAAW,mBAAmB;IAClC,oEAAoE;IACpE,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,yEAAyE;IACzE,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,4EAA4E;IAC5E,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAC/B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IACP,iBAAiB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IAC1C,mBAAmB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IAC5C,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;CACvC,GACA,OAAO,CAAC,IAAI,CAAC,CAgDf;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAiChF;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUtE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,GAAG;IACtD,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAkCA"}

package/dist/src/quota-tracker.js

@@ -0,0 +1,155 @@
+/**
+ * Linear API Quota Tracker
+ *
+ * Stores Linear's rate limit response headers in Redis so any component
+ * can check the remaining budget before making a call.
+ *
+ * Redis keys:
+ * - `linear:quota:{workspaceId}:requests_remaining`
+ * - `linear:quota:{workspaceId}:complexity_remaining`
+ * - `linear:quota:{workspaceId}:requests_reset`  (timestamp)
+ * - `linear:quota:{workspaceId}:updated_at`       (timestamp)
+ *
+ * Usage:
+ * - After every Linear API call, call `recordQuota()` with response headers
+ * - Before making a call, check `getQuota()` to see remaining budget
+ * - If `requestsRemaining < LOW_QUOTA_THRESHOLD`, the rate limiter
+ *   should proactively throttle
+ */
+import { getRedisClient } from './redis.js';
+import { createLogger } from './logger.js';
+const log = createLogger('quota-tracker');
+/** Threshold below which we should proactively throttle */
+export const LOW_QUOTA_THRESHOLD = 500;
+/** Default quota TTL in Redis (2 hours, matching Linear's hourly reset) */
+const QUOTA_TTL_SECONDS = 7200;
+/**
+ * Record quota information from Linear API response headers.
+ *
+ * Call this after every successful Linear API response.
+ */
+export async function recordQuota(workspaceId, headers) {
+    try {
+        const redis = getRedisClient();
+        const prefix = `linear:quota:${workspaceId}`;
+        const pipeline = redis.pipeline();
+        const now = Date.now();
+        if (headers.requestsRemaining != null) {
+            const value = String(headers.requestsRemaining);
+            pipeline.set(`${prefix}:requests_remaining`, value, 'EX', QUOTA_TTL_SECONDS);
+            const remaining = parseInt(value, 10);
+            if (!isNaN(remaining) && remaining < LOW_QUOTA_THRESHOLD) {
+                log.warn('Linear quota running low', {
+                    workspaceId,
+                    requestsRemaining: remaining,
+                });
+            }
+        }
+        if (headers.complexityRemaining != null) {
+            pipeline.set(`${prefix}:complexity_remaining`, String(headers.complexityRemaining), 'EX', QUOTA_TTL_SECONDS);
+        }
+        if (headers.requestsReset != null) {
+            pipeline.set(`${prefix}:requests_reset`, String(headers.requestsReset), 'EX', QUOTA_TTL_SECONDS);
+        }
+        pipeline.set(`${prefix}:updated_at`, String(now), 'EX', QUOTA_TTL_SECONDS);
+        await pipeline.exec();
+    }
+    catch (err) {
+        // Non-critical — log and continue
+        log.error('Failed to record quota', {
+            workspaceId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+/**
+ * Get the current quota snapshot for a workspace.
+ */
+export async function getQuota(workspaceId) {
+    try {
+        const redis = getRedisClient();
+        const prefix = `linear:quota:${workspaceId}`;
+        const [requestsRemaining, complexityRemaining, requestsReset, updatedAt] = await Promise.all([
+            redis.get(`${prefix}:requests_remaining`),
+            redis.get(`${prefix}:complexity_remaining`),
+            redis.get(`${prefix}:requests_reset`),
+            redis.get(`${prefix}:updated_at`),
+        ]);
+        return {
+            requestsRemaining: requestsRemaining ? parseInt(requestsRemaining, 10) : null,
+            complexityRemaining: complexityRemaining
+                ? parseInt(complexityRemaining, 10)
+                : null,
+            requestsReset: requestsReset ? parseInt(requestsReset, 10) : null,
+            updatedAt: updatedAt ? parseInt(updatedAt, 10) : 0,
+        };
+    }
+    catch (err) {
+        log.error('Failed to get quota', {
+            workspaceId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return {
+            requestsRemaining: null,
+            complexityRemaining: null,
+            requestsReset: null,
+            updatedAt: 0,
+        };
+    }
+}
+/**
+ * Check if quota is critically low for a workspace.
+ *
+ * Returns true if we know the quota is below the threshold.
+ * Returns false if quota is healthy or unknown (fail open).
+ */
+export async function isQuotaLow(workspaceId) {
+    const quota = await getQuota(workspaceId);
+    if (quota.requestsRemaining === null)
+        return false; // unknown = allow
+    // Check staleness — if data is older than 5 minutes, don't trust it
+    const staleThreshold = 5 * 60 * 1000;
+    if (Date.now() - quota.updatedAt > staleThreshold)
+        return false;
+    return quota.requestsRemaining < LOW_QUOTA_THRESHOLD;
+}
+/**
+ * Extract quota headers from a Linear API response.
+ *
+ * Works with both fetch Response objects and plain header objects.
+ */
+export function extractQuotaHeaders(response) {
+    const result = {};
+    if (typeof response !== 'object' || response === null)
+        return result;
+    const resp = response;
+    // Try fetch-style Response with .headers.get()
+    const headers = resp.headers;
+    if (headers) {
+        if (typeof headers.get === 'function') {
+            const getHeader = headers.get;
+            const rr = getHeader.call(headers, 'x-ratelimit-requests-remaining');
+            const cr = getHeader.call(headers, 'x-ratelimit-complexity-remaining');
+            const rs = getHeader.call(headers, 'x-ratelimit-requests-reset');
+            if (rr)
+                result.requestsRemaining = rr;
+            if (cr)
+                result.complexityRemaining = cr;
+            if (rs)
+                result.requestsReset = rs;
+        }
+        else {
+            // Plain object headers
+            const rr = headers['x-ratelimit-requests-remaining'];
+            const cr = headers['x-ratelimit-complexity-remaining'];
+            const rs = headers['x-ratelimit-requests-reset'];
+            if (rr)
+                result.requestsRemaining = rr;
+            if (cr)
+                result.complexityRemaining = cr;
+            if (rs)
+                result.requestsReset = rs;
+        }
+    }
+    return result;
+}

package/dist/src/rate-limit.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Rate Limiter with LRU Cache
+ *
+ * In-memory rate limiting using sliding window algorithm.
+ * Uses LRU cache to prevent memory bloat from tracking many IPs.
+ */
+/**
+ * Rate limit configuration
+ */
+export interface RateLimitConfig {
+    /** Maximum requests allowed in the window */
+    limit: number;
+    /** Window size in milliseconds */
+    windowMs: number;
+}
+/**
+ * Rate limit check result
+ */
+export interface RateLimitResult {
+    /** Whether the request is allowed */
+    allowed: boolean;
+    /** Remaining requests in current window */
+    remaining: number;
+    /** Time until window resets (milliseconds) */
+    resetIn: number;
+    /** Total limit for this endpoint */
+    limit: number;
+}
+/**
+ * Default rate limit configurations by endpoint type
+ */
+export declare const RATE_LIMITS: {
+    /** Public API endpoints - 60 requests per minute */
+    readonly public: {
+        readonly limit: 60;
+        readonly windowMs: number;
+    };
+    /** Webhook endpoint - 10 requests per second per IP */
+    readonly webhook: {
+        readonly limit: 10;
+        readonly windowMs: 1000;
+    };
+    /** Dashboard - 30 requests per minute */
+    readonly dashboard: {
+        readonly limit: 30;
+        readonly windowMs: number;
+    };
+};
+/**
+ * LRU Rate Limiter
+ *
+ * Tracks request counts per key (typically IP address) using
+ * sliding window algorithm. Old entries are evicted using LRU policy.
+ */
+export declare class RateLimiter {
+    private cache;
+    private maxEntries;
+    private config;
+    constructor(config: RateLimitConfig, maxEntries?: number);
+    /**
+     * Check if a request should be allowed
+     *
+     * @param key - Unique identifier (usually IP address)
+     * @returns Rate limit result
+     */
+    check(key: string): RateLimitResult;
+    /**
+     * Evict least recently used entries if cache is full
+     */
+    private evictIfNeeded;
+    /**
+     * Clear all entries (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Get current cache size
+     */
+    get size(): number;
+}
+/**
+ * Get or create a rate limiter for an endpoint type
+ *
+ * @param type - Endpoint type ('public', 'webhook', 'dashboard')
+ * @returns Rate limiter instance
+ */
+export declare function getRateLimiter(type: keyof typeof RATE_LIMITS): RateLimiter;
+/**
+ * Check rate limit for a request
+ *
+ * @param type - Endpoint type
+ * @param key - Unique identifier (usually IP)
+ * @returns Rate limit result
+ */
+export declare function checkRateLimit(type: keyof typeof RATE_LIMITS, key: string): RateLimitResult;
+/**
+ * Extract client IP from request headers
+ *
+ * Handles various proxy scenarios (Vercel, Cloudflare, etc.)
+ *
+ * @param headers - Request headers
+ * @returns Client IP address
+ */
+export declare function getClientIP(headers: Headers): string;
+/**
+ * Build rate limit headers for response
+ *
+ * @param result - Rate limit result
+ * @returns Headers object
+ */
+export declare function buildRateLimitHeaders(result: RateLimitResult): Record<string, string>;
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/src/rate-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../src/rate-limit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAA;IACb,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,qCAAqC;IACrC,OAAO,EAAE,OAAO,CAAA;IAChB,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAA;IACjB,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAA;IACf,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAA;CACd;AAYD;;GAEG;AACH,eAAO,MAAM,WAAW;IACtB,oDAAoD;;;;;IAEpD,uDAAuD;;;;;IAEvD,yCAAyC;;;;;CAEjC,CAAA;AAEV;;;;;GAKG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAyC;IACtD,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,MAAM,CAAiB;gBAEnB,MAAM,EAAE,eAAe,EAAE,UAAU,SAAQ;IAKvD;;;;;OAKG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe;IA4CnC;;OAEG;IACH,OAAO,CAAC,aAAa;IAgBrB;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAKD;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,OAAO,WAAW,GAC7B,WAAW,CAOb;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,OAAO,WAAW,EAC9B,GAAG,EAAE,MAAM,GACV,eAAe,CAGjB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAsBpD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,eAAe,GACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMxB"}

package/dist/src/rate-limit.js

@@ -0,0 +1,171 @@
+/**
+ * Rate Limiter with LRU Cache
+ *
+ * In-memory rate limiting using sliding window algorithm.
+ * Uses LRU cache to prevent memory bloat from tracking many IPs.
+ */
+import { createLogger } from './logger.js';
+const log = createLogger('rate-limit');
+/**
+ * Default rate limit configurations by endpoint type
+ */
+export const RATE_LIMITS = {
+    /** Public API endpoints - 60 requests per minute */
+    public: { limit: 60, windowMs: 60 * 1000 },
+    /** Webhook endpoint - 10 requests per second per IP */
+    webhook: { limit: 10, windowMs: 1000 },
+    /** Dashboard - 30 requests per minute */
+    dashboard: { limit: 30, windowMs: 60 * 1000 },
+};
+/**
+ * LRU Rate Limiter
+ *
+ * Tracks request counts per key (typically IP address) using
+ * sliding window algorithm. Old entries are evicted using LRU policy.
+ */
+export class RateLimiter {
+    cache = new Map();
+    maxEntries;
+    config;
+    constructor(config, maxEntries = 10000) {
+        this.config = config;
+        this.maxEntries = maxEntries;
+    }
+    /**
+     * Check if a request should be allowed
+     *
+     * @param key - Unique identifier (usually IP address)
+     * @returns Rate limit result
+     */
+    check(key) {
+        const now = Date.now();
+        const windowStart = now - this.config.windowMs;
+        // Get or create entry
+        let entry = this.cache.get(key);
+        if (!entry) {
+            entry = { timestamps: [], lastAccess: now };
+        }
+        // Filter timestamps to only include those in the current window
+        entry.timestamps = entry.timestamps.filter((ts) => ts > windowStart);
+        entry.lastAccess = now;
+        // Calculate remaining requests
+        const requestCount = entry.timestamps.length;
+        const remaining = Math.max(0, this.config.limit - requestCount);
+        const allowed = requestCount < this.config.limit;
+        // Add this request if allowed
+        if (allowed) {
+            entry.timestamps.push(now);
+        }
+        // Update cache
+        this.cache.set(key, entry);
+        // Evict old entries if needed
+        this.evictIfNeeded();
+        // Calculate reset time
+        const oldestTimestamp = entry.timestamps[0];
+        const resetIn = oldestTimestamp
+            ? Math.max(0, oldestTimestamp + this.config.windowMs - now)
+            : 0;
+        return {
+            allowed,
+            remaining: allowed ? remaining - 1 : 0,
+            resetIn,
+            limit: this.config.limit,
+        };
+    }
+    /**
+     * Evict least recently used entries if cache is full
+     */
+    evictIfNeeded() {
+        if (this.cache.size <= this.maxEntries)
+            return;
+        // Find entries to evict (oldest lastAccess)
+        const entries = Array.from(this.cache.entries());
+        entries.sort((a, b) => a[1].lastAccess - b[1].lastAccess);
+        // Remove oldest 10% of entries
+        const toRemove = Math.ceil(this.maxEntries * 0.1);
+        for (let i = 0; i < toRemove && i < entries.length; i++) {
+            this.cache.delete(entries[i][0]);
+        }
+        log.debug('Evicted rate limit entries', { removed: toRemove });
+    }
+    /**
+     * Clear all entries (useful for testing)
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get current cache size
+     */
+    get size() {
+        return this.cache.size;
+    }
+}
+// Singleton rate limiters for different endpoint types
+const limiters = new Map();
+/**
+ * Get or create a rate limiter for an endpoint type
+ *
+ * @param type - Endpoint type ('public', 'webhook', 'dashboard')
+ * @returns Rate limiter instance
+ */
+export function getRateLimiter(type) {
+    let limiter = limiters.get(type);
+    if (!limiter) {
+        limiter = new RateLimiter(RATE_LIMITS[type]);
+        limiters.set(type, limiter);
+    }
+    return limiter;
+}
+/**
+ * Check rate limit for a request
+ *
+ * @param type - Endpoint type
+ * @param key - Unique identifier (usually IP)
+ * @returns Rate limit result
+ */
+export function checkRateLimit(type, key) {
+    const limiter = getRateLimiter(type);
+    return limiter.check(key);
+}
+/**
+ * Extract client IP from request headers
+ *
+ * Handles various proxy scenarios (Vercel, Cloudflare, etc.)
+ *
+ * @param headers - Request headers
+ * @returns Client IP address
+ */
+export function getClientIP(headers) {
+    // Vercel/Cloudflare proxy headers
+    const forwardedFor = headers.get('x-forwarded-for');
+    if (forwardedFor) {
+        // Take first IP (client IP before proxies)
+        return forwardedFor.split(',')[0].trim();
+    }
+    // Cloudflare specific
+    const cfConnectingIP = headers.get('cf-connecting-ip');
+    if (cfConnectingIP) {
+        return cfConnectingIP;
+    }
+    // Vercel specific
+    const realIP = headers.get('x-real-ip');
+    if (realIP) {
+        return realIP;
+    }
+    // Fallback
+    return 'unknown';
+}
+/**
+ * Build rate limit headers for response
+ *
+ * @param result - Rate limit result
+ * @returns Headers object
+ */
+export function buildRateLimitHeaders(result) {
+    return {
+        'X-RateLimit-Limit': result.limit.toString(),
+        'X-RateLimit-Remaining': result.remaining.toString(),
+        'X-RateLimit-Reset': Math.ceil(result.resetIn / 1000).toString(),
+    };
+}

package/dist/src/redis-circuit-breaker.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Redis Circuit Breaker
+ *
+ * Shares circuit breaker state across processes via Redis.
+ * All processes (dashboard, governor, CLI agents) see the same
+ * circuit state for a workspace.
+ *
+ * Redis keys:
+ * - `linear:circuit:{workspaceId}:state`    — 'closed' | 'open' | 'half-open'
+ * - `linear:circuit:{workspaceId}:failures` — consecutive failure count (with TTL)
+ * - `linear:circuit:{workspaceId}:opened_at` — timestamp when circuit was opened
+ * - `linear:circuit:{workspaceId}:reset_timeout` — current reset timeout (for backoff)
+ *
+ * Implements CircuitBreakerStrategy from @renseiai/agentfactory-linear
+ * so it can be injected into LinearAgentClient.
+ */
+import type { CircuitBreakerStrategy, CircuitBreakerConfig } from '@renseiai/agentfactory-linear';
+export interface RedisCircuitBreakerConfig extends CircuitBreakerConfig {
+    /** Workspace-specific key prefix */
+    workspaceId: string;
+}
+export declare class RedisCircuitBreaker implements CircuitBreakerStrategy {
+    private readonly config;
+    private readonly keyPrefix;
+    constructor(config: Partial<RedisCircuitBreakerConfig> & {
+        workspaceId: string;
+    });
+    private get stateKey();
+    private get failuresKey();
+    private get openedAtKey();
+    private get resetTimeoutKey();
+    /**
+     * Check if a call is allowed to proceed.
+     */
+    canProceed(): Promise<boolean>;
+    /**
+     * Record a successful API call. Resets the circuit to closed.
+     */
+    recordSuccess(): Promise<void>;
+    /**
+     * Record an auth failure. May trip the circuit to open.
+     */
+    recordAuthFailure(_statusCode?: number): Promise<void>;
+    /**
+     * Check if an error is an auth/rate-limit error.
+     * Reuses the same detection logic as the in-memory CircuitBreaker.
+     */
+    isAuthError(error: unknown): boolean;
+    /**
+     * Reset the circuit breaker to closed state.
+     */
+    reset(): Promise<void>;
+    /**
+     * Get diagnostic info for monitoring.
+     */
+    getStatus(): Promise<{
+        state: string;
+        failures: number;
+        openedAt: number | null;
+        currentResetTimeoutMs: number;
+    }>;
+}
+/**
+ * Create a Redis circuit breaker for a specific workspace.
+ */
+export declare function createRedisCircuitBreaker(workspaceId: string, config?: Partial<Omit<RedisCircuitBreakerConfig, 'workspaceId'>>): RedisCircuitBreaker;
+//# sourceMappingURL=redis-circuit-breaker.d.ts.map

package/dist/src/redis-circuit-breaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-circuit-breaker.d.ts","sourceRoot":"","sources":["../../src/redis-circuit-breaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,KAAK,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAA;AAIjG,MAAM,WAAW,yBAA0B,SAAQ,oBAAoB;IACrE,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAA;CACpB;AA6GD,qBAAa,mBAAoB,YAAW,sBAAsB;IAChE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAClD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;gBAEtB,MAAM,EAAE,OAAO,CAAC,yBAAyB,CAAC,GAAG;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE;IAKhF,OAAO,KAAK,QAAQ,GAEnB;IACD,OAAO,KAAK,WAAW,GAEtB;IACD,OAAO,KAAK,WAAW,GAEtB;IACD,OAAO,KAAK,eAAe,GAE1B;IAED;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IAuBpC;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAgBpC;;OAEG;IACG,iBAAiB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B5D;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAsCpC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB5B;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC;QACzB,KAAK,EAAE,MAAM,CAAA;QACb,QAAQ,EAAE,MAAM,CAAA;QAChB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;QACvB,qBAAqB,EAAE,MAAM,CAAA;KAC9B,CAAC;CA2BH;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,yBAAyB,EAAE,aAAa,CAAC,CAAC,GAC/D,mBAAmB,CAErB"}