@shipfox/api-workflows 13.1.0 → 15.0.0

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/inter-module.test.ts

@@ -1,3 +1,4 @@
+import {createWorkflowModelSnapshot} from '@shipfox/api-definitions-dto';
 import {workflowsInterModuleContract} from '@shipfox/api-workflows-dto/inter-module';
 import {workspacesInterModuleContract} from '@shipfox/api-workspaces-dto/inter-module';
 import {createInterModuleKnownError, isInterModuleKnownError} from '@shipfox/inter-module';
@@ -9,7 +10,13 @@ import {
   InterpolationUnresolvableError,
   ProjectMismatchError,
 } from '#core/index.js';
-import {createWorkflowsInterModulePresentation, toStartRunKnownError} from './inter-module.js';
+import {getWorkflowRunById} from '#db/workflow-runs.js';
+import {workflowModel} from '#test/index.js';
+import {
+  createWorkflowsInterModulePresentation,
+  toStartDevRunKnownError,
+  toStartRunKnownError,
+} from './inter-module.js';
 
 const mocks = vi.hoisted(() => ({
   deliverEventToListener: vi.fn(),
@@ -188,6 +195,129 @@ describe('Workflows inter-module presentation', () => {
     ).toBe('workspace-not-found');
   });
 
+  const devInput = {
+    workspaceId: input.workspaceId,
+    projectId: input.projectId,
+    workflowId: '00000000-0000-4000-8000-000000000006',
+    model: createWorkflowModelSnapshot(
+      workflowModel({name: 'Dev Workflow', jobs: {build: {steps: [{run: 'echo dev'}]}}}),
+    ),
+    sourceSnapshot: {content: 'name: Dev Workflow\n', format: 'yaml' as const},
+    devSource: {
+      ref: 'fix-triage-prompt',
+      commit: 'a'.repeat(40),
+      configPath: '.shipfox/workflows/triage-sentry.yml',
+      initiatedByUserId: input.triggerPayload.userId,
+    },
+    triggerPayload: {
+      source: 'manual' as const,
+      event: 'fire' as const,
+      userId: input.triggerPayload.userId,
+    },
+  };
+
+  test.each([
+    ['agent-config-unresolvable', () => new AgentConfigUnresolvableError(devInput.workflowId)],
+    [
+      'agent-integration-materialization-failed',
+      () => new AgentIntegrationMaterializationError('integration unavailable'),
+    ],
+    [
+      'interpolation-unresolvable',
+      () =>
+        new InterpolationUnresolvableError(devInput.workflowId, {
+          field: 'env',
+          source: 'event.ref',
+          envKey: 'REF',
+        }),
+    ],
+    ['invalid-job-runner-labels', () => new InvalidJobRunnerLabelsError(['gpu'])],
+  ] as const)('maps %s to the published dev-run contract error', (code, error) => {
+    const result = toStartDevRunKnownError(error());
+
+    expect(
+      isInterModuleKnownError(workflowsInterModuleContract.methods.startDevRun, result) &&
+        result.code,
+    ).toBe(code);
+  });
+
+  test.each([
+    ['definition-not-found', () => new DefinitionNotFoundError(devInput.workflowId)],
+    ['project-mismatch', () => new ProjectMismatchError(devInput.projectId, devInput.workflowId)],
+  ] as const)('does not map %s on the dev-run contract', (_code, error) => {
+    const result = toStartDevRunKnownError(error());
+
+    expect(isInterModuleKnownError(workflowsInterModuleContract.methods.startDevRun, result)).toBe(
+      false,
+    );
+  });
+
+  test.each([
+    ['suspended', 'workspace-suspended'],
+    ['deleted', 'workspace-deleted'],
+  ] as const)('rejects dev runs for %s workspaces before creating a run', async (status, code) => {
+    const getWorkspaceOperatingState = vi.fn().mockResolvedValue({status});
+    const presentation = createWorkflowsInterModulePresentation({
+      agent: {} as never,
+      definitions: {} as never,
+      integrations: {} as never,
+      projects: {} as never,
+      runners: {} as never,
+      secrets: {} as never,
+      workspaces: {getWorkspaceOperatingState} as never,
+    });
+
+    const error = await Promise.resolve(
+      presentation.handlers.startDevRun(devInput, {
+        signal: new AbortController().signal,
+      }),
+    ).catch((caught: unknown) => caught);
+
+    expect(getWorkspaceOperatingState).toHaveBeenCalledWith({workspaceId: devInput.workspaceId});
+    expect(
+      isInterModuleKnownError(workflowsInterModuleContract.methods.startDevRun, error) &&
+        error.code,
+    ).toBe(code);
+  });
+
+  test('creates a dev run with dev provenance and lineage numbering', async () => {
+    const presentation = createWorkflowsInterModulePresentation({
+      agent: {} as never,
+      definitions: {} as never,
+      integrations: {} as never,
+      projects: {} as never,
+      runners: {} as never,
+      secrets: {} as never,
+      workspaces: {
+        getWorkspaceOperatingState: vi.fn().mockResolvedValue({status: 'active'}),
+      } as never,
+    });
+    // A fresh lineage id keeps the assertion independent of counter rows left
+    // behind by earlier suite runs against the shared test database.
+    const workflowId = crypto.randomUUID();
+    const runInput = {...devInput, workflowId};
+
+    const first = await presentation.handlers.startDevRun(runInput, {
+      signal: new AbortController().signal,
+    });
+    const second = await presentation.handlers.startDevRun(runInput, {
+      signal: new AbortController().signal,
+    });
+
+    const firstRun = await getWorkflowRunById(first.id);
+    const secondRun = await getWorkflowRunById(second.id);
+    expect(firstRun).toMatchObject({
+      definitionId: workflowId,
+      origin: 'dev',
+      devSource: {...devInput.devSource, replayOfEventId: null},
+      number: 1,
+      name: 'Dev Workflow',
+      sourceSnapshot: devInput.sourceSnapshot,
+    });
+    // Each call is a distinct intent, so the lineage number sequence continues.
+    expect(secondRun).toMatchObject({definitionId: workflowId, origin: 'dev', number: 2});
+  });
+
   test.each([
     ['suspended', 'workspace-suspended'],
     ['deleted', 'workspace-deleted'],

package/src/presentation/inter-module.ts

@@ -27,6 +27,7 @@ import {
   DefinitionNotFoundError,
   InterpolationUnresolvableError,
   ProjectMismatchError,
+  runDevWorkflow,
   runWorkflow,
 } from '#core/index.js';
 import {resolveWorkflowRunTriggerReference} from '#core/resolve-trigger-reference.js';
@@ -72,6 +73,34 @@ export function createWorkflowsInterModulePresentation(params: {
         throw toStartRunKnownError(error, input.definitionId);
       }
     },
+    startDevRun: async (input) => {
+      try {
+        await assertWorkspaceAdmitsNewJobs(params.workspaces, input.workspaceId);
+        const run = await runDevWorkflow(
+          params.agent,
+          {
+            workspaceId: input.workspaceId,
+            projectId: input.projectId,
+            workflowId: input.workflowId,
+            model: input.model,
+            sourceSnapshot: input.sourceSnapshot,
+            devSource: {
+              ...input.devSource,
+              replayOfEventId: input.devSource.replayOfEventId ?? null,
+            },
+            triggerPayload: input.triggerPayload,
+            triggerConnectionId: input.triggerConnectionId,
+            inputs: input.inputs,
+            integrations: params.integrations,
+            projects: params.projects,
+          },
+          {secrets: params.secrets},
+        );
+        return {id: run.id, name: run.name};
+      } catch (error) {
+        throw toStartDevRunKnownError(error);
+      }
+    },
     resolveWorkflowRunTriggerReference: async (input) =>
       await resolveWorkflowRunTriggerReference({
         workspaceId: input.workspaceId,
@@ -158,14 +187,29 @@ export function createWorkflowsInterModulePresentation(params: {
 
 export function toStartRunKnownError(error: unknown, definitionId: string): unknown {
   const method = workflowsInterModuleContract.methods.startRunFromTrigger;
-  const workspaceError = toWorkspaceAdmissionKnownError(method, error);
-  if (workspaceError !== undefined) return workspaceError;
+  const mapped = toRunCreationKnownError(method, error);
+  if (mapped !== undefined) return mapped;
   if (error instanceof DefinitionNotFoundError) {
     return createInterModuleKnownError(method, 'definition-not-found', {definitionId});
   }
   if (error instanceof ProjectMismatchError) {
     return createInterModuleKnownError(method, 'project-mismatch', {});
   }
+  return error;
+}
+
+export function toStartDevRunKnownError(error: unknown): unknown {
+  return toRunCreationKnownError(workflowsInterModuleContract.methods.startDevRun, error) ?? error;
+}
+
+function toRunCreationKnownError(
+  method:
+    | typeof workflowsInterModuleContract.methods.startRunFromTrigger
+    | typeof workflowsInterModuleContract.methods.startDevRun,
+  error: unknown,
+): unknown {
+  const workspaceError = toWorkspaceAdmissionKnownError(method, error);
+  if (workspaceError !== undefined) return workspaceError;
   if (error instanceof AgentConfigUnresolvableError) {
     return createInterModuleKnownError(method, 'agent-config-unresolvable', {
       definitionId: error.definitionId,
@@ -187,12 +231,13 @@ export function toStartRunKnownError(error: unknown, definitionId: string): unkn
       labels: [...error.labels],
     });
   }
-  return error;
+  return undefined;
 }
 
 function toWorkspaceAdmissionKnownError(
   method:
     | typeof workflowsInterModuleContract.methods.startRunFromTrigger
+    | typeof workflowsInterModuleContract.methods.startDevRun
     | typeof workflowsInterModuleContract.methods.deliverEventToJobListener,
   error: unknown,
 ): WorkspaceAdmissionKnownError | undefined {

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,
       };

package/test/factories/workflow-run.ts

@@ -37,6 +37,8 @@ export const workflowRunFactory = Factory.define<WorkflowRun, WorkflowRunTransie
       workflowName: 'Test Workflow',
       nameOverride: null,
       status: 'pending',
+      origin: 'synced',
+      devSource: null,
       currentAttempt: 1,
       triggerProvider: null,
       triggerSource: 'manual',