@shipfox/api-triggers 13.0.0 → 14.0.0

package/drizzle/meta/_journal.json

@@ -8,6 +8,27 @@
       "when": 1783263628394,
       "tag": "0000_initial",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1787484039797,
+      "tag": "0001_nullable_subscription_events",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "7",
+      "when": 1787490844783,
+      "tag": "0002_dev_trigger_journal",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "7",
+      "when": 1787497786244,
+      "tag": "0003_add_origin_facet_index",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-triggers",
   "license": "MIT",
-  "version": "13.0.0",
+  "version": "14.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -23,12 +23,12 @@
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
     "@shipfox/api-auth-context": "12.2.0",
-    "@shipfox/api-definitions-dto": "12.3.0",
-    "@shipfox/api-integration-core-dto": "12.2.0",
-    "@shipfox/api-triggers-dto": "9.0.2",
-    "@shipfox/api-workflows-dto": "13.0.0",
+    "@shipfox/api-definitions-dto": "14.0.0",
+    "@shipfox/api-integration-core-dto": "14.0.0",
+    "@shipfox/api-triggers-dto": "14.0.0",
+    "@shipfox/api-workflows-dto": "14.0.0",
     "@shipfox/config": "1.2.4",
-    "@shipfox/expression": "2.2.0",
+    "@shipfox/expression": "2.2.1",
     "@shipfox/inter-module": "0.2.3",
     "@shipfox/node-drizzle": "0.3.5",
     "@shipfox/node-error-monitoring": "0.3.0",
@@ -38,7 +38,7 @@
     "@shipfox/node-outbox": "0.2.6",
     "@shipfox/node-postgres": "0.5.0",
     "@shipfox/node-temporal": "0.4.5",
-    "@shipfox/workflow-document": "3.0.1"
+    "@shipfox/workflow-document": "3.1.0"
   },
   "imports": {
     "#*": "./dist/*"

package/src/core/dispatch-integration-event.test.ts

@@ -310,6 +310,94 @@ describe('dispatchIntegrationEvent', () => {
     );
   });
 
+  test('fires a NULL-event source subscription for any delivered event, with the delivered event name', async () => {
+    const workspaceId = crypto.randomUUID();
+    const eventRef = crypto.randomUUID();
+    const subscription = await triggerSubscriptionFactory.create({
+      workspaceId,
+      source: 'github',
+      event: null,
+      config: {},
+    });
+
+    await dispatch({workspaceId, eventRef, source: 'github', event: 'pull_request'});
+
+    expect(runWorkflow).toHaveBeenCalledTimes(1);
+    expect(runWorkflow).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectId: subscription.projectId,
+        definitionId: subscription.workflowDefinitionId,
+        triggerPayload: expect.objectContaining({source: 'github', event: 'pull_request'}),
+      }),
+    );
+    const event = await receivedEvent(eventRef);
+    if (!event) throw new Error('received event not found');
+    expect(event.source).toBe('github');
+    expect(event.event).toBe('pull_request');
+    expect(event.outcome).toBe('routed');
+  });
+
+  test('fans out mixed exact-event and NULL-event subscriptions by delivered event', async () => {
+    const workspaceId = crypto.randomUUID();
+    const exactSubscription = await triggerSubscriptionFactory.create({
+      workspaceId,
+      source: 'github',
+      event: 'push',
+      config: {},
+    });
+    const wildcardSubscription = await triggerSubscriptionFactory.create({
+      workspaceId,
+      source: 'github',
+      event: null,
+      config: {},
+    });
+    const pushEventRef = crypto.randomUUID();
+
+    await dispatch({workspaceId, event: 'push', eventRef: pushEventRef});
+
+    expect(runWorkflow).toHaveBeenCalledTimes(2);
+    expect(runWorkflow.mock.calls.map(([params]) => params.idempotencyKey)).toEqual(
+      expect.arrayContaining([
+        `${exactSubscription.id}:${pushEventRef}`,
+        `${wildcardSubscription.id}:${pushEventRef}`,
+      ]),
+    );
+
+    runWorkflow.mockClear();
+    const pullRequestEventRef = crypto.randomUUID();
+    await dispatch({workspaceId, event: 'pull_request', eventRef: pullRequestEventRef});
+
+    expect(runWorkflow).toHaveBeenCalledTimes(1);
+    expect(runWorkflow).toHaveBeenCalledWith(
+      expect.objectContaining({
+        idempotencyKey: `${wildcardSubscription.id}:${pullRequestEventRef}`,
+      }),
+    );
+  });
+
+  test('does not fire a NULL-event subscription for a different source or workspace', async () => {
+    const workspaceId = crypto.randomUUID();
+    await triggerSubscriptionFactory.create({
+      workspaceId,
+      source: 'github',
+      event: null,
+      config: {},
+    });
+
+    await dispatch({
+      workspaceId,
+      source: 'sentry',
+      event: 'alert_triggered',
+    });
+    await dispatch({
+      workspaceId: crypto.randomUUID(),
+      source: 'github',
+      event: 'push',
+    });
+
+    expect(runWorkflow).not.toHaveBeenCalled();
+  });
+
   test('passes triggerIdempotencyKey = subscription.id:eventRef to runWorkflow', async () => {
     const workspaceId = crypto.randomUUID();
     const subscription = await triggerSubscriptionFactory.create({

package/src/core/entities/decision.ts

@@ -2,13 +2,14 @@ import type {JobListenerMatcherKind} from './job-listener-subscription.js';
 
 export const triggerDecisionOutcomes = ['triggered', 'filter-error', 'dispatch-error'] as const;
 export type TriggerDecisionOutcome = (typeof triggerDecisionOutcomes)[number];
-export type TriggerDecisionSubscriptionKind = 'trigger' | 'listener';
+export type TriggerDecisionSubscriptionKind = 'trigger' | 'listener' | 'dev';
 
 export interface TriggerDecision {
   id: string;
   receivedEventId: string;
   subscriptionKind: TriggerDecisionSubscriptionKind;
-  subscriptionId: string;
+  /** Null for `dev` decisions: a dev journal entry has no subscription row. */
+  subscriptionId: string | null;
   subscriptionName: string;
   workflowDefinitionId: string | null;
   projectId: string | null;

package/src/core/entities/job-listener-subscription.ts

@@ -8,7 +8,8 @@ export interface JobListenerSubscription {
   kind: JobListenerMatcherKind;
   matcherOrdinal: number;
   source: string;
-  event: string;
+  /** NULL is a source subscription: matches every event the source delivers. */
+  event: string | null;
   config: Record<string, unknown>;
   createdAt: Date;
 }

package/src/core/entities/received-event.ts

@@ -1,4 +1,4 @@
-export const triggerEventOrigins = ['integration', 'manual', 'cron'] as const;
+export const triggerEventOrigins = ['integration', 'manual', 'cron', 'dev'] as const;
 export type TriggerEventOrigin = (typeof triggerEventOrigins)[number];
 
 export const triggerEventOutcomes = [
@@ -18,6 +18,8 @@ export interface TriggerReceivedEvent {
   provider: string | null;
   source: string;
   event: string;
+  /** The source event this entry replays, when origin is `dev`. */
+  replayOfEventId: string | null;
   deliveryId: string | null;
   connectionId: string | null;
   connectionName: string | null;
@@ -29,6 +31,18 @@ export interface TriggerReceivedEvent {
   createdAt: Date;
 }
 
+/**
+ * A dev journal entry that replayed a source event. A missing run ID means
+ * that the replay has no recorded workflow run, including refusals and an
+ * incomplete or failed dev decision write.
+ */
+export interface TriggerEventReplay {
+  id: string;
+  receivedAt: Date;
+  outcome: TriggerEventOutcome;
+  runId: string | null;
+}
+
 /**
  * Trigger event shape for list read models.
  * It omits payload because webhook bodies can be large/untrusted and only detail views render them.

package/src/core/entities/subscription.ts

@@ -5,7 +5,8 @@ export interface TriggerSubscription {
   workflowDefinitionId: string;
   name: string;
   source: string;
-  event: string;
+  /** NULL is a source subscription: matches every event the source delivers. */
+  event: string | null;
   config: Record<string, unknown>;
   createdAt: Date;
   updatedAt: Date;

package/src/core/fire-cron.test.ts

@@ -140,6 +140,26 @@ describe('fireCronSubscription', () => {
     expect(decisions[0]?.decision).toBe('dispatch-error');
   });
 
+  test('falls back to tick in history when a bad row stores a NULL event', async () => {
+    const subscription = await triggerSubscriptionFactory.create({
+      source: 'cron',
+      event: null,
+      config: {},
+    });
+    runWorkflow.mockResolvedValue({id: crypto.randomUUID(), name: 'Cron run'});
+
+    await fireCronSubscription({
+      workflows,
+      subscriptionId: subscription.id,
+      scheduledSlot: SLOT,
+    });
+
+    const [event] = await eventsForWorkspace(subscription.workspaceId);
+    if (!event) throw new Error('received event not found');
+    expect(event.event).toBe('tick');
+    expect(event.outcome).toBe('routed');
+  });
+
   test('throws and records nothing when the subscription is not a cron trigger', async () => {
     const subscription = await triggerSubscriptionFactory.create({
       source: 'manual',

package/src/core/fire-cron.ts

@@ -47,7 +47,9 @@ export async function fireCronSubscription(
     workspaceId: subscription.workspaceId,
     provider: null,
     source: subscription.source,
-    event: subscription.event,
+    // Cron has no inbound event. Keep the canonical history event for a row
+    // that bypassed the projection write-path validation.
+    event: subscription.event ?? 'tick',
     deliveryId: null,
     connectionId: null,
     connectionName: null,

package/src/core/fire-manual.test.ts

@@ -132,6 +132,31 @@ describe('fireManualSubscription (trigger history)', () => {
     expect(decisions[0]?.reason).toContain('definition-not-found');
   });
 
+  test('falls back to fire in history when a bad row stores a NULL event', async () => {
+    const subscription = await triggerSubscriptionFactory.create({
+      source: 'manual',
+      event: null,
+      config: {},
+    });
+    const run = {id: crypto.randomUUID(), name: 'Manual run'};
+    runWorkflow.mockResolvedValue(run);
+
+    await fireManualSubscription({
+      workflows,
+      subscriptionId: subscription.id,
+      callerWorkspaceId: subscription.workspaceId,
+      userId: crypto.randomUUID(),
+    });
+
+    const [event] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.eventRef, run.id));
+    if (!event) throw new Error('received event not found');
+    expect(event.event).toBe('fire');
+    expect(event.outcome).toBe('routed');
+  });
+
   test('does not record a received event when the subscription is not a manual trigger', async () => {
     const subscription = await triggerSubscriptionFactory.create({
       source: 'github',

package/src/core/fire-manual.ts

@@ -46,7 +46,9 @@ export async function fireManualSubscription(
     workspaceId: subscription.workspaceId,
     provider: null,
     source: subscription.source,
-    event: subscription.event,
+    // Manual triggers have no inbound event. Keep the canonical history event
+    // for a row that bypassed the projection write-path validation.
+    event: subscription.event ?? 'fire',
     deliveryId: null,
     connectionId: null,
     connectionName: null,

package/src/core/record-trigger-history.test.ts

@@ -4,6 +4,8 @@ const runWorkflow = vi.fn();
 const insertReceivedEvent = vi.fn();
 const markReceivedEventRouted = vi.fn();
 const upsertTriggeredDecision = vi.fn();
+const upsertDevTriggeredDecision = vi.fn();
+const upsertDevFilterErrorDecision = vi.fn();
 
 vi.mock('#db/event-history.js', () => ({
   insertReceivedEvent: (...args: unknown[]) => insertReceivedEvent(...args),
@@ -12,6 +14,8 @@ vi.mock('#db/event-history.js', () => ({
   markReceivedEventFailed: vi.fn(),
   markReceivedEventErrored: vi.fn(),
   upsertTriggeredDecision: (...args: unknown[]) => upsertTriggeredDecision(...args),
+  upsertDevTriggeredDecision: (...args: unknown[]) => upsertDevTriggeredDecision(...args),
+  upsertDevFilterErrorDecision: (...args: unknown[]) => upsertDevFilterErrorDecision(...args),
   upsertDispatchErrorDecision: vi.fn(),
   upsertFilterErrorDecision: vi.fn(),
   upsertListenerTriggeredDecision: vi.fn(),
@@ -52,6 +56,12 @@ describe('trigger history is best-effort and never blocks triggering', () => {
     await expect(
       recorder.triggered(subscription, {id: crypto.randomUUID(), name: 'r'}),
     ).resolves.toBeUndefined();
+    await expect(
+      recorder.devTriggered('on_issue', crypto.randomUUID(), {id: crypto.randomUUID(), name: 'r'}),
+    ).resolves.toBeUndefined();
+    await expect(
+      recorder.devFilterErrored('on_issue', crypto.randomUUID(), 'filter is false'),
+    ).resolves.toBeUndefined();
     await expect(recorder.dispatchErrored(subscription, 'boom')).resolves.toBeUndefined();
     await expect(recorder.filterErrored(subscription, 'bad filter')).resolves.toBeUndefined();
     await expect(recorder.listenerTriggered(listenerSubscription)).resolves.toBeUndefined();
@@ -126,6 +136,74 @@ describe('a per-write failure after a successful insert is swallowed', () => {
   });
 });
 
+describe('dev recorder variants', () => {
+  beforeEach(() => {
+    insertReceivedEvent.mockReset();
+    upsertDevTriggeredDecision.mockReset();
+    upsertDevFilterErrorDecision.mockReset();
+    insertReceivedEvent.mockResolvedValue(crypto.randomUUID());
+  });
+
+  test('devTriggered writes a dev decision with the trigger key, lineage id, and run', async () => {
+    const recorder = await beginTriggerHistory({
+      eventRef: crypto.randomUUID(),
+      origin: 'dev',
+      workspaceId: crypto.randomUUID(),
+      provider: null,
+      source: 'manual',
+      event: 'fire',
+      deliveryId: null,
+      connectionId: null,
+      connectionName: null,
+      payload: null,
+      receivedAt: new Date(),
+    });
+    const run = {id: crypto.randomUUID(), name: 'Dev run'};
+
+    await recorder.devTriggered('on_issue', '019e98ab-0000-0000-0000-000000000001', run);
+
+    // The dev decision carries no subscription row: the trigger key stands in
+    // for subscription_name and the lineage id for workflow_definition_id.
+    expect(upsertDevTriggeredDecision).toHaveBeenCalledTimes(1);
+    expect(upsertDevTriggeredDecision).toHaveBeenCalledWith({
+      receivedEventId: expect.any(String),
+      triggerKey: 'on_issue',
+      workflowDefinitionId: '019e98ab-0000-0000-0000-000000000001',
+      run,
+    });
+  });
+
+  test('devFilterErrored writes a dev filter-error decision with the reason', async () => {
+    const recorder = await beginTriggerHistory({
+      eventRef: crypto.randomUUID(),
+      origin: 'dev',
+      workspaceId: crypto.randomUUID(),
+      provider: null,
+      source: 'github',
+      event: 'push',
+      deliveryId: null,
+      connectionId: null,
+      connectionName: null,
+      payload: null,
+      receivedAt: new Date(),
+    });
+
+    await recorder.devFilterErrored(
+      'on_push',
+      '019e98ab-0000-0000-0000-000000000002',
+      'filter is false',
+    );
+
+    expect(upsertDevFilterErrorDecision).toHaveBeenCalledTimes(1);
+    expect(upsertDevFilterErrorDecision).toHaveBeenCalledWith({
+      receivedEventId: expect.any(String),
+      triggerKey: 'on_push',
+      workflowDefinitionId: '019e98ab-0000-0000-0000-000000000002',
+      reason: 'filter is false',
+    });
+  });
+});
+
 describe('toReason', () => {
   test('caps an over-long message at the maximum reason length', () => {
     const reason = toReason(new Error('x'.repeat(5000)));

package/src/core/record-trigger-history.ts

@@ -9,6 +9,8 @@ import {
   markReceivedEventErrored,
   markReceivedEventFailed,
   markReceivedEventRouted,
+  upsertDevFilterErrorDecision,
+  upsertDevTriggeredDecision,
   upsertDispatchErrorDecision,
   upsertFilterErrorDecision,
   upsertListenerDispatchErrorDecision,
@@ -38,6 +40,10 @@ export interface TriggerRun {
 
 export interface TriggerHistoryRecorder {
   triggered(subscription: TriggerSubscription, run: TriggerRun): Promise<void>;
+  // Dev journal entries carry no subscription row: subscription_name is the
+  // trigger key and workflow_definition_id the workflow lineage id.
+  devTriggered(triggerKey: string, workflowDefinitionId: string, run: TriggerRun): Promise<void>;
+  devFilterErrored(triggerKey: string, workflowDefinitionId: string, reason: string): Promise<void>;
   filterErrored(subscription: TriggerSubscription, reason: string): Promise<void>;
   dispatchErrored(subscription: TriggerSubscription, reason: string): Promise<void>;
   listenerTriggered(subscription: JobListenerSubscription): Promise<void>;
@@ -88,6 +94,19 @@ export async function beginTriggerHistory(
         (id) => upsertTriggeredDecision({receivedEventId: id, subscription, run}),
         subscription.id,
       ),
+    devTriggered: (triggerKey, workflowDefinitionId, run) =>
+      record('dev-triggered-decision', (id) =>
+        upsertDevTriggeredDecision({receivedEventId: id, triggerKey, workflowDefinitionId, run}),
+      ),
+    devFilterErrored: (triggerKey, workflowDefinitionId, reason) =>
+      record('dev-filter-error-decision', (id) =>
+        upsertDevFilterErrorDecision({
+          receivedEventId: id,
+          triggerKey,
+          workflowDefinitionId,
+          reason,
+        }),
+      ),
     filterErrored: (subscription, reason) =>
       record(
         'filter-error-decision',

package/src/core/route-event-to-job-listeners.test.ts

@@ -66,6 +66,8 @@ function route(overrides: RouteOverrides = {}) {
 function buildHistory(): TriggerHistoryRecorder {
   return {
     triggered: vi.fn(),
+    devTriggered: vi.fn(),
+    devFilterErrored: vi.fn(),
     filterErrored: vi.fn(),
     dispatchErrored: vi.fn(),
     listenerTriggered,
@@ -194,6 +196,51 @@ describe('routeEventToJobListeners', () => {
     );
   });
 
+  it('gives a NULL-event until matcher precedence over an exact on matcher', async () => {
+    const workspaceId = crypto.randomUUID();
+    const jobId = crypto.randomUUID();
+    await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      jobId,
+      kind: 'on',
+      matcherOrdinal: 0,
+      source: 'github',
+      event: 'pull_request',
+    });
+    await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      jobId,
+      kind: 'until',
+      matcherOrdinal: 0,
+      source: 'github',
+      event: null,
+    });
+    await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      jobId: crypto.randomUUID(),
+      kind: 'on',
+      matcherOrdinal: 0,
+      source: 'sentry',
+      event: null,
+    });
+
+    const result = await route({workspaceId, event: 'pull_request'});
+
+    expect(deliverEventToListener).toHaveBeenCalledTimes(1);
+    expect(deliverEventToListener).toHaveBeenCalledWith(
+      expect.objectContaining({
+        jobId,
+        source: 'github',
+        event: 'pull_request',
+        disposition: 'resolve',
+      }),
+    );
+    expect(listenerTriggered).toHaveBeenCalledWith(
+      expect.objectContaining({jobId, kind: 'until', source: 'github', event: null}),
+    );
+    expect(result).toMatchObject({engagedCount: 1, matchedJobCount: 1, acceptedJobCount: 1});
+  });
+
   it('does not deliver when no listener subscription matches', async () => {
     const workspaceId = crypto.randomUUID();
     await jobListenerSubscriptionFactory.create({

package/src/core/route-event-to-job-listeners.ts

@@ -335,6 +335,8 @@ function listenerDisposition(subscription: JobListenerSubscription): 'fire' | 'r
 }
 
 function listenerMatcherSortKey(subscription: JobListenerSubscription): string {
+  // An until matcher wins over an on matcher, including when the until matcher
+  // is a source wildcard. Resolving the job intentionally suppresses delivery.
   const kindRank = subscription.kind === 'until' ? '0' : '1';
   return `${kindRank}:${subscription.matcherOrdinal.toString().padStart(10, '0')}`;
 }

package/src/db/event-history.test.ts

@@ -9,6 +9,8 @@ import {
   markReceivedEventErrored,
   markReceivedEventFailed,
   markReceivedEventRouted,
+  upsertDevFilterErrorDecision,
+  upsertDevTriggeredDecision,
   upsertDispatchErrorDecision,
   upsertFilterErrorDecision,
   upsertListenerDispatchErrorDecision,
@@ -257,6 +259,117 @@ describe('received-event outcome transitions', () => {
   });
 });
 
+describe('dev decision inserts', () => {
+  it('records a dev triggered decision with a null subscription id', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const workflowDefinitionId = crypto.randomUUID();
+    const run = {id: crypto.randomUUID(), name: 'Dev run'};
+
+    await upsertDevTriggeredDecision({
+      receivedEventId,
+      triggerKey: 'on_issue',
+      workflowDefinitionId,
+      run,
+    });
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      subscriptionKind: 'dev',
+      subscriptionId: null,
+      subscriptionName: 'on_issue',
+      workflowDefinitionId,
+      projectId: null,
+      decision: 'triggered',
+      runId: run.id,
+      runName: run.name,
+      reason: null,
+    });
+  });
+
+  it('records a dev filter-error decision with the reason and no run', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const workflowDefinitionId = crypto.randomUUID();
+
+    await upsertDevFilterErrorDecision({
+      receivedEventId,
+      triggerKey: 'on_push',
+      workflowDefinitionId,
+      reason: 'filter is false',
+    });
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      subscriptionKind: 'dev',
+      subscriptionId: null,
+      subscriptionName: 'on_push',
+      workflowDefinitionId,
+      projectId: null,
+      decision: 'filter-error',
+      runId: null,
+      runName: null,
+      reason: 'filter is false',
+    });
+  });
+
+  it('converges repeated dev triggered writes to one decision', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const workflowDefinitionId = crypto.randomUUID();
+    const firstRun = {id: crypto.randomUUID(), name: 'First dev run'};
+    const secondRun = {id: crypto.randomUUID(), name: 'Second dev run'};
+
+    await upsertDevTriggeredDecision({
+      receivedEventId,
+      triggerKey: 'on_issue',
+      workflowDefinitionId,
+      run: firstRun,
+    });
+    await upsertDevTriggeredDecision({
+      receivedEventId,
+      triggerKey: 'on_issue',
+      workflowDefinitionId,
+      run: secondRun,
+    });
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      decision: 'triggered',
+      runId: secondRun.id,
+      runName: secondRun.name,
+    });
+  });
+
+  it('does not downgrade a dev triggered decision on a filter-error replay', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const workflowDefinitionId = crypto.randomUUID();
+    const run = {id: crypto.randomUUID(), name: 'Dev run'};
+
+    await upsertDevTriggeredDecision({
+      receivedEventId,
+      triggerKey: 'on_issue',
+      workflowDefinitionId,
+      run,
+    });
+    await upsertDevFilterErrorDecision({
+      receivedEventId,
+      triggerKey: 'on_issue',
+      workflowDefinitionId,
+      reason: 'late filter failure',
+    });
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      decision: 'triggered',
+      runId: run.id,
+      runName: run.name,
+      reason: null,
+    });
+  });
+});
+
 describe('decision upserts', () => {
   it('is idempotent on (received_event_id, subscription_id)', async () => {
     const receivedEventId = await insertReceivedEvent(buildEventParams());
@@ -376,6 +489,16 @@ describe('decision upserts', () => {
     });
   });
 
+  it('names a NULL-event listener as a source wildcard', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const subscription = buildListenerSubscription({event: null});
+
+    await upsertListenerTriggeredDecision({receivedEventId, subscription});
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows[0]?.subscriptionName).toBe('listener on[0] github/*');
+  });
+
   it('flips a listener dispatch-error decision to triggered on a successful retry', async () => {
     const receivedEventId = await insertReceivedEvent(buildEventParams());
     const subscription = buildListenerSubscription();