@renseiai/agentfactory 0.8.0

package/dist/src/governor/decision-engine.test.js

@@ -0,0 +1,629 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { decideAction } from './decision-engine.js';
+import { DEFAULT_GOVERNOR_CONFIG } from './governor-types.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Create a minimal GovernorIssue with sensible defaults. */
+function makeIssue(overrides = {}) {
+    return {
+        id: 'issue-1',
+        identifier: 'SUP-100',
+        title: 'Test Issue',
+        description: undefined,
+        status: 'Backlog',
+        labels: [],
+        createdAt: Date.now() - 2 * 60 * 60 * 1000, // 2 hours ago
+        ...overrides,
+    };
+}
+/** Build a well-researched description (long + structured header). */
+function wellResearchedDescription() {
+    return ('## Acceptance Criteria\n' +
+        '- The system should handle X\n' +
+        '- The system should handle Y\n' +
+        '\n' +
+        '## Technical Approach\n' +
+        'We will implement this by modifying the governor module to add top-of-funnel ' +
+        'triggers that automatically research issues in the Icebox. This approach ' +
+        'ensures issues are enriched before entering the active backlog.');
+}
+/** Build a sparse description (too short / no headers). */
+function sparseDescription() {
+    return 'Fix the thing.';
+}
+/** Build a default DecisionContext for testing. */
+function makeContext(overrides = {}) {
+    return {
+        issue: makeIssue(),
+        config: { ...DEFAULT_GOVERNOR_CONFIG, projects: ['TestProject'] },
+        hasActiveSession: false,
+        isHeld: false,
+        isWithinCooldown: false,
+        isParentIssue: false,
+        workflowStrategy: undefined,
+        researchCompleted: false,
+        backlogCreationCompleted: false,
+        completedSessionCount: 0,
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// Universal skip conditions
+// ---------------------------------------------------------------------------
+describe('decideAction — universal skip conditions', () => {
+    it('returns none when issue has an active session', () => {
+        const ctx = makeContext({ hasActiveSession: true });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('active agent session');
+    });
+    it('returns none when issue is within cooldown', () => {
+        const ctx = makeContext({ isWithinCooldown: true });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('cooldown');
+    });
+    it('returns none when issue is held', () => {
+        const ctx = makeContext({ isHeld: true });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('HOLD');
+    });
+    it('evaluates skip conditions in order: active session before cooldown', () => {
+        const ctx = makeContext({ hasActiveSession: true, isWithinCooldown: true, isHeld: true });
+        const result = decideAction(ctx);
+        expect(result.reason).toContain('active agent session');
+    });
+    it('evaluates skip conditions in order: cooldown before hold', () => {
+        const ctx = makeContext({ isWithinCooldown: true, isHeld: true });
+        const result = decideAction(ctx);
+        expect(result.reason).toContain('cooldown');
+    });
+    it('trips circuit breaker when session count exceeds max', () => {
+        const ctx = makeContext({ completedSessionCount: 3 });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('circuit breaker');
+    });
+    it('allows dispatch when session count is below max', () => {
+        const ctx = makeContext({ completedSessionCount: 2 });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-development');
+    });
+});
+// ---------------------------------------------------------------------------
+// Terminal statuses
+// ---------------------------------------------------------------------------
+describe('decideAction — terminal statuses', () => {
+    it('returns none for Accepted status', () => {
+        const ctx = makeContext({ issue: makeIssue({ status: 'Accepted' }) });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('terminal status');
+        expect(result.reason).toContain('Accepted');
+    });
+    it('returns none for Canceled status', () => {
+        const ctx = makeContext({ issue: makeIssue({ status: 'Canceled' }) });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('terminal status');
+    });
+    it('returns none for Duplicate status', () => {
+        const ctx = makeContext({ issue: makeIssue({ status: 'Duplicate' }) });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('terminal status');
+    });
+});
+// ---------------------------------------------------------------------------
+// Icebox (top-of-funnel delegation)
+// ---------------------------------------------------------------------------
+describe('decideAction — Icebox (top-of-funnel)', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-06-01T12:00:00Z'));
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    const iceboxConfig = {
+        ...DEFAULT_GOVERNOR_CONFIG,
+        projects: ['TestProject'],
+        enableAutoResearch: true,
+        enableAutoBacklogCreation: true,
+    };
+    it('triggers research for sparse Icebox issue', () => {
+        const ctx = makeContext({
+            issue: makeIssue({
+                status: 'Icebox',
+                description: sparseDescription(),
+                createdAt: Date.now() - 2 * 60 * 60 * 1000,
+            }),
+            config: iceboxConfig,
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-research');
+    });
+    it('triggers backlog-creation for well-researched Icebox issue', () => {
+        const ctx = makeContext({
+            issue: makeIssue({
+                status: 'Icebox',
+                description: wellResearchedDescription(),
+                createdAt: Date.now() - 2 * 60 * 60 * 1000,
+            }),
+            config: iceboxConfig,
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-backlog-creation');
+    });
+    it('returns none for Icebox parent issue', () => {
+        const ctx = makeContext({
+            issue: makeIssue({
+                status: 'Icebox',
+                description: sparseDescription(),
+                createdAt: Date.now() - 2 * 60 * 60 * 1000,
+            }),
+            isParentIssue: true,
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('coordination');
+    });
+    it('returns none when auto-research is disabled and description is sparse', () => {
+        const ctx = makeContext({
+            issue: makeIssue({
+                status: 'Icebox',
+                description: sparseDescription(),
+                createdAt: Date.now() - 2 * 60 * 60 * 1000,
+            }),
+            config: {
+                ...DEFAULT_GOVERNOR_CONFIG,
+                projects: ['TestProject'],
+                enableAutoResearch: false,
+            },
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+    });
+    it('returns none when auto-backlog-creation is disabled', () => {
+        const ctx = makeContext({
+            issue: makeIssue({
+                status: 'Icebox',
+                description: wellResearchedDescription(),
+                createdAt: Date.now() - 2 * 60 * 60 * 1000,
+            }),
+            config: {
+                ...DEFAULT_GOVERNOR_CONFIG,
+                projects: ['TestProject'],
+                enableAutoBacklogCreation: false,
+            },
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+    });
+    it('skips research when research already completed', () => {
+        const ctx = makeContext({
+            issue: makeIssue({
+                status: 'Icebox',
+                description: sparseDescription(),
+                createdAt: Date.now() - 2 * 60 * 60 * 1000,
+            }),
+            researchCompleted: true,
+        });
+        const result = decideAction(ctx);
+        // Research completed but description still sparse -- none
+        expect(result.action).toBe('none');
+    });
+    it('returns none for Icebox issue created too recently', () => {
+        const ctx = makeContext({
+            issue: makeIssue({
+                status: 'Icebox',
+                description: sparseDescription(),
+                createdAt: Date.now() - 10 * 60 * 1000, // 10 minutes ago
+            }),
+            config: iceboxConfig,
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('not been in Icebox long enough');
+    });
+    it('respects topOfFunnel config overrides', () => {
+        const ctx = makeContext({
+            issue: makeIssue({
+                status: 'Icebox',
+                description: sparseDescription(),
+                createdAt: Date.now() - 10 * 60 * 1000, // 10 minutes ago
+            }),
+            config: {
+                ...DEFAULT_GOVERNOR_CONFIG,
+                projects: ['TestProject'],
+                enableAutoResearch: true,
+                topOfFunnel: {
+                    iceboxResearchDelayMs: 5 * 60 * 1000, // 5 minutes
+                },
+            },
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-research');
+    });
+});
+// ---------------------------------------------------------------------------
+// Backlog (development)
+// ---------------------------------------------------------------------------
+describe('decideAction — Backlog', () => {
+    it('triggers development for Backlog issue', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Backlog' }),
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-development');
+        expect(result.reason).toContain('triggering development');
+    });
+    it('triggers development for parent Backlog issue (coordination)', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Backlog' }),
+            isParentIssue: true,
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-development');
+        expect(result.reason).toContain('coordination');
+    });
+    it('skips sub-issues in Backlog (coordinator manages via parent)', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Backlog', parentId: 'parent-issue-id' }),
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('Sub-issue');
+        expect(result.reason).toContain('coordinator manages sub-issues via parent');
+    });
+    it('skips sub-issues before checking enableAutoDevelopment', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Backlog', parentId: 'parent-issue-id' }),
+            config: {
+                ...DEFAULT_GOVERNOR_CONFIG,
+                projects: ['TestProject'],
+                enableAutoDevelopment: false,
+            },
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('Sub-issue');
+    });
+    it('skips sub-issues in Finished (coordinator manages QA via parent)', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished', parentId: 'parent-issue-id' }),
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('Sub-issue');
+        expect(result.reason).toContain('coordinator manages sub-issues via parent');
+    });
+    it('skips sub-issues in Delivered (coordinator manages acceptance via parent)', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Delivered', parentId: 'parent-issue-id' }),
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('Sub-issue');
+        expect(result.reason).toContain('coordinator manages sub-issues via parent');
+    });
+    it('skips sub-issues in Rejected (coordinator manages refinement via parent)', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Rejected', parentId: 'parent-issue-id' }),
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('Sub-issue');
+        expect(result.reason).toContain('coordinator manages sub-issues via parent');
+    });
+    it('returns none when auto-development is disabled', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Backlog' }),
+            config: {
+                ...DEFAULT_GOVERNOR_CONFIG,
+                projects: ['TestProject'],
+                enableAutoDevelopment: false,
+            },
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('disabled');
+    });
+});
+// ---------------------------------------------------------------------------
+// Started
+// ---------------------------------------------------------------------------
+describe('decideAction — Started', () => {
+    it('returns none for Started status (agent already working)', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Started' }),
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('Started');
+    });
+});
+// ---------------------------------------------------------------------------
+// Finished (QA)
+// ---------------------------------------------------------------------------
+describe('decideAction — Finished (QA)', () => {
+    it('triggers QA for Finished issue', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-qa');
+        expect(result.reason).toContain('triggering QA');
+    });
+    it('returns none when auto-QA is disabled', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+            config: {
+                ...DEFAULT_GOVERNOR_CONFIG,
+                projects: ['TestProject'],
+                enableAutoQA: false,
+            },
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('disabled');
+    });
+    it('escalates to human when strategy is escalate-human', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+            workflowStrategy: 'escalate-human',
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('escalate-human');
+        expect(result.reason).toContain('human review');
+    });
+    it('triggers decompose when strategy is decompose', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+            workflowStrategy: 'decompose',
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('decompose');
+        expect(result.reason).toContain('decomposition');
+    });
+    it('triggers normal QA when strategy is normal', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+            workflowStrategy: 'normal',
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-qa');
+    });
+    it('triggers normal QA when strategy is context-enriched', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+            workflowStrategy: 'context-enriched',
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-qa');
+    });
+});
+// ---------------------------------------------------------------------------
+// Delivered (acceptance)
+// ---------------------------------------------------------------------------
+describe('decideAction — Delivered (acceptance)', () => {
+    it('triggers acceptance for Delivered issue', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Delivered' }),
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-acceptance');
+        expect(result.reason).toContain('triggering acceptance');
+    });
+    it('returns none when auto-acceptance is disabled', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Delivered' }),
+            config: {
+                ...DEFAULT_GOVERNOR_CONFIG,
+                projects: ['TestProject'],
+                enableAutoAcceptance: false,
+            },
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('disabled');
+    });
+});
+// ---------------------------------------------------------------------------
+// Rejected (refinement)
+// ---------------------------------------------------------------------------
+describe('decideAction — Rejected (refinement)', () => {
+    it('triggers refinement for Rejected issue', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Rejected' }),
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-refinement');
+        expect(result.reason).toContain('triggering refinement');
+    });
+    it('escalates to human when strategy is escalate-human', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Rejected' }),
+            workflowStrategy: 'escalate-human',
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('escalate-human');
+        expect(result.reason).toContain('human intervention');
+    });
+    it('triggers decompose when strategy is decompose', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Rejected' }),
+            workflowStrategy: 'decompose',
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('decompose');
+        expect(result.reason).toContain('decomposition');
+    });
+    it('triggers normal refinement when strategy is normal', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Rejected' }),
+            workflowStrategy: 'normal',
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-refinement');
+    });
+    it('triggers normal refinement when strategy is context-enriched', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Rejected' }),
+            workflowStrategy: 'context-enriched',
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-refinement');
+    });
+});
+// ---------------------------------------------------------------------------
+// Unknown status
+// ---------------------------------------------------------------------------
+describe('decideAction — unknown status', () => {
+    it('returns none for unrecognized status', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'CustomStatus' }),
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('unrecognized status');
+        expect(result.reason).toContain('CustomStatus');
+    });
+});
+// ---------------------------------------------------------------------------
+// Config enable/disable flags across statuses
+// ---------------------------------------------------------------------------
+describe('decideAction — config flags integration', () => {
+    it('disabling all flags causes all non-terminal statuses to return none', () => {
+        const config = {
+            ...DEFAULT_GOVERNOR_CONFIG,
+            projects: ['TestProject'],
+            enableAutoResearch: false,
+            enableAutoBacklogCreation: false,
+            enableAutoDevelopment: false,
+            enableAutoQA: false,
+            enableAutoAcceptance: false,
+        };
+        const statuses = ['Backlog', 'Finished', 'Delivered'];
+        for (const status of statuses) {
+            const ctx = makeContext({
+                issue: makeIssue({ status }),
+                config,
+            });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('none');
+        }
+    });
+    it('Rejected issues always trigger refinement (no disable flag)', () => {
+        const config = {
+            ...DEFAULT_GOVERNOR_CONFIG,
+            projects: ['TestProject'],
+            enableAutoResearch: false,
+            enableAutoBacklogCreation: false,
+            enableAutoDevelopment: false,
+            enableAutoQA: false,
+            enableAutoAcceptance: false,
+        };
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Rejected' }),
+            config,
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-refinement');
+    });
+});
+// ---------------------------------------------------------------------------
+// Parent issue handling
+// ---------------------------------------------------------------------------
+describe('decideAction — parent issue handling', () => {
+    it('parent Backlog issue triggers development (coordination template)', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Backlog' }),
+            isParentIssue: true,
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-development');
+        expect(result.reason).toContain('Parent issue');
+        expect(result.reason).toContain('coordination');
+    });
+    it('parent Icebox issue returns none (coordination, no top-of-funnel)', () => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-06-01T12:00:00Z'));
+        const ctx = makeContext({
+            issue: makeIssue({
+                status: 'Icebox',
+                description: sparseDescription(),
+                createdAt: Date.now() - 2 * 60 * 60 * 1000,
+            }),
+            isParentIssue: true,
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        vi.useRealTimers();
+    });
+    it('parent Finished issue triggers QA normally', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+            isParentIssue: true,
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-qa');
+    });
+    it('parent Delivered issue triggers acceptance normally', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Delivered' }),
+            isParentIssue: true,
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-acceptance');
+    });
+});
+// ---------------------------------------------------------------------------
+// Escalation strategy effects across statuses
+// ---------------------------------------------------------------------------
+describe('decideAction — escalation strategy effects', () => {
+    it('escalate-human on Finished yields escalate-human', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+            workflowStrategy: 'escalate-human',
+        });
+        expect(decideAction(ctx).action).toBe('escalate-human');
+    });
+    it('escalate-human on Rejected yields escalate-human', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Rejected' }),
+            workflowStrategy: 'escalate-human',
+        });
+        expect(decideAction(ctx).action).toBe('escalate-human');
+    });
+    it('decompose on Finished yields decompose', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+            workflowStrategy: 'decompose',
+        });
+        expect(decideAction(ctx).action).toBe('decompose');
+    });
+    it('decompose on Rejected yields decompose', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Rejected' }),
+            workflowStrategy: 'decompose',
+        });
+        expect(decideAction(ctx).action).toBe('decompose');
+    });
+    it('escalate-human on Backlog has no effect (Backlog uses enableAutoDevelopment)', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Backlog' }),
+            workflowStrategy: 'escalate-human',
+        });
+        expect(decideAction(ctx).action).toBe('trigger-development');
+    });
+    it('escalate-human on Delivered has no effect (Delivered uses enableAutoAcceptance)', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Delivered' }),
+            workflowStrategy: 'escalate-human',
+        });
+        expect(decideAction(ctx).action).toBe('trigger-acceptance');
+    });
+});

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

@@ -0,0 +1,43 @@
+/**
+ * Governor Event Bus Interface
+ *
+ * Defines the contract for event transport between producers (webhooks, poll
+ * sweeps) and consumers (EventDrivenGovernor). Implementations include
+ * InMemoryEventBus (testing/single-process) and RedisEventBus (production).
+ */
+import type { GovernorEvent } from './event-types.js';
+/**
+ * Transport layer for GovernorEvents.
+ *
+ * - `publish`: Enqueue an event for processing.
+ * - `subscribe`: Returns an AsyncIterable that yields events one at a time.
+ * - `ack`: Acknowledge successful processing (allows the bus to remove it).
+ * - `close`: Gracefully shut down the bus.
+ */
+export interface GovernorEventBus {
+    /**
+     * Publish an event to the bus.
+     * Returns the event ID assigned by the transport.
+     */
+    publish(event: GovernorEvent): Promise<string>;
+    /**
+     * Subscribe to events. Returns an AsyncIterable that yields events
+     * as they become available. The iterable ends when `close()` is called.
+     *
+     * Each yielded item includes the transport-assigned event ID for acking.
+     */
+    subscribe(): AsyncIterable<{
+        id: string;
+        event: GovernorEvent;
+    }>;
+    /**
+     * Acknowledge that an event has been successfully processed.
+     * The bus may use this to remove the event from pending state.
+     */
+    ack(eventId: string): Promise<void>;
+    /**
+     * Gracefully close the bus, ending any active subscriptions.
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=event-bus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.d.ts","sourceRoot":"","sources":["../../../src/governor/event-bus.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAMrD;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAE9C;;;;;OAKG;IACH,SAAS,IAAI,aAAa,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,aAAa,CAAA;KAAE,CAAC,CAAA;IAEhE;;;OAGG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEnC;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB"}

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

@@ -0,0 +1,8 @@
+/**
+ * Governor Event Bus Interface
+ *
+ * Defines the contract for event transport between producers (webhooks, poll
+ * sweeps) and consumers (EventDrivenGovernor). Implementations include
+ * InMemoryEventBus (testing/single-process) and RedisEventBus (production).
+ */
+export {};