diff --git a/CONTEXT.md b/CONTEXT.md
new file mode 100644
index 0000000..f0b82d2
--- /dev/null
+++ b/CONTEXT.md
@@ -0,0 +1,17 @@
+# Clearance
+
+Clearance determines who must review a pull request and tracks whether the required approvals are current.
+
+## Language
+
+**Review requirement**:
+An approval obligation derived from the ownership rules for the files changed by a pull request.
+
+**Review transition**:
+A change to a pull request's Clearance state together with the comments, statuses, reviewer requests,
+and notifications that must follow that change. Acceptance means that all of this work is retained
+for execution; it does not mean GitHub has completed it.
+
+**Escalation**:
+A warning, additional reviewer request, or fallback notification triggered by a review requirement
+remaining pending beyond its configured time.
diff --git a/docs/testing.md b/docs/testing.md
index 5797ca9..d8c3e22 100644
--- a/docs/testing.md
+++ b/docs/testing.md
@@ -34,7 +34,12 @@ Covered areas:
 - `state`: hidden state parsing, rendering, review approvals, scoped invalidation.
 - `review`: GitHub-native review marker parsing, patchset/index projection, attention state, and
   file review marks.
-- `db`: persistence boundary behavior is covered through workflow tests; use Supabase local database checks when changing migrations or Drizzle schema.
+- `db`: durable review transitions use Drizzle with embedded PostgreSQL (PGlite). Tests inject SQL
+  constraint failures, verify rollback through stored state and claimed jobs, and retry PR changes,
+  submitted reviews, and escalation. The fixture applies the Clearance migration with native
+  `gen_random_uuid` in place of the Supabase `pgcrypto` wrapper; it does not verify Supabase hosting,
+  connection pooling, or concurrent workers. Use Supabase local database checks when changing
+  migrations or Drizzle schema.
 - `checks`: status decisions.
 - `escalation`: timing decisions.
 - `override`: break-glass authorization.
@@ -66,6 +71,7 @@ Covered areas:
 - invalid config behavior
 - scoped stale approval retention and invalidation
 - escalation action application
+- atomic acceptance of review state and outgoing GitHub job intent; failures remain retryable
 
 ### Webhook handler tests
 
@@ -87,4 +93,6 @@ Reference: [`@octokit/webhooks` README](https://github.com/octokit/webhooks.js#r
 - Include one success case and one unhappy path for each new adapter or workflow branch.
 - Prefer result values and diagnostics for expected operational failures.
 - Reserve thrown errors for programmer errors, test helpers, or truly unexpected runtime failures.
+  Durable review acceptance is an explicit exception: transaction failures propagate so webhook
+  deliveries are recorded as failed and escalation runs can retry without losing outgoing work.
 - Keep hidden sticky comment snapshot round-trip tests whenever the state shape changes.
diff --git a/package-lock.json b/package-lock.json
index 66489d8..0eacbfd 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -35,6 +35,7 @@
         "zod": "^4.4.3"
       },
       "devDependencies": {
+        "@electric-sql/pglite": "0.5.8",
         "@playwright/test": "^1.60.0",
         "@types/node": "^25.8.0",
         "@types/react": "^19.2.15",
@@ -950,6 +951,13 @@
         "@noble/ciphers": "^1.0.0"
       }
     },
+    "node_modules/@electric-sql/pglite": {
+      "version": "0.5.8",
+      "resolved": "https://registry.npmjs.org/@electric-sql/pglite/-/pglite-0.5.8.tgz",
+      "integrity": "sha512-n9tsbUOhwx2epK1V0ZG9Ar4SHWUju04dhmzZXiSBXwBoleOvIfals33NAaWgagQVAL4Rbvx/Ptsu3P+pA09f6Q==",
+      "devOptional": true,
+      "license": "Apache-2.0"
+    },
     "node_modules/@esbuild/aix-ppc64": {
       "version": "0.28.0",
       "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.0.tgz",
diff --git a/package.json b/package.json
index e653cec..1daf2b4 100644
--- a/package.json
+++ b/package.json
@@ -60,6 +60,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@electric-sql/pglite": "0.5.8",
     "@playwright/test": "^1.60.0",
     "@types/node": "^25.8.0",
     "@types/react": "^19.2.15",
diff --git a/src/db/store.ts b/src/db/store.ts
index 38ddc2b..49c1a3b 100644
--- a/src/db/store.ts
+++ b/src/db/store.ts
@@ -1,6 +1,7 @@
 import { and, asc, eq, inArray, lte, sql } from "drizzle-orm";
 
-import type { ClearanceDatabase } from "./client.js";
+import type { PgDatabase, PgQueryResultHKT } from "drizzle-orm/pg-core";
+import type * as schema from "./schema.js";
 import {
   approvals,
   assignments,
@@ -58,7 +59,7 @@ export type OutboxJobFailureInput = {
 };
 
 export class DrizzleClearanceStore {
-  constructor(private readonly db: ClearanceDatabase) {}
+  constructor(private readonly db: PgDatabase<PgQueryResultHKT, typeof schema>) {}
 
   async listTrackedRepositories(): Promise<TrackedRepository[]> {
     return this.db
@@ -88,7 +89,11 @@ export class DrizzleClearanceStore {
     return rows[0]?.state;
   }
 
-  async savePullRequestState(input: PullRequestStateRef, state: ClearanceState): Promise<void> {
+  async savePullRequestTransition(
+    input: PullRequestStateRef,
+    state: ClearanceState,
+    jobs: OutboxJobInput[],
+  ): Promise<void> {
     await this.db.transaction(async (tx) => {
       const rows = await tx
         .insert(pullRequests)
@@ -208,6 +213,10 @@ export class DrizzleClearanceStore {
           })),
         );
       }
+
+      if (jobs.length > 0) {
+        await tx.insert(outboxJobs).values(jobs);
+      }
     });
   }
 
@@ -278,14 +287,6 @@ export class DrizzleClearanceStore {
     return true;
   }
 
-  async enqueueOutboxJob(input: OutboxJobInput): Promise<void> {
-    await this.db.insert(outboxJobs).values({
-      availableAt: input.availableAt,
-      payload: input.payload,
-      type: input.type,
-    });
-  }
-
   async claimOutboxJobs(limit: number): Promise<OutboxJobRecord[]> {
     if (limit <= 0) {
       return [];
diff --git a/src/github/escalation-runner.ts b/src/github/escalation-runner.ts
index 3ab3104..a08614c 100644
--- a/src/github/escalation-runner.ts
+++ b/src/github/escalation-runner.ts
@@ -1,6 +1,9 @@
 import { buildEscalationRequirementsFromState, processEscalationRun } from "../workflow/index.js";
 import type { ClearanceState } from "../state/index.js";
-import { enqueueGithubOutboxJob, githubOutboxJobTypes, type GithubOutboxStore } from "./outbox.js";
+import {
+  commitGithubReviewTransition,
+  type GithubReviewTransitionStore,
+} from "./review-transition.js";
 import {
   listOpenPullRequests,
   type OpenPullRequest,
@@ -14,25 +17,12 @@ export type EscalationRunnerRepository = {
 
 export type GithubEscalationRunnerOctokit = OpenPullRequestsOctokit;
 
-export type GithubEscalationRunnerStateStore = {
-  enqueueOutboxJob: GithubOutboxStore["enqueueOutboxJob"];
+export type GithubEscalationRunnerStateStore = GithubReviewTransitionStore & {
   loadPullRequestState(input: {
     owner: string;
     pullNumber: number;
     repo: string;
   }): Promise<ClearanceState | undefined>;
-  savePullRequestState(
-    input: {
-      author: string;
-      headSha: string;
-      labels: string[];
-      now: string;
-      owner: string;
-      pullNumber: number;
-      repo: string;
-    },
-    state: ClearanceState,
-  ): Promise<void>;
 };
 
 export type GithubEscalationRunnerOptions = {
@@ -44,7 +34,6 @@ export type EscalationPullResult =
   | {
       actions: number;
       pullNumber: number;
-      sideEffectFailures: number;
       status: "processed";
     }
   | {
@@ -101,32 +90,9 @@ async function processPullRequest(
       state: storedState,
     },
     {
-      postComment: async (body) => {
-        await enqueueGithubOutboxJob(options.stateStore, {
-          payload: {
-            body,
-            installationId: options.installationId,
-            owner: repository.owner,
-            pullNumber: pullRequest.number,
-            repo: repository.repo,
-          },
-          type: githubOutboxJobTypes.postComment,
-        });
-      },
-      requestReviewers: async (reviewers) => {
-        await enqueueGithubOutboxJob(options.stateStore, {
-          payload: {
-            installationId: options.installationId,
-            owner: repository.owner,
-            pullNumber: pullRequest.number,
-            repo: repository.repo,
-            reviewers,
-          },
-          type: githubOutboxJobTypes.requestReviewers,
-        });
-      },
-      saveState: async (nextState) => {
-        await options.stateStore.savePullRequestState(
+      commitTransition: (transition) =>
+        commitGithubReviewTransition(
+          options.stateStore,
           {
             author: pullRequest.author,
             headSha: pullRequest.headSha,
@@ -136,28 +102,15 @@ async function processPullRequest(
             pullNumber: pullRequest.number,
             repo: repository.repo,
           },
-          nextState,
-        );
-      },
-      upsertComment: async (body) => {
-        await enqueueGithubOutboxJob(options.stateStore, {
-          payload: {
-            body,
-            installationId: options.installationId,
-            owner: repository.owner,
-            pullNumber: pullRequest.number,
-            repo: repository.repo,
-          },
-          type: githubOutboxJobTypes.upsertComment,
-        });
-      },
+          options.installationId,
+          transition,
+        ),
     },
   );
 
   return {
     actions: result.actions.length,
     pullNumber: pullRequest.number,
-    sideEffectFailures: result.sideEffectFailures.length,
     status: "processed",
   };
 }
diff --git a/src/github/handlers.ts b/src/github/handlers.ts
index 8cecefb..ee00dbb 100644
--- a/src/github/handlers.ts
+++ b/src/github/handlers.ts
@@ -7,14 +7,11 @@ import {
   listPullRequestReviewerSignals,
   loadOwnershipTree,
   parseReviewThreadMarker,
-  enqueueGithubOutboxJob,
-  githubOutboxJobTypes,
   resolveGithubIdentities,
   stripReviewThreadMarker,
   type CommitCompareOctokit,
   type GithubIdentityOctokit,
   type GithubStatusesOctokit,
-  type GithubOutboxStore,
   type NotificationCommentOctokit,
   type OwnershipTreeOctokit,
   type PullRequestFilesOctokit,
@@ -31,6 +28,10 @@ import {
 import type { ClearanceState } from "../state/index.js";
 import { parseOverrideCommentCommand } from "../override/index.js";
 import type { ReviewPatchsetInput, ReviewPullRequestRef } from "../review/index.js";
+import {
+  commitGithubReviewTransition,
+  type GithubReviewTransitionStore,
+} from "./review-transition.js";
 
 const pullRequestActions = new Set(["opened", "reopened", "synchronize", "ready_for_review"]);
 
@@ -66,14 +67,13 @@ export type GithubInstallationClientFactory = {
   getInstallationOctokit(installationId: number): Promise<GithubWorkflowOctokit>;
 };
 
-export type GithubHandlerStateStore = {
+export type GithubHandlerStateStore = GithubReviewTransitionStore & {
   beginWebhookDelivery(input: {
     action?: string;
     deliveryId: string;
     event: string;
     payload?: unknown;
   }): Promise<boolean>;
-  enqueueOutboxJob: GithubOutboxStore["enqueueOutboxJob"];
   loadPullRequestState(
     input: Pick<PullRequestWorkflowInput, "owner" | "pullNumber" | "repo">,
   ): Promise<ClearanceState | undefined>;
@@ -85,7 +85,6 @@ export type GithubHandlerStateStore = {
     payload?: unknown;
     status: "failed" | "processed" | "processing";
   }): Promise<void>;
-  savePullRequestState(input: PullRequestWorkflowInput, state: ClearanceState): Promise<void>;
 };
 
 export type GithubHandlerReviewStore = {
@@ -171,7 +170,6 @@ export function registerGithubHandlers(
         console.info(
           {
             checks: result.checks,
-            sideEffectFailures: result.sideEffectFailures,
             pullNumber,
             requestedReviewers: result.requestedReviewers,
             repository,
@@ -253,7 +251,6 @@ export function registerGithubHandlers(
         console.info(
           {
             checks: result.checks,
-            sideEffectFailures: result.sideEffectFailures,
             pullNumber: payload.pull_request.number,
             repository: payload.repository.full_name,
             reviewer,
@@ -408,7 +405,6 @@ export function registerGithubHandlers(
               command: command.type,
               pullNumber,
               repository,
-              sideEffectFailures: result.sideEffectFailures,
             },
             "processed override comment event",
           );
@@ -617,70 +613,9 @@ function buildWorkflowDependencies(
         ref: input.headSha,
         repo: input.repo,
       }),
-    requestReviewers: async (input, reviewers) => {
-      if (reviewers.length === 0) {
-        return;
-      }
-
-      await enqueueGithubOutboxJob(options.stateStore, {
-        payload: {
-          installationId,
-          owner: input.owner,
-          pullNumber: input.pullNumber,
-          repo: input.repo,
-          reviewers,
-        },
-        type: githubOutboxJobTypes.requestReviewers,
-      });
-    },
     resolveIdentities: async (tree) => resolveGithubIdentities(octokit, tree.files),
-    saveState: async (input, state) => {
-      await options.stateStore.savePullRequestState(input, state);
-    },
-    sendNotifications: async (input, notifications) => {
-      if (notifications.length === 0) {
-        return;
-      }
-
-      await enqueueGithubOutboxJob(options.stateStore, {
-        payload: {
-          installationId,
-          notifications,
-          owner: input.owner,
-          pullNumber: input.pullNumber,
-          repo: input.repo,
-        },
-        type: githubOutboxJobTypes.sendNotifications,
-      });
-    },
-    setStatuses: async (input, decisions) => {
-      if (decisions.length === 0) {
-        return;
-      }
-
-      await enqueueGithubOutboxJob(options.stateStore, {
-        payload: {
-          decisions,
-          installationId,
-          owner: input.owner,
-          repo: input.repo,
-          sha: input.headSha,
-        },
-        type: githubOutboxJobTypes.setStatuses,
-      });
-    },
-    upsertComment: async (input, body) => {
-      await enqueueGithubOutboxJob(options.stateStore, {
-        payload: {
-          body,
-          installationId,
-          owner: input.owner,
-          pullNumber: input.pullNumber,
-          repo: input.repo,
-        },
-        type: githubOutboxJobTypes.upsertComment,
-      });
-    },
+    commitTransition: (input, transition) =>
+      commitGithubReviewTransition(options.stateStore, input, installationId, transition),
   };
 }
 
diff --git a/src/github/index.ts b/src/github/index.ts
index 69dafbb..5d044b6 100644
--- a/src/github/index.ts
+++ b/src/github/index.ts
@@ -51,14 +51,12 @@ export {
   type ReviewerSignalsRef,
 } from "./reviewer-signals.js";
 export {
-  enqueueGithubOutboxJob,
   executeGithubOutboxJob,
   githubOutboxJobTypes,
   type GithubOutboxInstallationClientFactory,
   type GithubOutboxJobInput,
   type GithubOutboxJobType,
   type GithubOutboxOctokit,
-  type GithubOutboxStore,
 } from "./outbox.js";
 export {
   runGithubOutboxOnce,
diff --git a/src/github/outbox.ts b/src/github/outbox.ts
index 56bc0e1..6c2953c 100644
--- a/src/github/outbox.ts
+++ b/src/github/outbox.ts
@@ -1,5 +1,5 @@
 import type { CheckDecision } from "../checks/index.js";
-import type { OutboxJobInput, OutboxJobRecord } from "../db/index.js";
+import type { OutboxJobRecord } from "../db/index.js";
 import type { NotificationRecord } from "../resolution/index.js";
 import { sendPullRequestNotifications, type NotificationCommentOctokit } from "./notifications.js";
 import { requestPullRequestReviewers, type PullRequestReviewersOctokit } from "./reviewers.js";
@@ -21,10 +21,6 @@ export type GithubOutboxOctokit = GithubStatusesOctokit &
   PullRequestReviewersOctokit &
   StickyCommentOctokit;
 
-export type GithubOutboxStore = {
-  enqueueOutboxJob(input: OutboxJobInput): Promise<void>;
-};
-
 export type GithubOutboxInstallationClientFactory = {
   getInstallationOctokit(installationId: number): Promise<GithubOutboxOctokit>;
 };
@@ -82,16 +78,6 @@ export type GithubOutboxJobInput =
       type: typeof githubOutboxJobTypes.sendNotifications;
     };
 
-export async function enqueueGithubOutboxJob(
-  store: GithubOutboxStore,
-  job: GithubOutboxJobInput,
-): Promise<void> {
-  await store.enqueueOutboxJob({
-    payload: job.payload,
-    type: job.type,
-  });
-}
-
 export async function executeGithubOutboxJob(
   job: OutboxJobRecord,
   installationClientFactory: GithubOutboxInstallationClientFactory,
diff --git a/src/github/review-transition.ts b/src/github/review-transition.ts
new file mode 100644
index 0000000..de69945
--- /dev/null
+++ b/src/github/review-transition.ts
@@ -0,0 +1,43 @@
+import type { DrizzleClearanceStore, PullRequestStateRef } from "../db/index.js";
+import type { ReviewTransition } from "../workflow/transition.js";
+import { githubOutboxJobTypes, type GithubOutboxJobInput } from "./outbox.js";
+
+export type GithubReviewTransitionStore = Pick<DrizzleClearanceStore, "savePullRequestTransition">;
+
+/** Accept the state and GitHub work together; remote execution belongs to the outbox runner. */
+export async function commitGithubReviewTransition(
+  store: GithubReviewTransitionStore,
+  input: PullRequestStateRef,
+  installationId: number,
+  transition: ReviewTransition,
+): Promise<void> {
+  const base = { installationId, owner: input.owner, repo: input.repo };
+  const pull = { ...base, pullNumber: input.pullNumber };
+  const jobs = transition.effects.map((effect): GithubOutboxJobInput => {
+    switch (effect.type) {
+      case "upsert-comment":
+        return {
+          type: githubOutboxJobTypes.upsertComment,
+          payload: { ...pull, body: effect.body },
+        };
+      case "post-comment":
+        return { type: githubOutboxJobTypes.postComment, payload: { ...pull, body: effect.body } };
+      case "request-reviewers":
+        return {
+          type: githubOutboxJobTypes.requestReviewers,
+          payload: { ...pull, reviewers: effect.reviewers },
+        };
+      case "set-statuses":
+        return {
+          type: githubOutboxJobTypes.setStatuses,
+          payload: { ...base, sha: input.headSha, decisions: effect.decisions },
+        };
+      case "send-notifications":
+        return {
+          type: githubOutboxJobTypes.sendNotifications,
+          payload: { ...pull, notifications: effect.notifications },
+        };
+    }
+  });
+  await store.savePullRequestTransition(input, transition.state, jobs);
+}
diff --git a/src/workflow/escalation.ts b/src/workflow/escalation.ts
index 0e9efe7..549bda0 100644
--- a/src/workflow/escalation.ts
+++ b/src/workflow/escalation.ts
@@ -9,6 +9,7 @@ import {
   type ClearanceStateRequirement,
   type StateEvent,
 } from "../state/index.js";
+import type { ReviewTransition, ReviewTransitionEffect } from "./transition.js";
 
 export type EscalationWorkflowInput = {
   now: string;
@@ -17,20 +18,11 @@ export type EscalationWorkflowInput = {
 };
 
 export type EscalationWorkflowDependencies = {
-  postComment(body: string): Promise<void>;
-  requestReviewers(reviewers: string[]): Promise<void>;
-  saveState(state: ClearanceState): Promise<void>;
-  upsertComment(body: string): Promise<void>;
-};
-
-export type EscalationSideEffectFailure = {
-  message: string;
-  operation: "post-comment" | "request-reviewers" | "upsert-comment";
+  commitTransition(transition: ReviewTransition): Promise<void>;
 };
 
 export type EscalationWorkflowResult = {
   actions: EscalationAction[];
-  sideEffectFailures: EscalationSideEffectFailure[];
   state: ClearanceState;
 };
 
@@ -49,25 +41,19 @@ export async function processEscalationRun(
       });
   const nextState = applyEscalationActions(state, actions, input.now);
 
-  await dependencies.saveState(nextState);
-
-  const sideEffectFailures = await runEscalationSideEffects([
-    {
-      execute: () => dependencies.upsertComment(renderClearanceComment(nextState)),
-      operation: "upsert-comment",
-    },
-    ...actions.map((action) => ({
-      execute: () => applyEscalationSideEffect(action, dependencies),
-      operation:
+  const effects: ReviewTransitionEffect[] = [
+    { type: "upsert-comment", body: renderClearanceComment(nextState) },
+    ...actions.map(
+      (action): ReviewTransitionEffect =>
         action.type === "request_reviewer"
-          ? ("request-reviewers" as const)
-          : ("post-comment" as const),
-    })),
-  ]);
+          ? { type: "request-reviewers", reviewers: [action.reviewer] }
+          : { type: "post-comment", body: renderActionComment(action) },
+    ),
+  ];
+  await dependencies.commitTransition({ state: nextState, effects });
 
   return {
     actions,
-    sideEffectFailures,
     state: nextState,
   };
 }
@@ -125,41 +111,6 @@ function applyEscalationActions(
   };
 }
 
-async function applyEscalationSideEffect(
-  action: EscalationAction,
-  dependencies: EscalationWorkflowDependencies,
-): Promise<void> {
-  if (action.type === "request_reviewer") {
-    await dependencies.requestReviewers([action.reviewer]);
-    return;
-  }
-
-  await dependencies.postComment(renderActionComment(action));
-}
-
-async function runEscalationSideEffects(
-  effects: Array<{
-    execute(): Promise<void>;
-    operation: EscalationSideEffectFailure["operation"];
-  }>,
-): Promise<EscalationSideEffectFailure[]> {
-  const results = await Promise.all(
-    effects.map(async (effect): Promise<EscalationSideEffectFailure | undefined> => {
-      try {
-        await effect.execute();
-        return undefined;
-      } catch (error) {
-        return {
-          message: getErrorMessage(error, "unknown error"),
-          operation: effect.operation,
-        };
-      }
-    }),
-  );
-
-  return results.filter((failure): failure is EscalationSideEffectFailure => failure !== undefined);
-}
-
 function getAssignedReviewers(
   state: ClearanceState,
   requirement: ClearanceStateRequirement,
@@ -181,10 +132,6 @@ function getAssignmentTime(
   )?.assignedAt;
 }
 
-function getErrorMessage(error: unknown, fallback: string): string {
-  return error instanceof Error ? error.message : fallback;
-}
-
 function createStateEvent(action: EscalationAction, now: string): StateEvent {
   if (action.type === "warn") {
     return {
diff --git a/src/workflow/index.ts b/src/workflow/index.ts
index 38f7147..8548d8e 100644
--- a/src/workflow/index.ts
+++ b/src/workflow/index.ts
@@ -9,8 +9,8 @@ export {
 export {
   buildEscalationRequirementsFromState,
   processEscalationRun,
-  type EscalationSideEffectFailure,
   type EscalationWorkflowDependencies,
   type EscalationWorkflowInput,
   type EscalationWorkflowResult,
 } from "./escalation.js";
+export type { ReviewTransition, ReviewTransitionEffect } from "./transition.js";
diff --git a/src/workflow/pull-request.ts b/src/workflow/pull-request.ts
index 34847f9..129d9a8 100644
--- a/src/workflow/pull-request.ts
+++ b/src/workflow/pull-request.ts
@@ -29,6 +29,7 @@ import {
   type ReviewRequirementDefinition,
 } from "../state/index.js";
 import type { GithubIdentityResolution } from "../github/index.js";
+import type { ReviewTransition, ReviewTransitionEffect } from "./transition.js";
 
 export type PullRequestWorkflowInput = {
   author: string;
@@ -57,34 +58,17 @@ export type PullRequestWorkflowDependencies = {
   ): Promise<ReviewerSignal[]>;
   loadState(input: PullRequestWorkflowInput): Promise<ClearanceState | undefined>;
   loadOwnershipTree(input: PullRequestWorkflowInput): Promise<OwnershipTree>;
-  requestReviewers(input: PullRequestWorkflowInput, reviewers: string[]): Promise<void>;
   resolveIdentities(tree: OwnershipTree): Promise<GithubIdentityResolution>;
-  saveState(input: PullRequestWorkflowInput, state: ClearanceState): Promise<void>;
-  sendNotifications(
-    input: PullRequestWorkflowInput,
-    notifications: NotificationRecord[],
-  ): Promise<void>;
-  setStatuses(input: PullRequestWorkflowInput, decisions: CheckDecision[]): Promise<void>;
-  upsertComment(input: PullRequestWorkflowInput, body: string): Promise<void>;
+  /** Resolves only after state and every outgoing effect are durably accepted together. */
+  commitTransition(input: PullRequestWorkflowInput, transition: ReviewTransition): Promise<void>;
 };
 
 export type ReviewerSignal = Pick<ReviewerCandidate, "login"> &
   Partial<Omit<ReviewerCandidate, "id" | "login" | "unavailable">>;
 
-export type WorkflowSideEffectFailure = {
-  message: string;
-  operation: "request-reviewers" | "send-notifications" | "set-statuses" | "upsert-comment";
-};
-
-type WorkflowSideEffect = {
-  execute(): Promise<void>;
-  operation: WorkflowSideEffectFailure["operation"];
-};
-
 export type PullRequestWorkflowResult = {
   changedFiles: string[];
   checks: CheckDecision[];
-  sideEffectFailures: WorkflowSideEffectFailure[];
   requestedReviewers: string[];
   state: ClearanceState;
 };
@@ -163,28 +147,23 @@ export async function processPullRequestChange(
     ].toSorted(compareStrings),
   };
 
-  await dependencies.saveState(input, finalStateWithNotifications);
-
-  const sideEffectFailures = await runWorkflowSideEffects([
-    {
-      execute: () =>
-        dependencies.upsertComment(input, renderClearanceComment(finalStateWithNotifications)),
-      operation: "upsert-comment",
-    },
-    ...getEnforcementSideEffects(
-      input,
-      dependencies,
-      checks,
-      requestedReviewers,
-      pendingNotifications,
-      dryRun,
-    ),
-  ]);
+  const effects: ReviewTransitionEffect[] = [
+    { type: "upsert-comment", body: renderClearanceComment(finalStateWithNotifications) },
+  ];
+  if (!dryRun) {
+    effects.push({ type: "set-statuses", decisions: checks });
+    if (requestedReviewers.length > 0) {
+      effects.push({ type: "request-reviewers", reviewers: requestedReviewers });
+    }
+    if (pendingNotifications.length > 0) {
+      effects.push({ type: "send-notifications", notifications: pendingNotifications });
+    }
+  }
+  await dependencies.commitTransition(input, { state: finalStateWithNotifications, effects });
 
   return {
     changedFiles: context.changedFiles,
     checks,
-    sideEffectFailures,
     requestedReviewers,
     state: finalStateWithNotifications,
   };
@@ -211,20 +190,17 @@ export async function processSubmittedReview(
     reconciledState.override !== undefined,
   );
 
-  await dependencies.saveState(input, reconciledState);
-
-  const sideEffectFailures = await runWorkflowSideEffects([
-    {
-      execute: () => dependencies.upsertComment(input, renderClearanceComment(reconciledState)),
-      operation: "upsert-comment",
-    },
-    ...getSubmittedReviewEnforcementSideEffects(input, dependencies, checks, dryRun),
-  ]);
+  const effects: ReviewTransitionEffect[] = [
+    { type: "upsert-comment", body: renderClearanceComment(reconciledState) },
+  ];
+  if (!dryRun) {
+    effects.push({ type: "set-statuses", decisions: checks });
+  }
+  await dependencies.commitTransition(input, { state: reconciledState, effects });
 
   return {
     changedFiles: context.changedFiles,
     checks,
-    sideEffectFailures,
     requestedReviewers: [],
     state: reconciledState,
   };
@@ -243,52 +219,6 @@ function applyDryRunState(state: ClearanceState, dryRun: boolean): ClearanceStat
   return nextState;
 }
 
-function getEnforcementSideEffects(
-  input: PullRequestWorkflowInput,
-  dependencies: PullRequestWorkflowDependencies,
-  checks: CheckDecision[],
-  requestedReviewers: string[],
-  pendingNotifications: NotificationRecord[],
-  dryRun: boolean,
-): WorkflowSideEffect[] {
-  if (dryRun) {
-    return [];
-  }
-
-  return [
-    {
-      execute: () => dependencies.setStatuses(input, checks),
-      operation: "set-statuses",
-    },
-    {
-      execute: () => dependencies.requestReviewers(input, requestedReviewers),
-      operation: "request-reviewers",
-    },
-    {
-      execute: () => dependencies.sendNotifications(input, pendingNotifications),
-      operation: "send-notifications",
-    },
-  ];
-}
-
-function getSubmittedReviewEnforcementSideEffects(
-  input: PullRequestWorkflowInput,
-  dependencies: PullRequestWorkflowDependencies,
-  checks: CheckDecision[],
-  dryRun: boolean,
-): WorkflowSideEffect[] {
-  if (dryRun) {
-    return [];
-  }
-
-  return [
-    {
-      execute: () => dependencies.setStatuses(input, checks),
-      operation: "set-statuses",
-    },
-  ];
-}
-
 async function loadPreviousState(
   input: PullRequestWorkflowInput,
   dependencies: PullRequestWorkflowDependencies,
@@ -707,30 +637,6 @@ function createWorkflowChecks(
   ];
 }
 
-async function runWorkflowSideEffects(
-  effects: WorkflowSideEffect[],
-): Promise<WorkflowSideEffectFailure[]> {
-  const results = await Promise.all(
-    effects.map(async (effect): Promise<WorkflowSideEffectFailure | undefined> => {
-      try {
-        await effect.execute();
-        return undefined;
-      } catch (error) {
-        return {
-          message: getErrorMessage(error, "unknown error"),
-          operation: effect.operation,
-        };
-      }
-    }),
-  );
-
-  return results.filter((failure): failure is WorkflowSideEffectFailure => failure !== undefined);
-}
-
-function getErrorMessage(error: unknown, fallback: string): string {
-  return error instanceof Error ? error.message : fallback;
-}
-
 function compareStrings(left: string, right: string): number {
   if (left < right) {
     return -1;
diff --git a/src/workflow/transition.ts b/src/workflow/transition.ts
new file mode 100644
index 0000000..55bd898
--- /dev/null
+++ b/src/workflow/transition.ts
@@ -0,0 +1,16 @@
+import type { CheckDecision } from "../checks/index.js";
+import type { NotificationRecord } from "../resolution/index.js";
+import type { ClearanceState } from "../state/index.js";
+
+/** GitHub work accepted with a review-policy state change, executed asynchronously. */
+export type ReviewTransitionEffect =
+  | { type: "upsert-comment"; body: string }
+  | { type: "post-comment"; body: string }
+  | { type: "request-reviewers"; reviewers: string[] }
+  | { type: "set-statuses"; decisions: CheckDecision[] }
+  | { type: "send-notifications"; notifications: NotificationRecord[] };
+
+export type ReviewTransition = {
+  state: ClearanceState;
+  effects: ReviewTransitionEffect[];
+};
diff --git a/test/github/escalation-runner.test.ts b/test/github/escalation-runner.test.ts
index 2f7c52e..1c3dbfc 100644
--- a/test/github/escalation-runner.test.ts
+++ b/test/github/escalation-runner.test.ts
@@ -53,13 +53,12 @@ describe("runGithubEscalationSweep", () => {
         {
           actions: 2,
           pullNumber: 42,
-          sideEffectFailures: 0,
           status: "processed",
         },
       ],
       repository: "acme/clearance",
     });
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           body: "Warn assigned reviewers for and:platform: @alice",
@@ -68,7 +67,7 @@ describe("runGithubEscalationSweep", () => {
         type: "github.post-comment",
       }),
     );
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           reviewers: ["bob"],
@@ -76,7 +75,7 @@ describe("runGithubEscalationSweep", () => {
         type: "github.request-reviewers",
       }),
     );
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           body: expect.stringContaining("<!-- clearance-state:v1"),
@@ -107,7 +106,7 @@ describe("runGithubEscalationSweep", () => {
         status: "skipped",
       },
     ]);
-    expect(stateStore.enqueueOutboxJob).not.toHaveBeenCalled();
+    expect(stateStore.jobs).toEqual([]);
   });
 
   it("saves updated stored Clearance state", async () => {
@@ -144,11 +143,10 @@ describe("runGithubEscalationSweep", () => {
       {
         actions: 1,
         pullNumber: 42,
-        sideEffectFailures: 0,
         status: "processed",
       },
     ]);
-    expect(stateStore.savePullRequestState).toHaveBeenCalledWith(
+    expect(stateStore.savePullRequestTransition).toHaveBeenCalledWith(
       expect.objectContaining({
         owner: "acme",
         pullNumber: 42,
@@ -162,6 +160,7 @@ describe("runGithubEscalationSweep", () => {
           }),
         ],
       }),
+      expect.any(Array),
     );
   });
 
@@ -201,12 +200,11 @@ describe("runGithubEscalationSweep", () => {
       {
         actions: 0,
         pullNumber: 42,
-        sideEffectFailures: 0,
         status: "processed",
       },
     ]);
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledTimes(1);
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toHaveLength(1);
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           body: expect.stringContaining("Dry run mode is active."),
@@ -218,7 +216,7 @@ describe("runGithubEscalationSweep", () => {
 });
 
 type TestEscalationStateStore = GithubEscalationRunnerStateStore & {
-  jobs: Array<Parameters<GithubEscalationRunnerStateStore["enqueueOutboxJob"]>[0]>;
+  jobs: Parameters<GithubEscalationRunnerStateStore["savePullRequestTransition"]>[2];
   savedState?: ClearanceState;
 };
 
@@ -226,15 +224,13 @@ function createStateStore(initialState?: ClearanceState): TestEscalationStateSto
   const jobs: TestEscalationStateStore["jobs"] = [];
   let savedState = initialState;
   const store: TestEscalationStateStore = {
-    enqueueOutboxJob: vi.fn<GithubEscalationRunnerStateStore["enqueueOutboxJob"]>(async (job) => {
-      jobs.push(job);
-    }),
     jobs,
     loadPullRequestState: vi.fn<GithubEscalationRunnerStateStore["loadPullRequestState"]>(
       async () => savedState,
     ),
-    savePullRequestState: vi.fn<GithubEscalationRunnerStateStore["savePullRequestState"]>(
-      async (_input, state) => {
+    savePullRequestTransition: vi.fn<GithubEscalationRunnerStateStore["savePullRequestTransition"]>(
+      async (_input, state, acceptedJobs) => {
+        jobs.push(...acceptedJobs);
         savedState = state;
         store.savedState = state;
       },
diff --git a/test/github/handlers.test.ts b/test/github/handlers.test.ts
index b950314..cbe2768 100644
--- a/test/github/handlers.test.ts
+++ b/test/github/handlers.test.ts
@@ -12,6 +12,7 @@ import {
 } from "../../src/github/handlers.js";
 import { appendReviewThreadMarker } from "../../src/github/index.js";
 import { parseClearanceState, type ClearanceState } from "../../src/state/index.js";
+import { createTransactionalStore } from "../helpers/transactional-store.js";
 
 type GetBlob = GithubWorkflowOctokit["rest"]["git"]["getBlob"];
 type GetTree = GithubWorkflowOctokit["rest"]["git"]["getTree"];
@@ -69,7 +70,7 @@ describe("registerGithubHandlers", () => {
     });
     expect(octokit.rest.issues.createComment).not.toHaveBeenCalled();
     expect(octokit.rest.repos.createCommitStatus).not.toHaveBeenCalled();
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           body: expect.stringContaining("<!-- clearance-state:v1"),
@@ -79,7 +80,7 @@ describe("registerGithubHandlers", () => {
         type: "github.upsert-comment",
       }),
     );
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           reviewers: ["alice"],
@@ -87,7 +88,7 @@ describe("registerGithubHandlers", () => {
         type: "github.request-reviewers",
       }),
     );
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           decisions: expect.arrayContaining([
@@ -102,6 +103,62 @@ describe("registerGithubHandlers", () => {
     );
   });
 
+  it.each(["pull_request", "pull_request_review"] as const)(
+    "retries a failed %s delivery after its durable transition rolls back",
+    async (name) => {
+      vi.spyOn(console, "info").mockImplementation(() => {});
+      vi.spyOn(console, "error").mockImplementation(() => {});
+      const { database, store } = await createTransactionalStore();
+      const recordDelivery = vi.spyOn(store, "recordWebhookDelivery");
+      const octokit = createWorkflowOctokit();
+      const webhooks = new Webhooks({ secret: "test-secret" });
+      registerGithubHandlers(
+        webhooks,
+        { getInstallationOctokit: async () => octokit },
+        createHandlerOptions(store),
+      );
+      const payload = JSON.stringify(
+        name === "pull_request"
+          ? createPullRequestPayload("opened")
+          : createPullRequestReviewPayload("submitted"),
+      );
+      const event = {
+        id: "retry-delivery",
+        name,
+        payload,
+        signature: await webhooks.sign(payload),
+      };
+      const ref = { owner: "acme", repo: "clearance", pullNumber: 42 };
+      await database.exec(
+        "alter table clearance.outbox_jobs add constraint fail_status check (type <> 'github.set-statuses')",
+      );
+
+      await expect(webhooks.verifyAndReceive(event)).rejects.toThrow(/outbox_jobs/);
+      expect(recordDelivery).toHaveBeenLastCalledWith(
+        expect.objectContaining({ deliveryId: "retry-delivery", status: "failed" }),
+      );
+      expect(await store.loadPullRequestState(ref)).toBeUndefined();
+      expect(await store.claimOutboxJobs(10)).toEqual([]);
+
+      await database.exec("alter table clearance.outbox_jobs drop constraint fail_status");
+      await webhooks.verifyAndReceive(event);
+      expect(recordDelivery).toHaveBeenLastCalledWith(
+        expect.objectContaining({ deliveryId: "retry-delivery", status: "processed" }),
+      );
+      expect(await store.loadPullRequestState(ref)).toBeDefined();
+      expect((await store.claimOutboxJobs(10)).map(({ type }) => type).toSorted()).toEqual(
+        name === "pull_request"
+          ? ["github.request-reviewers", "github.set-statuses", "github.upsert-comment"]
+          : ["github.set-statuses", "github.upsert-comment"],
+      );
+      await webhooks.verifyAndReceive(event);
+      expect(await store.claimOutboxJobs(10)).toEqual([]);
+      expect(octokit.rest.issues.createComment).not.toHaveBeenCalled();
+      expect(octokit.rest.repos.createCommitStatus).not.toHaveBeenCalled();
+    },
+    20000,
+  );
+
   it("uses dry-run mode to update only the sticky comment", async () => {
     vi.spyOn(console, "info").mockImplementation(() => {});
     const webhooks = new Webhooks({ secret: "test-secret" });
@@ -125,8 +182,8 @@ describe("registerGithubHandlers", () => {
     } as unknown as EmitterWebhookEvent);
 
     expect(octokit.rest.issues.createComment).not.toHaveBeenCalled();
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledTimes(1);
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toHaveLength(1);
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           body: expect.stringContaining("Dry run mode is active."),
@@ -196,7 +253,7 @@ describe("registerGithubHandlers", () => {
       tree_sha: "head-sha",
     });
     expect(octokit.rest.issues.createComment).not.toHaveBeenCalled();
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           body: expect.stringContaining("<!-- clearance-state:v1"),
@@ -307,7 +364,7 @@ describe("registerGithubHandlers", () => {
       repo: "clearance",
     });
     expect(octokit.rest.repos.createCommitStatus).not.toHaveBeenCalled();
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           decisions: expect.arrayContaining([
@@ -339,7 +396,7 @@ describe("registerGithubHandlers", () => {
     const latestUpsertBody = stateStore.jobs.findLast((job) => job.type === "github.upsert-comment")
       ?.payload.body;
     expect(parseClearanceState(String(latestUpsertBody)).state.override).toBeUndefined();
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           decisions: expect.arrayContaining([
@@ -431,8 +488,8 @@ describe("registerGithubHandlers", () => {
 
     expect(octokit.rest.issues.createComment).not.toHaveBeenCalled();
     expect(octokit.rest.repos.createCommitStatus).not.toHaveBeenCalled();
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledTimes(3);
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toHaveLength(3);
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           body: expect.stringContaining("<!-- clearance-state:v1"),
@@ -442,7 +499,7 @@ describe("registerGithubHandlers", () => {
         type: "github.upsert-comment",
       }),
     );
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           reviewers: ["alice"],
@@ -450,7 +507,7 @@ describe("registerGithubHandlers", () => {
         type: "github.request-reviewers",
       }),
     );
-    expect(stateStore.enqueueOutboxJob).toHaveBeenCalledWith(
+    expect(stateStore.jobs).toContainEqual(
       expect.objectContaining({
         payload: expect.objectContaining({
           decisions: expect.arrayContaining([
@@ -619,7 +676,7 @@ describe("registerGithubHandlers", () => {
 });
 
 type TestStateStore = GithubHandlerStateStore & {
-  jobs: Array<Parameters<GithubHandlerStateStore["enqueueOutboxJob"]>[0]>;
+  jobs: Parameters<GithubHandlerStateStore["savePullRequestTransition"]>[2];
   savedState?: ClearanceState;
 };
 
@@ -635,16 +692,14 @@ function createStateStore(
     beginWebhookDelivery: vi.fn<GithubHandlerStateStore["beginWebhookDelivery"]>(
       options.beginWebhookDelivery ?? (async () => true),
     ),
-    enqueueOutboxJob: vi.fn<GithubHandlerStateStore["enqueueOutboxJob"]>(async (job) => {
-      jobs.push(job);
-    }),
     jobs,
     loadPullRequestState: vi.fn<GithubHandlerStateStore["loadPullRequestState"]>(
       async () => savedState,
     ),
     recordWebhookDelivery: vi.fn<GithubHandlerStateStore["recordWebhookDelivery"]>(async () => {}),
-    savePullRequestState: vi.fn<GithubHandlerStateStore["savePullRequestState"]>(
-      async (_input, state) => {
+    savePullRequestTransition: vi.fn<GithubHandlerStateStore["savePullRequestTransition"]>(
+      async (_input, state, acceptedJobs) => {
+        jobs.push(...acceptedJobs);
         savedState = state;
         store.savedState = state;
       },
diff --git a/test/helpers/transactional-store.ts b/test/helpers/transactional-store.ts
new file mode 100644
index 0000000..b3242e7
--- /dev/null
+++ b/test/helpers/transactional-store.ts
@@ -0,0 +1,26 @@
+import { readFile } from "node:fs/promises";
+import { PGlite } from "@electric-sql/pglite";
+import { drizzle } from "drizzle-orm/pglite";
+import { onTestFinished } from "vitest";
+
+import { DrizzleClearanceStore } from "../../src/db/store.js";
+import * as schema from "../../src/db/schema.js";
+
+export async function createTransactionalStore() {
+  const database = new PGlite();
+  onTestFinished(() => database.close());
+  const migration = await readFile(
+    new URL(
+      "../../supabase/migrations/20260518185844_create_clearance_schema.sql",
+      import.meta.url,
+    ),
+    "utf8",
+  );
+  // PGlite runs PostgreSQL but does not bundle pgcrypto. Its native UUID function is equivalent.
+  await database.exec(
+    migration
+      .replace(/^create extension[^;]+;/, "")
+      .replaceAll("extensions.gen_random_uuid()", "gen_random_uuid()"),
+  );
+  return { database, store: new DrizzleClearanceStore(drizzle(database, { schema })) };
+}
diff --git a/test/workflow/durable-transition.test.ts b/test/workflow/durable-transition.test.ts
new file mode 100644
index 0000000..c1b9a3c
--- /dev/null
+++ b/test/workflow/durable-transition.test.ts
@@ -0,0 +1,181 @@
+import { describe, expect, it } from "vitest";
+
+import { DrizzleClearanceStore } from "../../src/db/store.js";
+import { createTransactionalStore as createStore } from "../helpers/transactional-store.js";
+import { createEmptyClearanceState } from "../../src/state/index.js";
+import { commitGithubReviewTransition } from "../../src/github/review-transition.js";
+import { parseOwnersToml } from "../../src/owners/index.js";
+import {
+  processPullRequestChange,
+  processSubmittedReview,
+  processEscalationRun,
+  buildEscalationRequirementsFromState,
+  type PullRequestWorkflowDependencies,
+} from "../../src/workflow/index.js";
+
+const ref = {
+  author: "author",
+  headSha: "head",
+  labels: [],
+  now: "2026-05-17T12:00:00.000Z",
+  owner: "acme",
+  pullNumber: 42,
+  repo: "clearance",
+  sender: "author",
+};
+
+describe("durable review transitions", () => {
+  it("keeps assignments and notification intent retryable after a rejected outbox insert", async () => {
+    const { database, store } = await createStore();
+    const dependencies = workflowDependencies(store);
+    await database.exec(
+      "alter table clearance.outbox_jobs add constraint fail_notification check (type <> 'github.send-notifications')",
+    );
+
+    await expect(processPullRequestChange(ref, dependencies)).rejects.toThrow(/outbox_jobs/);
+    expect(await store.loadPullRequestState(ref)).toBeUndefined();
+    expect(await store.claimOutboxJobs(10)).toEqual([]);
+
+    await database.exec("alter table clearance.outbox_jobs drop constraint fail_notification");
+    const accepted = await processPullRequestChange(ref, dependencies);
+    expect(accepted.requestedReviewers).toEqual(["alice"]);
+    expect(accepted.state.notificationsSent).toHaveLength(1);
+    expect(await store.loadPullRequestState(ref)).toEqual(accepted.state);
+    expect((await store.claimOutboxJobs(10)).map(({ type }) => type).toSorted()).toEqual([
+      "github.request-reviewers",
+      "github.send-notifications",
+      "github.set-statuses",
+      "github.upsert-comment",
+    ]);
+
+    const repeated = await processPullRequestChange(ref, dependencies);
+    expect(repeated.requestedReviewers).toEqual([]);
+    expect((await store.claimOutboxJobs(10)).map(({ type }) => type).toSorted()).toEqual([
+      "github.set-statuses",
+      "github.upsert-comment",
+    ]);
+  }, 20000);
+
+  it("rolls back an approval when its status job fails and accepts the submitted review on retry", async () => {
+    const { database, store } = await createStore();
+    const dependencies = workflowDependencies(store);
+    const initial = await processPullRequestChange(ref, dependencies);
+    await store.claimOutboxJobs(10);
+    await database.exec(
+      "alter table clearance.outbox_jobs add constraint fail_status check (type <> 'github.set-statuses') not valid",
+    );
+    const review = { ...ref, reviewState: "approved", reviewer: "alice" };
+
+    await expect(processSubmittedReview(review, dependencies)).rejects.toThrow(/outbox_jobs/);
+    expect(await store.loadPullRequestState(ref)).toEqual(initial.state);
+    expect(await store.claimOutboxJobs(10)).toEqual([]);
+
+    await database.exec("alter table clearance.outbox_jobs drop constraint fail_status");
+    const accepted = await processSubmittedReview(review, dependencies);
+    expect(accepted.state.requirements[0]?.status).toBe("approved");
+    expect(await store.loadPullRequestState(ref)).toEqual(accepted.state);
+    expect((await store.claimOutboxJobs(10)).map(({ type }) => type).toSorted()).toEqual([
+      "github.set-statuses",
+      "github.upsert-comment",
+    ]);
+  }, 20000);
+
+  it("keeps escalation due after a rejected reviewer job and records it once on retry", async () => {
+    const { database, store } = await createStore();
+    const initial = {
+      ...createEmptyClearanceState(),
+      requirements: [
+        {
+          approvedBy: [],
+          assignedReviewers: ["alice"],
+          eligibleReviewers: ["alice", "bob"],
+          identity: "and:platform",
+          label: "Platform",
+          pendingSince: "2026-05-17T07:00:00.000Z",
+          requiredCount: 1,
+          status: "pending" as const,
+          type: "and" as const,
+          warnAfter: "1h",
+          escalateAfter: "2h",
+          fallbackAfter: "4h",
+          fallbackTeam: "@org/leads",
+        },
+      ],
+    };
+    await store.savePullRequestTransition(ref, initial, []);
+    const run = async () => {
+      const state = (await store.loadPullRequestState(ref))!;
+      return processEscalationRun(
+        { now: ref.now, requirements: buildEscalationRequirementsFromState(state, ref.now), state },
+        {
+          commitTransition: (transition) =>
+            commitGithubReviewTransition(store, ref, 123, transition),
+        },
+      );
+    };
+    await database.exec(
+      "alter table clearance.outbox_jobs add constraint fail_reviewer check (type <> 'github.request-reviewers')",
+    );
+
+    await expect(run()).rejects.toThrow(/outbox_jobs/);
+    expect(await store.loadPullRequestState(ref)).toEqual(initial);
+    expect(await store.claimOutboxJobs(10)).toEqual([]);
+
+    await database.exec("alter table clearance.outbox_jobs drop constraint fail_reviewer");
+    const accepted = await run();
+    expect(accepted.actions.map(({ type }) => type)).toEqual([
+      "warn",
+      "request_reviewer",
+      "fallback",
+    ]);
+    expect(await store.loadPullRequestState(ref)).toEqual(accepted.state);
+    expect((await store.claimOutboxJobs(10)).map(({ type }) => type).toSorted()).toEqual([
+      "github.post-comment",
+      "github.post-comment",
+      "github.request-reviewers",
+      "github.upsert-comment",
+    ]);
+    expect((await run()).actions).toEqual([]);
+    expect((await store.claimOutboxJobs(10)).map(({ type }) => type)).toEqual([
+      "github.upsert-comment",
+    ]);
+  }, 20000);
+});
+
+function workflowDependencies(store: DrizzleClearanceStore): PullRequestWorkflowDependencies {
+  const parsed = parseOwnersToml(`
+[[rule]]
+paths = ["src/**"]
+require = [{ from = "@alice", count = 1 }]
+[[notify]]
+paths = ["src/**"]
+users = ["@alice"]
+`);
+  if (!parsed.ok) throw new Error("invalid test ownership config");
+  return {
+    listChangedFiles: async () => ["src/index.ts"],
+    listReviewerSignals: async () => [],
+    loadState: (input) => store.loadPullRequestState(input),
+    loadOwnershipTree: async () => ({
+      diagnostics: [],
+      truncated: false,
+      files: [
+        {
+          config: parsed.config,
+          diagnostics: [],
+          directory: ".",
+          path: "OWNERS.toml",
+          sha: "owners",
+        },
+      ],
+    }),
+    resolveIdentities: async () => ({
+      candidateReviewersByTeam: new Map(),
+      diagnostics: [],
+      teams: new Map(),
+      users: new Map([["@alice", { actor: "@alice", id: 1, login: "alice", type: "user" }]]),
+    }),
+    commitTransition: (input, transition) =>
+      commitGithubReviewTransition(store, input, 123, transition),
+  };
+}
diff --git a/test/workflow/escalation.test.ts b/test/workflow/escalation.test.ts
index b7b9434..f929a40 100644
--- a/test/workflow/escalation.test.ts
+++ b/test/workflow/escalation.test.ts
@@ -4,6 +4,7 @@ import {
   buildEscalationRequirementsFromState,
   processEscalationRun,
   type EscalationWorkflowDependencies,
+  type ReviewTransitionEffect,
 } from "../../src/workflow/index.js";
 import { createEmptyClearanceState } from "../../src/state/index.js";
 
@@ -55,17 +56,19 @@ describe("processEscalationRun", () => {
         type: "fallback",
       }),
     ]);
-    expect(dependencies.postComment).toHaveBeenCalledWith(
-      "Warn assigned reviewers for and:platform: @alice",
-    );
-    expect(dependencies.postComment).toHaveBeenCalledWith(
-      "Notify fallback team @org/leads for and:platform: @org/leads",
-    );
-    expect(dependencies.requestReviewers).toHaveBeenCalledWith(["bob"]);
-    expect(dependencies.upsertComment).toHaveBeenCalledWith(
-      expect.stringContaining("<!-- clearance-state:v1"),
-    );
-    expect(result.sideEffectFailures).toEqual([]);
+    expect(dependencies.effects).toContainEqual({
+      type: "post-comment",
+      body: "Warn assigned reviewers for and:platform: @alice",
+    });
+    expect(dependencies.effects).toContainEqual({
+      type: "post-comment",
+      body: "Notify fallback team @org/leads for and:platform: @org/leads",
+    });
+    expect(dependencies.effects).toContainEqual({ type: "request-reviewers", reviewers: ["bob"] });
+    expect(dependencies.effects).toContainEqual({
+      type: "upsert-comment",
+      body: expect.stringContaining("<!-- clearance-state:v1"),
+    });
   });
 
   it("does nothing when no escalation actions are due", async () => {
@@ -93,9 +96,11 @@ describe("processEscalationRun", () => {
     );
 
     expect(result.actions).toEqual([]);
-    expect(dependencies.postComment).not.toHaveBeenCalled();
-    expect(dependencies.requestReviewers).not.toHaveBeenCalled();
-    expect(dependencies.upsertComment).toHaveBeenCalledTimes(1);
+    expect(dependencies.effects.some((effect) => effect.type === "post-comment")).toBe(false);
+    expect(dependencies.effects.some((effect) => effect.type === "request-reviewers")).toBe(false);
+    expect(dependencies.effects.filter((effect) => effect.type === "upsert-comment")).toHaveLength(
+      1,
+    );
   });
 
   it("updates only the sticky comment in dry-run mode", async () => {
@@ -125,44 +130,12 @@ describe("processEscalationRun", () => {
 
     expect(result.actions).toEqual([]);
     expect(result.state.escalations).toEqual([]);
-    expect(dependencies.upsertComment).toHaveBeenCalledWith(
-      expect.stringContaining("Dry run mode is active."),
-    );
-    expect(dependencies.postComment).not.toHaveBeenCalled();
-    expect(dependencies.requestReviewers).not.toHaveBeenCalled();
-  });
-
-  it("returns side effect failures instead of throwing", async () => {
-    const dependencies = createDependencies();
-    dependencies.postComment = vi.fn<EscalationWorkflowDependencies["postComment"]>(async () => {
-      throw new Error("comment unavailable");
+    expect(dependencies.effects).toContainEqual({
+      type: "upsert-comment",
+      body: expect.stringContaining("Dry run mode is active."),
     });
-
-    const result = await processEscalationRun(
-      {
-        now: "2026-05-17T12:00:00.000Z",
-        requirements: [
-          {
-            assignedReviewers: ["alice"],
-            eligibleReviewers: ["alice"],
-            identity: "and:platform",
-            pendingSince: "2026-05-17T07:00:00.000Z",
-            status: "pending",
-            warnAfter: "1h",
-          },
-        ],
-        state: createEmptyClearanceState(),
-      },
-      dependencies,
-    );
-
-    expect(result.sideEffectFailures).toEqual([
-      {
-        message: "comment unavailable",
-        operation: "post-comment",
-      },
-    ]);
-    expect(dependencies.upsertComment).toHaveBeenCalled();
+    expect(dependencies.effects.some((effect) => effect.type === "post-comment")).toBe(false);
+    expect(dependencies.effects.some((effect) => effect.type === "request-reviewers")).toBe(false);
   });
 
   it("builds escalation requirements from persisted state", () => {
@@ -223,11 +196,16 @@ describe("processEscalationRun", () => {
   });
 });
 
-function createDependencies(): EscalationWorkflowDependencies {
-  return {
-    postComment: vi.fn<EscalationWorkflowDependencies["postComment"]>(async () => {}),
-    requestReviewers: vi.fn<EscalationWorkflowDependencies["requestReviewers"]>(async () => {}),
-    saveState: vi.fn<EscalationWorkflowDependencies["saveState"]>(async () => {}),
-    upsertComment: vi.fn<EscalationWorkflowDependencies["upsertComment"]>(async () => {}),
+function createDependencies(): EscalationWorkflowDependencies & {
+  effects: ReviewTransitionEffect[];
+} {
+  const dependencies: EscalationWorkflowDependencies & { effects: ReviewTransitionEffect[] } = {
+    effects: [],
+    commitTransition: vi.fn<EscalationWorkflowDependencies["commitTransition"]>(
+      async (transition) => {
+        dependencies.effects = transition.effects;
+      },
+    ),
   };
+  return dependencies;
 }
diff --git a/test/workflow/pull-request.test.ts b/test/workflow/pull-request.test.ts
index 137c4d8..95471ad 100644
--- a/test/workflow/pull-request.test.ts
+++ b/test/workflow/pull-request.test.ts
@@ -13,6 +13,7 @@ import {
   processSubmittedReview,
   type PullRequestWorkflowDependencies,
   type PullRequestWorkflowInput,
+  type ReviewTransitionEffect,
 } from "../../src/workflow/index.js";
 
 describe("pull request workflow", () => {
@@ -60,12 +61,15 @@ require = [{ from = "@org/platform", count = 1 }]
         reviewers: ["alice"],
       },
     ]);
-    expect(dependencies.upsertComment).toHaveBeenCalledWith(
-      expect.objectContaining({ pullNumber: 42 }),
-      expect.stringContaining("<!-- clearance-state:v1"),
-    );
-    expect(dependencies.setStatuses).toHaveBeenCalledWith(input(), result.checks);
-    expect(dependencies.requestReviewers).toHaveBeenCalledWith(input(), ["alice"]);
+    expect(dependencies.effects).toContainEqual({
+      type: "upsert-comment",
+      body: expect.stringContaining("<!-- clearance-state:v1"),
+    });
+    expect(dependencies.effects).toContainEqual({ type: "set-statuses", decisions: result.checks });
+    expect(dependencies.effects).toContainEqual({
+      type: "request-reviewers",
+      reviewers: ["alice"],
+    });
   });
 
   it("renders the comment only in dry-run mode", async () => {
@@ -96,13 +100,13 @@ users = ["@alice"]
     expect(result.state.assignments).toEqual([]);
     expect(result.state.requirements[0]?.assignedReviewers).toEqual(["alice"]);
     expect(result.state.notificationsSent).toEqual([]);
-    expect(dependencies.upsertComment).toHaveBeenCalledWith(
-      input(),
-      expect.stringContaining("Dry run mode is active."),
-    );
-    expect(dependencies.setStatuses).not.toHaveBeenCalled();
-    expect(dependencies.requestReviewers).not.toHaveBeenCalled();
-    expect(dependencies.sendNotifications).not.toHaveBeenCalled();
+    expect(dependencies.effects).toContainEqual({
+      type: "upsert-comment",
+      body: expect.stringContaining("Dry run mode is active."),
+    });
+    expect(dependencies.effects.some((effect) => effect.type === "set-statuses")).toBe(false);
+    expect(dependencies.effects.some((effect) => effect.type === "request-reviewers")).toBe(false);
+    expect(dependencies.effects.some((effect) => effect.type === "send-notifications")).toBe(false);
 
     const enforcingDependencies = createDependencies({
       changedFiles: ["src/index.ts"],
@@ -118,7 +122,10 @@ require = [{ from = "@org/platform", count = 1 }]
     const enforcingResult = await processPullRequestChange(input(), enforcingDependencies);
 
     expect(enforcingResult.requestedReviewers).toEqual(["alice"]);
-    expect(enforcingDependencies.requestReviewers).toHaveBeenCalledWith(input(), ["alice"]);
+    expect(enforcingDependencies.effects).toContainEqual({
+      type: "request-reviewers",
+      reviewers: ["alice"],
+    });
   });
 
   it("uses reviewer signals before assigning reviewers", async () => {
@@ -193,7 +200,7 @@ require = [{ from = "@org/platform", count = 1 }]
         reviewers: ["alice"],
       },
     ]);
-    expect(dependencies.requestReviewers).toHaveBeenCalledWith(input(), []);
+    expect(dependencies.effects.some((effect) => effect.type === "request-reviewers")).toBe(false);
   });
 
   it("loads previous state from persistence", async () => {
@@ -222,7 +229,7 @@ require = [{ from = "@org/platform", count = 1 }]
     expect(dependencies.loadState).toHaveBeenCalledWith(input());
     expect(result.requestedReviewers).toEqual([]);
     expect(result.state.assignments[0]?.assignedAt).toBe("2026-05-17T10:00:00.000Z");
-    expect(dependencies.saveState).toHaveBeenCalledWith(input(), result.state);
+    expect(dependencies.savedState).toEqual(result.state);
   });
 
   it("sends new notifications once and records them in sticky state", async () => {
@@ -240,13 +247,16 @@ users = ["@alice"]
     const result = await processPullRequestChange(input(), dependencies);
 
     expect(result.state.notificationsSent).toEqual(["notify:.:teams=@org/docs:users=@alice"]);
-    expect(dependencies.sendNotifications).toHaveBeenCalledWith(input(), [
-      expect.objectContaining({
-        identity: "notify:.:teams=@org/docs:users=@alice",
-        teams: ["@org/docs"],
-        users: ["@alice"],
-      }),
-    ]);
+    expect(dependencies.effects).toContainEqual({
+      type: "send-notifications",
+      notifications: [
+        expect.objectContaining({
+          identity: "notify:.:teams=@org/docs:users=@alice",
+          teams: ["@org/docs"],
+          users: ["@alice"],
+        }),
+      ],
+    });
 
     const repeatedDependencies = createDependencies({
       changedFiles: ["docs/readme.md"],
@@ -265,7 +275,9 @@ users = ["@alice"]
     expect(repeatedResult.state.notificationsSent).toEqual([
       "notify:.:teams=@org/docs:users=@alice",
     ]);
-    expect(repeatedDependencies.sendNotifications).toHaveBeenCalledWith(input(), []);
+    expect(
+      repeatedDependencies.effects.some((effect) => effect.type === "send-notifications"),
+    ).toBe(false);
   });
 
   it("stores escalation policy metadata on review requirements", async () => {
@@ -337,7 +349,9 @@ require = [{ from = "@org/platform", count = 1 }]
       description: "All review requirements are satisfied",
       state: "success",
     });
-    expect(reviewDependencies.requestReviewers).not.toHaveBeenCalled();
+    expect(reviewDependencies.effects.some((effect) => effect.type === "request-reviewers")).toBe(
+      false,
+    );
   });
 
   it("revokes submitted approvals when a reviewer requests changes", async () => {
@@ -399,12 +413,12 @@ require = [{ from = "@org/platform", count = 1 }]
     );
 
     expect(result.checks[1]?.state).toBe("success");
-    expect(dependencies.upsertComment).toHaveBeenCalledWith(
-      expect.objectContaining({ pullNumber: 42 }),
-      expect.stringContaining("Dry run mode is active."),
-    );
-    expect(dependencies.setStatuses).not.toHaveBeenCalled();
-    expect(dependencies.requestReviewers).not.toHaveBeenCalled();
+    expect(dependencies.effects).toContainEqual({
+      type: "upsert-comment",
+      body: expect.stringContaining("Dry run mode is active."),
+    });
+    expect(dependencies.effects.some((effect) => effect.type === "set-statuses")).toBe(false);
+    expect(dependencies.effects.some((effect) => effect.type === "request-reviewers")).toBe(false);
 
     const enforcingDependencies = createDependencies({
       changedFiles: ["src/index.ts"],
@@ -420,7 +434,9 @@ require = [{ from = "@org/platform", count = 1 }]
     const enforcingResult = await processPullRequestChange(input(), enforcingDependencies);
 
     expect(enforcingResult.requestedReviewers).toEqual([]);
-    expect(enforcingDependencies.requestReviewers).toHaveBeenCalledWith(input(), []);
+    expect(
+      enforcingDependencies.effects.some((effect) => effect.type === "request-reviewers"),
+    ).toBe(false);
   });
 
   it("sets failing checks and skips reviewer requests for invalid config", async () => {
@@ -553,68 +569,33 @@ teams = ["@org/admins"]
     });
   });
 
-  it("returns side effect failures instead of throwing", async () => {
-    const dependencies = createDependencies({
-      changedFiles: ["src/index.ts"],
-      identityResolution: identityResolution(),
-      ownershipTree: ownershipTree(`
+  it.each(["pull request", "submitted review"])(
+    "rejects a %s when durable acceptance fails",
+    async (event) => {
+      const dependencies = createDependencies({
+        changedFiles: ["src/index.ts"],
+        identityResolution: identityResolution(),
+        ownershipTree: ownershipTree(`
 [[rule]]
 paths = ["src/**"]
 require = [{ from = "@org/platform", count = 1 }]
 `),
-    });
-    dependencies.requestReviewers = vi.fn<PullRequestWorkflowDependencies["requestReviewers"]>(
-      async () => {
-        throw new Error("reviewer API unavailable");
-      },
-    );
-
-    const result = await processPullRequestChange(input(), dependencies);
-
-    expect(result.sideEffectFailures).toEqual([
-      {
-        message: "reviewer API unavailable",
-        operation: "request-reviewers",
-      },
-    ]);
-    expect(result.requestedReviewers).toEqual(["alice"]);
-    expect(dependencies.upsertComment).toHaveBeenCalled();
-    expect(dependencies.setStatuses).toHaveBeenCalled();
-  });
-
-  it("returns submitted-review side effect failures instead of throwing", async () => {
-    const dependencies = createDependencies({
-      changedFiles: ["src/index.ts"],
-      existingComment: approvedComment("head-sha"),
-      identityResolution: identityResolution(),
-      ownershipTree: ownershipTree(`
-[[rule]]
-paths = ["src/**"]
-require = [{ from = "@org/platform", count = 1 }]
-`),
-    });
-    dependencies.setStatuses = vi.fn<PullRequestWorkflowDependencies["setStatuses"]>(async () => {
-      throw new Error("status API unavailable");
-    });
-
-    const result = await processSubmittedReview(
-      {
-        ...input(),
-        reviewState: "approved",
-        reviewer: "alice",
-      },
-      dependencies,
-    );
-
-    expect(result.sideEffectFailures).toEqual([
-      {
-        message: "status API unavailable",
-        operation: "set-statuses",
-      },
-    ]);
-    expect(dependencies.upsertComment).toHaveBeenCalled();
-    expect(dependencies.requestReviewers).not.toHaveBeenCalled();
-  });
+      });
+      dependencies.commitTransition = vi.fn<PullRequestWorkflowDependencies["commitTransition"]>(
+        async () => {
+          throw new Error("database unavailable");
+        },
+      );
+      const result =
+        event === "pull request"
+          ? processPullRequestChange(input(), dependencies)
+          : processSubmittedReview(
+              { ...input(), reviewState: "approved", reviewer: "alice" },
+              dependencies,
+            );
+      await expect(result).rejects.toThrow("database unavailable");
+    },
+  );
 
   it("fails review checks when an OR requirement has no eligible reviewers", async () => {
     const dependencies = createDependencies({
@@ -698,7 +679,10 @@ require_any = [
       },
     ]);
     await processPullRequestChange(input(), dependencies);
-    expect(dependencies.requestReviewers).toHaveBeenCalledWith(input(), ["security-reviewer"]);
+    expect(dependencies.effects).toContainEqual({
+      type: "request-reviewers",
+      reviewers: ["security-reviewer"],
+    });
 
     const reviewDependencies = createDependencies({
       changedFiles: ["src/index.ts"],
@@ -861,7 +845,11 @@ function createDependencies(options: {
   existingState?: ClearanceState;
   identityResolution: GithubIdentityResolution;
   ownershipTree: OwnershipTree;
-}): PullRequestWorkflowDependencies & { savedState?: ClearanceState; upsertedBody?: string } {
+}): PullRequestWorkflowDependencies & {
+  savedState?: ClearanceState;
+  upsertedBody?: string;
+  effects: ReviewTransitionEffect[];
+} {
   let storedState =
     options.existingState ??
     (options.existingComment === undefined
@@ -870,6 +858,7 @@ function createDependencies(options: {
   const dependencies: PullRequestWorkflowDependencies & {
     savedState?: ClearanceState;
     upsertedBody?: string;
+    effects: ReviewTransitionEffect[];
   } = {
     listChangedFiles: vi.fn<PullRequestWorkflowDependencies["listChangedFiles"]>(
       async () => options.changedFiles,
@@ -881,19 +870,20 @@ function createDependencies(options: {
     loadOwnershipTree: vi.fn<PullRequestWorkflowDependencies["loadOwnershipTree"]>(
       async () => options.ownershipTree,
     ),
-    requestReviewers: vi.fn<PullRequestWorkflowDependencies["requestReviewers"]>(async () => {}),
     resolveIdentities: vi.fn<PullRequestWorkflowDependencies["resolveIdentities"]>(
       async () => options.identityResolution,
     ),
-    saveState: vi.fn<PullRequestWorkflowDependencies["saveState"]>(async (_input, state) => {
-      storedState = state;
-      dependencies.savedState = state;
-    }),
-    sendNotifications: vi.fn<PullRequestWorkflowDependencies["sendNotifications"]>(async () => {}),
-    setStatuses: vi.fn<PullRequestWorkflowDependencies["setStatuses"]>(async () => {}),
-    upsertComment: vi.fn<PullRequestWorkflowDependencies["upsertComment"]>(async (_input, body) => {
-      dependencies.upsertedBody = body;
-    }),
+    effects: [],
+    commitTransition: vi.fn<PullRequestWorkflowDependencies["commitTransition"]>(
+      async (_input, transition) => {
+        storedState = transition.state;
+        dependencies.savedState = transition.state;
+        dependencies.effects = transition.effects;
+        dependencies.upsertedBody = transition.effects.find(
+          (effect) => effect.type === "upsert-comment",
+        )?.body;
+      },
+    ),
   };
 
   return dependencies;