@shipfox/api-workflows 13.1.0 → 14.0.0

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,45 @@ 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 normalized integration trigger facts alongside the payload', async () => {
       const triggerConnectionId = crypto.randomUUID();
       const integrations = {

package/src/presentation/dto/workflow-run.ts

@@ -1,10 +1,15 @@
 import type {
   WorkflowRunAttemptDto,
+  WorkflowRunDevSourceDto,
   WorkflowRunDto,
   WorkflowRunListItemDto,
   WorkflowRunTriggerReferenceDto,
 } from '@shipfox/api-workflows-dto';
-import type {WorkflowRun, WorkflowRunTriggerReference} from '#core/entities/workflow-run.js';
+import type {
+  WorkflowRun,
+  WorkflowRunDevSource,
+  WorkflowRunTriggerReference,
+} from '#core/entities/workflow-run.js';
 import type {WorkflowRunAttempt} from '#core/entities/workflow-run-attempt.js';
 import type {WorkflowRunJobsSummary} from '#db/index.js';
 
@@ -17,6 +22,8 @@ export function toRunDto(run: WorkflowRun, latestAttempt = run.currentAttempt):
     name: run.name,
     workflow_name: run.workflowName,
     status: run.status,
+    origin: run.origin,
+    dev_source: toDevSourceDto(run.devSource),
     current_attempt: run.currentAttempt,
     latest_attempt: latestAttempt,
     trigger_provider: run.triggerProvider,
@@ -76,6 +83,21 @@ function toTriggerReferenceDto(
   };
 }
 
+// The persisted dev source uses camelCase field names while the API contract is snake_case,
+// so each field is mapped explicitly rather than spread onto the response.
+function toDevSourceDto(
+  devSource: WorkflowRunDevSource | null | undefined,
+): WorkflowRunDevSourceDto | null {
+  if (!devSource) return null;
+  return {
+    ref: devSource.ref,
+    commit: devSource.commit,
+    config_path: devSource.configPath,
+    initiated_by_user_id: devSource.initiatedByUserId,
+    replay_of_event_id: devSource.replayOfEventId,
+  };
+}
+
 export function toRunAttemptDto(attempt: WorkflowRunAttempt): WorkflowRunAttemptDto {
   return {
     id: attempt.id,

package/src/presentation/routes/checkout-token.test.ts

@@ -179,6 +179,35 @@ describe('POST /runs/jobs/current/steps/:stepId/checkout-token', () => {
     });
   });
 
+  test('defaults a dev run checkout to its pinned source commit', async () => {
+    const devCommit = 'b'.repeat(40);
+    const {project, job, step} = await createRunningCheckoutStep({devCommit});
+    getProjectById.mockResolvedValue({project});
+    resolveCheckoutTarget.mockResolvedValue({
+      projectId: project.id,
+      connectionId: project.sourceConnectionId,
+      externalRepositoryId: project.sourceExternalRepositoryId,
+    });
+    createCheckoutSpec.mockResolvedValue({...githubSpec('ghs-dev-token'), ref: devCommit});
+    const token = await mintActiveLeaseToken({jobId: job.id});
+
+    const res = await app.inject({
+      method: 'POST',
+      url: checkoutUrl(step.id, step.currentAttempt),
+      headers: {authorization: `Bearer ${token}`},
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toMatchObject({ref: devCommit});
+    expect(createCheckoutSpec).toHaveBeenCalledWith({
+      workspaceId: project.workspaceId,
+      connectionId: project.sourceConnectionId,
+      externalRepositoryId: project.sourceExternalRepositoryId,
+      ref: devCommit,
+      permissions: {contents: 'read'},
+    });
+  });
+
   test('returns checkout-unavailable when the run project no longer resolves', async () => {
     const {job, step} = await createRunningCheckoutStep({kind: 'checkout'});
     getProjectById.mockResolvedValue({project: null});
@@ -521,6 +550,7 @@ async function createRunningCheckoutStep(
   options: {
     kind?: 'setup' | 'checkout' | 'run';
     checkout?: CheckoutConfig;
+    devCommit?: string;
     status?: StepStatus;
   } = {},
 ) {
@@ -546,6 +576,21 @@ async function createRunningCheckoutStep(
       userId: crypto.randomUUID(),
     },
   });
+  if (options.devCommit) {
+    await db()
+      .update(workflowRuns)
+      .set({
+        origin: 'dev',
+        devSource: {
+          ref: 'feature/checkout',
+          commit: options.devCommit,
+          config_path: '.shipfox/workflows/checkout.yml',
+          initiated_by_user_id: crypto.randomUUID(),
+          replay_of_event_id: null,
+        },
+      })
+      .where(eq(workflowRuns.id, run.id));
+  }
   const [job] = await getJobsByWorkflowRunId(run.id);
   if (!job) throw new Error('Expected workflow job');
   await db().update(jobsTable).set({status: 'running'}).where(eq(jobsTable.id, job.id));

package/src/presentation/routes/checkout-token.ts

@@ -122,7 +122,7 @@ export function createCheckoutTokenRoute(clients: {
     handler: async (request, reply) => {
       const {stepId} = request.params;
       const {attempt} = request.query;
-      const {step, workspaceId, projectId, triggerReference} = await loadRunningLeasedStep({
+      const {step, workspaceId, projectId, triggerReference, run} = await loadRunningLeasedStep({
         runners: clients.runners,
         request,
         stepId,
@@ -138,6 +138,7 @@ export function createCheckoutTokenRoute(clients: {
         workspaceId,
         projectId,
         triggerReference,
+        run,
         integrations: clients.integrations,
         projects: clients.projects,
       });

package/src/presentation/routes/get-run-aggregates.test.ts

@@ -1,8 +1,11 @@
 import {buildUserContext, setUserContext} from '@shipfox/api-auth-context';
 import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module';
+import {eq} from 'drizzle-orm';
 import type {FastifyInstance} from 'fastify';
 import Fastify from 'fastify';
 import {serializerCompiler, validatorCompiler} from 'fastify-type-provider-zod';
+import {db} from '#db/db.js';
+import {workflowRuns} from '#db/schema/workflow-runs.js';
 import {createWorkflowRun, updateWorkflowRunStatus} from '#db/workflow-runs.js';
 import {workflowModel} from '#test/index.js';
 import {getRunAggregatesRoute} from './get-run-aggregates.js';
@@ -117,4 +120,57 @@ describe('GET /api/workflows/runs/aggregates', () => {
     expect(body.trigger_source).toEqual([{value: 'manual', count: 1}]);
     expect(body.workflow).toEqual([{value: deployDefinitionId, count: 1}]);
   });
+
+  test('filters faceted counts by origin so the Runs tab facet follows', async () => {
+    await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: crypto.randomUUID(),
+      name: 'Synced',
+      model: workflowModel({name: 'Synced'}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    const devRun = await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: crypto.randomUUID(),
+      name: 'Dev',
+      model: workflowModel({name: 'Dev'}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    await db()
+      .update(workflowRuns)
+      .set({
+        origin: 'dev',
+        devSource: {
+          ref: 'fix-triage-prompt',
+          commit: 'abc123',
+          config_path: '.shipfox/workflows/triage-sentry.yml',
+          initiated_by_user_id: crypto.randomUUID(),
+          replay_of_event_id: null,
+        },
+      })
+      .where(eq(workflowRuns.id, devRun.id));
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/api/workflows/runs/aggregates?project_id=${projectId}&origin=dev`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json();
+    expect(body.status).toEqual([{value: 'pending', count: 1}]);
+    expect(body.trigger_source).toEqual([{value: 'manual', count: 1}]);
+    expect(body.workflow).toEqual([{value: devRun.definitionId, count: 1}]);
+  });
 });

package/src/presentation/routes/get-run-aggregates.ts

@@ -26,6 +26,7 @@ export function getRunAggregatesRoute(projects: ProjectsModuleClient) {
         status,
         definition_id: definitionId,
         trigger_source: triggerSource,
+        origin,
         created_from: createdFrom,
         created_to: createdTo,
       } = request.query;
@@ -35,6 +36,7 @@ export function getRunAggregatesRoute(projects: ProjectsModuleClient) {
         status,
         definitionId,
         triggerSource,
+        origin,
         createdFrom: createdFrom ? new Date(createdFrom) : undefined,
         createdTo: createdTo ? new Date(createdTo) : undefined,
       };

package/src/presentation/routes/get-step-secrets.test.ts

@@ -210,6 +210,7 @@ describe('GET /runs/jobs/current/steps/:stepId/secrets', () => {
       workspaceId: run.workspaceId,
       projectId: run.projectId,
       triggerReference: null,
+      run: {origin: 'synced', devSource: null},
     });
   });
 });

package/src/presentation/routes/leased-step.ts

@@ -2,7 +2,10 @@ import {type LeasedJobContext, requireLeasedJobContext} from '@shipfox/api-auth-
 import type {RunnersInterModuleClient} from '@shipfox/api-runners-dto/inter-module';
 import {ClientError} from '@shipfox/node-fastify';
 import type {Step} 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 {getJobScope, getStepByIdForJobExecution} from '#db/index.js';
 
 export interface LoadedRunningLeasedStep {
@@ -11,6 +14,8 @@ export interface LoadedRunningLeasedStep {
   workspaceId: string;
   projectId: string;
   triggerReference: WorkflowRunTriggerReference | null;
+  /** The run's origin state, forwarded for checkout fallbacks. */
+  run: WorkflowRunOriginState;
 }
 
 export async function loadRunningLeasedStep(params: {
@@ -59,5 +64,6 @@ export async function loadRunningLeasedStep(params: {
     workspaceId: scope.workspaceId,
     projectId: scope.projectId,
     triggerReference: scope.triggerReference,
+    run: scope.run,
   };
 }

package/src/presentation/routes/list-runs.test.ts

@@ -164,6 +164,81 @@ describe('GET /api/workflows/runs', () => {
     expect(res.json().runs[0].trigger_reference).toBeNull();
   });
 
+  test('labels runs with the synced origin and no dev source by default', async () => {
+    await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: crypto.randomUUID(),
+      name: 'Manual',
+      model: workflowModel({name: 'Manual'}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/api/workflows/runs?project_id=${projectId}`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json().runs[0]).toMatchObject({origin: 'synced', dev_source: null});
+  });
+
+  test('filters runs by origin', async () => {
+    await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: crypto.randomUUID(),
+      name: 'Synced',
+      model: workflowModel({name: 'Synced'}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    const devRun = await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: crypto.randomUUID(),
+      name: 'Dev',
+      model: workflowModel({name: 'Dev'}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    const initiatedByUserId = crypto.randomUUID();
+    await markDevRun(devRun.id, initiatedByUserId);
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/api/workflows/runs?project_id=${projectId}&origin=dev`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json();
+    expect(body.runs.map((run: {id: string}) => run.id)).toEqual([devRun.id]);
+    expect(body.filtered_total_count).toBe(1);
+    expect(body.runs[0]).toMatchObject({
+      origin: 'dev',
+      dev_source: {
+        ref: 'fix-triage-prompt',
+        commit: 'abc123',
+        config_path: '.shipfox/workflows/triage-sentry.yml',
+        initiated_by_user_id: initiatedByUserId,
+        replay_of_event_id: null,
+      },
+    });
+  });
+
   test('returns empty array for project with no runs', async () => {
     const res = await app.inject({
       method: 'GET',
@@ -257,6 +332,67 @@ describe('GET /api/workflows/runs', () => {
     expect(next.json().runs.map((run: {id: string}) => run.id)).toEqual([first.id]);
   });
 
+  test('keeps the origin filter across cursor pages', async () => {
+    const devFirst = await createRunAt({
+      workspaceId,
+      projectId,
+      name: 'Dev first',
+      createdAt: new Date('2026-05-07T00:00:00.000Z'),
+    });
+    await markDevRun(devFirst.id);
+    await createRunAt({
+      workspaceId,
+      projectId,
+      name: 'Synced middle one',
+      createdAt: new Date('2026-05-07T01:00:00.000Z'),
+    });
+    const devSecond = await createRunAt({
+      workspaceId,
+      projectId,
+      name: 'Dev second',
+      createdAt: new Date('2026-05-07T02:00:00.000Z'),
+    });
+    await markDevRun(devSecond.id);
+    await createRunAt({
+      workspaceId,
+      projectId,
+      name: 'Synced middle two',
+      createdAt: new Date('2026-05-07T03:00:00.000Z'),
+    });
+    const devThird = await createRunAt({
+      workspaceId,
+      projectId,
+      name: 'Dev third',
+      createdAt: new Date('2026-05-07T04:00:00.000Z'),
+    });
+    await markDevRun(devThird.id);
+
+    const firstPage = await app.inject({
+      method: 'GET',
+      url: `/api/workflows/runs?project_id=${projectId}&origin=dev&limit=2`,
+    });
+
+    expect(firstPage.statusCode).toBe(200);
+    const firstBody = firstPage.json();
+    expect(firstBody.runs.map((run: {name: string}) => run.name)).toEqual([
+      'Dev third',
+      'Dev second',
+    ]);
+    expect(firstBody.runs.every((run: {origin: string}) => run.origin === 'dev')).toBe(true);
+    expect(firstBody.filtered_total_count).toBe(3);
+
+    const secondPage = await app.inject({
+      method: 'GET',
+      url: `/api/workflows/runs?project_id=${projectId}&origin=dev&limit=2&cursor=${firstBody.next_cursor}`,
+    });
+
+    expect(secondPage.statusCode).toBe(200);
+    const secondBody = secondPage.json();
+    expect(secondBody.runs.map((run: {name: string}) => run.name)).toEqual(['Dev first']);
+    expect(secondBody.runs.every((run: {origin: string}) => run.origin === 'dev')).toBe(true);
+    expect(secondBody.next_cursor).toBeNull();
+  });
+
   test('invalid cursor returns stable client error', async () => {
     const res = await app.inject({
       method: 'GET',
@@ -309,3 +445,19 @@ async function createRunAt({
 
   return {...run, createdAt, updatedAt: createdAt};
 }
+
+async function markDevRun(runId: string, initiatedByUserId = crypto.randomUUID()) {
+  await db()
+    .update(workflowRuns)
+    .set({
+      origin: 'dev',
+      devSource: {
+        ref: 'fix-triage-prompt',
+        commit: 'abc123',
+        config_path: '.shipfox/workflows/triage-sentry.yml',
+        initiated_by_user_id: initiatedByUserId,
+        replay_of_event_id: null,
+      },
+    })
+    .where(eq(workflowRuns.id, runId));
+}

package/src/presentation/routes/list-runs.ts

@@ -30,6 +30,7 @@ export function listRunsRoute(projects: ProjectsModuleClient) {
         status,
         definition_id: definitionId,
         trigger_source: triggerSource,
+        origin,
         created_from: createdFrom,
         created_to: createdTo,
       } = request.query;
@@ -44,6 +45,7 @@ export function listRunsRoute(projects: ProjectsModuleClient) {
         status,
         definitionId,
         triggerSource,
+        origin,
         createdFrom: createdFrom ? new Date(createdFrom) : undefined,
         createdTo: createdTo ? new Date(createdTo) : undefined,
       };