@renseiai/agentfactory 0.8.8 → 0.8.9

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

@@ -0,0 +1,240 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { evaluateGatesForPhase, activateGatesForPhase, clearGatesForIssue, getApplicableGates, } from './gate-evaluator.js';
+import { InMemoryGateStorage } from '../gate-state.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeGateDefinition(overrides = {}) {
+    return {
+        name: 'test-gate',
+        type: 'signal',
+        trigger: { source: 'comment', match: 'APPROVE' },
+        ...overrides,
+    };
+}
+function makeWorkflow(gates = []) {
+    return {
+        apiVersion: 'v1.1',
+        kind: 'WorkflowDefinition',
+        metadata: { name: 'test-workflow' },
+        phases: [{ name: 'development', template: 'dev' }],
+        transitions: [{ from: 'Backlog', to: 'development' }],
+        gates,
+    };
+}
+// ---------------------------------------------------------------------------
+// evaluateGatesForPhase
+// ---------------------------------------------------------------------------
+describe('evaluateGatesForPhase', () => {
+    let storage;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-06-01T12:00:00Z'));
+        storage = new InMemoryGateStorage();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('returns all satisfied when no gates apply', async () => {
+        const workflow = makeWorkflow([]);
+        const result = await evaluateGatesForPhase({
+            issueId: 'issue-1',
+            phase: 'development',
+            workflow,
+            storage,
+        });
+        expect(result.allSatisfied).toBe(true);
+        expect(result.activeGates).toEqual([]);
+        expect(result.newlySatisfied).toEqual([]);
+        expect(result.timeoutResolutions).toEqual([]);
+        expect(result.reason).toContain('No gates apply');
+    });
+    it('satisfies active signal gate when a matching comment is provided', async () => {
+        const gate = makeGateDefinition({
+            name: 'approval',
+            type: 'signal',
+            trigger: { source: 'comment', match: 'APPROVE' },
+            appliesTo: ['development'],
+        });
+        const workflow = makeWorkflow([gate]);
+        // Activate the gate first
+        await activateGatesForPhase('issue-1', 'development', workflow, storage);
+        // Evaluate with a matching comment
+        const result = await evaluateGatesForPhase({
+            issueId: 'issue-1',
+            phase: 'development',
+            workflow,
+            storage,
+            comments: [{ text: 'APPROVE', isBot: false }],
+        });
+        expect(result.allSatisfied).toBe(true);
+        expect(result.newlySatisfied).toHaveLength(1);
+        expect(result.newlySatisfied[0].gateName).toBe('approval');
+    });
+    it('timer gate fires at correct time', async () => {
+        const gate = makeGateDefinition({
+            name: 'scheduled',
+            type: 'timer',
+            trigger: { cron: '0 12 * * *' }, // fires at 12:00
+            appliesTo: ['development'],
+        });
+        const workflow = makeWorkflow([gate]);
+        // Activate the gate
+        await activateGatesForPhase('issue-1', 'development', workflow, storage);
+        // Evaluate at 12:00:30 (should fire since current minute matches)
+        const now = new Date(2025, 5, 1, 12, 0, 30, 0).getTime();
+        const result = await evaluateGatesForPhase({
+            issueId: 'issue-1',
+            phase: 'development',
+            workflow,
+            storage,
+            now,
+        });
+        expect(result.allSatisfied).toBe(true);
+        expect(result.newlySatisfied).toHaveLength(1);
+        expect(result.newlySatisfied[0].gateName).toBe('scheduled');
+    });
+    it('unsatisfied gates block (allSatisfied is false)', async () => {
+        const gate = makeGateDefinition({
+            name: 'approval',
+            type: 'signal',
+            trigger: { source: 'comment', match: 'APPROVE' },
+            appliesTo: ['development'],
+        });
+        const workflow = makeWorkflow([gate]);
+        // Activate the gate
+        await activateGatesForPhase('issue-1', 'development', workflow, storage);
+        // Evaluate without matching comments
+        const result = await evaluateGatesForPhase({
+            issueId: 'issue-1',
+            phase: 'development',
+            workflow,
+            storage,
+            comments: [{ text: 'not a match', isBot: false }],
+        });
+        expect(result.allSatisfied).toBe(false);
+        expect(result.activeGates).toHaveLength(1);
+        expect(result.activeGates[0].gateName).toBe('approval');
+        expect(result.reason).toContain('Unsatisfied gates');
+    });
+    it('processes timeouts for active gates', async () => {
+        const gate = makeGateDefinition({
+            name: 'timed-gate',
+            type: 'signal',
+            trigger: { source: 'comment', match: 'APPROVE' },
+            timeout: { duration: '1h', action: 'fail' },
+            appliesTo: ['development'],
+        });
+        const workflow = makeWorkflow([gate]);
+        // Activate the gate
+        await activateGatesForPhase('issue-1', 'development', workflow, storage);
+        // Advance time past the timeout
+        vi.advanceTimersByTime(2 * 60 * 60 * 1000); // 2 hours
+        const result = await evaluateGatesForPhase({
+            issueId: 'issue-1',
+            phase: 'development',
+            workflow,
+            storage,
+        });
+        expect(result.timeoutResolutions).toHaveLength(1);
+        expect(result.timeoutResolutions[0].type).toBe('fail');
+        expect(result.timeoutResolutions[0].gateName).toBe('timed-gate');
+    });
+});
+// ---------------------------------------------------------------------------
+// activateGatesForPhase
+// ---------------------------------------------------------------------------
+describe('activateGatesForPhase', () => {
+    let storage;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-06-01T12:00:00Z'));
+        storage = new InMemoryGateStorage();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('activates applicable gates', async () => {
+        const gates = [
+            makeGateDefinition({ name: 'gate-1', type: 'signal', appliesTo: ['development'] }),
+            makeGateDefinition({ name: 'gate-2', type: 'timer', trigger: { cron: '0 9 * * *' }, appliesTo: ['development'] }),
+        ];
+        const workflow = makeWorkflow(gates);
+        const activated = await activateGatesForPhase('issue-1', 'development', workflow, storage);
+        expect(activated).toHaveLength(2);
+        expect(activated.map(g => g.gateName)).toContain('gate-1');
+        expect(activated.map(g => g.gateName)).toContain('gate-2');
+    });
+    it('skips already-activated gates', async () => {
+        const gate = makeGateDefinition({ name: 'gate-1', type: 'signal', appliesTo: ['development'] });
+        const workflow = makeWorkflow([gate]);
+        // Activate once
+        const first = await activateGatesForPhase('issue-1', 'development', workflow, storage);
+        expect(first).toHaveLength(1);
+        // Activate again — should skip
+        const second = await activateGatesForPhase('issue-1', 'development', workflow, storage);
+        expect(second).toHaveLength(0);
+    });
+    it('returns empty array when no gates apply', async () => {
+        const workflow = makeWorkflow([]);
+        const activated = await activateGatesForPhase('issue-1', 'development', workflow, storage);
+        expect(activated).toEqual([]);
+    });
+    it('does not activate gates for other phases', async () => {
+        const gate = makeGateDefinition({ name: 'qa-gate', type: 'signal', appliesTo: ['qa'] });
+        const workflow = makeWorkflow([gate]);
+        const activated = await activateGatesForPhase('issue-1', 'development', workflow, storage);
+        expect(activated).toEqual([]);
+    });
+});
+// ---------------------------------------------------------------------------
+// clearGatesForIssue
+// ---------------------------------------------------------------------------
+describe('clearGatesForIssue', () => {
+    it('delegates to storage.clearGateStates', async () => {
+        const storage = new InMemoryGateStorage();
+        // Add some gates
+        await storage.setGateState('issue-1', 'gate-a', {
+            issueId: 'issue-1',
+            gateName: 'gate-a',
+            gateType: 'signal',
+            status: 'active',
+            activatedAt: Date.now(),
+        });
+        await clearGatesForIssue('issue-1', storage);
+        const result = await storage.getGateState('issue-1', 'gate-a');
+        expect(result).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// getApplicableGates
+// ---------------------------------------------------------------------------
+describe('getApplicableGates', () => {
+    it('aggregates gates across all types', () => {
+        const gates = [
+            makeGateDefinition({ name: 'signal-1', type: 'signal', appliesTo: ['development'] }),
+            makeGateDefinition({ name: 'timer-1', type: 'timer', trigger: { cron: '0 9 * * *' }, appliesTo: ['development'] }),
+            makeGateDefinition({ name: 'webhook-1', type: 'webhook', trigger: { endpoint: '/api' }, appliesTo: ['development'] }),
+        ];
+        const workflow = makeWorkflow(gates);
+        const result = getApplicableGates(workflow, 'development');
+        expect(result).toHaveLength(3);
+        expect(result.map(g => g.name)).toContain('signal-1');
+        expect(result.map(g => g.name)).toContain('timer-1');
+        expect(result.map(g => g.name)).toContain('webhook-1');
+    });
+    it('returns empty array when no gates match phase', () => {
+        const gates = [
+            makeGateDefinition({ name: 'qa-gate', type: 'signal', appliesTo: ['qa'] }),
+        ];
+        const workflow = makeWorkflow(gates);
+        const result = getApplicableGates(workflow, 'development');
+        expect(result).toEqual([]);
+    });
+    it('returns empty array when workflow has no gates', () => {
+        const workflow = makeWorkflow();
+        delete workflow.gates;
+        const result = getApplicableGates(workflow, 'development');
+        expect(result).toEqual([]);
+    });
+});

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

@@ -0,0 +1,114 @@
+/**
+ * Signal Gate Executor
+ *
+ * Evaluates whether comments or directives satisfy a signal gate.
+ * Signal gates pause workflow execution until a matching comment or
+ * directive is detected. This module is backward compatible with
+ * existing HOLD/RESUME directives from the override-parser system.
+ *
+ * All evaluator functions are pure (no I/O) — they take inputs and
+ * return results without side effects.
+ */
+import type { GateDefinition, WorkflowDefinition } from '../workflow-types.js';
+/**
+ * Trigger configuration for a signal gate.
+ * Defines how incoming comments are matched against the gate condition.
+ */
+export interface SignalGateTrigger {
+    /** Whether to match against the full comment text or the first-line directive only */
+    source: 'comment' | 'directive';
+    /** String to match — can be an exact string or a regex pattern */
+    match: string;
+}
+/**
+ * Result of evaluating a comment against a signal gate
+ */
+export interface SignalGateResult {
+    /** Whether the comment matched the signal gate trigger */
+    matched: boolean;
+    /** The content that matched (the full comment or directive line) */
+    source?: string;
+}
+/**
+ * Type guard to validate that a trigger object has the correct shape
+ * for a signal gate trigger.
+ *
+ * A valid SignalGateTrigger must have:
+ * - `source`: either 'comment' or 'directive'
+ * - `match`: a non-empty string
+ *
+ * @param trigger - The trigger record to validate
+ * @returns True if the trigger is a valid SignalGateTrigger
+ */
+export declare function isSignalGateTrigger(trigger: Record<string, unknown>): trigger is Record<string, unknown> & SignalGateTrigger;
+/**
+ * Evaluate whether a comment satisfies a signal gate trigger.
+ *
+ * This is a pure function (no I/O) that checks if a comment matches
+ * the signal gate's trigger configuration.
+ *
+ * Matching rules:
+ * - Bot comments are always skipped (returns { matched: false })
+ * - When `trigger.source` is 'directive', only the first non-empty line
+ *   of the comment is checked (consistent with override-parser.ts)
+ * - When `trigger.source` is 'comment', the full trimmed comment text is checked
+ * - The `trigger.match` string is first tried as an exact case-insensitive match,
+ *   then as a regex pattern (case-insensitive)
+ *
+ * @param gate - The gate definition containing a signal trigger
+ * @param comment - The full comment body text
+ * @param isBot - Whether the comment was authored by a bot
+ * @returns A SignalGateResult indicating whether the comment matched
+ */
+export declare function evaluateSignalGate(gate: GateDefinition, comment: string, isBot: boolean): SignalGateResult;
+/**
+ * Get all signal gates from a workflow definition that apply to a given phase.
+ *
+ * Filters gates by:
+ * 1. `type === 'signal'`
+ * 2. `appliesTo` includes the given phase name, OR `appliesTo` is not defined
+ *    (gate applies to all phases)
+ *
+ * @param workflow - The workflow definition containing gate configurations
+ * @param phase - The phase name to filter by
+ * @returns Array of GateDefinition objects that are signal gates applicable to the phase
+ */
+export declare function getApplicableSignalGates(workflow: WorkflowDefinition, phase: string): GateDefinition[];
+/**
+ * Name used for the implicit HOLD gate created for backward compatibility
+ */
+export declare const IMPLICIT_HOLD_GATE_NAME = "__implicit-hold";
+/**
+ * Name used for the implicit RESUME gate created for backward compatibility
+ */
+export declare const IMPLICIT_RESUME_GATE_NAME = "__implicit-resume";
+/**
+ * Create an implicit signal gate definition that matches the HOLD directive.
+ *
+ * This provides backward compatibility with the existing HOLD/RESUME system.
+ * When a HOLD directive is detected and no explicit signal gate is defined,
+ * this creates a gate that will pause the workflow until a RESUME directive
+ * is received.
+ *
+ * The created gate matches:
+ * - Directive source: first line of comment
+ * - Pattern: `^hold(?:\s*[---]\s*(.+))?$` (matches HOLD or HOLD -- reason)
+ *
+ * @returns A GateDefinition representing the implicit HOLD gate
+ */
+export declare function createImplicitHoldGate(): GateDefinition;
+/**
+ * Create an implicit signal gate definition that matches the RESUME directive.
+ *
+ * This is the counterpart to the implicit HOLD gate. When a workflow is
+ * paused by a HOLD directive, this gate defines the condition that will
+ * release the hold — receiving a RESUME directive.
+ *
+ * The created gate matches:
+ * - Directive source: first line of comment
+ * - Pattern: `^resume$` (exact match for RESUME directive)
+ *
+ * @returns A GateDefinition representing the implicit RESUME gate
+ */
+export declare function createImplicitResumeGate(): GateDefinition;
+//# sourceMappingURL=signal-gate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signal-gate.d.ts","sourceRoot":"","sources":["../../../../src/workflow/gates/signal-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAa9E;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,sFAAsF;IACtF,MAAM,EAAE,SAAS,GAAG,WAAW,CAAA;IAC/B,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,0DAA0D;IAC1D,OAAO,EAAE,OAAO,CAAA;IAChB,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,iBAAiB,CAM5H;AAwBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAgD1G;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE,CAiBtG;AAMD;;GAEG;AACH,eAAO,MAAM,uBAAuB,oBAAoB,CAAA;AAExD;;GAEG;AACH,eAAO,MAAM,yBAAyB,sBAAsB,CAAA;AAE5D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,IAAI,cAAc,CAUvD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,IAAI,cAAc,CAUzD"}

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

@@ -0,0 +1,216 @@
+/**
+ * Signal Gate Executor
+ *
+ * Evaluates whether comments or directives satisfy a signal gate.
+ * Signal gates pause workflow execution until a matching comment or
+ * directive is detected. This module is backward compatible with
+ * existing HOLD/RESUME directives from the override-parser system.
+ *
+ * All evaluator functions are pure (no I/O) — they take inputs and
+ * return results without side effects.
+ */
+const log = {
+    info: (msg, data) => console.log(`[signal-gate] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[signal-gate] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[signal-gate] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+// ============================================
+// Type Guards
+// ============================================
+/**
+ * Type guard to validate that a trigger object has the correct shape
+ * for a signal gate trigger.
+ *
+ * A valid SignalGateTrigger must have:
+ * - `source`: either 'comment' or 'directive'
+ * - `match`: a non-empty string
+ *
+ * @param trigger - The trigger record to validate
+ * @returns True if the trigger is a valid SignalGateTrigger
+ */
+export function isSignalGateTrigger(trigger) {
+    if (typeof trigger.source !== 'string')
+        return false;
+    if (trigger.source !== 'comment' && trigger.source !== 'directive')
+        return false;
+    if (typeof trigger.match !== 'string')
+        return false;
+    if (trigger.match.length === 0)
+        return false;
+    return true;
+}
+// ============================================
+// Signal Gate Evaluator
+// ============================================
+/**
+ * Extract the first non-empty line from a comment body.
+ * Mirrors the directive extraction logic in override-parser.ts.
+ *
+ * @param body - The full comment body text
+ * @returns The trimmed first non-empty line, or empty string if none
+ */
+function extractDirectiveLine(body) {
+    const lines = body.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0) {
+            return trimmed;
+        }
+    }
+    return '';
+}
+/**
+ * Evaluate whether a comment satisfies a signal gate trigger.
+ *
+ * This is a pure function (no I/O) that checks if a comment matches
+ * the signal gate's trigger configuration.
+ *
+ * Matching rules:
+ * - Bot comments are always skipped (returns { matched: false })
+ * - When `trigger.source` is 'directive', only the first non-empty line
+ *   of the comment is checked (consistent with override-parser.ts)
+ * - When `trigger.source` is 'comment', the full trimmed comment text is checked
+ * - The `trigger.match` string is first tried as an exact case-insensitive match,
+ *   then as a regex pattern (case-insensitive)
+ *
+ * @param gate - The gate definition containing a signal trigger
+ * @param comment - The full comment body text
+ * @param isBot - Whether the comment was authored by a bot
+ * @returns A SignalGateResult indicating whether the comment matched
+ */
+export function evaluateSignalGate(gate, comment, isBot) {
+    // Bot comments are always ignored
+    if (isBot) {
+        log.debug('Skipping bot comment for signal gate', { gateName: gate.name });
+        return { matched: false };
+    }
+    // Validate trigger shape
+    if (!isSignalGateTrigger(gate.trigger)) {
+        log.warn('Gate has invalid signal trigger configuration', { gateName: gate.name, trigger: gate.trigger });
+        return { matched: false };
+    }
+    const trigger = gate.trigger;
+    // Determine the text to match against based on trigger source
+    let textToMatch;
+    if (trigger.source === 'directive') {
+        textToMatch = extractDirectiveLine(comment);
+    }
+    else {
+        textToMatch = comment.trim();
+    }
+    // Empty text cannot match
+    if (textToMatch.length === 0) {
+        return { matched: false };
+    }
+    // Try exact case-insensitive match first
+    if (textToMatch.toLowerCase() === trigger.match.toLowerCase()) {
+        log.debug('Signal gate matched (exact)', { gateName: gate.name, source: textToMatch });
+        return { matched: true, source: textToMatch };
+    }
+    // Try regex match (case-insensitive)
+    try {
+        const regex = new RegExp(trigger.match, 'i');
+        const match = textToMatch.match(regex);
+        if (match) {
+            log.debug('Signal gate matched (regex)', { gateName: gate.name, source: textToMatch });
+            return { matched: true, source: textToMatch };
+        }
+    }
+    catch {
+        // Invalid regex pattern — treat as exact match only (already tried above)
+        log.warn('Invalid regex in signal gate trigger match', { gateName: gate.name, match: trigger.match });
+    }
+    return { matched: false };
+}
+// ============================================
+// Workflow Query Helpers
+// ============================================
+/**
+ * Get all signal gates from a workflow definition that apply to a given phase.
+ *
+ * Filters gates by:
+ * 1. `type === 'signal'`
+ * 2. `appliesTo` includes the given phase name, OR `appliesTo` is not defined
+ *    (gate applies to all phases)
+ *
+ * @param workflow - The workflow definition containing gate configurations
+ * @param phase - The phase name to filter by
+ * @returns Array of GateDefinition objects that are signal gates applicable to the phase
+ */
+export function getApplicableSignalGates(workflow, phase) {
+    if (!workflow.gates || workflow.gates.length === 0) {
+        return [];
+    }
+    return workflow.gates.filter((gate) => {
+        // Must be a signal gate
+        if (gate.type !== 'signal')
+            return false;
+        // If appliesTo is defined, the phase must be in the list
+        if (gate.appliesTo && gate.appliesTo.length > 0) {
+            return gate.appliesTo.includes(phase);
+        }
+        // No appliesTo restriction — applies to all phases
+        return true;
+    });
+}
+// ============================================
+// HOLD/RESUME Backward Compatibility
+// ============================================
+/**
+ * Name used for the implicit HOLD gate created for backward compatibility
+ */
+export const IMPLICIT_HOLD_GATE_NAME = '__implicit-hold';
+/**
+ * Name used for the implicit RESUME gate created for backward compatibility
+ */
+export const IMPLICIT_RESUME_GATE_NAME = '__implicit-resume';
+/**
+ * Create an implicit signal gate definition that matches the HOLD directive.
+ *
+ * This provides backward compatibility with the existing HOLD/RESUME system.
+ * When a HOLD directive is detected and no explicit signal gate is defined,
+ * this creates a gate that will pause the workflow until a RESUME directive
+ * is received.
+ *
+ * The created gate matches:
+ * - Directive source: first line of comment
+ * - Pattern: `^hold(?:\s*[---]\s*(.+))?$` (matches HOLD or HOLD -- reason)
+ *
+ * @returns A GateDefinition representing the implicit HOLD gate
+ */
+export function createImplicitHoldGate() {
+    return {
+        name: IMPLICIT_HOLD_GATE_NAME,
+        description: 'Implicit gate created for backward-compatible HOLD directive',
+        type: 'signal',
+        trigger: {
+            source: 'directive',
+            match: '^hold(?:\\s*[\\u2014\\u2013-]\\s*(.+))?$',
+        },
+    };
+}
+/**
+ * Create an implicit signal gate definition that matches the RESUME directive.
+ *
+ * This is the counterpart to the implicit HOLD gate. When a workflow is
+ * paused by a HOLD directive, this gate defines the condition that will
+ * release the hold — receiving a RESUME directive.
+ *
+ * The created gate matches:
+ * - Directive source: first line of comment
+ * - Pattern: `^resume$` (exact match for RESUME directive)
+ *
+ * @returns A GateDefinition representing the implicit RESUME gate
+ */
+export function createImplicitResumeGate() {
+    return {
+        name: IMPLICIT_RESUME_GATE_NAME,
+        description: 'Implicit gate created for backward-compatible RESUME directive',
+        type: 'signal',
+        trigger: {
+            source: 'directive',
+            match: '^resume$',
+        },
+    };
+}

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

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

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

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