@shipfox/api-workflows 13.1.0 → 15.0.0

package/src/core/run-workflow.test.ts

@@ -3,9 +3,9 @@ import {createWorkflowModelSnapshot, type WorkflowModel} from '@shipfox/api-defi
 import type {DefinitionsInterModuleClient} from '@shipfox/api-definitions-dto/inter-module';
 import {agentValidationCatalog} from '#test/fixtures/agent-inter-module.js';
 import {workflowModel} from '#test/index.js';
-import type {TriggerPayload} from './entities/workflow-run.js';
+import type {TriggerPayload, WorkflowRunDevSource} from './entities/workflow-run.js';
 import {DefinitionNotFoundError, ProjectMismatchError} from './errors.js';
-import {runWorkflow} from './run-workflow.js';
+import {runDevWorkflow, runWorkflow} from './run-workflow.js';
 
 const mockResolveAgentConfig = vi.hoisted(() =>
   vi.fn().mockResolvedValue({
@@ -23,6 +23,12 @@ type DefinitionForWorkflowRun = NonNullable<
 let definitionResponse: DefinitionForWorkflowRun | null = null;
 const definitions: DefinitionsInterModuleClient = {
   getDefinitionForWorkflowRun: async () => ({definition: definitionResponse}),
+  resolveDefinitionAtRef: () => {
+    throw new Error('resolveDefinitionAtRef is not used by runWorkflow');
+  },
+  listDefinitionsAtRef: () => {
+    throw new Error('listDefinitionsAtRef is not used by runWorkflow');
+  },
 };
 
 function buildDefinition(
@@ -31,6 +37,7 @@ function buildDefinition(
   const {model = workflowModel(), ...definitionOverrides} = overrides;
   return {
     id: crypto.randomUUID(),
+    workflowId: crypto.randomUUID(),
     projectId: crypto.randomUUID(),
     name: 'Test Workflow',
     model: createWorkflowModelSnapshot(model),
@@ -79,7 +86,7 @@ describe('runWorkflow', () => {
 
     expect(run.id).toBeDefined();
     expect(run.projectId).toBe(projectId);
-    expect(run.definitionId).toBe(definition.id);
+    expect(run.definitionId).toBe(definition.workflowId);
     expect(run.name).toBe(definition.name);
     expect(run.status).toBe('pending');
     expect(run.triggerProvider).toBeNull();
@@ -151,6 +158,48 @@ describe('runWorkflow', () => {
     expect(run.sourceSnapshot).toEqual(sourceSnapshot);
   });
 
+  test('numbers runs by the workflow lineage id, not the definition row id', async () => {
+    const lineageId = crypto.randomUUID();
+    // A lineage whose id differs from the definition row id, as happens after
+    // the backfill when a lineage id diverges from the synced row it was born from.
+    const definition = buildDefinition({projectId, id: crypto.randomUUID(), workflowId: lineageId});
+    definitionResponse = definition;
+
+    const first = await runWorkflow(definitions, {
+      workspaceId,
+      projectId,
+      definitionId: definition.id,
+      triggerPayload: manualPayload(),
+      agent,
+    });
+    const second = await runWorkflow(definitions, {
+      workspaceId,
+      projectId,
+      definitionId: definition.id,
+      triggerPayload: manualPayload(),
+      agent,
+    });
+
+    expect(first.definitionId).toBe(lineageId);
+    expect(second.definitionId).toBe(lineageId);
+    expect(first.number).toBe(1);
+    expect(second.number).toBe(2);
+
+    // A later definition row that resolves to the same lineage continues the sequence.
+    const resynced = buildDefinition({projectId, id: crypto.randomUUID(), workflowId: lineageId});
+    definitionResponse = resynced;
+    const third = await runWorkflow(definitions, {
+      workspaceId,
+      projectId,
+      definitionId: resynced.id,
+      triggerPayload: manualPayload(),
+      agent,
+    });
+
+    expect(third.definitionId).toBe(lineageId);
+    expect(third.number).toBe(3);
+  });
+
   test('throws DefinitionNotFoundError for unknown definition', async () => {
     definitionResponse = null;
 
@@ -199,3 +248,102 @@ describe('runWorkflow', () => {
     expect(run.inputs).toEqual({env: 'staging'});
   });
 });
+
+describe('runDevWorkflow', () => {
+  let workspaceId: string;
+  let projectId: string;
+  const agent: AgentInterModuleClient = {
+    getValidationCatalog: vi.fn().mockResolvedValue(agentValidationCatalog),
+    resolveAgentConfig: mockResolveAgentConfig,
+    resolveRuntimeCredentials: vi.fn(),
+  };
+
+  beforeEach(() => {
+    workspaceId = crypto.randomUUID();
+    projectId = crypto.randomUUID();
+    mockResolveAgentConfig.mockClear();
+  });
+
+  const devSource: WorkflowRunDevSource = {
+    ref: 'fix-triage-prompt',
+    commit: 'a'.repeat(40),
+    configPath: '.shipfox/workflows/triage-sentry.yml',
+    initiatedByUserId: crypto.randomUUID(),
+    replayOfEventId: null,
+  };
+
+  function devPayload(): TriggerPayload {
+    return {source: 'manual', event: 'fire', userId: crypto.randomUUID()};
+  }
+
+  function buildDevRun(workflowId: string, triggerPayload: TriggerPayload = devPayload()) {
+    return runDevWorkflow(agent, {
+      workspaceId,
+      projectId,
+      workflowId,
+      model: createWorkflowModelSnapshot(workflowModel({name: 'Dev Workflow'})),
+      sourceSnapshot: {content: 'name: Dev Workflow\n', format: 'yaml'},
+      devSource,
+      triggerPayload,
+    });
+  }
+
+  test('creates a dev run with the lineage id as definition_id and dev provenance', async () => {
+    const workflowId = crypto.randomUUID();
+    const triggerPayload = devPayload();
+    const run = await buildDevRun(workflowId, triggerPayload);
+
+    expect(run.definitionId).toBe(workflowId);
+    expect(run.origin).toBe('dev');
+    expect(run.devSource).toEqual(devSource);
+    expect(run.name).toBe('Dev Workflow');
+    expect(run.workflowName).toBe('Dev Workflow');
+    expect(run.sourceSnapshot).toEqual({content: 'name: Dev Workflow\n', format: 'yaml'});
+    expect(run.triggerPayload).toEqual(triggerPayload);
+    expect(run.triggerIdempotencyKey).toBeNull();
+  });
+
+  test('continues the lineage number sequence across dev and synced runs of one workflow file', async () => {
+    const workflowId = crypto.randomUUID();
+    // The file exists on the branch only: the dev run opens the sequence.
+    const devRun = await buildDevRun(workflowId);
+    expect(devRun.number).toBe(1);
+
+    // After merge, the synced run of the same lineage continues the sequence.
+    const definition = buildDefinition({
+      projectId,
+      id: crypto.randomUUID(),
+      workflowId,
+      model: workflowModel({name: 'Dev Workflow'}),
+    });
+    definitionResponse = definition;
+    const syncedRun = await runWorkflow(definitions, {
+      workspaceId,
+      projectId,
+      definitionId: definition.id,
+      triggerPayload: manualPayload(),
+      agent,
+    });
+    expect(syncedRun.definitionId).toBe(workflowId);
+    expect(syncedRun.origin).toBe('synced');
+    expect(syncedRun.number).toBe(2);
+
+    // And a later dev run of the same file keeps the sequence going.
+    const secondDevRun = await buildDevRun(workflowId);
+    expect(secondDevRun.number).toBe(3);
+  });
+
+  test('accepts a manual payload without a subscription id, as a dev trigger has no row', async () => {
+    const workflowId = crypto.randomUUID();
+    const triggerPayload = {
+      source: 'manual' as const,
+      event: 'fire' as const,
+      userId: crypto.randomUUID(),
+    };
+    const run = await buildDevRun(workflowId, triggerPayload);
+
+    expect(run.triggerProvider).toBeNull();
+    expect(run.triggerSource).toBe('manual');
+    expect(run.triggerPayload).toEqual(triggerPayload);
+  });
+});

package/src/core/run-workflow.ts

@@ -1,12 +1,17 @@
 import type {AgentInterModuleClient} from '@shipfox/api-agent-dto/inter-module';
-import {workflowModelFromSnapshot} from '@shipfox/api-definitions-dto';
+import {type WorkflowModelSnapshot, workflowModelFromSnapshot} from '@shipfox/api-definitions-dto';
 import type {DefinitionsInterModuleClient} from '@shipfox/api-definitions-dto/inter-module';
 import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/inter-module';
 import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module';
 import type {SecretsInterModuleClient} from '@shipfox/api-secrets-dto/inter-module';
 import {createWorkflowRun} from '#db/workflow-runs.js';
 import {createAgentDefaultsResolver} from './agent-defaults.js';
-import type {TriggerPayload, WorkflowRun} from './entities/workflow-run.js';
+import type {
+  TriggerPayload,
+  WorkflowRun,
+  WorkflowRunDevSource,
+  WorkflowSourceSnapshot,
+} from './entities/workflow-run.js';
 import {DefinitionNotFoundError, ProjectMismatchError} from './errors.js';
 import {modelHasAgentStep} from './step-config/materialize-workflow-model.js';
 
@@ -44,7 +49,7 @@ export async function runWorkflow(
   return createWorkflowRun({
     workspaceId: params.workspaceId,
     projectId: params.projectId,
-    definitionId: definition.id,
+    definitionId: definition.workflowId,
     name: definition.name,
     model,
     triggerPayload: params.triggerPayload,
@@ -58,3 +63,54 @@ export async function runWorkflow(
     projects: params.projects,
   });
 }
+
+export interface RunDevWorkflowParams {
+  workspaceId: string;
+  projectId: string;
+  /** Workflow lineage id, becomes the run's definition_id. */
+  workflowId: string;
+  model: WorkflowModelSnapshot;
+  sourceSnapshot: WorkflowSourceSnapshot;
+  devSource: WorkflowRunDevSource;
+  triggerPayload: TriggerPayload;
+  triggerConnectionId?: string | undefined;
+  inputs?: Record<string, unknown> | undefined;
+  integrations?: IntegrationsModuleClient | undefined;
+  projects?: ProjectsModuleClient | undefined;
+}
+
+/**
+ * Creates a dev run from an inline model and snapshot. Unlike
+ * trigger-originated runs, dev runs do not carry an idempotency key because
+ * each call represents a distinct intent. The lineage id is used as the run's
+ * definition_id so dev runs share the workflow numbering sequence before and
+ * after the file merges.
+ */
+export function runDevWorkflow(
+  agent: AgentInterModuleClient,
+  params: RunDevWorkflowParams,
+  options: {secrets?: Pick<SecretsInterModuleClient, 'getVariablesByNamespace'>} = {},
+): Promise<WorkflowRun> {
+  const model = workflowModelFromSnapshot(params.model);
+  const resolveAgentDefaults = createAgentDefaultsResolver(
+    agent,
+    modelHasAgentStep(model) ? params.workspaceId : null,
+  );
+
+  return createWorkflowRun({
+    workspaceId: params.workspaceId,
+    projectId: params.projectId,
+    definitionId: params.workflowId,
+    model,
+    triggerPayload: params.triggerPayload,
+    triggerConnectionId: params.triggerConnectionId,
+    inputs: params.inputs,
+    sourceSnapshot: params.sourceSnapshot,
+    origin: 'dev',
+    devSource: params.devSource,
+    resolveAgentDefaults,
+    secrets: options.secrets,
+    integrations: params.integrations,
+    projects: params.projects,
+  });
+}

package/src/core/workflow-run-creation.test.ts

@@ -144,6 +144,8 @@ function workflowRun(params: {inputs?: Record<string, unknown> | null} = {}): Wo
     workflowName: 'Test workflow',
     nameOverride: null,
     status: 'pending',
+    origin: 'synced',
+    devSource: null,
     currentAttempt: 1,
     triggerProvider: null,
     triggerSource: triggerPayload.source,

package/src/db/job-listeners.test.ts

@@ -278,6 +278,23 @@ describe('activateJobListener', () => {
     expect(result.executionCount).toBe(2);
   });
 
+  it('projects matchers with the event omitted', async () => {
+    const job = await createInactiveListeningJobWithMatchers({
+      on: [{source: 'github_acme'}],
+      until: [{source: 'github_acme', filter: 'event.action == "closed"'}],
+    });
+
+    await activateJobListener({jobId: job.id, expectedVersion: job.version});
+
+    const payload = await activatedPayload(job.id);
+    expectListeningPayload(payload);
+    expect(payload.on[0]).toEqual({source: 'github_acme'});
+    expect(payload.until?.[0]).toEqual({
+      source: 'github_acme',
+      filter: 'event.action == "closed"',
+    });
+  });
+
   it('omits filter snapshots for matchers without non-event roots', async () => {
     const job = await createInactiveListeningJobWithMatchers({
       on: [{source: 'github', event: 'pull_request'}],

package/src/db/schema/workflow-runs.ts

@@ -16,6 +16,7 @@ import {
 import type {
   TriggerPayload,
   WorkflowRun,
+  WorkflowRunOriginState,
   WorkflowRunTriggerReference,
   WorkflowSourceSnapshot,
 } from '#core/entities/workflow-run.js';
@@ -31,6 +32,14 @@ export const workflowRunStatusEnum = pgEnum('workflows_run_status', [
 
 export const workflowRunRerunModeEnum = pgEnum('workflows_rerun_mode', ['all', 'failed']);
 
+export interface WorkflowRunDevSourceDb {
+  ref: string;
+  commit: string;
+  config_path: string;
+  initiated_by_user_id: string;
+  replay_of_event_id: string | null;
+}
+
 export const workflowRuns = pgTable(
   'workflow_runs',
   {
@@ -42,6 +51,8 @@ export const workflowRuns = pgTable(
     name: text('name'),
     workflowName: text('workflow_name').notNull(),
     status: workflowRunStatusEnum('status').notNull().default('pending'),
+    origin: text('origin').notNull().default('synced'),
+    devSource: jsonb('dev_source').$type<WorkflowRunDevSourceDb>(),
     currentAttempt: integer('current_attempt').notNull().default(1),
     triggerProvider: text('trigger_provider'),
     triggerSource: text('trigger_source').notNull(),
@@ -62,6 +73,12 @@ export const workflowRuns = pgTable(
     uniqueIndex('workflows_wr_trigger_idempotency_key_unique').on(table.triggerIdempotencyKey),
     uniqueIndex('workflows_wr_definition_number_unique').on(table.definitionId, table.number),
     index('workflows_wr_project_created_id_idx').on(table.projectId, table.createdAt, table.id),
+    index('workflows_wr_project_origin_created_id_idx').on(
+      table.projectId,
+      table.origin,
+      table.createdAt,
+      table.id,
+    ),
     index('workflows_wr_project_status_created_id_idx').on(
       table.projectId,
       table.status,
@@ -85,6 +102,18 @@ export const workflowRuns = pgTable(
     // historical table grows.
     index('workflows_wr_running_idx').on(table.status).where(sql`${table.status} = 'running'`),
     check('workflows_wr_current_attempt_positive_ck', sql`${table.currentAttempt} > 0`),
+    check('workflows_wr_origin_ck', sql`${table.origin} in ('synced', 'dev')`),
+    check(
+      'workflows_wr_dev_source_ck',
+      sql`(
+        (${table.origin} = 'synced' and ${table.devSource} is null)
+        or (
+          ${table.origin} = 'dev'
+          and ${table.devSource} is not null
+          and jsonb_typeof(${table.devSource}) = 'object'
+        )
+      )`,
+    ),
   ],
 );
 
@@ -92,6 +121,7 @@ export type WorkflowRunDb = typeof workflowRuns.$inferSelect;
 export type WorkflowRunCreateDb = typeof workflowRuns.$inferInsert;
 
 export function toWorkflowRun(row: WorkflowRunDb): WorkflowRun {
+  const originState = toWorkflowRunOriginState(row);
   return {
     id: row.id,
     workspaceId: row.workspaceId,
@@ -102,6 +132,7 @@ export function toWorkflowRun(row: WorkflowRunDb): WorkflowRun {
     workflowName: row.workflowName,
     nameOverride: row.name,
     status: row.status,
+    ...originState,
     currentAttempt: row.currentAttempt,
     triggerProvider: row.triggerProvider,
     triggerSource: row.triggerSource,
@@ -119,3 +150,30 @@ export function toWorkflowRun(row: WorkflowRunDb): WorkflowRun {
     finishedAt: row.finishedAt,
   };
 }
+
+export function toWorkflowRunOriginState(
+  row: Pick<WorkflowRunDb, 'origin' | 'devSource'>,
+): WorkflowRunOriginState {
+  if (row.origin === 'synced') {
+    if (row.devSource !== null) {
+      throw new Error(`Synced workflow run has unexpected dev source`);
+    }
+    return {origin: 'synced', devSource: null};
+  }
+  if (row.origin !== 'dev') {
+    throw new Error(`Unknown workflow run origin: ${row.origin}`);
+  }
+  if (!row.devSource) {
+    throw new Error('Dev workflow run is missing its source');
+  }
+  return {
+    origin: 'dev',
+    devSource: {
+      ref: row.devSource.ref,
+      commit: row.devSource.commit,
+      configPath: row.devSource.config_path,
+      initiatedByUserId: row.devSource.initiated_by_user_id,
+      replayOfEventId: row.devSource.replay_of_event_id,
+    },
+  };
+}

package/src/db/workflow-runs/jobs.ts

@@ -5,7 +5,10 @@ import {and, asc, desc, eq, inArray, notInArray, sql} from 'drizzle-orm';
 import {isJobTerminal, type Job, type JobStatus, type JobStatusReason} from '#core/entities/job.js';
 import type {JobExecution} from '#core/entities/job-execution.js';
 import type {PersistedEvaluationTraceEntry} from '#core/entities/step.js';
-import type {WorkflowRunTriggerReference} from '#core/entities/workflow-run.js';
+import type {
+  WorkflowRunOriginState,
+  WorkflowRunTriggerReference,
+} from '#core/entities/workflow-run.js';
 import {JobNotFoundError} from '#core/errors.js';
 import {
   type DeriveJobSuccessResult,
@@ -21,7 +24,7 @@ import {writeWorkflowsOutboxEvent} from '../outbox-writes.js';
 import {jobExecutions, toJobExecution} from '../schema/job-executions.js';
 import {jobs, toJob} from '../schema/jobs.js';
 import {workflowRunAttempts} from '../schema/workflow-run-attempts.js';
-import {toWorkflowRun, workflowRuns} from '../schema/workflow-runs.js';
+import {toWorkflowRun, toWorkflowRunOriginState, workflowRuns} from '../schema/workflow-runs.js';
 import {getWorkflowRunById} from './queries.js';
 import {getWorkflowContextForJob, optimisticLockRetry, TERMINAL_JOB_STATUSES} from './shared.js';
 
@@ -71,6 +74,8 @@ export interface JobScope {
   workspaceId: string;
   projectId: string;
   triggerReference: WorkflowRunTriggerReference | null;
+  /** The run's origin state, so checkout fallbacks can read the dev source. */
+  run: WorkflowRunOriginState;
 }
 
 export async function getJobScope(jobId: string): Promise<JobScope | undefined> {
@@ -79,13 +84,22 @@ export async function getJobScope(jobId: string): Promise<JobScope | undefined>
       workspaceId: workflowRuns.workspaceId,
       projectId: workflowRuns.projectId,
       triggerReference: workflowRuns.triggerReference,
+      origin: workflowRuns.origin,
+      devSource: workflowRuns.devSource,
     })
     .from(jobs)
     .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
     .innerJoin(workflowRuns, eq(workflowRunAttempts.workflowRunId, workflowRuns.id))
     .where(eq(jobs.id, jobId))
     .limit(1);
-  return rows[0];
+  const row = rows[0];
+  if (!row) return undefined;
+  return {
+    workspaceId: row.workspaceId,
+    projectId: row.projectId,
+    triggerReference: row.triggerReference,
+    run: toWorkflowRunOriginState(row),
+  };
 }
 
 export async function getDirectDependencyJobContexts(

package/src/db/workflow-runs/queries.ts

@@ -13,6 +13,7 @@ import type {
   WorkflowJobDetail,
   WorkflowRun,
   WorkflowRunDetail,
+  WorkflowRunOrigin,
   WorkflowRunStatus,
 } from '#core/entities/workflow-run.js';
 import {db} from '../db.js';
@@ -29,6 +30,7 @@ export interface WorkflowRunFilters {
   status?: WorkflowRunStatus | undefined;
   definitionId?: string | undefined;
   triggerSource?: string | undefined;
+  origin?: WorkflowRunOrigin | undefined;
   createdFrom?: Date | undefined;
   createdTo?: Date | undefined;
 }
@@ -145,7 +147,7 @@ export function buildWorkflowRunListConditions(params: {
   projectId: string;
   filters?: WorkflowRunFilters | undefined;
   cursor?: WorkflowRunCursor | undefined;
-  omit?: 'status' | 'definitionId' | 'triggerSource' | undefined;
+  omit?: 'status' | 'definitionId' | 'triggerSource' | 'origin' | undefined;
 }): SQL[] {
   const filters = params.filters;
   const conditions: SQL[] = [eq(workflowRuns.projectId, params.projectId)];
@@ -164,6 +166,9 @@ export function buildWorkflowRunListConditions(params: {
   if (filters?.triggerSource && params.omit !== 'triggerSource') {
     conditions.push(eq(workflowRuns.triggerSource, filters.triggerSource));
   }
+  if (filters?.origin && params.omit !== 'origin') {
+    conditions.push(eq(workflowRuns.origin, filters.origin));
+  }
   if (filters?.createdFrom) {
     conditions.push(gte(workflowRuns.createdAt, filters.createdFrom));
   }

package/src/db/workflow-runs/run-create.test.ts

@@ -48,6 +48,93 @@ describe('workflow run queries', () => {
   });
 
   describe('createWorkflowRun', () => {
+    test('enforces the workflow run origin and dev source relationship at the database boundary', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel(),
+        triggerPayload: {
+          source: 'manual',
+          event: 'fire',
+          subscriptionId: crypto.randomUUID(),
+          userId: crypto.randomUUID(),
+        },
+      });
+
+      await expect(
+        db().execute(
+          sql`UPDATE ${workflowRuns} SET origin = 'dev', dev_source = '{}'::jsonb WHERE ${workflowRuns.id} = ${run.id}`,
+        ),
+      ).resolves.toBeDefined();
+
+      await expect(
+        db().update(workflowRuns).set({origin: 'synced'}).where(eq(workflowRuns.id, run.id)),
+      ).rejects.toThrow();
+
+      await db()
+        .update(workflowRuns)
+        .set({
+          origin: 'dev',
+          devSource: {
+            ref: 'main',
+            commit: 'abc123',
+            config_path: '.shipfox/workflows.yml',
+            initiated_by_user_id: crypto.randomUUID(),
+            replay_of_event_id: null,
+          },
+        })
+        .where(eq(workflowRuns.id, run.id));
+    });
+
+    test('persists a dev origin with its dev source', async () => {
+      const devSource = {
+        ref: 'fix-triage-prompt',
+        commit: 'a'.repeat(40),
+        configPath: '.shipfox/workflows/triage-sentry.yml',
+        initiatedByUserId: crypto.randomUUID(),
+        replayOfEventId: null,
+      };
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel(),
+        triggerPayload: {
+          source: 'manual',
+          event: 'fire',
+          userId: crypto.randomUUID(),
+        },
+        origin: 'dev',
+        devSource,
+      });
+
+      expect(run.origin).toBe('dev');
+      expect(run.devSource).toEqual(devSource);
+      await expect(getWorkflowRunById(run.id)).resolves.toMatchObject({
+        origin: 'dev',
+        devSource,
+      });
+      // The persisted jsonb carries snake_case keys, matching the read boundary.
+      await expect(
+        db()
+          .select({origin: workflowRuns.origin, devSource: workflowRuns.devSource})
+          .from(workflowRuns)
+          .where(eq(workflowRuns.id, run.id)),
+      ).resolves.toEqual([
+        {
+          origin: 'dev',
+          devSource: {
+            ref: devSource.ref,
+            commit: devSource.commit,
+            config_path: devSource.configPath,
+            initiated_by_user_id: devSource.initiatedByUserId,
+            replay_of_event_id: devSource.replayOfEventId,
+          },
+        },
+      ]);
+    });
+
     test('persists normalized integration trigger facts alongside the payload', async () => {
       const triggerConnectionId = crypto.randomUUID();
       const integrations = {

package/src/db/workflow-runs/run-create.ts

@@ -21,6 +21,8 @@ import {
 import type {
   TriggerPayload,
   WorkflowRun,
+  WorkflowRunDevSource,
+  WorkflowRunOrigin,
   WorkflowSourceSnapshot,
 } from '#core/entities/workflow-run.js';
 import {InterpolationUnresolvableError} from '#core/errors.js';
@@ -40,7 +42,7 @@ import {
 import {db, type Tx} from '../db.js';
 import {workflowRunAttempts} from '../schema/workflow-run-attempts.js';
 import {workflowRunCounters} from '../schema/workflow-run-counters.js';
-import {toWorkflowRun, workflowRuns} from '../schema/workflow-runs.js';
+import {toWorkflowRun, type WorkflowRunDevSourceDb, workflowRuns} from '../schema/workflow-runs.js';
 import {type MaterializedRunGraphJob, persistMaterializedRunGraph} from './run-graph.js';
 
 export type WorkflowModelJob = WorkflowModel['jobs'][number];
@@ -63,6 +65,9 @@ export interface CreateWorkflowRunParams {
   inputs?: Record<string, unknown> | undefined;
   sourceSnapshot?: WorkflowSourceSnapshot | null | undefined;
   triggerIdempotencyKey?: string | undefined;
+  /** Run provenance. Defaults to a synced run with no dev source. */
+  origin?: WorkflowRunOrigin | undefined;
+  devSource?: WorkflowRunDevSource | null | undefined;
   resolveAgentDefaults?: AgentDefaultsResolver | undefined;
   secrets?: Pick<SecretsInterModuleClient, 'getVariablesByNamespace'> | undefined;
   integrations?: IntegrationsModuleClient | undefined;
@@ -132,6 +137,11 @@ export async function createWorkflowRun(params: CreateWorkflowRunParams): Promis
         inputs: params.inputs ?? null,
         sourceSnapshot: params.sourceSnapshot ?? null,
         triggerIdempotencyKey: params.triggerIdempotencyKey ?? null,
+        origin: params.origin ?? 'synced',
+        devSource:
+          params.devSource === undefined || params.devSource === null
+            ? null
+            : toWorkflowRunDevSourceDb(params.devSource),
       })
       .onConflictDoNothing({target: workflowRuns.triggerIdempotencyKey})
       .returning();
@@ -281,6 +291,18 @@ async function allocateWorkflowRunNumber(tx: Tx, definitionId: string): Promise<
   return counterRow.number;
 }
 
+// The run entity carries camelCase dev-source fields while the persisted jsonb uses
+// snake_case keys, so the write boundary maps explicitly rather than spreading.
+function toWorkflowRunDevSourceDb(source: WorkflowRunDevSource): WorkflowRunDevSourceDb {
+  return {
+    ref: source.ref,
+    commit: source.commit,
+    config_path: source.configPath,
+    initiated_by_user_id: source.initiatedByUserId,
+    replay_of_event_id: source.replayOfEventId,
+  };
+}
+
 export async function loadReferencedVariables(params: {
   readonly model: WorkflowModel;
   readonly jobs?: readonly WorkflowModelJob[] | undefined;