@renseiai/agentfactory 0.8.0

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

@@ -0,0 +1,43 @@
+/**
+ * Event Deduplicator
+ *
+ * Prevents duplicate processing of events within a configurable time window.
+ * Dedup key is typically `${issueId}:${status}` — same issue at the same
+ * status within the window is a duplicate.
+ *
+ * Two implementations:
+ * - InMemoryEventDeduplicator: for testing and single-process CLI
+ * - RedisEventDeduplicator: for production (in packages/server)
+ */
+/**
+ * Deduplicator contract. `isDuplicate` checks and marks atomically.
+ */
+export interface EventDeduplicator {
+    /**
+     * Check if a key has been seen within the dedup window.
+     * If not seen, marks it and returns `false` (not a duplicate).
+     * If seen, returns `true` (is a duplicate, skip processing).
+     */
+    isDuplicate(key: string): Promise<boolean>;
+    /**
+     * Clear all dedup state. Primarily for testing.
+     */
+    clear(): Promise<void>;
+}
+export interface EventDeduplicatorConfig {
+    /** Time window in milliseconds. Events with the same key within this window are considered duplicates. */
+    windowMs: number;
+}
+export declare const DEFAULT_DEDUP_CONFIG: EventDeduplicatorConfig;
+export declare class InMemoryEventDeduplicator implements EventDeduplicator {
+    private seen;
+    private readonly windowMs;
+    constructor(config?: Partial<EventDeduplicatorConfig>);
+    isDuplicate(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    /** Remove expired entries */
+    private cleanup;
+    /** Get the number of active dedup entries */
+    get size(): number;
+}
+//# sourceMappingURL=event-deduplicator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event-deduplicator.d.ts","sourceRoot":"","sources":["../../../src/governor/event-deduplicator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAE1C;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAMD,MAAM,WAAW,uBAAuB;IACtC,0GAA0G;IAC1G,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,eAAO,MAAM,oBAAoB,EAAE,uBAElC,CAAA;AAMD,qBAAa,yBAA0B,YAAW,iBAAiB;IACjE,OAAO,CAAC,IAAI,CAA4B;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;gBAErB,MAAM,GAAE,OAAO,CAAC,uBAAuB,CAAM;IAInD,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAgB1C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,6BAA6B;IAC7B,OAAO,CAAC,OAAO;IAUf,6CAA6C;IAC7C,IAAI,IAAI,IAAI,MAAM,CAGjB;CACF"}

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

@@ -0,0 +1,53 @@
+/**
+ * Event Deduplicator
+ *
+ * Prevents duplicate processing of events within a configurable time window.
+ * Dedup key is typically `${issueId}:${status}` — same issue at the same
+ * status within the window is a duplicate.
+ *
+ * Two implementations:
+ * - InMemoryEventDeduplicator: for testing and single-process CLI
+ * - RedisEventDeduplicator: for production (in packages/server)
+ */
+export const DEFAULT_DEDUP_CONFIG = {
+    windowMs: 10_000, // 10 seconds
+};
+// ---------------------------------------------------------------------------
+// In-Memory Implementation
+// ---------------------------------------------------------------------------
+export class InMemoryEventDeduplicator {
+    seen = new Map(); // key → expiresAt
+    windowMs;
+    constructor(config = {}) {
+        this.windowMs = config.windowMs ?? DEFAULT_DEDUP_CONFIG.windowMs;
+    }
+    async isDuplicate(key) {
+        const now = Date.now();
+        // Clean expired entries on each check (cheap for in-memory)
+        this.cleanup(now);
+        const expiresAt = this.seen.get(key);
+        if (expiresAt !== undefined && now < expiresAt) {
+            return true; // duplicate
+        }
+        // Mark as seen
+        this.seen.set(key, now + this.windowMs);
+        return false;
+    }
+    async clear() {
+        this.seen.clear();
+    }
+    /** Remove expired entries */
+    cleanup(now) {
+        for (const [key, expiresAt] of this.seen) {
+            if (now >= expiresAt) {
+                this.seen.delete(key);
+            }
+        }
+    }
+    // ---- Test helpers ----
+    /** Get the number of active dedup entries */
+    get size() {
+        this.cleanup(Date.now());
+        return this.seen.size;
+    }
+}

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

@@ -0,0 +1,131 @@
+/**
+ * Event-Driven Governor
+ *
+ * Wraps the existing decision engine with an event-driven processing loop
+ * and a periodic poll safety net. This is a hybrid model: real-time events
+ * (from webhooks) trigger immediate evaluation, while a configurable poll
+ * sweep ensures nothing is missed even if an event is lost.
+ *
+ * The EventDrivenGovernor does NOT replace WorkflowGovernor. Instead, it
+ * provides an alternative execution model that can react to events in
+ * real time while still benefiting from periodic full scans.
+ */
+import type { GovernorEventBus } from './event-bus.js';
+import type { EventDeduplicator } from './event-deduplicator.js';
+import type { GovernorConfig } from './governor-types.js';
+import type { GovernorDependencies } from './governor.js';
+/**
+ * Configuration for the EventDrivenGovernor.
+ * Extends the base GovernorConfig with event-bus-specific options.
+ */
+export interface EventDrivenGovernorConfig extends GovernorConfig {
+    /** The event bus used to receive and publish events */
+    eventBus: GovernorEventBus;
+    /** Optional deduplicator to prevent processing the same event twice */
+    deduplicator?: EventDeduplicator;
+    /** Poll interval for the safety-net sweep in milliseconds (default: 300000 = 5 min) */
+    pollIntervalMs?: number;
+    /** Enable periodic poll sweep (default: true) */
+    enablePolling?: boolean;
+}
+/**
+ * Hybrid event-driven + poll-based governor.
+ *
+ * Listens for events on the GovernorEventBus and processes them through the
+ * decision engine. Optionally runs a periodic poll sweep that publishes
+ * PollSnapshotEvents for every issue, ensuring eventual consistency even
+ * if a webhook event is lost.
+ *
+ * Usage:
+ * ```ts
+ * const governor = new EventDrivenGovernor(config, deps)
+ * await governor.start()
+ * // ... governor processes events until stopped
+ * await governor.stop()
+ * ```
+ */
+export declare class EventDrivenGovernor {
+    private readonly config;
+    private readonly deps;
+    private readonly eventBus;
+    private readonly deduplicator;
+    private running;
+    private pollTimer;
+    private eventLoopPromise;
+    constructor(config: EventDrivenGovernorConfig, deps: GovernorDependencies);
+    /**
+     * Start the event-driven governor.
+     *
+     * Begins consuming events from the event bus and optionally starts a
+     * periodic poll sweep timer. The event loop runs until `stop()` is called.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the event-driven governor.
+     *
+     * Clears the poll timer, closes the event bus (which ends the event loop),
+     * and waits for the event loop to finish processing.
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if the governor is currently running.
+     */
+    isRunning(): boolean;
+    /**
+     * Main event processing loop. Consumes events from the event bus,
+     * deduplicates them, and routes to the appropriate handler.
+     *
+     * This runs until the event bus is closed (via `stop()`).
+     */
+    private runEventLoop;
+    /**
+     * Process a single event from the event bus.
+     *
+     * Steps:
+     * 1. Check for duplicates using the deduplicator (if configured)
+     * 2. Route the event to the appropriate handler based on type
+     * 3. Acknowledge the event on the bus
+     *
+     * @param eventId - Transport-assigned event ID for acknowledgement
+     * @param event - The governor event to process
+     */
+    private processEvent;
+    /**
+     * Handle a comment-added event by parsing it for override directives.
+     *
+     * If a directive is found:
+     * - `hold`: Persist the hold state via `setOverrideState`
+     * - `resume`: Clear override state and re-evaluate the issue immediately
+     * - `priority`: Persist the priority override via `setOverrideState`
+     * - Other directives: Persist via `setOverrideState`
+     *
+     * If no directive is found, the issue is still evaluated (the comment
+     * may contain context that affects the decision).
+     *
+     * @param event - The comment-added event to handle
+     */
+    private handleComment;
+    /**
+     * Evaluate a single issue and dispatch work if the decision engine
+     * determines an action is needed.
+     *
+     * Gathers all context in parallel (same approach as WorkflowGovernor),
+     * runs the decision engine, and dispatches if the action is not 'none'.
+     *
+     * @param issue - The issue to evaluate
+     */
+    private evaluateAndDispatch;
+    /**
+     * Run a full poll sweep across all configured projects.
+     *
+     * For each project, lists all issues and publishes a PollSnapshotEvent
+     * for each one. These events flow through the normal event loop and
+     * are subject to deduplication, ensuring that issues already processed
+     * via webhook events are not re-evaluated unnecessarily.
+     *
+     * This method is called periodically by the poll timer and can also
+     * be invoked manually for testing.
+     */
+    pollSweep(): Promise<void>;
+}
+//# sourceMappingURL=event-driven-governor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event-driven-governor.d.ts","sourceRoot":"","sources":["../../../src/governor/event-driven-governor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAOhE,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,qBAAqB,CAAA;AAGxE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AAyBzD;;;GAGG;AACH,MAAM,WAAW,yBAA0B,SAAQ,cAAc;IAC/D,uDAAuD;IACvD,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,uEAAuE;IACvE,YAAY,CAAC,EAAE,iBAAiB,CAAA;IAChC,uFAAuF;IACvF,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,iDAAiD;IACjD,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAMD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAClD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsB;IAC3C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA0B;IACvD,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,gBAAgB,CAA6B;gBAEzC,MAAM,EAAE,yBAAyB,EAAE,IAAI,EAAE,oBAAoB;IAWzE;;;;;OAKG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B5B;;;;;OAKG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA0B3B;;OAEG;IACH,SAAS,IAAI,OAAO;IAQpB;;;;;OAKG;YACW,YAAY;IAgC1B;;;;;;;;;;OAUG;YACW,YAAY;IA4C1B;;;;;;;;;;;;;OAaG;YACW,aAAa;IAqD3B;;;;;;;;OAQG;YACW,mBAAmB;IA4DjC;;;;;;;;;;OAUG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CA2CjC"}

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

@@ -0,0 +1,379 @@
+/**
+ * Event-Driven Governor
+ *
+ * Wraps the existing decision engine with an event-driven processing loop
+ * and a periodic poll safety net. This is a hybrid model: real-time events
+ * (from webhooks) trigger immediate evaluation, while a configurable poll
+ * sweep ensures nothing is missed even if an event is lost.
+ *
+ * The EventDrivenGovernor does NOT replace WorkflowGovernor. Instead, it
+ * provides an alternative execution model that can react to events in
+ * real time while still benefiting from periodic full scans.
+ */
+import { eventDedupKey, eventTimestamp } from './event-types.js';
+import { DEFAULT_GOVERNOR_CONFIG } from './governor-types.js';
+import { decideAction } from './decision-engine.js';
+import { parseOverrideDirective } from './override-parser.js';
+import { setOverrideState, clearOverrideState } from './human-touchpoints.js';
+// ---------------------------------------------------------------------------
+// Logging
+// ---------------------------------------------------------------------------
+const log = {
+    info: (msg, data) => console.log(`[event-governor] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[event-governor] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[event-governor] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+/** Default poll interval for the safety-net sweep (5 minutes) */
+const DEFAULT_POLL_INTERVAL_MS = 300_000;
+// ---------------------------------------------------------------------------
+// EventDrivenGovernor
+// ---------------------------------------------------------------------------
+/**
+ * Hybrid event-driven + poll-based governor.
+ *
+ * Listens for events on the GovernorEventBus and processes them through the
+ * decision engine. Optionally runs a periodic poll sweep that publishes
+ * PollSnapshotEvents for every issue, ensuring eventual consistency even
+ * if a webhook event is lost.
+ *
+ * Usage:
+ * ```ts
+ * const governor = new EventDrivenGovernor(config, deps)
+ * await governor.start()
+ * // ... governor processes events until stopped
+ * await governor.stop()
+ * ```
+ */
+export class EventDrivenGovernor {
+    config;
+    deps;
+    eventBus;
+    deduplicator;
+    running = false;
+    pollTimer = null;
+    eventLoopPromise = null;
+    constructor(config, deps) {
+        this.config = { ...DEFAULT_GOVERNOR_CONFIG, ...config };
+        this.deps = deps;
+        this.eventBus = config.eventBus;
+        this.deduplicator = config.deduplicator ?? null;
+    }
+    // -------------------------------------------------------------------------
+    // Lifecycle
+    // -------------------------------------------------------------------------
+    /**
+     * Start the event-driven governor.
+     *
+     * Begins consuming events from the event bus and optionally starts a
+     * periodic poll sweep timer. The event loop runs until `stop()` is called.
+     */
+    async start() {
+        if (this.running) {
+            log.warn('Event-driven governor is already running');
+            return;
+        }
+        this.running = true;
+        log.info('Event-driven governor started', {
+            projects: this.config.projects,
+            enablePolling: this.config.enablePolling !== false,
+            pollIntervalMs: this.config.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
+            hasDeduplicator: this.deduplicator !== null,
+        });
+        // Start the event processing loop (runs in background)
+        this.eventLoopPromise = this.runEventLoop();
+        // Start the poll safety net if enabled (default: true)
+        if (this.config.enablePolling !== false) {
+            const intervalMs = this.config.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+            this.pollTimer = setInterval(() => {
+                void this.pollSweep();
+            }, intervalMs);
+        }
+    }
+    /**
+     * Stop the event-driven governor.
+     *
+     * Clears the poll timer, closes the event bus (which ends the event loop),
+     * and waits for the event loop to finish processing.
+     */
+    async stop() {
+        if (!this.running) {
+            log.warn('Event-driven governor is not running');
+            return;
+        }
+        this.running = false;
+        // Clear the poll timer
+        if (this.pollTimer !== null) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        // Close the event bus, which will end the subscribe() async iterable
+        await this.eventBus.close();
+        // Wait for the event loop to finish
+        if (this.eventLoopPromise) {
+            await this.eventLoopPromise;
+            this.eventLoopPromise = null;
+        }
+        log.info('Event-driven governor stopped');
+    }
+    /**
+     * Check if the governor is currently running.
+     */
+    isRunning() {
+        return this.running;
+    }
+    // -------------------------------------------------------------------------
+    // Event Loop
+    // -------------------------------------------------------------------------
+    /**
+     * Main event processing loop. Consumes events from the event bus,
+     * deduplicates them, and routes to the appropriate handler.
+     *
+     * This runs until the event bus is closed (via `stop()`).
+     */
+    async runEventLoop() {
+        try {
+            for await (const { id, event } of this.eventBus.subscribe()) {
+                if (!this.running) {
+                    break;
+                }
+                try {
+                    await this.processEvent(id, event);
+                }
+                catch (err) {
+                    const errorMsg = err instanceof Error ? err.message : String(err);
+                    log.error('Error processing event', {
+                        eventId: id,
+                        eventType: event.type,
+                        issueId: event.issueId,
+                        error: errorMsg,
+                    });
+                }
+            }
+        }
+        catch (err) {
+            // The subscribe() iterable may throw if the bus encounters a fatal error
+            if (this.running) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                log.error('Event loop terminated unexpectedly', { error: errorMsg });
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Event Processing
+    // -------------------------------------------------------------------------
+    /**
+     * Process a single event from the event bus.
+     *
+     * Steps:
+     * 1. Check for duplicates using the deduplicator (if configured)
+     * 2. Route the event to the appropriate handler based on type
+     * 3. Acknowledge the event on the bus
+     *
+     * @param eventId - Transport-assigned event ID for acknowledgement
+     * @param event - The governor event to process
+     */
+    async processEvent(eventId, event) {
+        // Step 1: Deduplication
+        if (this.deduplicator) {
+            const dedupKey = eventDedupKey(event);
+            const isDuplicate = await this.deduplicator.isDuplicate(dedupKey);
+            if (isDuplicate) {
+                log.debug('Skipping duplicate event', {
+                    eventId,
+                    eventType: event.type,
+                    issueId: event.issueId,
+                    dedupKey,
+                });
+                await this.eventBus.ack(eventId);
+                return;
+            }
+        }
+        // Step 2: Route by event type
+        log.info('Processing event', {
+            eventId,
+            eventType: event.type,
+            issueId: event.issueId,
+        });
+        switch (event.type) {
+            case 'comment-added':
+                await this.handleComment(event);
+                break;
+            case 'issue-status-changed':
+            case 'session-completed':
+            case 'poll-snapshot':
+                await this.evaluateAndDispatch(event.issue);
+                break;
+        }
+        // Step 3: Acknowledge
+        await this.eventBus.ack(eventId);
+    }
+    // -------------------------------------------------------------------------
+    // Comment Handling
+    // -------------------------------------------------------------------------
+    /**
+     * Handle a comment-added event by parsing it for override directives.
+     *
+     * If a directive is found:
+     * - `hold`: Persist the hold state via `setOverrideState`
+     * - `resume`: Clear override state and re-evaluate the issue immediately
+     * - `priority`: Persist the priority override via `setOverrideState`
+     * - Other directives: Persist via `setOverrideState`
+     *
+     * If no directive is found, the issue is still evaluated (the comment
+     * may contain context that affects the decision).
+     *
+     * @param event - The comment-added event to handle
+     */
+    async handleComment(event) {
+        const commentInfo = {
+            id: event.commentId,
+            body: event.commentBody,
+            userId: event.userId ?? '',
+            isBot: false, // Events from the bus are pre-filtered; bot comments are not published
+            createdAt: new Date(event.timestamp).getTime(),
+        };
+        const directive = parseOverrideDirective(commentInfo);
+        if (directive) {
+            log.info('Override directive found in comment', {
+                issueId: event.issueId,
+                directiveType: directive.type,
+                commentId: event.commentId,
+            });
+            switch (directive.type) {
+                case 'hold':
+                    await setOverrideState(event.issueId, directive);
+                    break;
+                case 'resume':
+                    await clearOverrideState(event.issueId);
+                    // Re-evaluate immediately after resuming
+                    await this.evaluateAndDispatch(event.issue);
+                    break;
+                case 'priority':
+                    await setOverrideState(event.issueId, directive);
+                    break;
+                default:
+                    // skip-qa, decompose, reassign, etc.
+                    await setOverrideState(event.issueId, directive);
+                    break;
+            }
+        }
+        else {
+            // No directive found, but the comment may contain useful context.
+            // Evaluate the issue so the governor can react to any state changes.
+            log.debug('No directive in comment, evaluating issue', {
+                issueId: event.issueId,
+                commentId: event.commentId,
+            });
+            await this.evaluateAndDispatch(event.issue);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Issue Evaluation
+    // -------------------------------------------------------------------------
+    /**
+     * Evaluate a single issue and dispatch work if the decision engine
+     * determines an action is needed.
+     *
+     * Gathers all context in parallel (same approach as WorkflowGovernor),
+     * runs the decision engine, and dispatches if the action is not 'none'.
+     *
+     * @param issue - The issue to evaluate
+     */
+    async evaluateAndDispatch(issue) {
+        // Gather all context in parallel for efficiency
+        const [hasActiveSession, isWithinCooldown, isParentIssue, isHeld, workflowStrategy, researchCompleted, backlogCreationCompleted, completedSessionCount,] = await Promise.all([
+            this.deps.hasActiveSession(issue.id),
+            this.deps.isWithinCooldown(issue.id),
+            this.deps.isParentIssue(issue.id),
+            this.deps.isHeld(issue.id),
+            this.deps.getWorkflowStrategy(issue.id),
+            this.deps.isResearchCompleted(issue.id),
+            this.deps.isBacklogCreationCompleted(issue.id),
+            this.deps.getCompletedSessionCount(issue.id),
+        ]);
+        const ctx = {
+            issue,
+            config: this.config,
+            hasActiveSession,
+            isHeld,
+            isWithinCooldown,
+            isParentIssue,
+            workflowStrategy,
+            researchCompleted,
+            backlogCreationCompleted,
+            completedSessionCount,
+        };
+        const decision = decideAction(ctx);
+        if (decision.action === 'none') {
+            log.debug('No action for issue', {
+                issueId: issue.id,
+                identifier: issue.identifier,
+                reason: decision.reason,
+            });
+            return;
+        }
+        log.info('Dispatching action', {
+            issueId: issue.id,
+            identifier: issue.identifier,
+            action: decision.action,
+            reason: decision.reason,
+        });
+        await this.deps.dispatchWork(issue, decision.action);
+    }
+    // -------------------------------------------------------------------------
+    // Poll Sweep
+    // -------------------------------------------------------------------------
+    /**
+     * Run a full poll sweep across all configured projects.
+     *
+     * For each project, lists all issues and publishes a PollSnapshotEvent
+     * for each one. These events flow through the normal event loop and
+     * are subject to deduplication, ensuring that issues already processed
+     * via webhook events are not re-evaluated unnecessarily.
+     *
+     * This method is called periodically by the poll timer and can also
+     * be invoked manually for testing.
+     */
+    async pollSweep() {
+        log.info('Starting poll sweep', {
+            projects: this.config.projects,
+        });
+        let totalIssues = 0;
+        for (const project of this.config.projects) {
+            try {
+                const issues = await this.deps.listIssues(project);
+                totalIssues += issues.length;
+                for (const issue of issues) {
+                    const event = {
+                        type: 'poll-snapshot',
+                        issueId: issue.id,
+                        issue,
+                        project,
+                        timestamp: eventTimestamp(),
+                        source: 'poll',
+                    };
+                    await this.eventBus.publish(event);
+                }
+                log.debug('Poll sweep published events for project', {
+                    project,
+                    issueCount: issues.length,
+                });
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                log.error('Poll sweep failed for project', {
+                    project,
+                    error: errorMsg,
+                });
+            }
+        }
+        log.info('Poll sweep complete', {
+            projects: this.config.projects,
+            totalIssues,
+        });
+    }
+}

package/dist/src/governor/event-driven-governor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=event-driven-governor.test.d.ts.map

package/dist/src/governor/event-driven-governor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-driven-governor.test.d.ts","sourceRoot":"","sources":["../../../src/governor/event-driven-governor.test.ts"],"names":[],"mappings":""}