@renseiai/agentfactory 0.8.8 → 0.8.9

package/dist/src/workflow/gate-state.test.js

@@ -0,0 +1,251 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { parseDuration, InMemoryGateStorage, activateGate, satisfyGate, timeoutGate, } from './gate-state.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeGateDefinition(overrides = {}) {
+    return {
+        name: 'test-gate',
+        type: 'signal',
+        trigger: { source: 'comment', match: 'APPROVE' },
+        ...overrides,
+    };
+}
+function makeGateState(overrides = {}) {
+    return {
+        issueId: 'issue-1',
+        gateName: 'test-gate',
+        gateType: 'signal',
+        status: 'active',
+        activatedAt: Date.now(),
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// parseDuration
+// ---------------------------------------------------------------------------
+describe('parseDuration', () => {
+    it('parses hours: "4h" → 14400000ms', () => {
+        expect(parseDuration('4h')).toBe(14_400_000);
+    });
+    it('parses minutes: "30m" → 1800000ms', () => {
+        expect(parseDuration('30m')).toBe(1_800_000);
+    });
+    it('parses days: "2d" → 172800000ms', () => {
+        expect(parseDuration('2d')).toBe(172_800_000);
+    });
+    it('parses seconds: "15s" → 15000ms', () => {
+        expect(parseDuration('15s')).toBe(15_000);
+    });
+    it('throws on invalid format (missing unit)', () => {
+        expect(() => parseDuration('100')).toThrow('Invalid duration format');
+    });
+    it('throws on invalid format (unknown unit)', () => {
+        expect(() => parseDuration('5w')).toThrow('Invalid duration format');
+    });
+    it('throws on empty string', () => {
+        expect(() => parseDuration('')).toThrow('Invalid duration format');
+    });
+    it('throws on non-numeric value', () => {
+        expect(() => parseDuration('abch')).toThrow('Invalid duration format');
+    });
+});
+// ---------------------------------------------------------------------------
+// InMemoryGateStorage
+// ---------------------------------------------------------------------------
+describe('InMemoryGateStorage', () => {
+    let storage;
+    beforeEach(() => {
+        storage = new InMemoryGateStorage();
+    });
+    describe('getGateState', () => {
+        it('returns null for non-existent gate', async () => {
+            const result = await storage.getGateState('issue-1', 'missing-gate');
+            expect(result).toBeNull();
+        });
+        it('returns stored gate state', async () => {
+            const state = makeGateState();
+            await storage.setGateState('issue-1', 'test-gate', state);
+            const result = await storage.getGateState('issue-1', 'test-gate');
+            expect(result).toEqual(state);
+        });
+    });
+    describe('setGateState', () => {
+        it('stores and retrieves gate state', async () => {
+            const state = makeGateState({ gateName: 'my-gate' });
+            await storage.setGateState('issue-1', 'my-gate', state);
+            const result = await storage.getGateState('issue-1', 'my-gate');
+            expect(result).toEqual(state);
+        });
+        it('overwrites existing gate state', async () => {
+            const state1 = makeGateState({ status: 'active' });
+            const state2 = makeGateState({ status: 'satisfied', satisfiedAt: Date.now() });
+            await storage.setGateState('issue-1', 'test-gate', state1);
+            await storage.setGateState('issue-1', 'test-gate', state2);
+            const result = await storage.getGateState('issue-1', 'test-gate');
+            expect(result?.status).toBe('satisfied');
+        });
+    });
+    describe('getActiveGates', () => {
+        it('returns empty array when no gates exist', async () => {
+            const result = await storage.getActiveGates('issue-1');
+            expect(result).toEqual([]);
+        });
+        it('returns only active gates for the given issue', async () => {
+            const active1 = makeGateState({ gateName: 'gate-a', status: 'active' });
+            const satisfied = makeGateState({ gateName: 'gate-b', status: 'satisfied' });
+            const active2 = makeGateState({ gateName: 'gate-c', status: 'active' });
+            await storage.setGateState('issue-1', 'gate-a', active1);
+            await storage.setGateState('issue-1', 'gate-b', satisfied);
+            await storage.setGateState('issue-1', 'gate-c', active2);
+            const result = await storage.getActiveGates('issue-1');
+            expect(result).toHaveLength(2);
+            expect(result.map(g => g.gateName)).toContain('gate-a');
+            expect(result.map(g => g.gateName)).toContain('gate-c');
+        });
+        it('does not return gates from other issues', async () => {
+            const state = makeGateState({ issueId: 'issue-2', gateName: 'gate-a', status: 'active' });
+            await storage.setGateState('issue-2', 'gate-a', state);
+            const result = await storage.getActiveGates('issue-1');
+            expect(result).toEqual([]);
+        });
+    });
+    describe('clearGateStates', () => {
+        it('clears all gates for an issue', async () => {
+            await storage.setGateState('issue-1', 'gate-a', makeGateState({ gateName: 'gate-a' }));
+            await storage.setGateState('issue-1', 'gate-b', makeGateState({ gateName: 'gate-b' }));
+            await storage.clearGateStates('issue-1');
+            expect(await storage.getGateState('issue-1', 'gate-a')).toBeNull();
+            expect(await storage.getGateState('issue-1', 'gate-b')).toBeNull();
+        });
+        it('does not affect other issues', async () => {
+            await storage.setGateState('issue-1', 'gate-a', makeGateState({ issueId: 'issue-1', gateName: 'gate-a' }));
+            await storage.setGateState('issue-2', 'gate-b', makeGateState({ issueId: 'issue-2', gateName: 'gate-b' }));
+            await storage.clearGateStates('issue-1');
+            expect(await storage.getGateState('issue-1', 'gate-a')).toBeNull();
+            expect(await storage.getGateState('issue-2', 'gate-b')).not.toBeNull();
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// activateGate
+// ---------------------------------------------------------------------------
+describe('activateGate', () => {
+    let storage;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-06-01T12:00:00Z'));
+        storage = new InMemoryGateStorage();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('creates an active gate state', async () => {
+        const gateDef = makeGateDefinition();
+        const state = await activateGate('issue-1', gateDef, storage);
+        expect(state.issueId).toBe('issue-1');
+        expect(state.gateName).toBe('test-gate');
+        expect(state.gateType).toBe('signal');
+        expect(state.status).toBe('active');
+        expect(state.activatedAt).toBe(Date.now());
+    });
+    it('computes timeout deadline from gate definition', async () => {
+        const gateDef = makeGateDefinition({
+            timeout: { duration: '4h', action: 'escalate' },
+        });
+        const state = await activateGate('issue-1', gateDef, storage);
+        expect(state.timeoutDeadline).toBe(Date.now() + 14_400_000);
+        expect(state.timeoutAction).toBe('escalate');
+        expect(state.timeoutDuration).toBe('4h');
+    });
+    it('does not set timeout fields when gate has no timeout', async () => {
+        const gateDef = makeGateDefinition();
+        const state = await activateGate('issue-1', gateDef, storage);
+        expect(state.timeoutDeadline).toBeUndefined();
+        expect(state.timeoutAction).toBeUndefined();
+        expect(state.timeoutDuration).toBeUndefined();
+    });
+    it('persists gate state in storage', async () => {
+        const gateDef = makeGateDefinition();
+        await activateGate('issue-1', gateDef, storage);
+        const stored = await storage.getGateState('issue-1', 'test-gate');
+        expect(stored).not.toBeNull();
+        expect(stored?.status).toBe('active');
+    });
+});
+// ---------------------------------------------------------------------------
+// satisfyGate
+// ---------------------------------------------------------------------------
+describe('satisfyGate', () => {
+    let storage;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-06-01T12:00:00Z'));
+        storage = new InMemoryGateStorage();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('marks an active gate as satisfied with source', async () => {
+        await storage.setGateState('issue-1', 'test-gate', makeGateState({ status: 'active' }));
+        const result = await satisfyGate('issue-1', 'test-gate', 'comment-123', storage);
+        expect(result).not.toBeNull();
+        expect(result?.status).toBe('satisfied');
+        expect(result?.signalSource).toBe('comment-123');
+        expect(result?.satisfiedAt).toBe(Date.now());
+    });
+    it('returns null for non-existent gate', async () => {
+        const result = await satisfyGate('issue-1', 'missing-gate', 'source', storage);
+        expect(result).toBeNull();
+    });
+    it('returns null for non-active gate', async () => {
+        await storage.setGateState('issue-1', 'test-gate', makeGateState({ status: 'satisfied' }));
+        const result = await satisfyGate('issue-1', 'test-gate', 'source', storage);
+        expect(result).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// timeoutGate
+// ---------------------------------------------------------------------------
+describe('timeoutGate', () => {
+    let storage;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-06-01T12:00:00Z'));
+        storage = new InMemoryGateStorage();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('marks an active gate as timed-out', async () => {
+        await storage.setGateState('issue-1', 'test-gate', makeGateState({ status: 'active' }));
+        const result = await timeoutGate('issue-1', 'test-gate', storage);
+        expect(result).not.toBeNull();
+        expect(result?.status).toBe('timed-out');
+        expect(result?.timedOutAt).toBe(Date.now());
+    });
+    it('returns null for non-existent gate', async () => {
+        const result = await timeoutGate('issue-1', 'missing-gate', storage);
+        expect(result).toBeNull();
+    });
+    it('returns null for non-active gate', async () => {
+        await storage.setGateState('issue-1', 'test-gate', makeGateState({ status: 'timed-out' }));
+        const result = await timeoutGate('issue-1', 'test-gate', storage);
+        expect(result).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// getActiveGates (functional)
+// ---------------------------------------------------------------------------
+describe('getActiveGates returns only active gates', () => {
+    it('filters by status correctly', async () => {
+        const storage = new InMemoryGateStorage();
+        await storage.setGateState('issue-1', 'gate-active', makeGateState({ gateName: 'gate-active', status: 'active' }));
+        await storage.setGateState('issue-1', 'gate-satisfied', makeGateState({ gateName: 'gate-satisfied', status: 'satisfied' }));
+        await storage.setGateState('issue-1', 'gate-timed-out', makeGateState({ gateName: 'gate-timed-out', status: 'timed-out' }));
+        await storage.setGateState('issue-1', 'gate-pending', makeGateState({ gateName: 'gate-pending', status: 'pending' }));
+        const active = await storage.getActiveGates('issue-1');
+        expect(active).toHaveLength(1);
+        expect(active[0].gateName).toBe('gate-active');
+    });
+});

package/dist/src/workflow/gates/gate-evaluator.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Gate Evaluator — Decision Engine Integration Layer
+ *
+ * Unified gate evaluation module that the decision engine calls to check
+ * whether workflow phase transitions are blocked by unsatisfied gates.
+ * Wires together signal gates, timer gates, webhook gates, and the timeout
+ * engine into a single evaluation pipeline.
+ *
+ * Main entry points:
+ * - evaluateGatesForPhase() — called by the governor before decideAction()
+ * - activateGatesForPhase() — called when entering a new workflow phase
+ * - clearGatesForIssue()    — called when an issue reaches terminal state
+ */
+import type { GateState, GateStorage } from '../gate-state.js';
+import type { WorkflowDefinition, GateDefinition } from '../workflow-types.js';
+import type { TimeoutResolution } from './timeout-engine.js';
+/**
+ * Options for evaluating gates applicable to a workflow phase.
+ * The governor populates this before calling the decision engine.
+ */
+export interface GateEvaluationOptions {
+    /** The issue identifier */
+    issueId: string;
+    /** The current workflow phase name */
+    phase: string;
+    /** The workflow definition containing gate configurations */
+    workflow: WorkflowDefinition;
+    /** Storage adapter for gate state persistence */
+    storage: GateStorage;
+    /** For signal gates — latest comments to check */
+    comments?: Array<{
+        text: string;
+        isBot: boolean;
+    }>;
+    /** Current time for timer/timeout evaluation (epoch ms, defaults to Date.now()) */
+    now?: number;
+}
+/**
+ * Result of evaluating all gates for a workflow phase.
+ * Consumed by the decision engine to determine if transitions are blocked.
+ */
+export interface GateEvaluationResult {
+    /** Whether all gates for this phase are satisfied (or no gates apply) */
+    allSatisfied: boolean;
+    /** Active unsatisfied gates */
+    activeGates: GateState[];
+    /** Gates that were satisfied during this evaluation */
+    newlySatisfied: GateState[];
+    /** Timeout resolutions that need to be acted on */
+    timeoutResolutions: TimeoutResolution[];
+    /** Reason string for decision engine logging */
+    reason: string;
+}
+/**
+ * Get all gate definitions from a workflow that apply to a given phase,
+ * across all gate types (signal, timer, webhook).
+ *
+ * @param workflow - The workflow definition containing gate configurations
+ * @param phase - The phase name to filter by
+ * @returns Array of GateDefinition objects applicable to the phase
+ */
+export declare function getApplicableGates(workflow: WorkflowDefinition, phase: string): GateDefinition[];
+/**
+ * Evaluate all gates applicable to a workflow phase.
+ *
+ * This is the main entry point called by the governor before invoking
+ * the decision engine. It evaluates each active gate according to its
+ * type and returns an aggregated result indicating whether all gates
+ * are satisfied.
+ *
+ * Evaluation pipeline:
+ * 1. Get applicable gates for the phase from the workflow definition
+ * 2. For each applicable gate, retrieve its persisted state from storage
+ * 3. For each active gate:
+ *    - Signal gates: check each comment via evaluateSignalGate(); satisfy on match
+ *    - Timer gates: check via evaluateTimerGate(); satisfy if fired
+ *    - Webhook gates: check via evaluateWebhookGate() (satisfaction is external)
+ * 4. Check timeouts via processGateTimeouts()
+ * 5. Return aggregated result
+ *
+ * @param opts - Gate evaluation options
+ * @returns Aggregated gate evaluation result
+ */
+export declare function evaluateGatesForPhase(opts: GateEvaluationOptions): Promise<GateEvaluationResult>;
+/**
+ * Activate all gates applicable to a workflow phase.
+ *
+ * Called when a workflow transitions to a new phase. Finds all gate
+ * definitions that apply to the phase and activates each one via
+ * the gate-state module, creating persisted gate state with computed
+ * timeout deadlines.
+ *
+ * Gates that are already activated (i.e., have existing state) are
+ * skipped to prevent re-activation on subsequent poll cycles.
+ *
+ * For webhook gates, a cryptographic token is generated and stored in
+ * the gate state. The callback URL is stored in `signalSource` so
+ * external systems can discover it.
+ *
+ * @param issueId - The issue identifier
+ * @param phase - The phase being entered
+ * @param workflow - The workflow definition containing gate configurations
+ * @param storage - The gate storage adapter for persisting state
+ * @param baseUrl - Optional base URL for webhook callback URLs
+ * @returns Array of newly activated gate states
+ */
+export declare function activateGatesForPhase(issueId: string, phase: string, workflow: WorkflowDefinition, storage: GateStorage, baseUrl?: string): Promise<GateState[]>;
+/**
+ * Clear all gate states for an issue.
+ *
+ * Called when an issue reaches a terminal state (Accepted, Canceled,
+ * Duplicate) to clean up any persisted gate state. Delegates directly
+ * to the storage adapter's clearGateStates() method.
+ *
+ * @param issueId - The issue identifier
+ * @param storage - The gate storage adapter
+ */
+export declare function clearGatesForIssue(issueId: string, storage: GateStorage): Promise<void>;
+//# sourceMappingURL=gate-evaluator.d.ts.map

package/dist/src/workflow/gates/gate-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-evaluator.d.ts","sourceRoot":"","sources":["../../../../src/workflow/gates/gate-evaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAE9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAO9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAqB5D;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,2BAA2B;IAC3B,OAAO,EAAE,MAAM,CAAA;IACf,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAA;IACb,6DAA6D;IAC7D,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,iDAAiD;IACjD,OAAO,EAAE,WAAW,CAAA;IACpB,kDAAkD;IAClD,QAAQ,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;IAClD,mFAAmF;IACnF,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,yEAAyE;IACzE,YAAY,EAAE,OAAO,CAAA;IACrB,+BAA+B;IAC/B,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,uDAAuD;IACvD,cAAc,EAAE,SAAS,EAAE,CAAA;IAC3B,mDAAmD;IACnD,kBAAkB,EAAE,iBAAiB,EAAE,CAAA;IACvC,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAA;CACf;AAMD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE,CAMhG;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA2HtG;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,SAAS,EAAE,CAAC,CAwCtB;AAED;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC,CAGf"}

package/dist/src/workflow/gates/gate-evaluator.js

@@ -0,0 +1,243 @@
+/**
+ * Gate Evaluator — Decision Engine Integration Layer
+ *
+ * Unified gate evaluation module that the decision engine calls to check
+ * whether workflow phase transitions are blocked by unsatisfied gates.
+ * Wires together signal gates, timer gates, webhook gates, and the timeout
+ * engine into a single evaluation pipeline.
+ *
+ * Main entry points:
+ * - evaluateGatesForPhase() — called by the governor before decideAction()
+ * - activateGatesForPhase() — called when entering a new workflow phase
+ * - clearGatesForIssue()    — called when an issue reaches terminal state
+ */
+import { activateGate, satisfyGate } from '../gate-state.js';
+import { evaluateSignalGate } from './signal-gate.js';
+import { getApplicableSignalGates } from './signal-gate.js';
+import { evaluateTimerGate } from './timer-gate.js';
+import { getApplicableTimerGates } from './timer-gate.js';
+import { evaluateWebhookGate, generateWebhookToken, buildCallbackUrl } from './webhook-gate.js';
+import { getApplicableWebhookGates } from './webhook-gate.js';
+import { processGateTimeouts } from './timeout-engine.js';
+// ============================================
+// Logger
+// ============================================
+const log = {
+    info: (msg, data) => console.log(`[gate-evaluator] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[gate-evaluator] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[gate-evaluator] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+// ============================================
+// Gate Query Helpers
+// ============================================
+/**
+ * Get all gate definitions from a workflow that apply to a given phase,
+ * across all gate types (signal, timer, webhook).
+ *
+ * @param workflow - The workflow definition containing gate configurations
+ * @param phase - The phase name to filter by
+ * @returns Array of GateDefinition objects applicable to the phase
+ */
+export function getApplicableGates(workflow, phase) {
+    return [
+        ...getApplicableSignalGates(workflow, phase),
+        ...getApplicableTimerGates(workflow, phase),
+        ...getApplicableWebhookGates(workflow, phase),
+    ];
+}
+// ============================================
+// Main Entry Points
+// ============================================
+/**
+ * Evaluate all gates applicable to a workflow phase.
+ *
+ * This is the main entry point called by the governor before invoking
+ * the decision engine. It evaluates each active gate according to its
+ * type and returns an aggregated result indicating whether all gates
+ * are satisfied.
+ *
+ * Evaluation pipeline:
+ * 1. Get applicable gates for the phase from the workflow definition
+ * 2. For each applicable gate, retrieve its persisted state from storage
+ * 3. For each active gate:
+ *    - Signal gates: check each comment via evaluateSignalGate(); satisfy on match
+ *    - Timer gates: check via evaluateTimerGate(); satisfy if fired
+ *    - Webhook gates: check via evaluateWebhookGate() (satisfaction is external)
+ * 4. Check timeouts via processGateTimeouts()
+ * 5. Return aggregated result
+ *
+ * @param opts - Gate evaluation options
+ * @returns Aggregated gate evaluation result
+ */
+export async function evaluateGatesForPhase(opts) {
+    const { issueId, phase, workflow, storage, comments, now } = opts;
+    const currentTime = now ?? Date.now();
+    // 1. Get applicable gate definitions for this phase
+    const applicableGateDefs = getApplicableGates(workflow, phase);
+    // If no gates apply, everything is satisfied
+    if (applicableGateDefs.length === 0) {
+        return {
+            allSatisfied: true,
+            activeGates: [],
+            newlySatisfied: [],
+            timeoutResolutions: [],
+            reason: `No gates apply to phase "${phase}"`,
+        };
+    }
+    const newlySatisfied = [];
+    // 2. For each applicable gate, check if it's already activated
+    for (const gateDef of applicableGateDefs) {
+        const gateState = await storage.getGateState(issueId, gateDef.name);
+        // Gate not yet activated — skip evaluation (it will be activated
+        // when the phase is entered via activateGatesForPhase)
+        if (!gateState || gateState.status !== 'active') {
+            continue;
+        }
+        // 3. Evaluate based on gate type
+        switch (gateDef.type) {
+            case 'signal': {
+                // Check each comment against the signal gate
+                if (comments && comments.length > 0) {
+                    for (const comment of comments) {
+                        const result = evaluateSignalGate(gateDef, comment.text, comment.isBot);
+                        if (result.matched) {
+                            const satisfied = await satisfyGate(issueId, gateDef.name, result.source ?? 'signal-match', storage);
+                            if (satisfied) {
+                                newlySatisfied.push(satisfied);
+                                log.info('Signal gate satisfied by comment', {
+                                    issueId,
+                                    gateName: gateDef.name,
+                                    source: result.source,
+                                });
+                            }
+                            break; // Gate satisfied, no need to check more comments
+                        }
+                    }
+                }
+                break;
+            }
+            case 'timer': {
+                const result = evaluateTimerGate(gateDef, currentTime);
+                if (result.fired) {
+                    const satisfied = await satisfyGate(issueId, gateDef.name, `timer-fired:${result.nextFireTime}`, storage);
+                    if (satisfied) {
+                        newlySatisfied.push(satisfied);
+                        log.info('Timer gate fired', {
+                            issueId,
+                            gateName: gateDef.name,
+                            nextFireTime: result.nextFireTime,
+                        });
+                    }
+                }
+                break;
+            }
+            case 'webhook': {
+                // Webhook gates are satisfied externally via HTTP callback.
+                // We just evaluate the current state to check for timeout.
+                evaluateWebhookGate(gateDef, gateState);
+                break;
+            }
+        }
+    }
+    // 4. Check timeouts on all active gates
+    const activeGates = await storage.getActiveGates(issueId);
+    const timeoutResolutions = await processGateTimeouts(activeGates, storage, currentTime);
+    // 5. Re-fetch active gates after timeout processing (some may have been timed-out)
+    const remainingActiveGates = await storage.getActiveGates(issueId);
+    // Filter to only those gates that are relevant to this phase
+    const applicableGateNames = new Set(applicableGateDefs.map(g => g.name));
+    const phaseActiveGates = remainingActiveGates.filter(g => applicableGateNames.has(g.gateName));
+    const allSatisfied = phaseActiveGates.length === 0;
+    // Build reason string
+    let reason;
+    if (allSatisfied) {
+        if (newlySatisfied.length > 0) {
+            const names = newlySatisfied.map(g => g.gateName).join(', ');
+            reason = `All gates satisfied for phase "${phase}" (newly satisfied: ${names})`;
+        }
+        else {
+            reason = `All gates satisfied for phase "${phase}"`;
+        }
+    }
+    else {
+        const activeNames = phaseActiveGates.map(g => g.gateName).join(', ');
+        reason = `Unsatisfied gates for phase "${phase}": ${activeNames}`;
+    }
+    return {
+        allSatisfied,
+        activeGates: phaseActiveGates,
+        newlySatisfied,
+        timeoutResolutions,
+        reason,
+    };
+}
+/**
+ * Activate all gates applicable to a workflow phase.
+ *
+ * Called when a workflow transitions to a new phase. Finds all gate
+ * definitions that apply to the phase and activates each one via
+ * the gate-state module, creating persisted gate state with computed
+ * timeout deadlines.
+ *
+ * Gates that are already activated (i.e., have existing state) are
+ * skipped to prevent re-activation on subsequent poll cycles.
+ *
+ * For webhook gates, a cryptographic token is generated and stored in
+ * the gate state. The callback URL is stored in `signalSource` so
+ * external systems can discover it.
+ *
+ * @param issueId - The issue identifier
+ * @param phase - The phase being entered
+ * @param workflow - The workflow definition containing gate configurations
+ * @param storage - The gate storage adapter for persisting state
+ * @param baseUrl - Optional base URL for webhook callback URLs
+ * @returns Array of newly activated gate states
+ */
+export async function activateGatesForPhase(issueId, phase, workflow, storage, baseUrl) {
+    const applicableGateDefs = getApplicableGates(workflow, phase);
+    if (applicableGateDefs.length === 0) {
+        log.debug('No gates to activate for phase', { issueId, phase });
+        return [];
+    }
+    const activated = [];
+    for (const gateDef of applicableGateDefs) {
+        // Skip if already activated (prevent re-activation on repeated polls)
+        const existing = await storage.getGateState(issueId, gateDef.name);
+        if (existing) {
+            log.debug('Gate already activated, skipping', { issueId, gateName: gateDef.name, status: existing.status });
+            continue;
+        }
+        const gateState = await activateGate(issueId, gateDef, storage);
+        // For webhook gates, generate and persist a token + callback URL
+        if (gateDef.type === 'webhook' && baseUrl) {
+            const token = generateWebhookToken();
+            const callbackUrl = buildCallbackUrl(baseUrl, issueId, gateDef.name, token);
+            gateState.webhookToken = token;
+            gateState.signalSource = callbackUrl;
+            await storage.setGateState(issueId, gateDef.name, gateState);
+        }
+        activated.push(gateState);
+        log.info('Gate activated for phase', {
+            issueId,
+            phase,
+            gateName: gateDef.name,
+            gateType: gateDef.type,
+        });
+    }
+    return activated;
+}
+/**
+ * Clear all gate states for an issue.
+ *
+ * Called when an issue reaches a terminal state (Accepted, Canceled,
+ * Duplicate) to clean up any persisted gate state. Delegates directly
+ * to the storage adapter's clearGateStates() method.
+ *
+ * @param issueId - The issue identifier
+ * @param storage - The gate storage adapter
+ */
+export async function clearGatesForIssue(issueId, storage) {
+    await storage.clearGateStates(issueId);
+    log.info('Cleared all gate states for issue', { issueId });
+}

package/dist/src/workflow/gates/gate-evaluator.test.d.ts

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

package/dist/src/workflow/gates/gate-evaluator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-evaluator.test.d.ts","sourceRoot":"","sources":["../../../../src/workflow/gates/gate-evaluator.test.ts"],"names":[],"mappings":""}