diff --git a/apps/code/src/renderer/features/code-review/components/CommentAnnotation.tsx b/apps/code/src/renderer/features/code-review/components/CommentAnnotation.tsx
index e8ad71f9a..244531125 100644
--- a/apps/code/src/renderer/features/code-review/components/CommentAnnotation.tsx
+++ b/apps/code/src/renderer/features/code-review/components/CommentAnnotation.tsx
@@ -1,9 +1,10 @@
 import { sendPromptToAgent } from "@features/sessions/utils/sendPromptToAgent";
 import { PaperPlaneTilt, X } from "@phosphor-icons/react";
 import type { AnnotationSide } from "@pierre/diffs";
-import { Button, IconButton } from "@radix-ui/themes";
+import { Button, Checkbox, Flex, IconButton, Text } from "@radix-ui/themes";
 import { isSendMessageSubmitKey } from "@utils/sendMessageKey";
-import { useCallback, useRef } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useReviewDraftsStore } from "../stores/reviewDraftsStore";
 import { buildInlineCommentPrompt } from "../utils/reviewPrompts";
 
 interface CommentAnnotationProps {
@@ -13,6 +14,8 @@ interface CommentAnnotationProps {
   endLine: number;
   side: AnnotationSide;
   onDismiss: () => void;
+  initialText?: string;
+  editingDraftId?: string;
 }
 
 export function CommentAnnotation({
@@ -22,28 +25,78 @@ export function CommentAnnotation({
   endLine,
   side,
   onDismiss,
+  initialText,
+  editingDraftId,
 }: CommentAnnotationProps) {
   const textareaRef = useRef<HTMLTextAreaElement>(null);
+  const addDraft = useReviewDraftsStore((s) => s.addDraft);
+  const updateDraft = useReviewDraftsStore((s) => s.updateDraft);
+  const setBatchEnabled = useReviewDraftsStore((s) => s.setBatchEnabled);
+  const initialBatchEnabled = useReviewDraftsStore((s) =>
+    s.isBatchEnabled(taskId),
+  );
 
-  const setTextareaRef = useCallback((el: HTMLTextAreaElement | null) => {
-    (
-      textareaRef as React.MutableRefObject<HTMLTextAreaElement | null>
-    ).current = el;
-    if (el) {
-      requestAnimationFrame(() => el.focus());
-    }
-  }, []);
+  const [batch, setBatch] = useState(
+    editingDraftId ? true : initialBatchEnabled,
+  );
+
+  const setTextareaRef = useCallback(
+    (el: HTMLTextAreaElement | null) => {
+      (
+        textareaRef as React.MutableRefObject<HTMLTextAreaElement | null>
+      ).current = el;
+      if (el) {
+        if (initialText !== undefined) {
+          el.value = initialText;
+        }
+        requestAnimationFrame(() => el.focus());
+      }
+    },
+    [initialText],
+  );
+
+  // Keep the checkbox in sync if another action toggles batchEnabled while
+  // this textarea is open (e.g. user adds a draft elsewhere).
+  useEffect(() => {
+    if (editingDraftId) return;
+    setBatch(initialBatchEnabled);
+  }, [initialBatchEnabled, editingDraftId]);
 
   const handleSubmit = useCallback(() => {
     const text = textareaRef.current?.value?.trim();
-    if (text) {
+    if (!text) return;
+
+    if (editingDraftId) {
+      updateDraft(taskId, editingDraftId, text);
       onDismiss();
-      sendPromptToAgent(
-        taskId,
-        buildInlineCommentPrompt(filePath, startLine, endLine, side, text),
-      );
+      return;
     }
-  }, [taskId, filePath, startLine, endLine, side, onDismiss]);
+
+    if (batch) {
+      addDraft(taskId, { filePath, startLine, endLine, side, text });
+      setBatchEnabled(taskId, true);
+      onDismiss();
+      return;
+    }
+
+    onDismiss();
+    sendPromptToAgent(
+      taskId,
+      buildInlineCommentPrompt(filePath, startLine, endLine, side, text),
+    );
+  }, [
+    taskId,
+    filePath,
+    startLine,
+    endLine,
+    side,
+    onDismiss,
+    batch,
+    editingDraftId,
+    addDraft,
+    updateDraft,
+    setBatchEnabled,
+  ]);
 
   const handleKeyDown = useCallback(
     (e: React.KeyboardEvent) => {
@@ -59,27 +112,52 @@ export function CommentAnnotation({
     [handleSubmit, onDismiss],
   );
 
+  const submitLabel = editingDraftId
+    ? "Update comment"
+    : batch
+      ? "Add to review"
+      : "Send to agent";
+
   return (
     <div className="px-3 py-1.5">
       <div
         data-comment-annotation=""
-        className="whitespace-normal rounded-md border border-[var(--gray-5)] bg-[var(--gray-2)] px-2.5 py-2 font-sans"
+        className="whitespace-normal rounded-md border border-(--gray-5) bg-(--gray-2) px-2.5 py-2 font-sans"
       >
         <textarea
           ref={setTextareaRef}
           placeholder="Describe the changes you'd like..."
           onKeyDown={handleKeyDown}
-          className="min-h-[48px] w-full resize-none rounded border border-[var(--gray-6)] bg-[var(--color-background)] p-1.5 text-[13px] text-[var(--gray-12)] leading-normal outline-none"
+          className="min-h-[48px] w-full resize-none rounded border border-(--gray-6) bg-(--color-background) p-1.5 text-(--gray-12) text-[13px] leading-normal outline-none"
         />
-        <div className="mt-1.5 flex items-center gap-3">
-          <Button size="1" onClick={handleSubmit}>
-            <PaperPlaneTilt size={12} weight="fill" />
-            Send to agent
-          </Button>
-          <IconButton size="1" variant="ghost" color="gray" onClick={onDismiss}>
-            <X size={12} />
-          </IconButton>
-        </div>
+        <Flex align="center" justify="between" gap="3" className="mt-1.5">
+          <Flex align="center" gap="3">
+            <Button size="1" onClick={handleSubmit}>
+              <PaperPlaneTilt size={12} weight="fill" />
+              {submitLabel}
+            </Button>
+            <IconButton
+              size="1"
+              variant="ghost"
+              color="gray"
+              onClick={onDismiss}
+            >
+              <X size={12} />
+            </IconButton>
+          </Flex>
+          {!editingDraftId && (
+            <Text as="label" size="1" color="gray">
+              <Flex align="center" gap="1.5" className="cursor-pointer">
+                <Checkbox
+                  size="1"
+                  checked={batch}
+                  onCheckedChange={(value) => setBatch(value === true)}
+                />
+                Add to review
+              </Flex>
+            </Text>
+          )}
+        </Flex>
       </div>
     </div>
   );
diff --git a/apps/code/src/renderer/features/code-review/components/DraftCommentAnnotation.tsx b/apps/code/src/renderer/features/code-review/components/DraftCommentAnnotation.tsx
new file mode 100644
index 000000000..d14cd6d59
--- /dev/null
+++ b/apps/code/src/renderer/features/code-review/components/DraftCommentAnnotation.tsx
@@ -0,0 +1,64 @@
+import { PencilSimple, Trash } from "@phosphor-icons/react";
+import { Badge, Flex, IconButton, Text } from "@radix-ui/themes";
+import { useReviewDraftsStore } from "../stores/reviewDraftsStore";
+
+interface DraftCommentAnnotationProps {
+  taskId: string;
+  draftId: string;
+  onEdit: (draftId: string) => void;
+}
+
+export function DraftCommentAnnotation({
+  taskId,
+  draftId,
+  onEdit,
+}: DraftCommentAnnotationProps) {
+  const draft = useReviewDraftsStore((s) =>
+    (s.drafts[taskId] ?? []).find((d) => d.id === draftId),
+  );
+  const removeDraft = useReviewDraftsStore((s) => s.removeDraft);
+
+  if (!draft) return null;
+
+  return (
+    <div className="px-3 py-1.5">
+      <div
+        data-draft-comment-annotation=""
+        className="whitespace-normal rounded-md border border-(--gray-6) border-dashed bg-(--gray-2) px-2.5 py-2 font-sans"
+      >
+        <Flex align="center" justify="between" gap="2" className="mb-1">
+          <Badge color="gray" size="1" variant="soft">
+            Pending review comment
+          </Badge>
+          <Flex gap="1">
+            <IconButton
+              size="1"
+              variant="ghost"
+              color="gray"
+              onClick={() => onEdit(draftId)}
+              aria-label="Edit draft comment"
+            >
+              <PencilSimple size={12} />
+            </IconButton>
+            <IconButton
+              size="1"
+              variant="ghost"
+              color="gray"
+              onClick={() => removeDraft(taskId, draftId)}
+              aria-label="Delete draft comment"
+            >
+              <Trash size={12} />
+            </IconButton>
+          </Flex>
+        </Flex>
+        <Text
+          as="div"
+          size="1"
+          className="whitespace-pre-wrap text-(--gray-12) leading-normal"
+        >
+          {draft.text}
+        </Text>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/code/src/renderer/features/code-review/components/InteractiveFileDiff.tsx b/apps/code/src/renderer/features/code-review/components/InteractiveFileDiff.tsx
index bf58ece60..7a1da799e 100644
--- a/apps/code/src/renderer/features/code-review/components/InteractiveFileDiff.tsx
+++ b/apps/code/src/renderer/features/code-review/components/InteractiveFileDiff.tsx
@@ -8,8 +8,12 @@ import { FileDiff, MultiFileDiff } from "@pierre/diffs/react";
 import { trpcClient, useTRPC } from "@renderer/trpc/client";
 import { useQueryClient } from "@tanstack/react-query";
 import { useCallback, useMemo, useRef, useState } from "react";
-import { useCommentState } from "../hooks/useCommentState";
+import {
+  type CommentEditSeed,
+  useCommentState,
+} from "../hooks/useCommentState";
 import { useExpandableFileDiff } from "../hooks/useExpandableFileDiff";
+import { useReviewDraftsStore } from "../stores/reviewDraftsStore";
 import type {
   AnnotationMetadata,
   FilesDiffProps,
@@ -18,29 +22,50 @@ import type {
 } from "../types";
 import {
   buildCommentMergedOptions,
+  buildDraftAnnotations,
   buildHunkAnnotations,
 } from "../utils/diffAnnotations";
 import { buildFileAnnotations } from "../utils/prCommentAnnotations";
 import { CommentAnnotation } from "./CommentAnnotation";
+import { DraftCommentAnnotation } from "./DraftCommentAnnotation";
 import { PrCommentThread } from "./PrCommentThread";
 
+interface SharedAnnotationContext {
+  taskId: string;
+  filePath: string;
+  prUrl: string | null;
+  reset: () => void;
+  editSeed: CommentEditSeed | null;
+  onEditDraft: (draftId: string) => void;
+}
+
 function renderSharedAnnotation(
   annotation: DiffLineAnnotation<AnnotationMetadata>,
-  filePath: string,
-  taskId: string,
-  prUrl: string | null,
-  reset: () => void,
+  ctx: SharedAnnotationContext,
 ): React.ReactNode {
   if (annotation.metadata.kind === "comment") {
     const { startLine, endLine, side } = annotation.metadata;
+    const seed = ctx.editSeed;
     return (
       <CommentAnnotation
-        taskId={taskId}
-        filePath={filePath}
+        taskId={ctx.taskId}
+        filePath={ctx.filePath}
         startLine={startLine}
         endLine={endLine}
         side={side}
-        onDismiss={reset}
+        onDismiss={ctx.reset}
+        initialText={seed?.text}
+        editingDraftId={seed?.draftId}
+      />
+    );
+  }
+
+  if (annotation.metadata.kind === "draft-comment") {
+    return (
+      <DraftCommentAnnotation
+        taskId={ctx.taskId}
+        draftId={annotation.metadata.draftId}
+        onEdit={ctx.onEditDraft}
       />
     );
   }
@@ -48,9 +73,9 @@ function renderSharedAnnotation(
   if (annotation.metadata.kind === "pr-comment") {
     return (
       <PrCommentThread
-        taskId={taskId}
-        prUrl={prUrl}
-        filePath={filePath}
+        taskId={ctx.taskId}
+        prUrl={ctx.prUrl}
+        filePath={ctx.filePath}
         metadata={annotation.metadata}
       />
     );
@@ -97,6 +122,35 @@ export function InteractiveFileDiff(props: InteractiveFileDiffProps) {
   return <FilesDiffView {...props} />;
 }
 
+function useFileDrafts(taskId: string | undefined, filePath: string) {
+  return useReviewDraftsStore((s) =>
+    taskId
+      ? (s.drafts[taskId] ?? []).filter((d) => d.filePath === filePath)
+      : [],
+  );
+}
+
+function useEditDraftHandler(
+  fileDrafts: ReturnType<typeof useFileDrafts>,
+  openCommentForEdit: (seed: CommentEditSeed) => void,
+) {
+  return useCallback(
+    (draftId: string) => {
+      const draft = fileDrafts.find((d) => d.id === draftId);
+      if (!draft) return;
+      openCommentForEdit({
+        draftId: draft.id,
+        text: draft.text,
+        filePath: draft.filePath,
+        startLine: draft.startLine,
+        endLine: draft.endLine,
+        side: draft.side,
+      });
+    },
+    [fileDrafts, openCommentForEdit],
+  );
+}
+
 function PatchDiffView({
   fileDiff: patchFileDiff,
   repoPath,
@@ -123,8 +177,10 @@ function PatchDiffView({
     selectedRange,
     commentAnnotation,
     hasOpenComment,
+    editSeed,
     reset,
     handleLineSelectionEnd,
+    openCommentForEdit,
   } = useCommentState();
 
   const [lastPatch, setLastPatch] = useState(patchFileDiff);
@@ -144,6 +200,9 @@ function PatchDiffView({
   const filePathRef = useRef(currentFilePath);
   filePathRef.current = currentFilePath;
 
+  const fileDrafts = useFileDrafts(taskId, currentFilePath);
+  const handleEditDraft = useEditDraftHandler(fileDrafts, openCommentForEdit);
+
   const hunkAnnotations = useMemo(
     () => (repoPath ? buildHunkAnnotations(fileDiff) : []),
     [fileDiff, repoPath],
@@ -155,11 +214,17 @@ function PatchDiffView({
         : [],
     [commentThreads, currentFilePath],
   );
+  const draftAnnotations = useMemo(() => {
+    const drafts = editSeed
+      ? fileDrafts.filter((d) => d.id !== editSeed.draftId)
+      : fileDrafts;
+    return buildDraftAnnotations(drafts);
+  }, [fileDrafts, editSeed]);
   const annotations = useMemo(() => {
-    const all = [...hunkAnnotations, ...prAnnotations];
+    const all = [...hunkAnnotations, ...prAnnotations, ...draftAnnotations];
     if (commentAnnotation) all.push(commentAnnotation);
     return all;
-  }, [hunkAnnotations, prAnnotations, commentAnnotation]);
+  }, [hunkAnnotations, prAnnotations, draftAnnotations, commentAnnotation]);
 
   const handleRevert = useCallback(
     async (hunkIndex: number) => {
@@ -226,15 +291,25 @@ function PatchDiffView({
         );
       }
 
-      return renderSharedAnnotation(
-        annotation,
-        currentFilePath,
-        taskId ?? "",
-        prUrl ?? null,
+      return renderSharedAnnotation(annotation, {
+        taskId: taskId ?? "",
+        filePath: currentFilePath,
+        prUrl: prUrl ?? null,
         reset,
-      );
+        editSeed,
+        onEditDraft: handleEditDraft,
+      });
     },
-    [handleRevert, revertingHunks, reset, taskId, prUrl, currentFilePath],
+    [
+      handleRevert,
+      revertingHunks,
+      reset,
+      taskId,
+      prUrl,
+      currentFilePath,
+      editSeed,
+      handleEditDraft,
+    ],
   );
 
   const mergedOptions = useMemo(
@@ -272,33 +347,45 @@ function FilesDiffView({
     selectedRange,
     commentAnnotation,
     hasOpenComment,
+    editSeed,
     reset,
     handleLineSelectionEnd,
+    openCommentForEdit,
   } = useCommentState();
 
   const filePath = newFile.name || oldFile.name;
 
+  const fileDrafts = useFileDrafts(taskId, filePath);
+  const handleEditDraft = useEditDraftHandler(fileDrafts, openCommentForEdit);
+
   const prAnnotations = useMemo(
     () =>
       commentThreads ? buildFileAnnotations(commentThreads, filePath) : [],
     [commentThreads, filePath],
   );
+  const draftAnnotations = useMemo(() => {
+    const drafts = editSeed
+      ? fileDrafts.filter((d) => d.id !== editSeed.draftId)
+      : fileDrafts;
+    return buildDraftAnnotations(drafts);
+  }, [fileDrafts, editSeed]);
   const annotations = useMemo(() => {
-    const all = [...prAnnotations];
+    const all = [...prAnnotations, ...draftAnnotations];
     if (commentAnnotation) all.push(commentAnnotation);
     return all;
-  }, [prAnnotations, commentAnnotation]);
+  }, [prAnnotations, draftAnnotations, commentAnnotation]);
 
   const renderAnnotation = useCallback(
     (annotation: DiffLineAnnotation<AnnotationMetadata>) =>
-      renderSharedAnnotation(
-        annotation,
+      renderSharedAnnotation(annotation, {
+        taskId: taskId ?? "",
         filePath,
-        taskId ?? "",
-        prUrl ?? null,
+        prUrl: prUrl ?? null,
         reset,
-      ),
-    [reset, taskId, prUrl, filePath],
+        editSeed,
+        onEditDraft: handleEditDraft,
+      }),
+    [reset, taskId, prUrl, filePath, editSeed, handleEditDraft],
   );
 
   const mergedOptions = useMemo(
diff --git a/apps/code/src/renderer/features/code-review/components/PendingReviewBar.tsx b/apps/code/src/renderer/features/code-review/components/PendingReviewBar.tsx
new file mode 100644
index 000000000..c995534d3
--- /dev/null
+++ b/apps/code/src/renderer/features/code-review/components/PendingReviewBar.tsx
@@ -0,0 +1,142 @@
+import { sendPromptToAgent } from "@features/sessions/utils/sendPromptToAgent";
+import {
+  CaretDown,
+  CaretUp,
+  PaperPlaneTilt,
+  Trash,
+} from "@phosphor-icons/react";
+import { Badge, Button, Flex, IconButton, Text } from "@radix-ui/themes";
+import { useState } from "react";
+import {
+  type DraftComment,
+  useReviewDraftsStore,
+} from "../stores/reviewDraftsStore";
+import { useReviewNavigationStore } from "../stores/reviewNavigationStore";
+import { buildBatchedInlineCommentsPrompt } from "../utils/reviewPrompts";
+
+interface PendingReviewBarProps {
+  taskId: string;
+}
+
+function formatLineRef(d: DraftComment): string {
+  const sideLabel = d.side === "deletions" ? "old" : "new";
+  return d.startLine === d.endLine
+    ? `L${d.startLine} ${sideLabel}`
+    : `L${d.startLine}-${d.endLine} ${sideLabel}`;
+}
+
+export function PendingReviewBar({ taskId }: PendingReviewBarProps) {
+  const drafts = useReviewDraftsStore((s) => s.drafts[taskId] ?? []);
+  const clearDrafts = useReviewDraftsStore((s) => s.clearDrafts);
+  const removeDraft = useReviewDraftsStore((s) => s.removeDraft);
+  const requestScrollToFile = useReviewNavigationStore(
+    (s) => s.requestScrollToFile,
+  );
+
+  const [collapsed, setCollapsed] = useState(false);
+
+  if (drafts.length === 0) return null;
+
+  const handleSend = () => {
+    const prompt = buildBatchedInlineCommentsPrompt(drafts);
+    if (!prompt) return;
+    sendPromptToAgent(taskId, prompt);
+    clearDrafts(taskId);
+  };
+
+  const countLabel = `${drafts.length} pending comment${drafts.length === 1 ? "" : "s"}`;
+
+  return (
+    <div className="shrink-0 border-(--gray-5) border-t bg-(--gray-2)">
+      <Flex align="center" justify="between" gap="3" className="px-3 py-2">
+        <Flex align="center" gap="2">
+          <IconButton
+            size="1"
+            variant="ghost"
+            color="gray"
+            onClick={() => setCollapsed((v) => !v)}
+            aria-label={
+              collapsed ? "Expand pending review" : "Collapse pending review"
+            }
+          >
+            {collapsed ? <CaretUp size={12} /> : <CaretDown size={12} />}
+          </IconButton>
+          <Badge color="iris" variant="soft" size="1">
+            Pending review
+          </Badge>
+          <Text size="1" color="gray">
+            {countLabel}
+          </Text>
+        </Flex>
+        <Flex align="center" gap="2">
+          <Button
+            size="1"
+            variant="ghost"
+            color="gray"
+            onClick={() => clearDrafts(taskId)}
+          >
+            Discard all
+          </Button>
+          <Button size="1" onClick={handleSend}>
+            <PaperPlaneTilt size={12} weight="fill" />
+            Send to agent
+          </Button>
+        </Flex>
+      </Flex>
+      {!collapsed && (
+        <div className="max-h-48 overflow-auto border-(--gray-5) border-t">
+          {drafts.map((d) => (
+            <Flex
+              key={d.id}
+              align="start"
+              justify="between"
+              gap="2"
+              className="border-(--gray-4) border-b px-3 py-1.5 last:border-b-0"
+            >
+              <button
+                type="button"
+                onClick={() => requestScrollToFile(taskId, d.filePath)}
+                className="min-w-0 flex-1 cursor-pointer border-0 bg-transparent p-0 text-left"
+              >
+                <Flex align="center" gap="2" className="mb-0.5">
+                  <Text
+                    size="1"
+                    weight="medium"
+                    className="truncate text-(--gray-12)"
+                    title={d.filePath}
+                  >
+                    {d.filePath}
+                  </Text>
+                  <Text
+                    size="1"
+                    color="gray"
+                    className="shrink-0 font-mono text-[11px]"
+                  >
+                    {formatLineRef(d)}
+                  </Text>
+                </Flex>
+                <Text
+                  as="div"
+                  size="1"
+                  color="gray"
+                  className="line-clamp-2 whitespace-pre-wrap"
+                >
+                  {d.text}
+                </Text>
+              </button>
+              <IconButton
+                size="1"
+                variant="ghost"
+                color="gray"
+                onClick={() => removeDraft(taskId, d.id)}
+                aria-label="Delete draft comment"
+              >
+                <Trash size={12} />
+              </IconButton>
+            </Flex>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/apps/code/src/renderer/features/code-review/components/ReviewShell.test.tsx b/apps/code/src/renderer/features/code-review/components/ReviewShell.test.tsx
index 602f83901..beb911c00 100644
--- a/apps/code/src/renderer/features/code-review/components/ReviewShell.test.tsx
+++ b/apps/code/src/renderer/features/code-review/components/ReviewShell.test.tsx
@@ -24,6 +24,13 @@ vi.mock("@pierre/diffs/worker/worker.js?worker&url", () => ({ default: "" }));
 vi.mock("@components/ui/FileIcon", () => ({
   FileIcon: () => <span data-testid="file-icon" />,
 }));
+vi.mock("@renderer/trpc/client", () => ({
+  trpcClient: {},
+  useTRPC: vi.fn(),
+}));
+vi.mock("@features/sessions/service/service", () => ({
+  getSessionService: vi.fn(),
+}));
 
 import { DeferredDiffPlaceholder, DiffFileHeader } from "./ReviewShell";
 
diff --git a/apps/code/src/renderer/features/code-review/components/ReviewShell.tsx b/apps/code/src/renderer/features/code-review/components/ReviewShell.tsx
index 7fb1d8c41..ae0f1b05f 100644
--- a/apps/code/src/renderer/features/code-review/components/ReviewShell.tsx
+++ b/apps/code/src/renderer/features/code-review/components/ReviewShell.tsx
@@ -7,6 +7,7 @@ import type { FileDiffMetadata } from "@pierre/diffs/react";
 import { WorkerPoolContextProvider } from "@pierre/diffs/react";
 import WorkerUrl from "@pierre/diffs/worker/worker.js?worker&url";
 import { Flex, Spinner, Text } from "@radix-ui/themes";
+import { useReviewDraftsStore } from "@renderer/features/code-review/stores/reviewDraftsStore";
 import { useReviewNavigationStore } from "@renderer/features/code-review/stores/reviewNavigationStore";
 import type { ChangedFile, Task } from "@shared/types";
 import { useThemeStore } from "@stores/themeStore";
@@ -19,6 +20,7 @@ import {
   useState,
 } from "react";
 import type { ResolvedDiffSource } from "../utils/resolveDiffSource";
+import { PendingReviewBar } from "./PendingReviewBar";
 import { ReviewToolbar } from "./ReviewToolbar";
 
 function splitFilePath(fullPath: string): {
@@ -340,7 +342,10 @@ export function ReviewShell({
   const clearTask = useReviewNavigationStore((s) => s.clearTask);
 
   useEffect(() => {
-    return () => clearTask(taskId);
+    return () => {
+      clearTask(taskId);
+      useReviewDraftsStore.getState().clearDrafts(taskId);
+    };
   }, [taskId, clearTask]);
 
   useEffect(() => {
@@ -430,25 +435,28 @@ export function ReviewShell({
           defaultBranch={defaultBranch}
         />
         <Flex className="min-h-0 flex-1">
-          <div
-            ref={scrollContainerRef}
-            className="scrollbar-overlay-y min-w-0 flex-1 space-y-2 overflow-auto"
-            id="review-shell-diff-container"
-          >
-            {isLoading ? (
-              <Flex align="center" justify="center" height="100%">
-                <Spinner size="2" />
-              </Flex>
-            ) : isEmpty ? (
-              <Flex align="center" justify="center" height="100%">
-                <Text color="gray" className="text-sm">
-                  No file changes to review
-                </Text>
-              </Flex>
-            ) : (
-              children
-            )}
-          </div>
+          <Flex direction="column" className="min-w-0 flex-1">
+            <div
+              ref={scrollContainerRef}
+              className="scrollbar-overlay-y min-h-0 flex-1 space-y-2 overflow-auto"
+              id="review-shell-diff-container"
+            >
+              {isLoading ? (
+                <Flex align="center" justify="center" height="100%">
+                  <Spinner size="2" />
+                </Flex>
+              ) : isEmpty ? (
+                <Flex align="center" justify="center" height="100%">
+                  <Text color="gray" className="text-sm">
+                    No file changes to review
+                  </Text>
+                </Flex>
+              ) : (
+                children
+              )}
+            </div>
+            <PendingReviewBar taskId={taskId} />
+          </Flex>
 
           {isExpanded && <ExpandedSidebar task={task} />}
         </Flex>
diff --git a/apps/code/src/renderer/features/code-review/hooks/useCommentState.ts b/apps/code/src/renderer/features/code-review/hooks/useCommentState.ts
index 8cc5f3a93..eeef9cf5e 100644
--- a/apps/code/src/renderer/features/code-review/hooks/useCommentState.ts
+++ b/apps/code/src/renderer/features/code-review/hooks/useCommentState.ts
@@ -6,24 +6,39 @@ import type {
 import { useCallback, useState } from "react";
 import type { AnnotationMetadata } from "../types";
 
+export interface CommentEditSeed {
+  draftId: string;
+  text: string;
+  filePath: string;
+  startLine: number;
+  endLine: number;
+  side: AnnotationSide;
+}
+
 export function useCommentState() {
   const [selectedRange, setSelectedRange] = useState<SelectedLineRange | null>(
     null,
   );
   const [commentAnnotation, setCommentAnnotation] =
     useState<DiffLineAnnotation<AnnotationMetadata> | null>(null);
+  const [editSeed, setEditSeed] = useState<CommentEditSeed | null>(null);
 
   const hasOpenComment = commentAnnotation !== null;
 
   const reset = useCallback(() => {
     setCommentAnnotation(null);
     setSelectedRange(null);
+    setEditSeed(null);
   }, []);
 
   const handleLineSelectionEnd = useCallback(
     (range: SelectedLineRange | null) => {
       setSelectedRange(range);
-      if (range == null) return;
+      setEditSeed(null);
+      if (range == null) {
+        setCommentAnnotation(null);
+        return;
+      }
       const derivedSide = range.endSide ?? range.side;
       const side: AnnotationSide =
         derivedSide === "deletions" ? "deletions" : "additions";
@@ -39,11 +54,33 @@ export function useCommentState() {
     [],
   );
 
+  const openCommentForEdit = useCallback((seed: CommentEditSeed) => {
+    setSelectedRange({
+      start: seed.startLine,
+      end: seed.endLine,
+      side: seed.side,
+      endSide: seed.side,
+    });
+    setCommentAnnotation({
+      side: seed.side,
+      lineNumber: seed.endLine,
+      metadata: {
+        kind: "comment",
+        startLine: seed.startLine,
+        endLine: seed.endLine,
+        side: seed.side,
+      },
+    });
+    setEditSeed(seed);
+  }, []);
+
   return {
     selectedRange,
     commentAnnotation,
     hasOpenComment,
+    editSeed,
     reset,
     handleLineSelectionEnd,
+    openCommentForEdit,
   };
 }
diff --git a/apps/code/src/renderer/features/code-review/stores/reviewDraftsStore.test.ts b/apps/code/src/renderer/features/code-review/stores/reviewDraftsStore.test.ts
new file mode 100644
index 000000000..0451460b9
--- /dev/null
+++ b/apps/code/src/renderer/features/code-review/stores/reviewDraftsStore.test.ts
@@ -0,0 +1,111 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { useReviewDraftsStore } from "./reviewDraftsStore";
+
+const TASK_A = "task-a";
+const TASK_B = "task-b";
+
+function resetStore() {
+  useReviewDraftsStore.setState({ drafts: {}, batchEnabled: {} });
+}
+
+function addSampleDraft(
+  taskId: string,
+  overrides: Partial<{
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    text: string;
+  }> = {},
+) {
+  return useReviewDraftsStore.getState().addDraft(taskId, {
+    filePath: overrides.filePath ?? "src/foo.ts",
+    startLine: overrides.startLine ?? 1,
+    endLine: overrides.endLine ?? 2,
+    side: "additions",
+    text: overrides.text ?? "comment text",
+  });
+}
+
+describe("reviewDraftsStore", () => {
+  beforeEach(() => {
+    resetStore();
+  });
+
+  it("addDraft assigns an id and returns it", () => {
+    const id = addSampleDraft(TASK_A);
+    expect(id).toBeTruthy();
+    const drafts = useReviewDraftsStore.getState().getDrafts(TASK_A);
+    expect(drafts).toHaveLength(1);
+    expect(drafts[0].id).toBe(id);
+    expect(drafts[0].taskId).toBe(TASK_A);
+    expect(drafts[0].text).toBe("comment text");
+  });
+
+  it("addDraft accumulates per task without cross-talk", () => {
+    addSampleDraft(TASK_A, { text: "a1" });
+    addSampleDraft(TASK_A, { text: "a2" });
+    addSampleDraft(TASK_B, { text: "b1" });
+
+    expect(useReviewDraftsStore.getState().getDraftCount(TASK_A)).toBe(2);
+    expect(useReviewDraftsStore.getState().getDraftCount(TASK_B)).toBe(1);
+  });
+
+  it("updateDraft replaces text without changing other fields or duplicating", () => {
+    const id = addSampleDraft(TASK_A, { text: "original" });
+    useReviewDraftsStore.getState().updateDraft(TASK_A, id, "edited");
+
+    const drafts = useReviewDraftsStore.getState().getDrafts(TASK_A);
+    expect(drafts).toHaveLength(1);
+    expect(drafts[0].text).toBe("edited");
+    expect(drafts[0].id).toBe(id);
+  });
+
+  it("removeDraft removes only the matching draft", () => {
+    const id1 = addSampleDraft(TASK_A, { text: "one" });
+    const id2 = addSampleDraft(TASK_A, { text: "two" });
+
+    useReviewDraftsStore.getState().removeDraft(TASK_A, id1);
+
+    const drafts = useReviewDraftsStore.getState().getDrafts(TASK_A);
+    expect(drafts).toHaveLength(1);
+    expect(drafts[0].id).toBe(id2);
+  });
+
+  it("clearDrafts wipes drafts and batchEnabled for the task only", () => {
+    addSampleDraft(TASK_A);
+    addSampleDraft(TASK_B);
+    useReviewDraftsStore.getState().setBatchEnabled(TASK_A, true);
+    useReviewDraftsStore.getState().setBatchEnabled(TASK_B, true);
+
+    useReviewDraftsStore.getState().clearDrafts(TASK_A);
+
+    expect(useReviewDraftsStore.getState().getDraftCount(TASK_A)).toBe(0);
+    expect(useReviewDraftsStore.getState().getDraftCount(TASK_B)).toBe(1);
+    expect(useReviewDraftsStore.getState().isBatchEnabled(TASK_A)).toBe(false);
+    expect(useReviewDraftsStore.getState().isBatchEnabled(TASK_B)).toBe(true);
+  });
+
+  it("getDraftsForFile filters by file path", () => {
+    addSampleDraft(TASK_A, { filePath: "src/foo.ts", text: "foo" });
+    addSampleDraft(TASK_A, { filePath: "src/bar.ts", text: "bar" });
+    addSampleDraft(TASK_A, { filePath: "src/foo.ts", text: "foo2" });
+
+    const fooDrafts = useReviewDraftsStore
+      .getState()
+      .getDraftsForFile(TASK_A, "src/foo.ts");
+    expect(fooDrafts).toHaveLength(2);
+    expect(fooDrafts.map((d) => d.text)).toEqual(["foo", "foo2"]);
+  });
+
+  it("isBatchEnabled defaults to true when drafts exist and no explicit value", () => {
+    expect(useReviewDraftsStore.getState().isBatchEnabled(TASK_A)).toBe(false);
+    addSampleDraft(TASK_A);
+    expect(useReviewDraftsStore.getState().isBatchEnabled(TASK_A)).toBe(true);
+  });
+
+  it("isBatchEnabled honors explicit setBatchEnabled even with drafts present", () => {
+    addSampleDraft(TASK_A);
+    useReviewDraftsStore.getState().setBatchEnabled(TASK_A, false);
+    expect(useReviewDraftsStore.getState().isBatchEnabled(TASK_A)).toBe(false);
+  });
+});
diff --git a/apps/code/src/renderer/features/code-review/stores/reviewDraftsStore.ts b/apps/code/src/renderer/features/code-review/stores/reviewDraftsStore.ts
new file mode 100644
index 000000000..a7d1141c1
--- /dev/null
+++ b/apps/code/src/renderer/features/code-review/stores/reviewDraftsStore.ts
@@ -0,0 +1,110 @@
+import type { AnnotationSide } from "@pierre/diffs";
+import { create } from "zustand";
+
+export interface DraftComment {
+  id: string;
+  taskId: string;
+  filePath: string;
+  startLine: number;
+  endLine: number;
+  side: AnnotationSide;
+  text: string;
+  createdAt: number;
+}
+
+interface ReviewDraftsStoreState {
+  drafts: Record<string, DraftComment[]>;
+  batchEnabled: Record<string, boolean>;
+}
+
+interface ReviewDraftsStoreActions {
+  addDraft: (
+    taskId: string,
+    draft: Omit<DraftComment, "id" | "taskId" | "createdAt">,
+  ) => string;
+  updateDraft: (taskId: string, draftId: string, text: string) => void;
+  removeDraft: (taskId: string, draftId: string) => void;
+  clearDrafts: (taskId: string) => void;
+  setBatchEnabled: (taskId: string, value: boolean) => void;
+  getDrafts: (taskId: string) => DraftComment[];
+  getDraftsForFile: (taskId: string, filePath: string) => DraftComment[];
+  getDraftCount: (taskId: string) => number;
+  isBatchEnabled: (taskId: string) => boolean;
+}
+
+type ReviewDraftsStore = ReviewDraftsStoreState & ReviewDraftsStoreActions;
+
+export const useReviewDraftsStore = create<ReviewDraftsStore>()((set, get) => ({
+  drafts: {},
+  batchEnabled: {},
+
+  addDraft: (taskId, draft) => {
+    const id = crypto.randomUUID();
+    set((state) => {
+      const existing = state.drafts[taskId] ?? [];
+      const next: DraftComment = {
+        id,
+        taskId,
+        createdAt: Date.now(),
+        ...draft,
+      };
+      return {
+        drafts: { ...state.drafts, [taskId]: [...existing, next] },
+      };
+    });
+    return id;
+  },
+
+  updateDraft: (taskId, draftId, text) =>
+    set((state) => {
+      const existing = state.drafts[taskId];
+      if (!existing) return state;
+      return {
+        drafts: {
+          ...state.drafts,
+          [taskId]: existing.map((d) =>
+            d.id === draftId ? { ...d, text } : d,
+          ),
+        },
+      };
+    }),
+
+  removeDraft: (taskId, draftId) =>
+    set((state) => {
+      const existing = state.drafts[taskId];
+      if (!existing) return state;
+      return {
+        drafts: {
+          ...state.drafts,
+          [taskId]: existing.filter((d) => d.id !== draftId),
+        },
+      };
+    }),
+
+  clearDrafts: (taskId) =>
+    set((state) => {
+      if (!(taskId in state.drafts) && !(taskId in state.batchEnabled)) {
+        return state;
+      }
+      const nextDrafts = { ...state.drafts };
+      delete nextDrafts[taskId];
+      const nextBatch = { ...state.batchEnabled };
+      delete nextBatch[taskId];
+      return { drafts: nextDrafts, batchEnabled: nextBatch };
+    }),
+
+  setBatchEnabled: (taskId, value) =>
+    set((state) => ({
+      batchEnabled: { ...state.batchEnabled, [taskId]: value },
+    })),
+
+  getDrafts: (taskId) => get().drafts[taskId] ?? [],
+  getDraftsForFile: (taskId, filePath) =>
+    (get().drafts[taskId] ?? []).filter((d) => d.filePath === filePath),
+  getDraftCount: (taskId) => (get().drafts[taskId] ?? []).length,
+  isBatchEnabled: (taskId) => {
+    const state = get();
+    if (taskId in state.batchEnabled) return state.batchEnabled[taskId];
+    return (state.drafts[taskId]?.length ?? 0) > 0;
+  },
+}));
diff --git a/apps/code/src/renderer/features/code-review/types.ts b/apps/code/src/renderer/features/code-review/types.ts
index 9ce27b804..a7e145e8f 100644
--- a/apps/code/src/renderer/features/code-review/types.ts
+++ b/apps/code/src/renderer/features/code-review/types.ts
@@ -15,6 +15,14 @@ export interface CommentMetadata {
   side: AnnotationSide;
 }
 
+export interface DraftCommentMetadata {
+  kind: "draft-comment";
+  draftId: string;
+  startLine: number;
+  endLine: number;
+  side: AnnotationSide;
+}
+
 export interface PrCommentMetadata {
   kind: "pr-comment";
   threadId: number;
@@ -29,6 +37,7 @@ export interface PrCommentMetadata {
 export type AnnotationMetadata =
   | HunkRevertMetadata
   | CommentMetadata
+  | DraftCommentMetadata
   | PrCommentMetadata;
 
 export type DiffOptions = FileDiffOptions<AnnotationMetadata>;
diff --git a/apps/code/src/renderer/features/code-review/utils/diffAnnotations.ts b/apps/code/src/renderer/features/code-review/utils/diffAnnotations.ts
index e817b943f..c918be990 100644
--- a/apps/code/src/renderer/features/code-review/utils/diffAnnotations.ts
+++ b/apps/code/src/renderer/features/code-review/utils/diffAnnotations.ts
@@ -3,6 +3,7 @@ import type {
   FileDiffMetadata,
   SelectedLineRange,
 } from "@pierre/diffs";
+import type { DraftComment } from "../stores/reviewDraftsStore";
 import type { AnnotationMetadata, DiffOptions } from "../types";
 
 export function getLastChangeLineNumber(
@@ -35,6 +36,22 @@ export function buildHunkAnnotations(
   });
 }
 
+export function buildDraftAnnotations(
+  drafts: DraftComment[],
+): DiffLineAnnotation<AnnotationMetadata>[] {
+  return drafts.map((d) => ({
+    side: d.side,
+    lineNumber: d.endLine,
+    metadata: {
+      kind: "draft-comment" as const,
+      draftId: d.id,
+      startLine: d.startLine,
+      endLine: d.endLine,
+      side: d.side,
+    },
+  }));
+}
+
 export function buildCommentMergedOptions(
   options: DiffOptions | undefined,
   hasOpenComment: boolean,
diff --git a/apps/code/src/renderer/features/code-review/utils/reviewPrompts.ts b/apps/code/src/renderer/features/code-review/utils/reviewPrompts.ts
index 5e753dd13..e842de787 100644
--- a/apps/code/src/renderer/features/code-review/utils/reviewPrompts.ts
+++ b/apps/code/src/renderer/features/code-review/utils/reviewPrompts.ts
@@ -1,5 +1,6 @@
 import type { PrReviewComment } from "@main/services/git/schemas";
 import type { AnnotationSide } from "@pierre/diffs";
+import type { DraftComment } from "../stores/reviewDraftsStore";
 
 function escapeXmlAttr(value: string): string {
   return value
@@ -14,6 +15,16 @@ function formatThreadForPrompt(comments: PrReviewComment[]): string {
   return comments.map((c) => `@${c.user.login}:\n> ${c.body}`).join("\n\n");
 }
 
+function formatLineRef(startLine: number, endLine: number): string {
+  return startLine === endLine
+    ? `line ${startLine}`
+    : `lines ${startLine}-${endLine}`;
+}
+
+function formatSideLabel(side: AnnotationSide): "old" | "new" {
+  return side === "deletions" ? "old" : "new";
+}
+
 export function buildInlineCommentPrompt(
   filePath: string,
   startLine: number,
@@ -21,15 +32,41 @@ export function buildInlineCommentPrompt(
   side: AnnotationSide,
   comment: string,
 ): string {
-  const lineRef =
-    startLine === endLine
-      ? `line ${startLine}`
-      : `lines ${startLine}-${endLine}`;
-  const sideLabel = side === "deletions" ? "old" : "new";
+  const lineRef = formatLineRef(startLine, endLine);
+  const sideLabel = formatSideLabel(side);
   const escapedPath = escapeXmlAttr(filePath);
   return `In file <file path="${escapedPath}" />, ${lineRef} (${sideLabel}):\n\n${comment}`;
 }
 
+export function buildBatchedInlineCommentsPrompt(
+  drafts: DraftComment[],
+): string {
+  if (drafts.length === 0) return "";
+  if (drafts.length === 1) {
+    const [d] = drafts;
+    return buildInlineCommentPrompt(
+      d.filePath,
+      d.startLine,
+      d.endLine,
+      d.side,
+      d.text,
+    );
+  }
+  const items = drafts
+    .map((d) => {
+      const lineRef = formatLineRef(d.startLine, d.endLine);
+      const sideLabel = formatSideLabel(d.side);
+      const escapedPath = escapeXmlAttr(d.filePath);
+      const indented = d.text
+        .split("\n")
+        .map((line) => `  ${line}`)
+        .join("\n");
+      return `- In file <file path="${escapedPath}" />, ${lineRef} (${sideLabel}):\n${indented}`;
+    })
+    .join("\n\n");
+  return `Please address these review comments:\n\n${items}`;
+}
+
 export function buildFixPrCommentPrompt(
   filePath: string,
   line: number,