diff --git a/apps/code/src/main/services/git/create-pr-flow-saga.ts b/apps/code/src/main/services/git/create-pr-flow-saga.ts
new file mode 100644
index 000000000..e884f9c7a
--- /dev/null
+++ b/apps/code/src/main/services/git/create-pr-flow-saga.ts
@@ -0,0 +1,209 @@
+import { getGitOperationManager } from "@posthog/git/operation-manager";
+import { getHeadSha } from "@posthog/git/queries";
+import { Saga, type SagaLogger } from "@posthog/shared";
+import type { LlmCredentials } from "../llm-gateway/schemas";
+import type {
+  ChangedFile,
+  CommitOutput,
+  CreatePrFlowProgressPayload,
+  CreatePrOutput,
+  GitSyncStatus,
+  PublishOutput,
+  PushOutput,
+} from "./schemas";
+
+export interface CreatePrFlowSagaInput {
+  directoryPath: string;
+  branchName?: string;
+  commitMessage?: string;
+  prTitle?: string;
+  prBody?: string;
+  draft?: boolean;
+  credentials?: LlmCredentials;
+}
+
+export interface CreatePrFlowSagaOutput {
+  prUrl: string | null;
+}
+
+export interface CreatePrFlowDeps {
+  getCurrentBranch(dir: string): Promise<string | null>;
+  createBranch(dir: string, name: string): Promise<void>;
+  checkoutBranch(
+    dir: string,
+    name: string,
+  ): Promise<{ previousBranch: string; currentBranch: string }>;
+  getChangedFilesHead(dir: string): Promise<ChangedFile[]>;
+  generateCommitMessage(
+    dir: string,
+    credentials: LlmCredentials,
+  ): Promise<{ message: string }>;
+  commit(dir: string, message: string): Promise<CommitOutput>;
+  getSyncStatus(dir: string): Promise<GitSyncStatus>;
+  push(dir: string): Promise<PushOutput>;
+  publish(dir: string): Promise<PublishOutput>;
+  generatePrTitleAndBody(
+    dir: string,
+    credentials: LlmCredentials,
+  ): Promise<{ title: string; body: string }>;
+  createPr(
+    dir: string,
+    title?: string,
+    body?: string,
+    draft?: boolean,
+  ): Promise<CreatePrOutput>;
+  onProgress(
+    step: CreatePrFlowProgressPayload["step"],
+    message: string,
+    prUrl?: string,
+  ): void;
+}
+
+export class CreatePrFlowSaga extends Saga<
+  CreatePrFlowSagaInput,
+  CreatePrFlowSagaOutput
+> {
+  readonly sagaName = "CreatePrFlowSaga";
+  private deps: CreatePrFlowDeps;
+
+  constructor(deps: CreatePrFlowDeps, logger?: SagaLogger) {
+    super(logger);
+    this.deps = deps;
+  }
+
+  protected async execute(
+    input: CreatePrFlowSagaInput,
+  ): Promise<CreatePrFlowSagaOutput> {
+    const { directoryPath, draft, credentials } = input;
+    let { commitMessage, prTitle, prBody } = input;
+
+    if (input.branchName) {
+      this.deps.onProgress(
+        "creating-branch",
+        `Creating branch ${input.branchName}...`,
+      );
+
+      const originalBranch = await this.readOnlyStep(
+        "get-original-branch",
+        () => this.deps.getCurrentBranch(directoryPath),
+      );
+
+      await this.step({
+        name: "creating-branch",
+        execute: () => this.deps.createBranch(directoryPath, input.branchName!),
+        rollback: async () => {
+          if (originalBranch) {
+            await this.deps.checkoutBranch(directoryPath, originalBranch);
+          }
+        },
+      });
+    }
+
+    const changedFiles = await this.readOnlyStep("check-changes", () =>
+      this.deps.getChangedFilesHead(directoryPath),
+    );
+
+    if (changedFiles.length > 0) {
+      if (!commitMessage && credentials) {
+        this.deps.onProgress("committing", "Generating commit message...");
+        const generated = await this.readOnlyStep(
+          "generate-commit-message",
+          async () => {
+            try {
+              return await this.deps.generateCommitMessage(
+                directoryPath,
+                credentials,
+              );
+            } catch {
+              return null;
+            }
+          },
+        );
+        if (generated) commitMessage = generated.message;
+      }
+
+      if (!commitMessage) {
+        throw new Error("Commit message is required.");
+      }
+
+      this.deps.onProgress("committing", "Committing changes...");
+
+      const preCommitSha = await this.readOnlyStep("get-pre-commit-sha", () =>
+        getHeadSha(directoryPath),
+      );
+
+      await this.step({
+        name: "committing",
+        execute: async () => {
+          const result = await this.deps.commit(directoryPath, commitMessage!);
+          if (!result.success) throw new Error(result.message);
+          return result;
+        },
+        rollback: async () => {
+          const manager = getGitOperationManager();
+          await manager.executeWrite(directoryPath, (git) =>
+            git.reset(["--soft", preCommitSha]),
+          );
+        },
+      });
+    }
+
+    this.deps.onProgress("pushing", "Pushing to remote...");
+
+    const syncStatus = await this.readOnlyStep("check-sync-status", () =>
+      this.deps.getSyncStatus(directoryPath),
+    );
+
+    await this.step({
+      name: "pushing",
+      execute: async () => {
+        const result = syncStatus.hasRemote
+          ? await this.deps.push(directoryPath)
+          : await this.deps.publish(directoryPath);
+        if (!result.success) throw new Error(result.message);
+        return result;
+      },
+      rollback: async () => {}, // no meaningful rollback can happen here w/o force push
+    });
+
+    if ((!prTitle || !prBody) && credentials) {
+      this.deps.onProgress("creating-pr", "Generating PR description...");
+      const generated = await this.readOnlyStep(
+        "generate-pr-description",
+        async () => {
+          try {
+            return await this.deps.generatePrTitleAndBody(
+              directoryPath,
+              credentials,
+            );
+          } catch {
+            return null;
+          }
+        },
+      );
+      if (generated) {
+        if (!prTitle) prTitle = generated.title;
+        if (!prBody) prBody = generated.body;
+      }
+    }
+
+    this.deps.onProgress("creating-pr", "Creating pull request...");
+
+    const prResult = await this.step({
+      name: "creating-pr",
+      execute: async () => {
+        const result = await this.deps.createPr(
+          directoryPath,
+          prTitle || undefined,
+          prBody || undefined,
+          draft,
+        );
+        if (!result.success) throw new Error(result.message);
+        return result;
+      },
+      rollback: async () => {},
+    });
+
+    return { prUrl: prResult.prUrl };
+  }
+}
diff --git a/apps/code/src/main/services/git/schemas.ts b/apps/code/src/main/services/git/schemas.ts
index 310856ada..36d40b88c 100644
--- a/apps/code/src/main/services/git/schemas.ts
+++ b/apps/code/src/main/services/git/schemas.ts
@@ -414,3 +414,53 @@ export const searchGithubIssuesInput = z.object({
 });
 
 export const searchGithubIssuesOutput = z.array(githubIssueSchema);
+
+export const createPrFlowStep = z.enum([
+  "creating-branch",
+  "committing",
+  "pushing",
+  "creating-pr",
+  "complete",
+  "error",
+]);
+
+export type CreatePrFlowStep = z.infer<typeof createPrFlowStep>;
+
+export const createPrFlowInput = z.object({
+  directoryPath: z.string(),
+  flowId: z.string(),
+  branchName: z.string().optional(),
+  commitMessage: z.string().optional(),
+  prTitle: z.string().optional(),
+  prBody: z.string().optional(),
+  draft: z.boolean().optional(),
+  credentials: z
+    .object({
+      apiKey: z.string(),
+      apiHost: z.string(),
+    })
+    .optional(),
+});
+
+export type CreatePrFlowInput = z.infer<typeof createPrFlowInput>;
+
+export const createPrFlowProgressPayload = z.object({
+  flowId: z.string(),
+  step: createPrFlowStep,
+  message: z.string(),
+  prUrl: z.string().optional(),
+});
+
+export type CreatePrFlowProgressPayload = z.infer<
+  typeof createPrFlowProgressPayload
+>;
+
+export const createPrFlowOutput = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  prUrl: z.string().nullable(),
+  failedStep: createPrFlowStep.nullable(),
+  state: gitStateSnapshotSchema.optional(),
+});
+
+export type CreatePrFlowOutput = z.infer<typeof createPrFlowOutput>;
diff --git a/apps/code/src/main/services/git/service.ts b/apps/code/src/main/services/git/service.ts
index 740071fcf..060446789 100644
--- a/apps/code/src/main/services/git/service.ts
+++ b/apps/code/src/main/services/git/service.ts
@@ -32,10 +32,13 @@ import { logger } from "../../utils/logger";
 import { TypedEventEmitter } from "../../utils/typed-event-emitter";
 import type { LlmCredentials } from "../llm-gateway/schemas";
 import type { LlmGatewayService } from "../llm-gateway/service";
+import { CreatePrFlowSaga } from "./create-pr-flow-saga";
 import type {
   ChangedFile,
   CloneProgressPayload,
   CommitOutput,
+  CreatePrFlowOutput,
+  CreatePrFlowProgressPayload,
   CreatePrOutput,
   DetectRepoResult,
   DiffStats,
@@ -61,10 +64,12 @@ const fsPromises = fs.promises;
 
 export const GitServiceEvent = {
   CloneProgress: "cloneProgress",
+  CreatePrFlowProgress: "createPrFlowProgress",
 } as const;
 
 export interface GitServiceEvents {
   [GitServiceEvent.CloneProgress]: CloneProgressPayload;
+  [GitServiceEvent.CreatePrFlowProgress]: CreatePrFlowProgressPayload;
 }
 
 const log = logger.scope("git-service");
@@ -460,6 +465,91 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
     };
   }
 
+  public async createPrFlow(input: {
+    directoryPath: string;
+    flowId: string;
+    branchName?: string;
+    commitMessage?: string;
+    prTitle?: string;
+    prBody?: string;
+    draft?: boolean;
+    credentials?: { apiKey: string; apiHost: string };
+  }): Promise<CreatePrFlowOutput> {
+    const { directoryPath, flowId } = input;
+
+    const emitProgress = (
+      step: CreatePrFlowProgressPayload["step"],
+      message: string,
+      prUrl?: string,
+    ) => {
+      this.emit(GitServiceEvent.CreatePrFlowProgress, {
+        flowId,
+        step,
+        message,
+        prUrl,
+      });
+    };
+
+    const saga = new CreatePrFlowSaga(
+      {
+        getCurrentBranch: (dir) => getCurrentBranch(dir),
+        createBranch: (dir, name) => this.createBranch(dir, name),
+        checkoutBranch: (dir, name) => this.checkoutBranch(dir, name),
+        getChangedFilesHead: (dir) => this.getChangedFilesHead(dir),
+        generateCommitMessage: (dir, creds) =>
+          this.generateCommitMessage(dir, creds),
+        commit: (dir, msg) => this.commit(dir, msg),
+        getSyncStatus: (dir) => this.getGitSyncStatus(dir),
+        push: (dir) => this.push(dir),
+        publish: (dir) => this.publish(dir),
+        generatePrTitleAndBody: (dir, creds) =>
+          this.generatePrTitleAndBody(dir, creds),
+        createPr: (dir, title, body, draft) =>
+          this.createPr(dir, title, body, draft),
+        onProgress: emitProgress,
+      },
+      log,
+    );
+
+    const result = await saga.run({
+      directoryPath,
+      branchName: input.branchName,
+      commitMessage: input.commitMessage,
+      prTitle: input.prTitle,
+      prBody: input.prBody,
+      draft: input.draft,
+      credentials: input.credentials,
+    });
+
+    if (!result.success) {
+      emitProgress("error", result.error);
+      return {
+        success: false,
+        message: result.error,
+        prUrl: null,
+        failedStep: result.failedStep as CreatePrFlowOutput["failedStep"],
+      };
+    }
+
+    const state = await this.getStateSnapshot(directoryPath, {
+      includePrStatus: true,
+    });
+
+    emitProgress(
+      "complete",
+      "Pull request created",
+      result.data.prUrl ?? undefined,
+    );
+
+    return {
+      success: true,
+      message: "Pull request created",
+      prUrl: result.data.prUrl,
+      failedStep: null,
+      state,
+    };
+  }
+
   public async getPrTemplate(
     directoryPath: string,
   ): Promise<GetPrTemplateOutput> {
diff --git a/apps/code/src/main/trpc/routers/git.ts b/apps/code/src/main/trpc/routers/git.ts
index 384bc1c96..b218e934b 100644
--- a/apps/code/src/main/trpc/routers/git.ts
+++ b/apps/code/src/main/trpc/routers/git.ts
@@ -9,6 +9,8 @@ import {
   commitInput,
   commitOutput,
   createBranchInput,
+  createPrFlowInput,
+  createPrFlowOutput,
   createPrInput,
   createPrOutput,
   detectRepoInput,
@@ -301,4 +303,19 @@ export const gitRouter = router({
         input.limit,
       ),
     ),
+
+  createPrFlow: publicProcedure
+    .input(createPrFlowInput)
+    .output(createPrFlowOutput)
+    .mutation(({ input }) => getService().createPrFlow(input)),
+
+  onCreatePrFlowProgress: publicProcedure.subscription(async function* (opts) {
+    const service = getService();
+    const iterable = service.toIterable(GitServiceEvent.CreatePrFlowProgress, {
+      signal: opts.signal,
+    });
+    for await (const data of iterable) {
+      yield data;
+    }
+  }),
 });
diff --git a/apps/code/src/renderer/features/git-interaction/components/CreatePrFlowDialog.stories.tsx b/apps/code/src/renderer/features/git-interaction/components/CreatePrFlowDialog.stories.tsx
new file mode 100644
index 000000000..e97ca2afb
--- /dev/null
+++ b/apps/code/src/renderer/features/git-interaction/components/CreatePrFlowDialog.stories.tsx
@@ -0,0 +1,349 @@
+import { useGitInteractionStore } from "@features/git-interaction/state/gitInteractionStore";
+import type { CreatePrFlowStep } from "@features/git-interaction/types";
+import type { Meta, StoryObj } from "@storybook/react-vite";
+import { CreatePrFlowDialog } from "./CreatePrFlowDialog";
+
+function setStoreState(overrides: {
+  branchName?: string;
+  commitMessage?: string;
+  prTitle?: string;
+  prBody?: string;
+  createPrFlowOpen?: boolean;
+  createPrFlowStep?: CreatePrFlowStep;
+  createPrFlowError?: string | null;
+  createPrFlowNeedsBranch?: boolean;
+  createPrFlowNeedsCommit?: boolean;
+  createPrFlowBaseBranch?: string | null;
+  createPrFlowDraft?: boolean;
+  createPrFlowFailedStep?: CreatePrFlowStep | null;
+  isGeneratingCommitMessage?: boolean;
+  isGeneratingPr?: boolean;
+  isSubmitting?: boolean;
+}) {
+  useGitInteractionStore.setState({
+    branchName: "",
+    commitMessage: "",
+    prTitle: "",
+    prBody: "",
+    createPrFlowOpen: true,
+    createPrFlowStep: "idle",
+    createPrFlowError: null,
+    createPrFlowNeedsBranch: false,
+    createPrFlowNeedsCommit: false,
+    createPrFlowBaseBranch: null,
+    createPrFlowDraft: false,
+    createPrFlowFailedStep: null,
+    isGeneratingCommitMessage: false,
+    isGeneratingPr: false,
+    isSubmitting: false,
+    ...overrides,
+  });
+}
+
+const noop = () => {};
+
+const meta: Meta<typeof CreatePrFlowDialog> = {
+  title: "Git/CreatePrFlowDialog",
+  component: CreatePrFlowDialog,
+  parameters: { layout: "centered" },
+};
+
+export default meta;
+
+export const SetupFull: StoryObj<typeof CreatePrFlowDialog> = {
+  decorators: [
+    (Story) => {
+      setStoreState({
+        createPrFlowNeedsBranch: true,
+        createPrFlowNeedsCommit: true,
+        createPrFlowBaseBranch: "main",
+        branchName: "feature/add-auth",
+      });
+      return <Story />;
+    },
+  ],
+  render: () => (
+    <CreatePrFlowDialog
+      open={true}
+      onOpenChange={noop}
+      currentBranch="main"
+      diffStats={{ filesChanged: 3, linesAdded: 42, linesRemoved: 12 }}
+      isSubmitting={false}
+      onSubmit={noop}
+      onGenerateCommitMessage={noop}
+      onGeneratePr={noop}
+    />
+  ),
+};
+
+export const SetupCommitOnly: StoryObj<typeof CreatePrFlowDialog> = {
+  decorators: [
+    (Story) => {
+      setStoreState({
+        createPrFlowNeedsCommit: true,
+      });
+      return <Story />;
+    },
+  ],
+  render: () => (
+    <CreatePrFlowDialog
+      open={true}
+      onOpenChange={noop}
+      currentBranch="feature/add-auth"
+      diffStats={{ filesChanged: 1, linesAdded: 10, linesRemoved: 2 }}
+      isSubmitting={false}
+      onSubmit={noop}
+      onGenerateCommitMessage={noop}
+      onGeneratePr={noop}
+    />
+  ),
+};
+
+export const SetupPushOnly: StoryObj<typeof CreatePrFlowDialog> = {
+  decorators: [
+    (Story) => {
+      setStoreState({});
+      return <Story />;
+    },
+  ],
+  render: () => (
+    <CreatePrFlowDialog
+      open={true}
+      onOpenChange={noop}
+      currentBranch="feature/add-auth"
+      diffStats={{ filesChanged: 0, linesAdded: 0, linesRemoved: 0 }}
+      isSubmitting={false}
+      onSubmit={noop}
+      onGenerateCommitMessage={noop}
+      onGeneratePr={noop}
+    />
+  ),
+};
+
+export const SetupWithDraft: StoryObj<typeof CreatePrFlowDialog> = {
+  decorators: [
+    (Story) => {
+      setStoreState({
+        createPrFlowNeedsCommit: true,
+        createPrFlowDraft: true,
+        prTitle: "Add user authentication",
+        prBody: "Closes #123",
+      });
+      return <Story />;
+    },
+  ],
+  render: () => (
+    <CreatePrFlowDialog
+      open={true}
+      onOpenChange={noop}
+      currentBranch="feature/add-auth"
+      diffStats={{ filesChanged: 3, linesAdded: 42, linesRemoved: 12 }}
+      isSubmitting={false}
+      onSubmit={noop}
+      onGenerateCommitMessage={noop}
+      onGeneratePr={noop}
+    />
+  ),
+};
+
+export const SetupWithError: StoryObj<typeof CreatePrFlowDialog> = {
+  decorators: [
+    (Story) => {
+      setStoreState({
+        createPrFlowNeedsBranch: true,
+        createPrFlowError: "Branch name is required.",
+      });
+      return <Story />;
+    },
+  ],
+  render: () => (
+    <CreatePrFlowDialog
+      open={true}
+      onOpenChange={noop}
+      currentBranch="main"
+      diffStats={{ filesChanged: 1, linesAdded: 5, linesRemoved: 0 }}
+      isSubmitting={false}
+      onSubmit={noop}
+      onGenerateCommitMessage={noop}
+      onGeneratePr={noop}
+    />
+  ),
+};
+
+export const SetupGeneratingCommitMessage: StoryObj<typeof CreatePrFlowDialog> =
+  {
+    decorators: [
+      (Story) => {
+        setStoreState({
+          createPrFlowNeedsCommit: true,
+          isGeneratingCommitMessage: true,
+        });
+        return <Story />;
+      },
+    ],
+    render: () => (
+      <CreatePrFlowDialog
+        open={true}
+        onOpenChange={noop}
+        currentBranch="feature/add-auth"
+        diffStats={{ filesChanged: 3, linesAdded: 42, linesRemoved: 12 }}
+        isSubmitting={false}
+        onSubmit={noop}
+        onGenerateCommitMessage={noop}
+        onGeneratePr={noop}
+      />
+    ),
+  };
+
+export const SetupGeneratingPr: StoryObj<typeof CreatePrFlowDialog> = {
+  decorators: [
+    (Story) => {
+      setStoreState({
+        createPrFlowNeedsCommit: true,
+        isGeneratingPr: true,
+      });
+      return <Story />;
+    },
+  ],
+  render: () => (
+    <CreatePrFlowDialog
+      open={true}
+      onOpenChange={noop}
+      currentBranch="feature/add-auth"
+      diffStats={{ filesChanged: 3, linesAdded: 42, linesRemoved: 12 }}
+      isSubmitting={false}
+      onSubmit={noop}
+      onGenerateCommitMessage={noop}
+      onGeneratePr={noop}
+    />
+  ),
+};
+
+export const ExecutingCreatingBranch: StoryObj<typeof CreatePrFlowDialog> = {
+  decorators: [
+    (Story) => {
+      setStoreState({
+        createPrFlowNeedsBranch: true,
+        createPrFlowNeedsCommit: true,
+        createPrFlowStep: "creating-branch",
+        branchName: "feature/add-auth",
+      });
+      return <Story />;
+    },
+  ],
+  render: () => (
+    <CreatePrFlowDialog
+      open={true}
+      onOpenChange={noop}
+      currentBranch="main"
+      diffStats={{ filesChanged: 3, linesAdded: 42, linesRemoved: 12 }}
+      isSubmitting={true}
+      onSubmit={noop}
+      onGenerateCommitMessage={noop}
+      onGeneratePr={noop}
+    />
+  ),
+};
+
+export const ExecutingCommitting: StoryObj<typeof CreatePrFlowDialog> = {
+  decorators: [
+    (Story) => {
+      setStoreState({
+        createPrFlowNeedsBranch: true,
+        createPrFlowNeedsCommit: true,
+        createPrFlowStep: "committing",
+        branchName: "feature/add-auth",
+      });
+      return <Story />;
+    },
+  ],
+  render: () => (
+    <CreatePrFlowDialog
+      open={true}
+      onOpenChange={noop}
+      currentBranch="main"
+      diffStats={{ filesChanged: 3, linesAdded: 42, linesRemoved: 12 }}
+      isSubmitting={true}
+      onSubmit={noop}
+      onGenerateCommitMessage={noop}
+      onGeneratePr={noop}
+    />
+  ),
+};
+
+export const ExecutingPushing: StoryObj<typeof CreatePrFlowDialog> = {
+  decorators: [
+    (Story) => {
+      setStoreState({
+        createPrFlowNeedsCommit: true,
+        createPrFlowStep: "pushing",
+      });
+      return <Story />;
+    },
+  ],
+  render: () => (
+    <CreatePrFlowDialog
+      open={true}
+      onOpenChange={noop}
+      currentBranch="feature/add-auth"
+      diffStats={{ filesChanged: 3, linesAdded: 42, linesRemoved: 12 }}
+      isSubmitting={true}
+      onSubmit={noop}
+      onGenerateCommitMessage={noop}
+      onGeneratePr={noop}
+    />
+  ),
+};
+
+export const ExecutingCreatingPr: StoryObj<typeof CreatePrFlowDialog> = {
+  decorators: [
+    (Story) => {
+      setStoreState({
+        createPrFlowNeedsCommit: true,
+        createPrFlowStep: "creating-pr",
+      });
+      return <Story />;
+    },
+  ],
+  render: () => (
+    <CreatePrFlowDialog
+      open={true}
+      onOpenChange={noop}
+      currentBranch="feature/add-auth"
+      diffStats={{ filesChanged: 3, linesAdded: 42, linesRemoved: 12 }}
+      isSubmitting={true}
+      onSubmit={noop}
+      onGenerateCommitMessage={noop}
+      onGeneratePr={noop}
+    />
+  ),
+};
+
+export const ExecutingError: StoryObj<typeof CreatePrFlowDialog> = {
+  decorators: [
+    (Story) => {
+      setStoreState({
+        createPrFlowNeedsBranch: true,
+        createPrFlowNeedsCommit: true,
+        createPrFlowStep: "error",
+        createPrFlowError:
+          "Failed to push: remote rejected (permission denied)",
+        createPrFlowFailedStep: "pushing",
+        branchName: "feature/add-auth",
+      });
+      return <Story />;
+    },
+  ],
+  render: () => (
+    <CreatePrFlowDialog
+      open={true}
+      onOpenChange={noop}
+      currentBranch="main"
+      diffStats={{ filesChanged: 3, linesAdded: 42, linesRemoved: 12 }}
+      isSubmitting={false}
+      onSubmit={noop}
+      onGenerateCommitMessage={noop}
+      onGeneratePr={noop}
+    />
+  ),
+};
diff --git a/apps/code/src/renderer/features/git-interaction/components/CreatePrFlowDialog.tsx b/apps/code/src/renderer/features/git-interaction/components/CreatePrFlowDialog.tsx
new file mode 100644
index 000000000..723e87850
--- /dev/null
+++ b/apps/code/src/renderer/features/git-interaction/components/CreatePrFlowDialog.tsx
@@ -0,0 +1,323 @@
+import {
+  ErrorContainer,
+  GenerateButton,
+} from "@features/git-interaction/components/GitInteractionDialogs";
+import { useGitInteractionStore } from "@features/git-interaction/state/gitInteractionStore";
+import type { CreatePrFlowStep } from "@features/git-interaction/types";
+import {
+  CheckCircle,
+  Circle,
+  GitPullRequest,
+  XCircle,
+} from "@phosphor-icons/react";
+import {
+  Button,
+  Checkbox,
+  Dialog,
+  Flex,
+  Spinner,
+  Text,
+  TextArea,
+  TextField,
+} from "@radix-ui/themes";
+
+const ICON_SIZE = 14;
+
+interface StepDef {
+  id: CreatePrFlowStep;
+  label: string;
+}
+
+function StepIndicator({
+  steps,
+  currentStep,
+  failedStep,
+}: {
+  steps: StepDef[];
+  currentStep: CreatePrFlowStep;
+  failedStep?: CreatePrFlowStep | null;
+}) {
+  const stepOrder: CreatePrFlowStep[] = [
+    "creating-branch",
+    "committing",
+    "pushing",
+    "creating-pr",
+    "complete",
+  ];
+
+  const currentIndex = stepOrder.indexOf(currentStep);
+  const isError = currentStep === "error";
+
+  return (
+    <Flex direction="column" gap="3">
+      {steps.map((step) => {
+        const stepIndex = stepOrder.indexOf(step.id);
+        const isComplete =
+          currentStep === "complete" || stepIndex < currentIndex;
+        const isActive = step.id === currentStep;
+        const isFailed = isError && step.id === failedStep;
+
+        let icon: React.ReactNode;
+        if (isFailed) {
+          icon = <XCircle size={16} weight="fill" color="var(--red-9)" />;
+        } else if (isComplete) {
+          icon = <CheckCircle size={16} weight="fill" color="var(--green-9)" />;
+        } else if (isActive) {
+          icon = <Spinner size="1" />;
+        } else {
+          icon = <Circle size={16} color="var(--gray-6)" />;
+        }
+
+        return (
+          <Flex
+            key={step.id}
+            align="center"
+            gap="2"
+            style={{
+              transition: "opacity 150ms ease",
+              opacity: isComplete ? 0.6 : 1,
+            }}
+          >
+            <Flex
+              style={{
+                transition: "transform 200ms ease",
+                transform: isActive ? "scale(1.15)" : "scale(1)",
+              }}
+            >
+              {icon}
+            </Flex>
+            <Text
+              size="2"
+              weight={isActive ? "medium" : "regular"}
+              style={{
+                transition: "color 150ms ease",
+                color: isFailed
+                  ? "var(--red-11)"
+                  : isComplete
+                    ? "var(--green-11)"
+                    : isActive
+                      ? "var(--gray-12)"
+                      : "var(--gray-9)",
+              }}
+            >
+              {step.label}
+            </Text>
+          </Flex>
+        );
+      })}
+    </Flex>
+  );
+}
+
+export interface CreatePrFlowDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  currentBranch: string | null;
+  diffStats: { filesChanged: number; linesAdded: number; linesRemoved: number };
+  isSubmitting: boolean;
+  onSubmit: () => void;
+  onGenerateCommitMessage: () => void;
+  onGeneratePr: () => void;
+}
+
+export function CreatePrFlowDialog({
+  open,
+  onOpenChange,
+  currentBranch,
+  diffStats,
+  isSubmitting,
+  onSubmit,
+  onGenerateCommitMessage,
+  onGeneratePr,
+}: CreatePrFlowDialogProps) {
+  const store = useGitInteractionStore();
+  const { actions } = store;
+
+  const { createPrFlowStep: step } = store;
+  const isExecuting = step !== "idle" && step !== "complete";
+
+  // Build the step list based on what's needed
+  const steps: StepDef[] = [];
+  if (store.createPrFlowNeedsBranch) {
+    steps.push({
+      id: "creating-branch",
+      label: `Create branch ${store.branchName || ""}`.trim(),
+    });
+  }
+  if (store.createPrFlowNeedsCommit) {
+    steps.push({ id: "committing", label: "Commit changes" });
+  }
+  steps.push({ id: "pushing", label: "Push to remote" });
+  steps.push({ id: "creating-pr", label: "Create pull request" });
+
+  return (
+    <Dialog.Root open={open} onOpenChange={onOpenChange}>
+      <Dialog.Content maxWidth="500px" size="1">
+        <Flex direction="column" gap="3">
+          <Flex align="center" gap="2">
+            <GitPullRequest size={ICON_SIZE} />
+            <Text size="2" weight="medium">
+              {isExecuting ? "Creating PR..." : "Create PR"}
+            </Text>
+          </Flex>
+
+          {!isExecuting && (
+            <>
+              {store.createPrFlowNeedsBranch && (
+                <Flex direction="column" gap="1">
+                  <Text size="1" color="gray">
+                    Branch
+                  </Text>
+                  <TextField.Root
+                    value={store.branchName}
+                    onChange={(e) => actions.setBranchName(e.target.value)}
+                    placeholder="branch-name"
+                    size="1"
+                    autoFocus
+                  />
+                  {currentBranch && (
+                    <Text size="1" color="gray">
+                      from {currentBranch}
+                    </Text>
+                  )}
+                </Flex>
+              )}
+
+              {store.createPrFlowNeedsCommit && (
+                <Flex direction="column" gap="1">
+                  <Flex align="center" justify="between">
+                    <Text size="1" color="gray">
+                      Commit message
+                    </Text>
+                    <Flex align="center" gap="2">
+                      <Text size="1" color="gray">
+                        {diffStats.filesChanged} file
+                        {diffStats.filesChanged === 1 ? "" : "s"}
+                      </Text>
+                      <Text size="1" color="green">
+                        +{diffStats.linesAdded}
+                      </Text>
+                      <Text size="1" color="red">
+                        -{diffStats.linesRemoved}
+                      </Text>
+                      <GenerateButton
+                        onClick={onGenerateCommitMessage}
+                        isGenerating={store.isGeneratingCommitMessage}
+                      />
+                    </Flex>
+                  </Flex>
+                  <TextArea
+                    value={store.commitMessage}
+                    onChange={(e) => actions.setCommitMessage(e.target.value)}
+                    placeholder="Leave empty to generate"
+                    size="1"
+                    rows={1}
+                    disabled={store.isGeneratingCommitMessage}
+                    autoFocus={!store.createPrFlowNeedsBranch}
+                  />
+                </Flex>
+              )}
+
+              <Flex direction="column" gap="1">
+                <Flex align="center" justify="between">
+                  <Text size="1" color="gray">
+                    PR title
+                  </Text>
+                  <GenerateButton
+                    onClick={onGeneratePr}
+                    isGenerating={store.isGeneratingPr}
+                  />
+                </Flex>
+                <TextField.Root
+                  value={store.prTitle}
+                  onChange={(e) => actions.setPrTitle(e.target.value)}
+                  placeholder="Leave empty to generate"
+                  size="1"
+                  disabled={store.isGeneratingPr}
+                  autoFocus={
+                    !store.createPrFlowNeedsBranch &&
+                    !store.createPrFlowNeedsCommit
+                  }
+                />
+              </Flex>
+
+              <Flex direction="column" gap="1">
+                <Text size="1" color="gray">
+                  Description
+                </Text>
+                <TextArea
+                  value={store.prBody}
+                  onChange={(e) => actions.setPrBody(e.target.value)}
+                  placeholder="Leave empty to generate"
+                  size="1"
+                  rows={4}
+                  disabled={store.isGeneratingPr}
+                />
+              </Flex>
+
+              <Text as="label" size="1" color="gray">
+                <Flex gap="2" align="center">
+                  <Checkbox
+                    size="1"
+                    checked={store.createPrFlowDraft}
+                    onCheckedChange={(checked) =>
+                      actions.setCreatePrFlowDraft(checked === true)
+                    }
+                  />
+                  Create as draft
+                </Flex>
+              </Text>
+
+              {store.createPrFlowError && (
+                <ErrorContainer error={store.createPrFlowError} />
+              )}
+
+              <Flex gap="2" justify="end">
+                <Dialog.Close>
+                  <Button size="1" variant="soft" color="gray">
+                    Cancel
+                  </Button>
+                </Dialog.Close>
+                <Button
+                  size="1"
+                  disabled={isSubmitting}
+                  loading={isSubmitting}
+                  onClick={onSubmit}
+                >
+                  Create PR
+                </Button>
+              </Flex>
+            </>
+          )}
+
+          {isExecuting && (
+            <>
+              <StepIndicator
+                steps={steps}
+                currentStep={step}
+                failedStep={store.createPrFlowFailedStep}
+              />
+
+              {step === "error" && store.createPrFlowError && (
+                <ErrorContainer error={store.createPrFlowError} />
+              )}
+
+              <Flex gap="2" justify="end">
+                <Dialog.Close>
+                  <Button size="1" variant="soft" color="gray">
+                    {step === "error" ? "Close" : "Cancel"}
+                  </Button>
+                </Dialog.Close>
+                {step === "error" && (
+                  <Button size="1" onClick={onSubmit}>
+                    Retry
+                  </Button>
+                )}
+              </Flex>
+            </>
+          )}
+        </Flex>
+      </Dialog.Content>
+    </Dialog.Root>
+  );
+}
diff --git a/apps/code/src/renderer/features/git-interaction/components/GitInteractionDialogs.stories.tsx b/apps/code/src/renderer/features/git-interaction/components/GitInteractionDialogs.stories.tsx
index 7dbaf6a2a..e358f9998 100644
--- a/apps/code/src/renderer/features/git-interaction/components/GitInteractionDialogs.stories.tsx
+++ b/apps/code/src/renderer/features/git-interaction/components/GitInteractionDialogs.stories.tsx
@@ -1,10 +1,6 @@
 import { Flex } from "@radix-ui/themes";
 import type { Meta, StoryObj } from "@storybook/react-vite";
-import {
-  GitCommitDialog,
-  GitPrDialog,
-  GitPushDialog,
-} from "./GitInteractionDialogs";
+import { GitCommitDialog, GitPushDialog } from "./GitInteractionDialogs";
 
 function DialogShowcase() {
   return <Flex direction="column" gap="4" />;
@@ -29,7 +25,6 @@ export const CommitDefault: StoryObj<typeof GitCommitDialog> = {
       onCommitMessageChange={() => {}}
       nextStep="commit"
       onNextStepChange={() => {}}
-      prDisabledReason={null}
       pushDisabledReason={null}
       onContinue={() => {}}
       isSubmitting={false}
@@ -51,29 +46,6 @@ export const CommitWithMessage: StoryObj<typeof GitCommitDialog> = {
       onCommitMessageChange={() => {}}
       nextStep="commit-push"
       onNextStepChange={() => {}}
-      prDisabledReason={null}
-      pushDisabledReason={null}
-      onContinue={() => {}}
-      isSubmitting={false}
-      error={null}
-      onGenerateMessage={() => {}}
-      isGeneratingMessage={false}
-    />
-  ),
-};
-
-export const CommitPrDisabled: StoryObj<typeof GitCommitDialog> = {
-  render: () => (
-    <GitCommitDialog
-      open={true}
-      onOpenChange={() => {}}
-      branchName="main"
-      diffStats={{ filesChanged: 1, linesAdded: 10, linesRemoved: 2 }}
-      commitMessage="Fix typo"
-      onCommitMessageChange={() => {}}
-      nextStep="commit"
-      onNextStepChange={() => {}}
-      prDisabledReason="Checkout a feature branch to create PRs."
       pushDisabledReason={null}
       onContinue={() => {}}
       isSubmitting={false}
@@ -95,7 +67,6 @@ export const CommitSubmitting: StoryObj<typeof GitCommitDialog> = {
       onCommitMessageChange={() => {}}
       nextStep="commit"
       onNextStepChange={() => {}}
-      prDisabledReason={null}
       pushDisabledReason={null}
       onContinue={() => {}}
       isSubmitting={true}
@@ -117,7 +88,6 @@ export const CommitWithError: StoryObj<typeof GitCommitDialog> = {
       onCommitMessageChange={() => {}}
       nextStep="commit"
       onNextStepChange={() => {}}
-      prDisabledReason={null}
       pushDisabledReason={null}
       onContinue={() => {}}
       isSubmitting={false}
@@ -139,7 +109,6 @@ export const CommitWithLongPreCommitError: StoryObj<typeof GitCommitDialog> = {
       onCommitMessageChange={() => {}}
       nextStep="commit"
       onNextStepChange={() => {}}
-      prDisabledReason={null}
       pushDisabledReason={null}
       onContinue={() => {}}
       isSubmitting={false}
@@ -172,7 +141,6 @@ export const CommitGenerating: StoryObj<typeof GitCommitDialog> = {
       onCommitMessageChange={() => {}}
       nextStep="commit"
       onNextStepChange={() => {}}
-      prDisabledReason={null}
       pushDisabledReason={null}
       onContinue={() => {}}
       isSubmitting={false}
@@ -310,103 +278,3 @@ export const PublishSuccess: StoryObj<typeof GitPushDialog> = {
     />
   ),
 };
-
-export const PrCreate: StoryObj<typeof GitPrDialog> = {
-  render: () => (
-    <GitPrDialog
-      open={true}
-      onOpenChange={() => {}}
-      baseBranch="main"
-      headBranch="feature/add-auth"
-      title="Add user authentication"
-      onTitleChange={() => {}}
-      body="Closes #123\n\nAdded login and signup flows."
-      onBodyChange={() => {}}
-      onConfirm={() => {}}
-      isSubmitting={false}
-      error={null}
-      onGenerate={() => {}}
-      isGenerating={false}
-    />
-  ),
-};
-
-export const PrCreateEmpty: StoryObj<typeof GitPrDialog> = {
-  render: () => (
-    <GitPrDialog
-      open={true}
-      onOpenChange={() => {}}
-      baseBranch="main"
-      headBranch="feature/add-auth"
-      title=""
-      onTitleChange={() => {}}
-      body=""
-      onBodyChange={() => {}}
-      onConfirm={() => {}}
-      isSubmitting={false}
-      error={null}
-      onGenerate={() => {}}
-      isGenerating={false}
-    />
-  ),
-};
-
-export const PrGenerating: StoryObj<typeof GitPrDialog> = {
-  render: () => (
-    <GitPrDialog
-      open={true}
-      onOpenChange={() => {}}
-      baseBranch="main"
-      headBranch="feature/add-auth"
-      title=""
-      onTitleChange={() => {}}
-      body=""
-      onBodyChange={() => {}}
-      onConfirm={() => {}}
-      isSubmitting={false}
-      error={null}
-      onGenerate={() => {}}
-      isGenerating={true}
-    />
-  ),
-};
-
-export const PrSubmitting: StoryObj<typeof GitPrDialog> = {
-  render: () => (
-    <GitPrDialog
-      open={true}
-      onOpenChange={() => {}}
-      baseBranch="main"
-      headBranch="feature/add-auth"
-      title="Add user authentication"
-      onTitleChange={() => {}}
-      body="Added login flow"
-      onBodyChange={() => {}}
-      onConfirm={() => {}}
-      isSubmitting={true}
-      error={null}
-      onGenerate={() => {}}
-      isGenerating={false}
-    />
-  ),
-};
-
-export const PrWithError: StoryObj<typeof GitPrDialog> = {
-  render: () => (
-    <GitPrDialog
-      open={true}
-      onOpenChange={() => {}}
-      baseBranch="main"
-      headBranch="feature/add-auth"
-      title="Add user authentication"
-      onTitleChange={() => {}}
-      body="Added login flow"
-      onBodyChange={() => {}}
-      onConfirm={() => {}}
-      isSubmitting={false}
-      error="Failed to create PR: no commits between main and feature/add-auth"
-      onGenerate={() => {}}
-      isGenerating={false}
-    />
-  ),
-};
diff --git a/apps/code/src/renderer/features/git-interaction/components/GitInteractionDialogs.tsx b/apps/code/src/renderer/features/git-interaction/components/GitInteractionDialogs.tsx
index 9b44a4790..9240d0501 100644
--- a/apps/code/src/renderer/features/git-interaction/components/GitInteractionDialogs.tsx
+++ b/apps/code/src/renderer/features/git-interaction/components/GitInteractionDialogs.tsx
@@ -6,7 +6,6 @@ import {
   GitBranch,
   GitCommit,
   GitFork,
-  GitPullRequest,
   Sparkle,
 } from "@phosphor-icons/react";
 import { CheckIcon } from "@radix-ui/react-icons";
@@ -26,7 +25,7 @@ import { useState } from "react";
 
 const ICON_SIZE = 14;
 
-function ErrorContainer({ error }: { error: string }) {
+export function ErrorContainer({ error }: { error: string }) {
   const [copied, setCopied] = useState(false);
 
   const handleCopy = async () => {
@@ -75,6 +74,32 @@ function ErrorContainer({ error }: { error: string }) {
   );
 }
 
+export function GenerateButton({
+  onClick,
+  isGenerating,
+  disabled = false,
+  tooltip = "Generate with AI",
+}: {
+  onClick: () => void;
+  isGenerating: boolean;
+  disabled?: boolean;
+  tooltip?: string;
+}) {
+  return (
+    <Tooltip content={tooltip}>
+      <IconButton
+        size="1"
+        variant="ghost"
+        color="gray"
+        onClick={onClick}
+        disabled={isGenerating || disabled}
+      >
+        {isGenerating ? <Spinner size="1" /> : <Sparkle size={14} />}
+      </IconButton>
+    </Tooltip>
+  );
+}
+
 interface GitDialogProps {
   open: boolean;
   onOpenChange: (open: boolean) => void;
@@ -221,9 +246,8 @@ interface GitCommitDialogProps {
   diffStats: { filesChanged: number; linesAdded: number; linesRemoved: number };
   commitMessage: string;
   onCommitMessageChange: (value: string) => void;
-  nextStep: "commit" | "commit-push" | "commit-pr";
-  onNextStepChange: (value: "commit" | "commit-push" | "commit-pr") => void;
-  prDisabledReason: string | null;
+  nextStep: "commit" | "commit-push";
+  onNextStepChange: (value: "commit" | "commit-push") => void;
   pushDisabledReason: string | null;
   onContinue: () => void;
   isSubmitting: boolean;
@@ -241,7 +265,6 @@ export function GitCommitDialog({
   onCommitMessageChange,
   nextStep,
   onNextStepChange,
-  prDisabledReason,
   pushDisabledReason,
   onContinue,
   isSubmitting,
@@ -261,12 +284,6 @@ export function GitCommitDialog({
       icon: <CloudArrowUp size={ICON_SIZE} />,
       disabledReason: pushDisabledReason,
     },
-    {
-      id: "commit-pr" as const,
-      label: "Commit and create PR",
-      icon: <GitPullRequest size={ICON_SIZE} />,
-      disabledReason: prDisabledReason,
-    },
   ];
 
   return (
@@ -306,21 +323,12 @@ export function GitCommitDialog({
           <Text size="1" color="gray">
             Message
           </Text>
-          <Tooltip content="Generate commit message with AI">
-            <IconButton
-              size="1"
-              variant="ghost"
-              color="gray"
-              onClick={onGenerateMessage}
-              disabled={isGeneratingMessage || isSubmitting}
-            >
-              {isGeneratingMessage ? (
-                <Spinner size="1" />
-              ) : (
-                <Sparkle size={14} />
-              )}
-            </IconButton>
-          </Tooltip>
+          <GenerateButton
+            onClick={onGenerateMessage}
+            isGenerating={isGeneratingMessage}
+            disabled={isSubmitting}
+            tooltip="Generate commit message with AI"
+          />
         </Flex>
         <TextArea
           value={commitMessage}
@@ -433,103 +441,6 @@ export function GitPushDialog({
   );
 }
 
-interface GitPrDialogProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  baseBranch: string | null;
-  headBranch: string | null;
-  title: string;
-  onTitleChange: (value: string) => void;
-  body: string;
-  onBodyChange: (value: string) => void;
-  onConfirm: () => void;
-  isSubmitting: boolean;
-  error: string | null;
-  onGenerate: () => void;
-  isGenerating: boolean;
-}
-
-export function GitPrDialog({
-  open,
-  onOpenChange,
-  baseBranch,
-  headBranch,
-  title,
-  onTitleChange,
-  body,
-  onBodyChange,
-  onConfirm,
-  isSubmitting,
-  error,
-  onGenerate,
-  isGenerating,
-}: GitPrDialogProps) {
-  return (
-    <GitDialog
-      open={open}
-      onOpenChange={onOpenChange}
-      icon={<GitPullRequest size={ICON_SIZE} />}
-      title="Create PR"
-      error={error}
-      buttonLabel="Create PR"
-      buttonDisabled={!title.trim() || isGenerating}
-      isSubmitting={isSubmitting}
-      onSubmit={onConfirm}
-      maxWidth="500px"
-    >
-      <Flex direction="column" gap="1">
-        <InfoRow label="Base">
-          <BranchBadge branch={baseBranch} />
-        </InfoRow>
-        <InfoRow label="Head">
-          <BranchBadge branch={headBranch} />
-        </InfoRow>
-      </Flex>
-
-      <Flex direction="column" gap="1">
-        <Flex align="center" justify="between">
-          <Text size="1" color="gray">
-            Title
-          </Text>
-          <Tooltip content="Generate title and description with AI">
-            <IconButton
-              size="1"
-              variant="ghost"
-              color="gray"
-              onClick={onGenerate}
-              disabled={isGenerating || isSubmitting}
-            >
-              {isGenerating ? <Spinner size="1" /> : <Sparkle size={14} />}
-            </IconButton>
-          </Tooltip>
-        </Flex>
-        <TextField.Root
-          value={title}
-          onChange={(e) => onTitleChange(e.target.value)}
-          placeholder={isGenerating ? "Generating..." : "PR title"}
-          size="1"
-          autoFocus
-          disabled={isGenerating}
-        />
-      </Flex>
-
-      <Flex direction="column" gap="1">
-        <Text size="1" color="gray">
-          Description
-        </Text>
-        <TextArea
-          value={body}
-          onChange={(e) => onBodyChange(e.target.value)}
-          placeholder={isGenerating ? "Generating..." : "Describe your changes"}
-          size="1"
-          rows={6}
-          disabled={isGenerating}
-        />
-      </Flex>
-    </GitDialog>
-  );
-}
-
 interface GitBranchDialogProps {
   open: boolean;
   onOpenChange: (open: boolean) => void;
diff --git a/apps/code/src/renderer/features/git-interaction/components/GitInteractionHeader.tsx b/apps/code/src/renderer/features/git-interaction/components/GitInteractionHeader.tsx
index f9f891453..acf6c2b9f 100644
--- a/apps/code/src/renderer/features/git-interaction/components/GitInteractionHeader.tsx
+++ b/apps/code/src/renderer/features/git-interaction/components/GitInteractionHeader.tsx
@@ -1,7 +1,7 @@
+import { CreatePrFlowDialog } from "@features/git-interaction/components/CreatePrFlowDialog";
 import {
   GitBranchDialog,
   GitCommitDialog,
-  GitPrDialog,
   GitPushDialog,
 } from "@features/git-interaction/components/GitInteractionDialogs";
 import { GitInteractionMenu } from "@features/git-interaction/components/GitInteractionMenu";
@@ -46,7 +46,6 @@ export function GitInteractionHeader({ taskId }: GitInteractionHeaderProps) {
         onCommitMessageChange={actions.setCommitMessage}
         nextStep={modals.commitNextStep}
         onNextStepChange={actions.setCommitNextStep}
-        prDisabledReason={state.prDisabledReason}
         pushDisabledReason={state.pushDisabledReason}
         onContinue={actions.runCommit}
         isSubmitting={modals.isSubmitting}
@@ -69,24 +68,6 @@ export function GitInteractionHeader({ taskId }: GitInteractionHeaderProps) {
         isSubmitting={modals.isSubmitting}
       />
 
-      <GitPrDialog
-        open={modals.prOpen}
-        onOpenChange={(open) => {
-          if (!open) actions.closePr();
-        }}
-        baseBranch={state.prBaseBranch}
-        headBranch={state.prHeadBranch}
-        title={modals.prTitle}
-        onTitleChange={actions.setPrTitle}
-        body={modals.prBody}
-        onBodyChange={actions.setPrBody}
-        onConfirm={actions.runPr}
-        isSubmitting={modals.isSubmitting}
-        error={modals.prError}
-        onGenerate={actions.generatePrTitleAndBody}
-        isGenerating={modals.isGeneratingPr}
-      />
-
       <GitBranchDialog
         open={modals.branchOpen}
         onOpenChange={(open) => {
@@ -98,6 +79,19 @@ export function GitInteractionHeader({ taskId }: GitInteractionHeaderProps) {
         isSubmitting={modals.isSubmitting}
         error={modals.branchError}
       />
+
+      <CreatePrFlowDialog
+        open={modals.createPrFlowOpen}
+        onOpenChange={(open) => {
+          if (!open) actions.closeCreatePrFlow();
+        }}
+        currentBranch={modals.createPrFlowBaseBranch}
+        diffStats={state.diffStats}
+        isSubmitting={modals.isSubmitting}
+        onSubmit={actions.runCreatePrFlow}
+        onGenerateCommitMessage={actions.generateCommitMessage}
+        onGeneratePr={actions.generatePrTitleAndBody}
+      />
     </>
   );
 }
diff --git a/apps/code/src/renderer/features/git-interaction/components/GitInteractionMenu.tsx b/apps/code/src/renderer/features/git-interaction/components/GitInteractionMenu.tsx
index 91af37ec5..db8147074 100644
--- a/apps/code/src/renderer/features/git-interaction/components/GitInteractionMenu.tsx
+++ b/apps/code/src/renderer/features/git-interaction/components/GitInteractionMenu.tsx
@@ -78,7 +78,7 @@ function getActionIcon(actionId: GitMenuActionId) {
       return <ArrowsClockwise size={12} weight="bold" />;
     case "publish":
       return <GitBranch size={12} weight="bold" />;
-    case "create-pr":
+    case "create-pr-flow":
       return <GitPullRequest size={12} weight="bold" />;
     case "view-pr":
       return <Eye size={12} weight="bold" />;
diff --git a/apps/code/src/renderer/features/git-interaction/hooks/useGitInteraction.ts b/apps/code/src/renderer/features/git-interaction/hooks/useGitInteraction.ts
index 4b6ef4a8e..82fe29b6f 100644
--- a/apps/code/src/renderer/features/git-interaction/hooks/useGitInteraction.ts
+++ b/apps/code/src/renderer/features/git-interaction/hooks/useGitInteraction.ts
@@ -14,19 +14,30 @@ import {
   createBranch,
   getBranchNameInputState,
 } from "@features/git-interaction/utils/branchCreation";
+import { invalidateGitBranchQueries } from "@features/git-interaction/utils/gitCacheKeys";
 import { updateGitCacheFromSnapshot } from "@features/git-interaction/utils/updateGitCache";
 import { trpc, trpcClient } from "@renderer/trpc";
+import { getCloudUrlFromRegion } from "@shared/constants/oauth";
 import { ANALYTICS_EVENTS } from "@shared/types/analytics";
 import { useQueryClient } from "@tanstack/react-query";
 import { track } from "@utils/analytics";
 import { logger } from "@utils/logger";
 import { useMemo } from "react";
+import { sanitizeBranchName } from "../utils/branchNameValidation";
 import { getSuggestedBranchName } from "../utils/getSuggestedBranchName";
 
 const log = logger.scope("git-interaction");
 
 export type { GitMenuAction, GitMenuActionId };
 
+function getLlmCredentials(): { apiKey: string; apiHost: string } | null {
+  const authState = useAuthStore.getState();
+  const apiKey = authState.oauthAccessToken;
+  const cloudRegion = authState.cloudRegion;
+  if (!apiKey || !cloudRegion) return null;
+  return { apiKey, apiHost: getCloudUrlFromRegion(cloudRegion) };
+}
+
 interface GitInteractionState {
   primaryAction: GitMenuAction;
   actions: GitMenuAction[];
@@ -40,7 +51,6 @@ interface GitInteractionState {
   diffStats: { filesChanged: number; linesAdded: number; linesRemoved: number };
   prUrl: string | null;
   pushDisabledReason: string | null;
-  prDisabledReason: string | null;
   isLoading: boolean;
 }
 
@@ -48,7 +58,6 @@ interface GitInteractionActions {
   openAction: (actionId: GitMenuActionId) => void;
   closeCommit: () => void;
   closePush: () => void;
-  closePr: () => void;
   closeBranch: () => void;
   setCommitMessage: (value: string) => void;
   setCommitNextStep: (value: CommitNextStep) => void;
@@ -57,10 +66,13 @@ interface GitInteractionActions {
   setBranchName: (value: string) => void;
   runCommit: () => Promise<void>;
   runPush: () => Promise<void>;
-  runPr: () => Promise<void>;
   runBranch: () => Promise<void>;
+  runCreatePrFlow: () => Promise<void>;
   generateCommitMessage: () => Promise<void>;
   generatePrTitleAndBody: () => Promise<void>;
+  closeCreatePrFlow: () => void;
+  setCreatePrFlowBranchName: (value: string) => void;
+  setCreatePrFlowDraft: (value: boolean) => void;
 }
 
 function trackGitAction(taskId: string, actionType: string, success: boolean) {
@@ -70,7 +82,7 @@ function trackGitAction(taskId: string, actionType: string, success: boolean) {
       | "push"
       | "sync"
       | "publish"
-      | "create-pr"
+      | "create-pr-flow"
       | "view-pr"
       | "update-pr",
     success,
@@ -128,34 +140,100 @@ export function useGitInteraction(
     ],
   );
 
-  const openCreatePr = async () => {
-    modal.openPr("", "");
+  const openCreatePrFlow = () => {
+    const prExists = git.prStatus?.prExists ?? false;
+    const needsBranch = !git.isFeatureBranch || prExists;
+    const needsCommit = git.hasChanges;
+    modal.openCreatePrFlow({
+      needsBranch,
+      needsCommit,
+      baseBranch: git.currentBranch,
+      suggestedBranchName: needsBranch
+        ? getSuggestedBranchName(taskId, repoPath)
+        : undefined,
+    });
+  };
+
+  const runCreatePrFlow = async () => {
     if (!repoPath) return;
 
-    const authState = useAuthStore.getState();
-    const apiKey = authState.oauthAccessToken;
-    const cloudRegion = authState.cloudRegion;
-    if (!apiKey || !cloudRegion) return;
+    if (store.createPrFlowNeedsBranch && !store.branchName.trim()) {
+      modal.setCreatePrFlowError("Branch name is required.");
+      return;
+    }
 
-    const apiHost =
-      cloudRegion === "eu"
-        ? "https://eu.posthog.com"
-        : "https://us.posthog.com";
+    modal.setIsSubmitting(true);
+    modal.setCreatePrFlowError(null);
+    modal.setCreatePrFlowStep("idle");
+    modal.setCreatePrFlowFailedStep(null);
+
+    const flowId = crypto.randomUUID();
+
+    const subscription = trpcClient.git.onCreatePrFlowProgress.subscribe(
+      undefined,
+      {
+        onData: (data) => {
+          if (data.flowId !== flowId) return;
+          if (useGitInteractionStore.getState().createPrFlowStep === data.step)
+            return;
+          modal.setCreatePrFlowStep(data.step);
+        },
+      },
+    );
 
-    modal.setIsGeneratingPr(true);
     try {
-      const result = await trpcClient.git.generatePrTitleAndBody.mutate({
+      const credentials = getLlmCredentials() ?? undefined;
+
+      const result = await trpcClient.git.createPrFlow.mutate({
         directoryPath: repoPath,
-        credentials: { apiKey, apiHost },
+        flowId,
+        branchName: store.createPrFlowNeedsBranch
+          ? store.branchName.trim()
+          : undefined,
+        commitMessage: store.commitMessage.trim() || undefined,
+        prTitle: store.prTitle.trim() || undefined,
+        prBody: store.prBody.trim() || undefined,
+        draft: store.createPrFlowDraft || undefined,
+        credentials,
       });
-      if (result.title || result.body) {
-        modal.setPrTitle(result.title);
-        modal.setPrBody(result.body);
+
+      if (!result.success) {
+        trackGitAction(taskId, "create-pr-flow", false);
+        useGitInteractionStore.setState({
+          createPrFlowError: result.message,
+          createPrFlowFailedStep: result.failedStep ?? null,
+          createPrFlowStep: "error",
+        });
+        return;
       }
+
+      trackGitAction(taskId, "create-pr-flow", true);
+      track(ANALYTICS_EVENTS.PR_CREATED, { task_id: taskId, success: true });
+
+      if (result.state) {
+        updateGitCacheFromSnapshot(queryClient, repoPath, result.state);
+      }
+      if (store.createPrFlowNeedsBranch) {
+        invalidateGitBranchQueries(repoPath);
+      }
+
+      if (result.prUrl) {
+        await trpcClient.os.openExternal.mutate({ url: result.prUrl });
+      }
+
+      modal.closeCreatePrFlow();
     } catch (error) {
-      log.error("Failed to auto-generate PR title and body", error);
+      log.error("Create PR flow failed", error);
+      useGitInteractionStore.setState({
+        createPrFlowFailedStep:
+          useGitInteractionStore.getState().createPrFlowStep,
+        createPrFlowError:
+          error instanceof Error ? error.message : "Create PR flow failed.",
+        createPrFlowStep: "error",
+      });
     } finally {
-      modal.setIsGeneratingPr(false);
+      subscription.unsubscribe();
+      modal.setIsSubmitting(false);
     }
   };
 
@@ -166,8 +244,9 @@ export function useGitInteraction(
       sync: () => modal.openPush("sync"),
       publish: () => modal.openPush("publish"),
       "view-pr": () => viewPr(),
-      "create-pr": () => openCreatePr(),
-      "branch-here": () => modal.openBranch(getSuggestedBranchName(taskId)),
+      "create-pr-flow": () => openCreatePrFlow(),
+      "branch-here": () =>
+        modal.openBranch(getSuggestedBranchName(taskId, repoPath)),
     };
     actionMap[id]();
   };
@@ -185,11 +264,6 @@ export function useGitInteraction(
   const runCommit = async () => {
     if (!repoPath) return;
 
-    if (store.commitNextStep === "commit-pr" && computed.prDisabledReason) {
-      modal.setCommitError(computed.prDisabledReason);
-      return;
-    }
-
     if (store.commitNextStep === "commit-push" && computed.pushDisabledReason) {
       modal.setCommitError(computed.pushDisabledReason);
       return;
@@ -201,11 +275,8 @@ export function useGitInteraction(
     let message = store.commitMessage.trim();
 
     if (!message) {
-      const authState = useAuthStore.getState();
-      const apiKey = authState.oauthAccessToken;
-      const cloudRegion = authState.cloudRegion;
-
-      if (!apiKey || !cloudRegion) {
+      const credentials = getLlmCredentials();
+      if (!credentials) {
         modal.setCommitError(
           "Authentication required to generate commit message.",
         );
@@ -213,15 +284,10 @@ export function useGitInteraction(
         return;
       }
 
-      const apiHost =
-        cloudRegion === "eu"
-          ? "https://eu.posthog.com"
-          : "https://us.posthog.com";
-
       try {
         const generated = await trpcClient.git.generateCommitMessage.mutate({
           directoryPath: repoPath,
-          credentials: { apiKey, apiHost },
+          credentials,
         });
 
         if (!generated.message) {
@@ -267,13 +333,7 @@ export function useGitInteraction(
       modal.setCommitMessage("");
       modal.closeCommit();
 
-      const shouldPush =
-        store.commitNextStep === "commit-push" ||
-        store.commitNextStep === "commit-pr";
-      if (shouldPush) {
-        if (store.commitNextStep === "commit-pr" && !git.prStatus?.prExists) {
-          modal.setOpenPrAfterPush(true);
-        }
+      if (store.commitNextStep === "commit-push") {
         modal.openPush(git.hasRemote ? "push" : "publish");
       }
     } finally {
@@ -315,72 +375,6 @@ export function useGitInteraction(
       }
 
       modal.setPushState("success");
-
-      if (store.openPrAfterPush) {
-        modal.closePush();
-        modal.setOpenPrAfterPush(false);
-        openCreatePr();
-      }
-    } finally {
-      modal.setIsSubmitting(false);
-    }
-  };
-
-  const runPr = async () => {
-    if (!repoPath) return;
-
-    const title = store.prTitle.trim();
-    const body = store.prBody.trim();
-
-    if (!title) {
-      modal.setPrError("PR title is required.");
-      return;
-    }
-
-    modal.setIsSubmitting(true);
-    modal.setPrError(null);
-
-    try {
-      if (!git.hasRemote || git.aheadOfRemote > 0) {
-        const pushFn = git.hasRemote
-          ? trpcClient.git.push
-          : trpcClient.git.publish;
-        const pushResult = await pushFn.mutate({ directoryPath: repoPath });
-
-        if (!pushResult.success) {
-          trackGitAction(taskId, "create-pr", false);
-          modal.setPrError(
-            pushResult.message || "Failed to push before creating PR.",
-          );
-          return;
-        }
-
-        if (pushResult.state) {
-          updateGitCacheFromSnapshot(queryClient, repoPath, pushResult.state);
-        }
-      }
-
-      const result = await trpcClient.git.createPr.mutate({
-        directoryPath: repoPath,
-        title,
-        body,
-      });
-
-      if (!result.success || !result.prUrl) {
-        trackGitAction(taskId, "create-pr", false);
-        modal.setPrError(result.message || "Unable to create PR.");
-        return;
-      }
-
-      trackGitAction(taskId, "create-pr", true);
-      track(ANALYTICS_EVENTS.PR_CREATED, { task_id: taskId, success: true });
-
-      if (result.state) {
-        updateGitCacheFromSnapshot(queryClient, repoPath, result.state);
-      }
-
-      await trpcClient.os.openExternal.mutate({ url: result.prUrl });
-      modal.closePr();
     } finally {
       modal.setIsSubmitting(false);
     }
@@ -389,29 +383,21 @@ export function useGitInteraction(
   const generateCommitMessage = async () => {
     if (!repoPath) return;
 
-    const authState = useAuthStore.getState();
-    const apiKey = authState.oauthAccessToken;
-    const cloudRegion = authState.cloudRegion;
-
-    if (!apiKey || !cloudRegion) {
+    const credentials = getLlmCredentials();
+    if (!credentials) {
       modal.setCommitError(
         "Authentication required to generate commit message.",
       );
       return;
     }
 
-    const apiHost =
-      cloudRegion === "eu"
-        ? "https://eu.posthog.com"
-        : "https://us.posthog.com";
-
     modal.setIsGeneratingCommitMessage(true);
     modal.setCommitError(null);
 
     try {
       const result = await trpcClient.git.generateCommitMessage.mutate({
         directoryPath: repoPath,
-        credentials: { apiKey, apiHost },
+        credentials,
       });
 
       if (result.message) {
@@ -436,38 +422,34 @@ export function useGitInteraction(
   const generatePrTitleAndBody = async () => {
     if (!repoPath) return;
 
-    const authState = useAuthStore.getState();
-    const apiKey = authState.oauthAccessToken;
-    const cloudRegion = authState.cloudRegion;
-
-    if (!apiKey || !cloudRegion) {
-      modal.setPrError("Authentication required to generate PR description.");
+    const credentials = getLlmCredentials();
+    if (!credentials) {
+      modal.setCreatePrFlowError(
+        "Authentication required to generate PR description.",
+      );
       return;
     }
 
-    const apiHost =
-      cloudRegion === "eu"
-        ? "https://eu.posthog.com"
-        : "https://us.posthog.com";
-
     modal.setIsGeneratingPr(true);
-    modal.setPrError(null);
+    modal.setCreatePrFlowError(null);
 
     try {
       const result = await trpcClient.git.generatePrTitleAndBody.mutate({
         directoryPath: repoPath,
-        credentials: { apiKey, apiHost },
+        credentials,
       });
 
       if (result.title || result.body) {
         modal.setPrTitle(result.title);
         modal.setPrBody(result.body);
       } else {
-        modal.setPrError("No changes detected to generate PR description.");
+        modal.setCreatePrFlowError(
+          "No changes detected to generate PR description.",
+        );
       }
     } catch (error) {
       log.error("Failed to generate PR title and body", error);
-      modal.setPrError(
+      modal.setCreatePrFlowError(
         error instanceof Error
           ? error.message
           : "Failed to generate PR description.",
@@ -527,7 +509,6 @@ export function useGitInteraction(
       diffStats: git.diffStats,
       prUrl: computed.prUrl,
       pushDisabledReason: computed.pushDisabledReason,
-      prDisabledReason: computed.prDisabledReason,
       isLoading: git.isLoading,
     },
     modals: store,
@@ -535,7 +516,6 @@ export function useGitInteraction(
       openAction,
       closeCommit: modal.closeCommit,
       closePush: modal.closePush,
-      closePr: modal.closePr,
       closeBranch: modal.closeBranch,
       setCommitMessage: modal.setCommitMessage,
       setCommitNextStep: modal.setCommitNextStep,
@@ -548,10 +528,16 @@ export function useGitInteraction(
       },
       runCommit,
       runPush,
-      runPr,
       runBranch,
+      runCreatePrFlow,
       generateCommitMessage,
       generatePrTitleAndBody,
+      closeCreatePrFlow: modal.closeCreatePrFlow,
+      setCreatePrFlowBranchName: (value: string) => {
+        const sanitized = sanitizeBranchName(value);
+        modal.setBranchName(sanitized);
+      },
+      setCreatePrFlowDraft: modal.setCreatePrFlowDraft,
     },
   };
 }
diff --git a/apps/code/src/renderer/features/git-interaction/state/gitInteractionLogic.test.ts b/apps/code/src/renderer/features/git-interaction/state/gitInteractionLogic.test.ts
index 971558f69..9fd3590d7 100644
--- a/apps/code/src/renderer/features/git-interaction/state/gitInteractionLogic.test.ts
+++ b/apps/code/src/renderer/features/git-interaction/state/gitInteractionLogic.test.ts
@@ -29,7 +29,7 @@ function actionIds(result: ReturnType<typeof computeGitInteractionState>) {
 
 describe("computeGitInteractionState", () => {
   describe("on default branch with changes", () => {
-    it("returns branch-here as primary action", () => {
+    it("returns create-pr-flow as primary action", () => {
       const result = computeGitInteractionState(
         makeState({
           currentBranch: "main",
@@ -37,10 +37,10 @@ describe("computeGitInteractionState", () => {
           hasChanges: true,
         }),
       );
-      expect(result.primaryAction.id).toBe("branch-here");
+      expect(result.primaryAction.id).toBe("create-pr-flow");
     });
 
-    it("works without a GitHub remote (defaultBranch null)", () => {
+    it("falls back to branch-here without GitHub remote", () => {
       const result = computeGitInteractionState(
         makeState({
           currentBranch: "main",
@@ -53,7 +53,7 @@ describe("computeGitInteractionState", () => {
       expect(result.primaryAction.id).toBe("branch-here");
     });
 
-    it("includes commit in actions as escape hatch", () => {
+    it("includes create-pr-flow, branch, and commit in actions", () => {
       const result = computeGitInteractionState(
         makeState({
           currentBranch: "main",
@@ -61,7 +61,11 @@ describe("computeGitInteractionState", () => {
           hasChanges: true,
         }),
       );
-      expect(actionIds(result)).toEqual(["branch-here", "commit"]);
+      expect(actionIds(result)).toEqual([
+        "create-pr-flow",
+        "branch-here",
+        "commit",
+      ]);
     });
 
     it("disables push and pr with feature branch message", () => {
@@ -73,7 +77,6 @@ describe("computeGitInteractionState", () => {
         }),
       );
       expect(result.pushDisabledReason).toBe("Create a feature branch first.");
-      expect(result.prDisabledReason).toBe("Create a feature branch first.");
     });
 
     it("is not detected as detached head", () => {
@@ -89,7 +92,7 @@ describe("computeGitInteractionState", () => {
   });
 
   describe("on default branch without changes", () => {
-    it("uses normal flow with commit as primary", () => {
+    it("returns branch-here as primary when nothing to ship", () => {
       const result = computeGitInteractionState(
         makeState({
           currentBranch: "main",
@@ -97,11 +100,10 @@ describe("computeGitInteractionState", () => {
           hasChanges: false,
         }),
       );
-      expect(result.primaryAction.id).toBe("commit");
-      expect(result.primaryAction.enabled).toBe(false);
+      expect(result.primaryAction.id).toBe("branch-here");
     });
 
-    it("returns standard three actions", () => {
+    it("returns only branch-here action", () => {
       const result = computeGitInteractionState(
         makeState({
           currentBranch: "main",
@@ -109,12 +111,12 @@ describe("computeGitInteractionState", () => {
           hasChanges: false,
         }),
       );
-      expect(actionIds(result)).toEqual(["commit", "push", "create-pr"]);
+      expect(actionIds(result)).toEqual(["branch-here"]);
     });
   });
 
   describe("on default branch with ahead commits but no changes", () => {
-    it("returns push as primary action", () => {
+    it("returns branch-here as primary", () => {
       const result = computeGitInteractionState(
         makeState({
           currentBranch: "main",
@@ -123,23 +125,43 @@ describe("computeGitInteractionState", () => {
           aheadOfRemote: 2,
         }),
       );
-      expect(result.primaryAction.id).toBe("push");
+      // On default branch without changes, only branch-here is shown
+      expect(result.primaryAction.id).toBe("branch-here");
     });
   });
 
   describe("on feature branch with changes", () => {
-    it("returns commit as primary action", () => {
+    it("returns create-pr-flow as primary action", () => {
       const result = computeGitInteractionState(
         makeState({ currentBranch: "feature/test", hasChanges: true }),
       );
-      expect(result.primaryAction.id).toBe("commit");
+      expect(result.primaryAction.id).toBe("create-pr-flow");
     });
 
-    it("returns standard three actions", () => {
+    it("returns create-pr-flow plus granular actions", () => {
       const result = computeGitInteractionState(
         makeState({ currentBranch: "feature/test", hasChanges: true }),
       );
-      expect(actionIds(result)).toEqual(["commit", "push", "create-pr"]);
+      expect(actionIds(result)).toEqual(["create-pr-flow", "commit", "push"]);
+    });
+  });
+
+  describe("on feature branch with existing PR", () => {
+    it("still offers create-pr-flow for stacking", () => {
+      const result = computeGitInteractionState(
+        makeState({
+          currentBranch: "feature/test",
+          hasChanges: true,
+          prStatus: {
+            prExists: true,
+            baseBranch: "main",
+            headBranch: "feature/test",
+            prUrl: "https://github.com/test/test/pull/1",
+          },
+        }),
+      );
+      // create-pr-flow still enabled — creates a new stacked branch
+      expect(result.primaryAction.id).toBe("create-pr-flow");
     });
   });
 
@@ -161,7 +183,7 @@ describe("computeGitInteractionState", () => {
   });
 
   describe("isFeatureBranch true even on main", () => {
-    it("falls through to normal commit flow", () => {
+    it("returns create-pr-flow as primary", () => {
       const result = computeGitInteractionState(
         makeState({
           currentBranch: "main",
@@ -169,7 +191,7 @@ describe("computeGitInteractionState", () => {
           hasChanges: true,
         }),
       );
-      expect(result.primaryAction.id).toBe("commit");
+      expect(result.primaryAction.id).toBe("create-pr-flow");
     });
   });
 
diff --git a/apps/code/src/renderer/features/git-interaction/state/gitInteractionLogic.ts b/apps/code/src/renderer/features/git-interaction/state/gitInteractionLogic.ts
index c24af1699..34ed5050a 100644
--- a/apps/code/src/renderer/features/git-interaction/state/gitInteractionLogic.ts
+++ b/apps/code/src/renderer/features/git-interaction/state/gitInteractionLogic.ts
@@ -29,7 +29,6 @@ interface GitComputed {
   actions: GitMenuAction[];
   primaryAction: GitMenuAction;
   pushDisabledReason: string | null;
-  prDisabledReason: string | null;
   prBaseBranch: string | null;
   prHeadBranch: string | null;
   prUrl: string | null;
@@ -95,10 +94,9 @@ function getPushDisabledReason(
   return null;
 }
 
-function getPrDisabledReason(
+function getCreatePrFlowDisabledReason(
   s: GitState,
   repoReason: string | null,
-  opts?: { assumeWillHaveCommits?: boolean },
 ): string | null {
   if (repoReason) return repoReason;
 
@@ -108,18 +106,15 @@ function getPrDisabledReason(
     return "Authenticate GitHub CLI with `gh auth login`";
   if (!s.repoInfo) return "No GitHub remote detected.";
 
-  const isOnDefaultBranch =
-    s.defaultBranch && s.currentBranch === s.defaultBranch;
-  if (isOnDefaultBranch) return "Checkout a feature branch to create PRs.";
-
-  if (s.behind > 0) return "Sync branch with remote first.";
-
-  if (s.prStatus?.prExists) return "PR already exists. Use commit and push.";
-
-  if (!opts?.assumeWillHaveCommits && s.aheadOfDefault === 0) {
-    return "No commits to create PR.";
+  if (s.prStatus?.prExists) {
+    if (!s.hasChanges) return "PR already exists.";
   }
 
+  // Something must be shippable: uncommitted changes or unpushed commits
+  const hasShippableWork =
+    s.hasChanges || s.aheadOfRemote > 0 || s.aheadOfDefault > 0 || !s.hasRemote;
+  if (!hasShippableWork) return "No changes to ship.";
+
   return null;
 }
 
@@ -144,26 +139,31 @@ function getPushAction(
   return makeAction("push", "Push", pushDisabledReason);
 }
 
-function getPrAction(
-  s: GitState,
-  prDisabledReason: string | null,
-): GitMenuAction {
+function getViewPrAction(s: GitState): GitMenuAction | null {
   if (s.prStatus?.prExists) return makeAction("view-pr", "View PR", null);
-  return makeAction("create-pr", "Create PR", prDisabledReason);
+  return null;
+}
+
+function getCreatePrFlowAction(
+  createPrFlowDisabledReason: string | null,
+): GitMenuAction {
+  return makeAction("create-pr-flow", "Create PR", createPrFlowDisabledReason);
 }
 
 function getPrimaryAction(
-  s: GitState,
+  createPrFlowAction: GitMenuAction,
   commitAction: GitMenuAction,
   pushAction: GitMenuAction,
-  prAction: GitMenuAction,
+  viewPrAction: GitMenuAction | null,
 ): GitMenuAction {
-  const allDisabled =
-    !commitAction.enabled && !pushAction.enabled && !prAction.enabled;
-  if (allDisabled) return commitAction;
-  if (s.hasChanges) return commitAction;
-  if (s.aheadOfRemote > 0 || !s.hasRemote || s.behind > 0) return pushAction;
-  return prAction;
+  // createPrFlow handles most cases for getting to a PR (branch creation,
+  // commit, push, etc), so it's always primary when available
+  if (createPrFlowAction.enabled) return createPrFlowAction;
+
+  if (commitAction.enabled) return commitAction;
+  if (pushAction.enabled) return pushAction;
+  if (viewPrAction) return viewPrAction;
+  return commitAction;
 }
 
 export function computeGitInteractionState(input: GitState): GitComputed {
@@ -176,7 +176,6 @@ export function computeGitInteractionState(input: GitState): GitComputed {
       actions: [branchAction],
       primaryAction: branchAction,
       pushDisabledReason: "Create a branch first.",
-      prDisabledReason: "Create a branch first.",
       prBaseBranch: input.defaultBranch,
       prHeadBranch: null,
       prUrl: null,
@@ -186,15 +185,28 @@ export function computeGitInteractionState(input: GitState): GitComputed {
   }
 
   const onDefaultBranch = isOnDefaultBranch(input);
+  const createPrFlowDisabledReason = getCreatePrFlowDisabledReason(
+    input,
+    repoReason,
+  );
+  const createPrFlowAction = getCreatePrFlowAction(createPrFlowDisabledReason);
 
-  if (onDefaultBranch && input.hasChanges) {
+  if (onDefaultBranch) {
     const branchAction = makeAction("branch-here", "New branch", repoReason);
     const commitAction = getCommitAction(input, repoReason);
+
+    const actions = input.hasChanges
+      ? [createPrFlowAction, branchAction, commitAction]
+      : [branchAction];
+    const primaryAction =
+      input.hasChanges && createPrFlowAction.enabled
+        ? createPrFlowAction
+        : branchAction;
+
     return {
-      actions: [branchAction, commitAction],
-      primaryAction: branchAction,
+      actions,
+      primaryAction,
       pushDisabledReason: "Create a feature branch first.",
-      prDisabledReason: "Create a feature branch first.",
       prBaseBranch: input.defaultBranch,
       prHeadBranch: input.currentBranch,
       prUrl: input.prStatus?.prUrl ?? null,
@@ -204,27 +216,28 @@ export function computeGitInteractionState(input: GitState): GitComputed {
   }
 
   const pushDisabledReason = getPushDisabledReason(input, repoReason);
-  const prDisabledReason = getPrDisabledReason(input, repoReason);
 
   const commitAction = getCommitAction(input, repoReason);
   const pushAction = getPushAction(input, pushDisabledReason);
-  const prAction = getPrAction(input, prDisabledReason);
+  const viewPrAction = getViewPrAction(input);
   const primaryAction = getPrimaryAction(
-    input,
+    createPrFlowAction,
     commitAction,
     pushAction,
-    prAction,
+    viewPrAction,
   );
 
+  const actions: GitMenuAction[] = [];
+  if (createPrFlowAction.enabled) actions.push(createPrFlowAction);
+  actions.push(commitAction, pushAction);
+  if (viewPrAction) actions.push(viewPrAction);
+
   return {
-    actions: [commitAction, pushAction, prAction],
+    actions,
     primaryAction,
     pushDisabledReason: getPushDisabledReason(input, repoReason, {
       assumeWillHaveCommits: true,
     }),
-    prDisabledReason: getPrDisabledReason(input, repoReason, {
-      assumeWillHaveCommits: true,
-    }),
     prBaseBranch: input.prStatus?.baseBranch ?? input.defaultBranch,
     prHeadBranch: input.prStatus?.headBranch ?? input.currentBranch,
     prUrl: input.prStatus?.prUrl ?? null,
diff --git a/apps/code/src/renderer/features/git-interaction/state/gitInteractionStore.ts b/apps/code/src/renderer/features/git-interaction/state/gitInteractionStore.ts
index 8839fd1f7..78df188b9 100644
--- a/apps/code/src/renderer/features/git-interaction/state/gitInteractionStore.ts
+++ b/apps/code/src/renderer/features/git-interaction/state/gitInteractionStore.ts
@@ -1,5 +1,6 @@
 import type {
   CommitNextStep,
+  CreatePrFlowStep,
   GitMenuActionId,
   PushMode,
   PushState,
@@ -11,7 +12,6 @@ export type { CommitNextStep, PushMode, PushState };
 interface GitInteractionState {
   commitOpen: boolean;
   pushOpen: boolean;
-  prOpen: boolean;
   branchOpen: boolean;
   commitMessage: string;
   commitNextStep: CommitNextStep;
@@ -20,20 +20,25 @@ interface GitInteractionState {
   pushError: string | null;
   prTitle: string;
   prBody: string;
-  prError: string | null;
   commitError: string | null;
   branchName: string;
   branchError: string | null;
   isSubmitting: boolean;
-  openPrAfterPush: boolean;
   isGeneratingCommitMessage: boolean;
   isGeneratingPr: boolean;
+  createPrFlowOpen: boolean;
+  createPrFlowStep: CreatePrFlowStep;
+  createPrFlowError: string | null;
+  createPrFlowNeedsBranch: boolean;
+  createPrFlowNeedsCommit: boolean;
+  createPrFlowBaseBranch: string | null;
+  createPrFlowDraft: boolean;
+  createPrFlowFailedStep: CreatePrFlowStep | null;
 }
 
 interface GitInteractionActions {
   setCommitOpen: (open: boolean) => void;
   setPushOpen: (open: boolean) => void;
-  setPrOpen: (open: boolean) => void;
   setBranchOpen: (open: boolean) => void;
   setCommitMessage: (value: string) => void;
   setCommitNextStep: (value: CommitNextStep) => void;
@@ -42,23 +47,31 @@ interface GitInteractionActions {
   setPushError: (value: string | null) => void;
   setPrTitle: (value: string) => void;
   setPrBody: (value: string) => void;
-  setPrError: (value: string | null) => void;
   setCommitError: (value: string | null) => void;
   setBranchName: (value: string) => void;
   setBranchError: (value: string | null) => void;
   setIsSubmitting: (value: boolean) => void;
-  setOpenPrAfterPush: (value: boolean) => void;
   setIsGeneratingCommitMessage: (value: boolean) => void;
   setIsGeneratingPr: (value: boolean) => void;
 
   openCommit: (nextStep: CommitNextStep) => void;
   openPush: (mode: PushMode) => void;
-  openPr: (defaultTitle?: string, defaultBody?: string) => void;
   openBranch: (suggestedName?: string) => void;
   closeCommit: () => void;
   closePush: () => void;
-  closePr: () => void;
   closeBranch: () => void;
+
+  openCreatePrFlow: (opts: {
+    needsBranch: boolean;
+    needsCommit: boolean;
+    baseBranch: string | null;
+    suggestedBranchName?: string;
+  }) => void;
+  closeCreatePrFlow: () => void;
+  setCreatePrFlowStep: (step: CreatePrFlowStep) => void;
+  setCreatePrFlowError: (error: string | null) => void;
+  setCreatePrFlowDraft: (value: boolean) => void;
+  setCreatePrFlowFailedStep: (step: CreatePrFlowStep | null) => void;
 }
 
 export interface GitInteractionStore extends GitInteractionState {
@@ -68,7 +81,6 @@ export interface GitInteractionStore extends GitInteractionState {
 const initialState: GitInteractionState = {
   commitOpen: false,
   pushOpen: false,
-  prOpen: false,
   branchOpen: false,
   commitMessage: "",
   commitNextStep: "commit",
@@ -77,14 +89,20 @@ const initialState: GitInteractionState = {
   pushError: null,
   prTitle: "",
   prBody: "",
-  prError: null,
   commitError: null,
   branchName: "",
   branchError: null,
   isSubmitting: false,
-  openPrAfterPush: false,
   isGeneratingCommitMessage: false,
   isGeneratingPr: false,
+  createPrFlowOpen: false,
+  createPrFlowStep: "idle",
+  createPrFlowError: null,
+  createPrFlowNeedsBranch: false,
+  createPrFlowNeedsCommit: false,
+  createPrFlowBaseBranch: null,
+  createPrFlowDraft: false,
+  createPrFlowFailedStep: null,
 };
 
 export const useGitInteractionStore = create<GitInteractionStore>((set) => ({
@@ -92,7 +110,6 @@ export const useGitInteractionStore = create<GitInteractionStore>((set) => ({
   actions: {
     setCommitOpen: (open) => set({ commitOpen: open }),
     setPushOpen: (open) => set({ pushOpen: open }),
-    setPrOpen: (open) => set({ prOpen: open }),
     setBranchOpen: (open) => set({ branchOpen: open }),
     setCommitMessage: (value) => set({ commitMessage: value }),
     setCommitNextStep: (value) => set({ commitNextStep: value }),
@@ -101,12 +118,10 @@ export const useGitInteractionStore = create<GitInteractionStore>((set) => ({
     setPushError: (value) => set({ pushError: value }),
     setPrTitle: (value) => set({ prTitle: value }),
     setPrBody: (value) => set({ prBody: value }),
-    setPrError: (value) => set({ prError: value }),
     setCommitError: (value) => set({ commitError: value }),
     setBranchName: (value) => set({ branchName: value }),
     setBranchError: (value) => set({ branchError: value }),
     setIsSubmitting: (value) => set({ isSubmitting: value }),
-    setOpenPrAfterPush: (value) => set({ openPrAfterPush: value }),
     setIsGeneratingCommitMessage: (value) =>
       set({ isGeneratingCommitMessage: value }),
     setIsGeneratingPr: (value) => set({ isGeneratingPr: value }),
@@ -120,13 +135,6 @@ export const useGitInteractionStore = create<GitInteractionStore>((set) => ({
         pushError: null,
         pushOpen: true,
       }),
-    openPr: (defaultTitle, defaultBody) =>
-      set({
-        prTitle: defaultTitle ?? "",
-        prBody: defaultBody ?? "",
-        prError: null,
-        prOpen: true,
-      }),
     openBranch: (suggestedName) =>
       set({
         branchName: suggestedName ?? "",
@@ -139,12 +147,39 @@ export const useGitInteractionStore = create<GitInteractionStore>((set) => ({
         pushOpen: false,
         pushState: "idle",
         pushError: null,
-        openPrAfterPush: false,
       }),
-    closePr: () =>
-      set({ prOpen: false, prError: null, prTitle: "", prBody: "" }),
     closeBranch: () =>
       set({ branchOpen: false, branchError: null, branchName: "" }),
+    openCreatePrFlow: ({
+      needsBranch,
+      needsCommit,
+      baseBranch,
+      suggestedBranchName,
+    }) =>
+      set({
+        createPrFlowOpen: true,
+        createPrFlowStep: "idle",
+        createPrFlowError: null,
+        createPrFlowNeedsBranch: needsBranch,
+        createPrFlowNeedsCommit: needsCommit,
+        createPrFlowBaseBranch: baseBranch,
+        createPrFlowDraft: false,
+        createPrFlowFailedStep: null,
+        branchName: suggestedBranchName ?? "",
+        commitMessage: "",
+        prTitle: "",
+        prBody: "",
+        isGeneratingCommitMessage: false,
+        isGeneratingPr: false,
+      }),
+    closeCreatePrFlow: () =>
+      set({
+        createPrFlowOpen: false,
+      }),
+    setCreatePrFlowStep: (step) => set({ createPrFlowStep: step }),
+    setCreatePrFlowError: (error) => set({ createPrFlowError: error }),
+    setCreatePrFlowDraft: (value) => set({ createPrFlowDraft: value }),
+    setCreatePrFlowFailedStep: (step) => set({ createPrFlowFailedStep: step }),
   },
 }));
 
@@ -160,7 +195,7 @@ export function getGitInteractionActionLabel(
       return "Sync";
     case "publish":
       return "Publish Branch";
-    case "create-pr":
+    case "create-pr-flow":
       return "Create PR";
     case "view-pr":
       return "View PR";
diff --git a/apps/code/src/renderer/features/git-interaction/types.ts b/apps/code/src/renderer/features/git-interaction/types.ts
index 5b6306265..62979906b 100644
--- a/apps/code/src/renderer/features/git-interaction/types.ts
+++ b/apps/code/src/renderer/features/git-interaction/types.ts
@@ -3,7 +3,7 @@ export type GitMenuActionId =
   | "push"
   | "sync"
   | "publish"
-  | "create-pr"
+  | "create-pr-flow"
   | "view-pr"
   | "branch-here";
 
@@ -14,6 +14,15 @@ export interface GitMenuAction {
   disabledReason: string | null;
 }
 
-export type CommitNextStep = "commit" | "commit-push" | "commit-pr";
+export type CommitNextStep = "commit" | "commit-push";
 export type PushMode = "push" | "sync" | "publish";
 export type PushState = "idle" | "success" | "error";
+
+export type CreatePrFlowStep =
+  | "idle"
+  | "creating-branch"
+  | "committing"
+  | "pushing"
+  | "creating-pr"
+  | "complete"
+  | "error";
diff --git a/apps/code/src/shared/types/analytics.ts b/apps/code/src/shared/types/analytics.ts
index 1b26ebd60..5a5ba6ab8 100644
--- a/apps/code/src/shared/types/analytics.ts
+++ b/apps/code/src/shared/types/analytics.ts
@@ -11,7 +11,7 @@ type GitActionType =
   | "publish"
   | "commit"
   | "commit-push"
-  | "create-pr"
+  | "create-pr-flow"
   | "view-pr"
   | "update-pr"
   | "branch-here";