diff --git a/src/cli.ts b/src/cli.ts
index 2a9e474..00ba854 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -7,6 +7,7 @@ import { scorecardsCommand } from "./commands/scorecards.js";
 import { snapshotsCommand } from "./commands/snapshots.js";
 import { studioCommand } from "./commands/studio.js";
 import { teamsCommand } from "./commands/teams.js";
+import { workflowRunsCommand } from "./commands/workflowRuns.js";
 import { workflowsCommand } from "./commands/workflows.js";
 import { handleError } from "./commandHelpers.js";
 
@@ -54,6 +55,7 @@ function createProgram(): Command {
   program.addCommand(snapshotsCommand());
   program.addCommand(studioCommand());
   program.addCommand(teamsCommand());
+  program.addCommand(workflowRunsCommand());
   program.addCommand(workflowsCommand());
 
   applyExitOverride(program);
diff --git a/src/commands/teams.ts b/src/commands/teams.ts
index 9846f32..07505d8 100644
--- a/src/commands/teams.ts
+++ b/src/commands/teams.ts
@@ -214,7 +214,7 @@ async function getTeamInfo(
   return response.body;
 }
 
-async function listTeams(runtime: Runtime): Promise<ListTeamsResponse> {
+export async function listTeams(runtime: Runtime): Promise<ListTeamsResponse> {
   const response = await request<ListTeamsResponse>(runtime, "/teams.list", {
     method: "GET",
   });
diff --git a/src/commands/workflowRuns.ts b/src/commands/workflowRuns.ts
new file mode 100644
index 0000000..b66273b
--- /dev/null
+++ b/src/commands/workflowRuns.ts
@@ -0,0 +1,19 @@
+import { Command } from "commander";
+
+import { addLinkCommand } from "./workflowRuns/addLink.js";
+import { changeStatusCommand } from "./workflowRuns/changeStatus.js";
+import { infoCommand } from "./workflowRuns/info.js";
+import { postMessageCommand } from "./workflowRuns/postMessage.js";
+
+export function workflowRunsCommand(): Command {
+  const workflowRuns = new Command()
+    .name("workflowRuns")
+    .description("Trigger and monitor Self-service workflow runs");
+
+  workflowRuns.addCommand(addLinkCommand());
+  workflowRuns.addCommand(changeStatusCommand());
+  workflowRuns.addCommand(infoCommand());
+  workflowRuns.addCommand(postMessageCommand());
+
+  return workflowRuns;
+}
diff --git a/src/commands/workflowRuns/addLink.ts b/src/commands/workflowRuns/addLink.ts
new file mode 100644
index 0000000..d61838c
--- /dev/null
+++ b/src/commands/workflowRuns/addLink.ts
@@ -0,0 +1,79 @@
+import { Command } from "commander";
+
+import {
+  createExampleText,
+  getContext,
+  wrapAction,
+} from "../../commandHelpers.js";
+import { buildRuntime } from "../../runtime.js";
+import { renderJson, renderRichText } from "../../renderers.js";
+import * as ui from "../../ui.js";
+import { request } from "../../http.js";
+import { Runtime } from "../../types.js";
+
+export function addLinkCommand() {
+  return new Command()
+    .name("addLink")
+    .description("Add a link to a workflow run")
+    .argument("<workflow-run-id>", "The ID of the workflow run")
+    .requiredOption("--url <url>", "The URL of the link")
+    .requiredOption("--label <label>", "The label of the link")
+    .addHelpText(
+      "afterAll",
+      createExampleText([
+        {
+          label: "Add a link to a workflow run",
+          command:
+            'dx workflowRuns addLink hvserjgz5lo7 --url https://www.example.com --label "Example Website"',
+        },
+      ]),
+    )
+    .action(
+      wrapAction(async (workflowRunId: string, options, command) => {
+        const context = getContext(command);
+        const runtime = buildRuntime(context);
+
+        const response = await addLink(
+          runtime,
+          workflowRunId,
+          options.url,
+          options.label,
+        );
+
+        if (runtime.context.json) {
+          renderJson(response);
+        } else {
+          renderRichText([
+            ui.p(
+              `${ui.success(ui.GLYPHS.CHECK)} Added link to workflow run ${ui.code(workflowRunId)}.`,
+            ),
+            ui.p(
+              `Web link: ${ui.link(ui.webLink(`/self-service/workflow-runs/${workflowRunId}`, runtime))}`,
+            ),
+          ]);
+        }
+      }),
+    );
+}
+
+type AddLinkResponse = {
+  ok: true;
+};
+
+async function addLink(
+  runtime: Runtime,
+  workflowRunId: string,
+  url: string,
+  label: string,
+): Promise<{ body: AddLinkResponse }> {
+  return request<AddLinkResponse>(runtime, "/workflowRuns.addLink", {
+    method: "POST",
+    body: {
+      workflow_run_id: workflowRunId,
+      link: {
+        url,
+        label,
+      },
+    },
+  });
+}
diff --git a/src/commands/workflowRuns/changeStatus.ts b/src/commands/workflowRuns/changeStatus.ts
new file mode 100644
index 0000000..14a5d00
--- /dev/null
+++ b/src/commands/workflowRuns/changeStatus.ts
@@ -0,0 +1,93 @@
+import { Command } from "commander";
+
+import {
+  createExampleText,
+  getContext,
+  wrapAction,
+} from "../../commandHelpers.js";
+import { buildRuntime } from "../../runtime.js";
+import { renderJson, renderRichText } from "../../renderers.js";
+import * as ui from "../../ui.js";
+import { request } from "../../http.js";
+import { Runtime } from "../../types.js";
+import { CliError, EXIT_CODES } from "../../errors.js";
+
+export function changeStatusCommand() {
+  return new Command()
+    .name("changeStatus")
+    .description("Change the status of a workflow run")
+    .argument("<workflow-run-id>", "The ID of the workflow run")
+    .requiredOption("--status <updated-status>", "The status to change to")
+    .addHelpText(
+      "afterAll",
+      createExampleText([
+        {
+          label: "Mark a workflow run as succeeded",
+          command:
+            "dx workflowRuns changeStatus hvserjgz5lo7 --status SUCCEEDED",
+        },
+        {
+          label: "Mark a workflow run as failed",
+          command: "dx workflowRuns changeStatus hvserjgz5lo7 --status FAILED",
+        },
+      ]),
+    )
+    .action(
+      wrapAction(async (workflowRunId: string, options, command) => {
+        const context = getContext(command);
+        const runtime = buildRuntime(context);
+
+        if (!isValidStatus(options.status)) {
+          throw new CliError(
+            `Invalid status: ${options.status}. Must be one of: SUCCEEDED, FAILED.`,
+            EXIT_CODES.ARGUMENT_ERROR,
+          );
+        }
+
+        const response = await changeStatus(
+          runtime,
+          workflowRunId,
+          options.status,
+        );
+
+        if (runtime.context.json) {
+          renderJson(response);
+        } else {
+          renderRichText([
+            ui.p(
+              `${ui.success(ui.GLYPHS.CHECK)} Changed status of workflow run ${ui.code(workflowRunId)} to ${ui.code(options.status)}.`,
+            ),
+            ui.p(
+              `Web link: ${ui.link(ui.webLink(`/self-service/workflow-runs/${workflowRunId}`, runtime))}`,
+            ),
+          ]);
+        }
+      }),
+    );
+}
+
+function isValidStatus(
+  updatedStatus: string,
+): updatedStatus is WorkflowRunStatus {
+  return updatedStatus === "SUCCEEDED" || updatedStatus === "FAILED";
+}
+
+type WorkflowRunStatus = "SUCCEEDED" | "FAILED";
+
+type ChangeStatusResponse = {
+  ok: true;
+};
+
+async function changeStatus(
+  runtime: Runtime,
+  workflowRunId: string,
+  status: WorkflowRunStatus,
+): Promise<{ body: ChangeStatusResponse }> {
+  return request<ChangeStatusResponse>(runtime, "/workflowRuns.changeStatus", {
+    method: "POST",
+    body: {
+      workflow_run_id: workflowRunId,
+      status,
+    },
+  });
+}
diff --git a/src/commands/workflowRuns/events.ts b/src/commands/workflowRuns/events.ts
new file mode 100644
index 0000000..8d5af41
--- /dev/null
+++ b/src/commands/workflowRuns/events.ts
@@ -0,0 +1,75 @@
+import { WorkflowRunEvent } from "./info.js";
+import * as ui from "../../ui.js";
+
+export function workflowRunEventContent(event: WorkflowRunEvent): ui.Block {
+  const ts = ui.dim(event.occurred_at);
+  const message = formatEventMessage(event);
+  return ui.p(`${ts} ${message}`, false);
+}
+
+function formatEventMessage(event: WorkflowRunEvent): string {
+  const userName = event.user?.name ?? event.user?.email ?? "API";
+
+  switch (event.type) {
+    case "WORKFLOW_TRIGGERED":
+      return `Workflow run triggered by ${ui.bold(userName)}`;
+
+    case "WORKFLOW_RUN_REQUESTED":
+      return `Workflow run requested by ${ui.bold(userName)}`;
+
+    case "APPROVERS_NOTIFIED":
+      return "Approvers notified";
+
+    case "APPROVAL_PERFORMED":
+      return `Approved by ${ui.bold(userName)}`;
+
+    case "REJECTION_PERFORMED":
+      return `Rejected by ${ui.bold(userName)}`;
+
+    case "HTTP_REQUEST_COMPLETED": {
+      const method = event.data?.request?.method?.toUpperCase();
+      const url = event.data?.request?.url;
+      const status = event.data?.response?.status;
+      const reqSummary = method && url ? ` ${ui.code(`${method} ${url}`)}` : "";
+      const statusSummary = status ? ` → ${ui.code(String(status))}` : "";
+      return `Sent HTTP request${reqSummary}${statusSummary}`;
+    }
+
+    case "POST_MESSAGE": {
+      const text = event.message ?? "";
+      const truncated = text.length > 120 ? text.slice(0, 120) + "…" : text;
+      return truncated;
+    }
+
+    case "ADD_LINK": {
+      const link = event.data?.link;
+      if (link) {
+        const label = link.label ? `${link.label}: ` : "";
+        return `Added link ${label}${ui.link(link.url)}`;
+      }
+      return "Added a link";
+    }
+
+    case "CHANGE_STATUS": {
+      const status = event.data?.status;
+      return status
+        ? `Status changed to ${ui.bold(status.toLowerCase())}`
+        : "Status changed";
+    }
+
+    case "WORKFLOW_SUCCEEDED":
+      return `${ui.success(ui.GLYPHS.CHECK)} Workflow run succeeded`;
+
+    case "WORKFLOW_FAILED":
+      return `${ui.error(ui.GLYPHS.ERROR)} Workflow run failed`;
+
+    case "WORKFLOW_TIMEOUT":
+      return `${ui.error(ui.GLYPHS.ERROR)} Workflow run timed out`;
+
+    case "WORKFLOW_CANCELLED":
+      return `${ui.warning(ui.GLYPHS.WARNING)} Workflow run cancelled by ${ui.bold(userName)}`;
+
+    default:
+      return `Event: ${(event as WorkflowRunEvent).type}`;
+  }
+}
diff --git a/src/commands/workflowRuns/info.ts b/src/commands/workflowRuns/info.ts
new file mode 100644
index 0000000..3482222
--- /dev/null
+++ b/src/commands/workflowRuns/info.ts
@@ -0,0 +1,182 @@
+import { Command } from "commander";
+
+import {
+  createExampleText,
+  getContext,
+  wrapAction,
+} from "../../commandHelpers.js";
+import { buildRuntime } from "../../runtime.js";
+import { renderJson, renderRichText } from "../../renderers.js";
+import * as ui from "../../ui.js";
+import { request } from "../../http.js";
+import { Runtime } from "../../types.js";
+import { workflowRunEventContent } from "./events.js";
+
+export function infoCommand() {
+  return new Command()
+    .name("info")
+    .description("Get info for a workflow run")
+    .argument("<workflow-run-id>", "The ID of the workflow run")
+    .addHelpText(
+      "afterAll",
+      createExampleText([
+        {
+          label: "Get info for a workflow run",
+          command: "dx workflowRuns info hvserjgz5lo7",
+        },
+      ]),
+    )
+    .action(
+      wrapAction(async (workflowRunId: string, options, command) => {
+        const context = getContext(command);
+        const runtime = buildRuntime(context);
+
+        const infoResponse = await getWorkflowRun(runtime, workflowRunId);
+        const workflowRun = infoResponse.body.workflow_run;
+
+        if (runtime.context.json) {
+          renderJson({ ok: true, workflow_run: workflowRun });
+        } else {
+          renderWorkflowRunInfo(workflowRun, runtime);
+        }
+      }),
+    );
+}
+
+function renderWorkflowRunInfo(run: WorkflowRunDetail, runtime: Runtime): void {
+  renderRichText([
+    ui.h2("Workflow run"),
+    ui.h3("Summary"),
+    ...summaryContent(run, runtime),
+    ui.h3("Events"),
+    ...eventsContent(run),
+  ]);
+}
+
+export function renderWorkflowRunSummary(
+  run: WorkflowRunDetail,
+  runtime: Runtime,
+) {
+  renderRichText([ui.h3("Workflow run"), ...summaryContent(run, runtime)]);
+}
+
+function summaryContent(run: WorkflowRunDetail, runtime: Runtime): ui.Block[] {
+  const items = [
+    ui.dli("Run ID", ui.code(run.id)),
+    ui.dli("Status", run.status),
+  ];
+  if (run.workflow) {
+    items.push(
+      ui.dli(
+        "Workflow",
+        `${run.workflow.name} (${ui.code(run.workflow.identifier)})`,
+      ),
+    );
+    items.push(
+      ui.dli(
+        "Web link",
+        ui.link(ui.webLink(`/self-service/workflow-runs/${run.id}`, runtime)),
+      ),
+    );
+  }
+  if (run.entity) {
+    items.push(
+      ui.dli("Entity", `${run.entity.name} (${run.entity.identifier})`),
+    );
+  }
+  if (run.started_at) {
+    items.push(ui.dli("Started", ui.timestampSummary(run.started_at)));
+  }
+  if (run.started_at && run.completed_at) {
+    items.push(ui.dli("Completed", ui.timestampSummary(run.completed_at)));
+    items.push(
+      ui.dli("Duration", ui.durationSummary(run.started_at, run.completed_at)),
+    );
+  }
+  if (run.links?.length) {
+    const linkSummaries: ui.Block[] = run.links.map((l) =>
+      ui.p(
+        l.label ? `${ui.bold(l.label)} ${ui.link(l.url)}` : ui.link(l.url),
+        false,
+      ),
+    );
+    items.push(ui.dli("Links", linkSummaries));
+  }
+
+  return [ui.dl(items, { termWidth: 14 })];
+}
+
+function eventsContent(run: WorkflowRunDetail): ui.Block[] {
+  const items = [];
+
+  for (const event of run.events ?? []) {
+    items.push(workflowRunEventContent(event));
+  }
+
+  items.push(ui.blankLine());
+
+  return items;
+}
+
+export type WorkflowRunEventType =
+  | "POST_MESSAGE"
+  | "ADD_LINK"
+  | "CHANGE_STATUS"
+  | "WORKFLOW_TRIGGERED"
+  | "WORKFLOW_RUN_REQUESTED"
+  | "APPROVERS_NOTIFIED"
+  | "APPROVAL_PERFORMED"
+  | "REJECTION_PERFORMED"
+  | "HTTP_REQUEST_COMPLETED"
+  | "WORKFLOW_SUCCEEDED"
+  | "WORKFLOW_FAILED"
+  | "WORKFLOW_TIMEOUT"
+  | "WORKFLOW_CANCELLED";
+
+export type WorkflowRunEvent = {
+  id: string;
+  type: WorkflowRunEventType;
+  occurred_at: string;
+  message: string | null;
+  user?: { name: string; email?: string };
+  data?: {
+    status?: string;
+    link?: { url: string; label?: string };
+    request?: { method?: string; url?: string };
+    response?: { status?: number };
+    [key: string]: unknown;
+  };
+};
+
+export type WorkflowRunDetail = {
+  id: string;
+  status: string;
+  started_at?: string;
+  completed_at?: string | null;
+  data?: Record<string, unknown>;
+  links?: Array<{ url: string; icon?: string; label?: string }>;
+  workflow?: {
+    identifier: string;
+    name: string;
+    description?: string | null;
+    scope: "GLOBAL" | "ENTITY";
+    execution_type: "SIMPLE" | "EVENT_DRIVEN";
+  };
+  entity?: { identifier: string; name: string };
+  events?: WorkflowRunEvent[];
+};
+
+export type InfoWorkflowRunResponse = {
+  ok: true;
+  workflow_run: WorkflowRunDetail;
+};
+
+export async function getWorkflowRun(
+  runtime: Runtime,
+  id: string,
+): Promise<{ body: InfoWorkflowRunResponse; retryAfterMs?: number }> {
+  return request<InfoWorkflowRunResponse>(runtime, "/workflowRuns.info", {
+    method: "GET",
+    query: { id },
+  });
+}
diff --git a/src/commands/workflowRuns/postMessage.ts b/src/commands/workflowRuns/postMessage.ts
new file mode 100644
index 0000000..d7b3672
--- /dev/null
+++ b/src/commands/workflowRuns/postMessage.ts
@@ -0,0 +1,78 @@
+import { Command } from "commander";
+
+import {
+  createExampleText,
+  getContext,
+  wrapAction,
+} from "../../commandHelpers.js";
+import { buildRuntime } from "../../runtime.js";
+import { renderJson, renderRichText } from "../../renderers.js";
+import * as ui from "../../ui.js";
+import { request } from "../../http.js";
+import { Runtime } from "../../types.js";
+
+export function postMessageCommand() {
+  return new Command()
+    .name("postMessage")
+    .description("Post a message to a workflow run")
+    .argument("<workflow-run-id>", "The ID of the workflow run")
+    .requiredOption("--message <message>", "The message to post")
+    .addHelpText(
+      "afterAll",
+      createExampleText([
+        {
+          label: "Post a message to a workflow run",
+          command:
+            'dx workflowRuns postMessage hvserjgz5lo7 --message "Hello from the CLI"',
+        },
+        {
+          label: "Post the contents of a markdown file to a workflow run",
+          command:
+            'dx workflowRuns postMessage hvserjgz5lo7 --message "$(cat message.md)"',
+        },
+      ]),
+    )
+    .action(
+      wrapAction(async (workflowRunId: string, options, command) => {
+        const context = getContext(command);
+        const runtime = buildRuntime(context);
+
+        const response = await postMessage(
+          runtime,
+          workflowRunId,
+          options.message,
+        );
+
+        if (runtime.context.json) {
+          renderJson(response);
+        } else {
+          renderRichText([
+            ui.p(
+              `${ui.success(ui.GLYPHS.CHECK)} Posted message to workflow run ${ui.code(workflowRunId)}.`,
+            ),
+            ui.p(
+              `Web link: ${ui.link(ui.webLink(`/self-service/workflow-runs/${workflowRunId}`, runtime))}`,
+            ),
+          ]);
+        }
+      }),
+    );
+}
+
+type PostMessageResponse = {
+  ok: true;
+};
+
+async function postMessage(
+  runtime: Runtime,
+  workflowRunId: string,
+  message: string,
+): Promise<{ body: PostMessageResponse }> {
+  return request<PostMessageResponse>(runtime, "/workflowRuns.postMessage", {
+    method: "POST",
+    body: {
+      workflow_run_id: workflowRunId,
+      message,
+    },
+  });
+}
diff --git a/src/commands/workflows.ts b/src/commands/workflows.ts
index bf2e862..3693580 100644
--- a/src/commands/workflows.ts
+++ b/src/commands/workflows.ts
@@ -119,7 +119,7 @@ export type WorkflowParameter = {
   default_value: unknown;
   is_required: boolean;
   type: WorkflowParameterType;
-  definition: unknown;
+  definition: null | { options: string[] };
 };
 
 export type WorkflowSummary = {
@@ -149,7 +149,7 @@ type ListWorkflowsResponse = {
 
 // --- API ---
 
-async function listWorkflows(
+export async function listWorkflows(
   runtime: Runtime,
   params: ListWorkflowsParams,
 ): Promise<ListWorkflowsResponse> {
diff --git a/src/ui.ts b/src/ui.ts
index ee805cc..f9e3511 100644
--- a/src/ui.ts
+++ b/src/ui.ts
@@ -152,6 +152,21 @@ export function timestampSummary(timestamp: string): string {
   return `${ts.fromNow()} ${dim(`(${timestamp})`)}`;
 }
 
+export function durationSummary(start: string, end: string): string {
+  const pluralizeWithCount = (word: string, n: number) =>
+    `${n} ${word}${n === 1 ? "" : "s"}`;
+
+  const duration = dayjs(end).diff(dayjs(start), "seconds");
+
+  if (duration < 60) {
+    return pluralizeWithCount("second", duration);
+  }
+
+  const minutes = Math.floor(duration / 60);
+  const seconds = duration % 60;
+  return `${pluralizeWithCount("minute", minutes)}, ${pluralizeWithCount("second", seconds)}`;
+}
+
 // Other helpers
 
 export function indent(text: string, level: number): string {
diff --git a/src/ui/blocks.ts b/src/ui/blocks.ts
index dba6e3e..2b2804c 100644
--- a/src/ui/blocks.ts
+++ b/src/ui/blocks.ts
@@ -97,13 +97,13 @@ export class DescriptionListItemContainer extends AbstractBlock {
 
   render(): string {
     if (!this.options) {
-      throw new Error("Options are not set");
+      throw new Error("DescriptionListItemContainer: Options are not set");
     }
 
-    return (
-      pc.bold(padEnd(`${this.term}:`, this.options.termWidth)) +
-      this.detailItems.map((item) => item.render()).join("\n")
-    );
+    const termPart = pc.bold(padEnd(`${this.term}:`, this.options.termWidth));
+    const detailText = this.detailItems.map((item) => item.render()).join("\n");
+    const padding = " ".repeat(this.options.termWidth);
+    return termPart + detailText.replace(/\n/g, `\n${padding}`);
   }
 
   setOptions(options?: DescriptionListBlockOptions): void {