diff --git a/client/src/adapter/__tests__/draftPodAdapter.test.ts b/client/src/adapter/__tests__/draftPodAdapter.test.ts
index 04ba6e049d..bea8f7e0ff 100644
--- a/client/src/adapter/__tests__/draftPodAdapter.test.ts
+++ b/client/src/adapter/__tests__/draftPodAdapter.test.ts
@@ -48,6 +48,7 @@ const mockHostOnEvent = vi.fn((_handler: (event: Record<string, unknown>) => voi
 const mockHostInitialize = vi.fn(async () => {});
 const mockHostStartDraft = vi.fn(async () => {});
 const mockHostSubmitHostPick = vi.fn(async () => mockView("Drafting"));
+const mockHostSubmitHostPickWithDraftEffect = vi.fn(async () => mockView("Drafting"));
 const mockHostSubmitHostDeck = vi.fn(async () => mockView("Deckbuilding"));
 const mockHostGetHostView = vi.fn(async () => mockView("Lobby"));
 const mockHostKickPlayer = vi.fn();
@@ -64,6 +65,7 @@ vi.mock("../p2p-draft-host", () => ({
       initialize: mockHostInitialize,
       startDraft: mockHostStartDraft,
       submitHostPick: mockHostSubmitHostPick,
+      submitHostPickWithDraftEffect: mockHostSubmitHostPickWithDraftEffect,
       submitHostDeck: mockHostSubmitHostDeck,
       getHostView: mockHostGetHostView,
       kickPlayer: mockHostKickPlayer,
@@ -83,6 +85,7 @@ vi.mock("../p2p-draft-host", () => ({
 const mockGuestOnEvent = vi.fn((_handler: (event: Record<string, unknown>) => void) => vi.fn());
 const mockGuestInitialize = vi.fn(async () => {});
 const mockGuestSubmitPick = vi.fn(async () => {});
+const mockGuestSubmitPickWithDraftEffect = vi.fn(async () => {});
 const mockGuestSubmitDeck = vi.fn(async () => {});
 const mockGuestLeave = vi.fn(async () => {});
 
@@ -92,6 +95,7 @@ vi.mock("../p2p-draft-guest", () => ({
       onEvent: mockGuestOnEvent,
       initialize: mockGuestInitialize,
       submitPick: mockGuestSubmitPick,
+      submitPickWithDraftEffect: mockGuestSubmitPickWithDraftEffect,
       submitDeck: mockGuestSubmitDeck,
       leave: mockGuestLeave,
       view: null,
@@ -112,6 +116,7 @@ function mockView(status: string): DraftPlayerView {
     pass_direction: "Left",
     current_pack: null,
     pool: [],
+    draft_effects: [],
     pool_groups: {
       color_groups: [],
       type_groups: [],
@@ -294,6 +299,21 @@ describe("DraftPodHostAdapter", () => {
     expect(view.status).toBe("Drafting");
   });
 
+  it("delegates draft-effect picks and returns view", async () => {
+    await adapter.initialize({
+      poolInput: { type: "Set", data: { set_pool_json: "{}" } },
+      kind: "Premier",
+      podSize: 8,
+      hostDisplayName: "Host",
+      tournamentFormat: "Swiss",
+      podPolicy: "Competitive",
+    });
+
+    const view = await adapter.submitPickWithDraftEffect("cogwork-1", ["card-1", "card-2"]);
+    expect(mockHostSubmitHostPickWithDraftEffect).toHaveBeenCalledWith("cogwork-1", ["card-1", "card-2"]);
+    expect(view.status).toBe("Drafting");
+  });
+
   it("delegates submitDeck and returns view", async () => {
     await adapter.initialize({
       poolInput: { type: "Set", data: { set_pool_json: "{}" } },
@@ -500,6 +520,13 @@ describe("DraftPodGuestAdapter", () => {
     expect(mockGuestSubmitPick).toHaveBeenCalledWith("card-456");
   });
 
+  it("delegates draft-effect picks to P2PDraftGuest", async () => {
+    await adapter.initialize({ roomCode: "ABCDE", displayName: "Alice" });
+
+    await adapter.submitPickWithDraftEffect("cogwork-1", ["card-1", "card-2"]);
+    expect(mockGuestSubmitPickWithDraftEffect).toHaveBeenCalledWith("cogwork-1", ["card-1", "card-2"]);
+  });
+
   it("delegates submitDeck to P2PDraftGuest", async () => {
     await adapter.initialize({ roomCode: "ABCDE", displayName: "Alice" });
 
diff --git a/client/src/adapter/__tests__/p2pDraftEffectPick.test.ts b/client/src/adapter/__tests__/p2pDraftEffectPick.test.ts
new file mode 100644
index 0000000000..ecff81901d
--- /dev/null
+++ b/client/src/adapter/__tests__/p2pDraftEffectPick.test.ts
@@ -0,0 +1,94 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { P2PDraftGuest } from "../p2p-draft-guest";
+import { P2PDraftHost } from "../p2p-draft-host";
+
+describe("P2P draft-effect picks", () => {
+  it("serializes guest draft-effect picks without a client-supplied seat", async () => {
+    const guest = new P2PDraftGuest(
+      {} as never,
+      "host-peer",
+      {} as never,
+      "Alice",
+    );
+    const send = vi.fn(async () => {});
+    (guest as unknown as { session: { send: typeof send } }).session = { send };
+
+    await guest.submitPickWithDraftEffect("cogwork-1", ["card-1", "card-2"]);
+
+    expect(send).toHaveBeenCalledWith({
+      type: "draft_pick_with_draft_effect",
+      effectCardInstanceId: "cogwork-1",
+      cardInstanceIds: ["card-1", "card-2"],
+    });
+  });
+
+  it("binds a guest draft-effect pick to the host-assigned seat", async () => {
+    const host = new P2PDraftHost(
+      { id: "host" } as never,
+      () => () => {},
+      { type: "Set", data: { set_pool_json: "{}" } } as never,
+      "Premier",
+      8,
+      "Host",
+      "Swiss",
+      "Competitive",
+    );
+    const privateHost = host as unknown as {
+      draftStarted: boolean;
+      paused: boolean;
+      handleGuestMessage: (seat: number, message: unknown) => Promise<void>;
+      handlePickWithDraftEffect: ReturnType<typeof vi.fn>;
+    };
+    privateHost.draftStarted = true;
+    privateHost.paused = false;
+    privateHost.handlePickWithDraftEffect = vi.fn(async () => {});
+
+    await privateHost.handleGuestMessage(3, {
+      type: "draft_pick_with_draft_effect",
+      effectCardInstanceId: "cogwork-1",
+      cardInstanceIds: ["card-1", "card-2"],
+    });
+
+    expect(privateHost.handlePickWithDraftEffect).toHaveBeenCalledWith(
+      3,
+      "cogwork-1",
+      ["card-1", "card-2"],
+    );
+  });
+
+  it("rejects host normal and draft-effect picks while paused", async () => {
+    const host = new P2PDraftHost(
+      { id: "host" } as never,
+      () => () => {},
+      { type: "Set", data: { set_pool_json: "{}" } } as never,
+      "Premier",
+      8,
+      "Host",
+      "Swiss",
+      "Competitive",
+    );
+    const privateHost = host as unknown as {
+      draftStarted: boolean;
+      paused: boolean;
+      adapter: {
+        submitPickForSeat: ReturnType<typeof vi.fn>;
+        submitPickWithDraftEffectForSeat: ReturnType<typeof vi.fn>;
+      };
+    };
+    privateHost.draftStarted = true;
+    privateHost.paused = true;
+    privateHost.adapter = {
+      submitPickForSeat: vi.fn(),
+      submitPickWithDraftEffectForSeat: vi.fn(),
+    };
+
+    await expect(host.submitHostPick("card-1")).rejects.toThrow("Draft is paused");
+    await expect(
+      host.submitHostPickWithDraftEffect("cogwork-1", ["card-1", "card-2"]),
+    ).rejects.toThrow("Draft is paused");
+
+    expect(privateHost.adapter.submitPickForSeat).not.toHaveBeenCalled();
+    expect(privateHost.adapter.submitPickWithDraftEffectForSeat).not.toHaveBeenCalled();
+  });
+});
\ No newline at end of file
diff --git a/client/src/adapter/__tests__/server-draft-adapter.test.ts b/client/src/adapter/__tests__/server-draft-adapter.test.ts
index a42de47ff9..ccad40aa25 100644
--- a/client/src/adapter/__tests__/server-draft-adapter.test.ts
+++ b/client/src/adapter/__tests__/server-draft-adapter.test.ts
@@ -67,6 +67,7 @@ function createMockDraftView(overrides: Partial<DraftPlayerView> = {}): DraftPla
     pass_direction: "Left",
     current_pack: null,
     pool: [],
+    draft_effects: [],
     pool_groups: EMPTY_DRAFT_POOL_GROUPS,
     seats: [],
     cards_per_pack: 14,
diff --git a/client/src/adapter/draft-adapter.ts b/client/src/adapter/draft-adapter.ts
index c949679498..c9baeb730a 100644
--- a/client/src/adapter/draft-adapter.ts
+++ b/client/src/adapter/draft-adapter.ts
@@ -12,6 +12,7 @@ export interface DraftCardInstance {
   colors: string[];
   cmc: number;
   type_line: string;
+  draft_effect?: "additional_pick";
 }
 
 export type DraftPoolGroupKind =
@@ -80,6 +81,7 @@ export interface SeatPublicView {
   connected: boolean;
   has_submitted_deck: boolean;
   pick_status: "Pending" | "Picked" | "TimedOut" | "NotDrafting";
+  face_up_draft_cards: DraftCardInstance[];
 }
 
 export type DraftStatus =
@@ -169,6 +171,7 @@ export interface DraftPlayerView {
   pass_direction: "Left" | "Right";
   current_pack: DraftCardInstance[] | null;
   pool: DraftCardInstance[];
+  draft_effects: DraftCardInstance[];
   /** Engine-owned grouping, ordering, and duplicate counts for the pool. */
   pool_groups: DraftPoolGroups;
   /** Engine-provided sealed packs in opening order. Absent for draft events. */
@@ -291,6 +294,17 @@ export class DraftAdapter {
     return wasm.submit_pick(cardInstanceId) as DraftPlayerView;
   }
 
+  async submitPickWithDraftEffect(
+    effectCardInstanceId: string,
+    cardInstanceIds: string[],
+  ): Promise<DraftPlayerView> {
+    const wasm = await ensureDraftWasm();
+    return wasm.submit_pick_with_draft_effect(
+      effectCardInstanceId,
+      JSON.stringify(cardInstanceIds),
+    ) as DraftPlayerView;
+  }
+
   /** Let the bot AI pick the best card from the current pack for the player. */
   async autoPick(): Promise<DraftPlayerView> {
     const wasm = await ensureDraftWasm();
@@ -360,6 +374,19 @@ export class DraftAdapter {
     return wasm.submit_pick_for_seat(seat, cardInstanceId) as DraftPlayerView;
   }
 
+  async submitPickWithDraftEffectForSeat(
+    seat: number,
+    effectCardInstanceId: string,
+    cardInstanceIds: string[],
+  ): Promise<DraftPlayerView> {
+    const wasm = await ensureDraftWasm();
+    return wasm.submit_pick_with_draft_effect_for_seat(
+      seat,
+      effectCardInstanceId,
+      JSON.stringify(cardInstanceIds),
+    ) as DraftPlayerView;
+  }
+
   async submitDeckForSeat(seat: number, mainDeck: string[]): Promise<DraftPlayerView> {
     const wasm = await ensureDraftWasm();
     return wasm.submit_deck_for_seat(seat, JSON.stringify(mainDeck)) as DraftPlayerView;
diff --git a/client/src/adapter/draftPodGuestAdapter.ts b/client/src/adapter/draftPodGuestAdapter.ts
index 24f2c923ca..dea5868e99 100644
--- a/client/src/adapter/draftPodGuestAdapter.ts
+++ b/client/src/adapter/draftPodGuestAdapter.ts
@@ -339,6 +339,14 @@ export class DraftPodGuestAdapter {
     await this.guest.submitPick(cardInstanceId);
   }
 
+  async submitPickWithDraftEffect(
+    effectCardInstanceId: string,
+    cardInstanceIds: string[],
+  ): Promise<void> {
+    if (!this.guest) throw new Error("Guest not initialized");
+    await this.guest.submitPickWithDraftEffect(effectCardInstanceId, cardInstanceIds);
+  }
+
   async submitDeck(mainDeck: string[]): Promise<void> {
     if (!this.guest) throw new Error("Guest not initialized");
     await this.guest.submitDeck(mainDeck);
diff --git a/client/src/adapter/draftPodHostAdapter.ts b/client/src/adapter/draftPodHostAdapter.ts
index 0dad1fd4f4..9459176c94 100644
--- a/client/src/adapter/draftPodHostAdapter.ts
+++ b/client/src/adapter/draftPodHostAdapter.ts
@@ -400,6 +400,14 @@ export class DraftPodHostAdapter {
     return this.host.submitHostPick(cardInstanceId);
   }
 
+  async submitPickWithDraftEffect(
+    effectCardInstanceId: string,
+    cardInstanceIds: string[],
+  ): Promise<DraftPlayerView> {
+    if (!this.host) throw new Error("Host not initialized");
+    return this.host.submitHostPickWithDraftEffect(effectCardInstanceId, cardInstanceIds);
+  }
+
   async submitDeck(mainDeck: string[]): Promise<DraftPlayerView> {
     if (!this.host) throw new Error("Host not initialized");
     return this.host.submitHostDeck(mainDeck);
diff --git a/client/src/adapter/p2p-draft-guest.ts b/client/src/adapter/p2p-draft-guest.ts
index 897db6972d..a8bb4476d7 100644
--- a/client/src/adapter/p2p-draft-guest.ts
+++ b/client/src/adapter/p2p-draft-guest.ts
@@ -130,6 +130,18 @@ export class P2PDraftGuest {
     await this.session.send({ type: "draft_pick", cardInstanceId });
   }
 
+  async submitPickWithDraftEffect(
+    effectCardInstanceId: string,
+    cardInstanceIds: string[],
+  ): Promise<void> {
+    if (!this.session) throw new Error("Not connected to draft host");
+    await this.session.send({
+      type: "draft_pick_with_draft_effect",
+      effectCardInstanceId,
+      cardInstanceIds,
+    });
+  }
+
   async submitDeck(mainDeck: string[]): Promise<void> {
     if (!this.session) throw new Error("Not connected to draft host");
     await this.session.send({ type: "draft_submit_deck", mainDeck });
diff --git a/client/src/adapter/p2p-draft-host.ts b/client/src/adapter/p2p-draft-host.ts
index bce95698d5..bfddac3398 100644
--- a/client/src/adapter/p2p-draft-host.ts
+++ b/client/src/adapter/p2p-draft-host.ts
@@ -461,16 +461,19 @@ export class P2PDraftHost {
   private async handleGuestMessage(seat: number, msg: DraftP2PMessage): Promise<void> {
     switch (msg.type) {
       case "draft_pick": {
-        if (!this.draftStarted || this.paused) {
-          this.guestSessions.get(seat)?.send({
-            type: "draft_error",
-            reason: this.paused ? "Draft is paused" : "Draft not started",
-          });
-          return;
-        }
+        if (!this.canGuestPick(seat)) return;
         await this.handlePick(seat, msg.cardInstanceId);
         break;
       }
+      case "draft_pick_with_draft_effect": {
+        if (!this.canGuestPick(seat)) return;
+        await this.handlePickWithDraftEffect(
+          seat,
+          msg.effectCardInstanceId,
+          msg.cardInstanceIds,
+        );
+        break;
+      }
       case "draft_submit_deck": {
         if (!this.draftStarted) {
           this.guestSessions.get(seat)?.send({
@@ -594,6 +597,14 @@ export class P2PDraftHost {
     return this.handlePick(0, cardInstanceId);
   }
 
+  /** Host submits an effect pick for seat 0. */
+  async submitHostPickWithDraftEffect(
+    effectCardInstanceId: string,
+    cardInstanceIds: string[],
+  ): Promise<DraftPlayerView> {
+    return this.handlePickWithDraftEffect(0, effectCardInstanceId, cardInstanceIds);
+  }
+
   /**
    * Host submits their own deck (seat 0).
    */
@@ -601,11 +612,28 @@ export class P2PDraftHost {
     return this.handleDeckSubmission(0, mainDeck);
   }
 
+  private assertPickAllowed(): void {
+    if (!this.draftStarted) throw new Error("Draft not started");
+    if (this.paused) throw new Error("Draft is paused");
+  }
+
+  private canGuestPick(seat: number): boolean {
+    try {
+      this.assertPickAllowed();
+      return true;
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      this.guestSessions.get(seat)?.send({ type: "draft_error", reason });
+      return false;
+    }
+  }
+
   private async handlePick(
     seat: number,
     cardInstanceId: string,
     resolveBots = true,
   ): Promise<DraftPlayerView> {
+    this.assertPickAllowed();
     return this.applyPick(seat, cardInstanceId, {
       acknowledge: true,
       emit: true,
@@ -614,13 +642,37 @@ export class P2PDraftHost {
     });
   }
 
+  private async handlePickWithDraftEffect(
+    seat: number,
+    effectCardInstanceId: string,
+    cardInstanceIds: string[],
+  ): Promise<DraftPlayerView> {
+    this.assertPickAllowed();
+    return this.applyPick(
+      seat,
+      effectCardInstanceId,
+      {
+        acknowledge: true,
+        emit: true,
+        persist: true,
+        resolveBots: true,
+      },
+      () => this.adapter.submitPickWithDraftEffectForSeat(
+        seat,
+        effectCardInstanceId,
+        cardInstanceIds,
+      ),
+    );
+  }
+
   private async applyPick(
     seat: number,
     cardInstanceId: string,
     options: PickOptions,
+    submitPick = () => this.adapter.submitPickForSeat(seat, cardInstanceId),
   ): Promise<DraftPlayerView> {
     try {
-      const view = await this.adapter.submitPickForSeat(seat, cardInstanceId);
+      const view = await submitPick();
       this.picksThisRound.add(seat);
 
       // Send pick acknowledgement to the picking player
@@ -2001,6 +2053,7 @@ export class P2PDraftHost {
         connected: i === 0 || this.guestSessions.has(i),
         has_submitted_deck: false,
         pick_status: "NotDrafting",
+        face_up_draft_cards: [],
       });
     }
     return seats;
@@ -2015,6 +2068,7 @@ export class P2PDraftHost {
       pass_direction: "Left",
       current_pack: null,
       pool: [],
+      draft_effects: [],
       pool_groups: EMPTY_DRAFT_POOL_GROUPS,
       seats: this.buildSeatPublicViews(),
       cards_per_pack: 14,
diff --git a/client/src/components/draft/HostControls.tsx b/client/src/components/draft/HostControls.tsx
index 2d02357f27..333adae463 100644
--- a/client/src/components/draft/HostControls.tsx
+++ b/client/src/components/draft/HostControls.tsx
@@ -92,7 +92,7 @@ export function HostControls() {
     return null;
 
   return (
-    <div className="fixed bottom-4 right-4 z-50 flex min-w-[180px] flex-col gap-2 rounded-[18px] border border-white/10 bg-black/18 p-3 shadow-[0_18px_54px_rgba(0,0,0,0.22)] backdrop-blur-md">
+    <div className="fixed bottom-[calc(env(safe-area-inset-bottom)+5.25rem)] right-3 z-50 flex min-w-[180px] flex-col gap-2 rounded-[18px] border border-white/10 bg-black/18 p-3 shadow-[0_18px_54px_rgba(0,0,0,0.22)] backdrop-blur-md min-[820px]:bottom-4 min-[820px]:right-4">
       <div className="text-[0.68rem] uppercase tracking-[0.18em] text-white/40">
         {t("hostControls.title")}
       </div>
diff --git a/client/src/components/draft/PackDisplay.tsx b/client/src/components/draft/PackDisplay.tsx
index fef8f80ff6..877d97f022 100644
--- a/client/src/components/draft/PackDisplay.tsx
+++ b/client/src/components/draft/PackDisplay.tsx
@@ -6,6 +6,8 @@ import { useDraftStore } from "../../stores/draftStore";
 import type { DraftCardInstance, DraftPlayerView } from "../../adapter/draft-adapter";
 import type { CardHoverInfo } from "../card/CardPreview";
 
+const EMPTY_DRAFT_EFFECTS: DraftCardInstance[] = [];
+
 // ── Card tile ───────────────────────────────────────────────────────────
 
 interface PackCardProps {
@@ -13,6 +15,7 @@ interface PackCardProps {
   isSelected: boolean;
   onSelect: (instanceId: string) => void;
   onConfirm: () => void;
+  confirmDisabled?: boolean;
   onHover: (info: CardHoverInfo | null) => void;
 }
 
@@ -21,6 +24,7 @@ function PackCard({
   isSelected,
   onSelect,
   onConfirm,
+  confirmDisabled = false,
   onHover,
 }: PackCardProps) {
   const { t } = useTranslation("draft");
@@ -60,7 +64,8 @@ function PackCard({
         {isSelected ? (
           <button
             onClick={onConfirm}
-            className="w-full rounded-lg bg-amber-500 py-0.5 text-xs font-semibold text-black transition-colors hover:bg-amber-400"
+            disabled={confirmDisabled}
+            className="w-full rounded-lg bg-amber-500 py-0.5 text-xs font-semibold text-black transition-colors hover:bg-amber-400 disabled:cursor-not-allowed disabled:opacity-50"
           >
             {t("pack.confirmPick")}
           </button>
@@ -115,20 +120,25 @@ interface PackDisplayProps {
   onCardHover: (info: CardHoverInfo | null) => void;
   /** Show the "Auto-pick" button when the active draft mode supports it. */
   showAutoPick?: boolean;
+  /** Show draft-effect controls for the local Draft page. */
+  enableDraftEffects?: boolean;
   view?: DraftPlayerView | null;
   selectedCard?: string | null;
   onSelectCard?: (instanceId: string | null) => void;
   onConfirmPick?: () => Promise<void> | void;
+  onPickWithDraftEffect?: (effectCardInstanceId: string, cardInstanceIds: string[]) => Promise<void> | void;
   onAutoPick?: () => Promise<void> | void;
 }
 
 export function PackDisplay({
   onCardHover,
   showAutoPick = false,
+  enableDraftEffects = false,
   view: viewOverride,
   selectedCard: selectedCardOverride,
   onSelectCard,
   onConfirmPick,
+  onPickWithDraftEffect,
   onAutoPick,
 }: PackDisplayProps) {
   const { t } = useTranslation("draft");
@@ -136,6 +146,7 @@ export function PackDisplay({
   const quickSelectedCard = useDraftStore((s) => s.selectedCard);
   const quickSelectCard = useDraftStore((s) => s.selectCard);
   const quickConfirmPick = useDraftStore((s) => s.confirmPick);
+  const quickPickCardWithDraftEffect = useDraftStore((s) => s.pickCardWithDraftEffect);
   const quickAutoPickCard = useDraftStore((s) => s.autoPickCard);
   const [autoPicking, setAutoPicking] = useState(false);
 
@@ -145,7 +156,10 @@ export function PackDisplay({
     : quickSelectedCard;
   const selectCard = onSelectCard ?? quickSelectCard;
   const confirmPick = onConfirmPick ?? quickConfirmPick;
+  const pickCardWithDraftEffect = onPickWithDraftEffect ?? quickPickCardWithDraftEffect;
   const autoPickCard = onAutoPick ?? quickAutoPickCard;
+  const [activeDraftEffect, setActiveDraftEffect] = useState<string | null>(null);
+  const [additionalCard, setAdditionalCard] = useState<string | null>(null);
 
   useEffect(() => {
     if (view?.current_pack?.length === 1 && !selectedCard) {
@@ -153,6 +167,21 @@ export function PackDisplay({
     }
   }, [view?.current_pack, selectedCard, selectCard]);
 
+  const draftEffects = view?.draft_effects ?? EMPTY_DRAFT_EFFECTS;
+
+  useEffect(() => {
+    if (
+      activeDraftEffect &&
+      !draftEffects.some((card) => card.instance_id === activeDraftEffect)
+    ) {
+      setActiveDraftEffect(null);
+    }
+  }, [activeDraftEffect, draftEffects]);
+
+  useEffect(() => {
+    if (!activeDraftEffect) setAdditionalCard(null);
+  }, [activeDraftEffect]);
+
   if (!view) return null;
 
   const pack = view.current_pack;
@@ -174,17 +203,73 @@ export function PackDisplay({
     }
   };
 
+  const handleConfirmPick = async () => {
+    if (activeDraftEffect && selectedCard && additionalCard) {
+      await pickCardWithDraftEffect(activeDraftEffect, [selectedCard, additionalCard]);
+      setActiveDraftEffect(null);
+      setAdditionalCard(null);
+      return;
+    }
+    if (activeDraftEffect) return;
+    await confirmPick();
+  };
+
+  const handleSelectCard = (instanceId: string) => {
+    if (!activeDraftEffect) {
+      selectCard(instanceId);
+      return;
+    }
+    if (selectedCard === instanceId) {
+      selectCard(null);
+      setAdditionalCard(null);
+    } else if (additionalCard === instanceId) {
+      setAdditionalCard(null);
+    } else if (!selectedCard) {
+      selectCard(instanceId);
+    } else {
+      setAdditionalCard(instanceId);
+    }
+  };
+
+  const handleToggleDraftEffect = (instanceId: string) => {
+    setAdditionalCard(null);
+    setActiveDraftEffect((current) => (current === instanceId ? null : instanceId));
+  };
+
   const sections = groupByRarity(pack);
 
   return (
     <div className="flex flex-col gap-4">
+      {enableDraftEffects && draftEffects.length > 0 && (
+        <div className="flex flex-wrap items-center gap-x-4 gap-y-2 rounded-lg border border-amber-300/15 bg-amber-300/[0.04] px-3 py-2">
+          <span className="shrink-0 text-xs font-semibold text-amber-100">
+            {t("pack.draftEffects")}
+          </span>
+          <div className="flex flex-wrap items-center gap-x-4 gap-y-2">
+            {draftEffects.map((card) => (
+              <label
+                key={card.instance_id}
+                className="flex min-h-11 cursor-pointer items-center gap-2 text-xs text-white/75"
+              >
+                <input
+                  type="checkbox"
+                  checked={activeDraftEffect === card.instance_id}
+                  onChange={() => handleToggleDraftEffect(card.instance_id)}
+                  className="h-4 w-4 accent-amber-400"
+                />
+                <span>{card.name}</span>
+              </label>
+            ))}
+          </div>
+        </div>
+      )}
       <div className="flex items-center justify-between">
         <span className="text-xs text-white/40">{t("pack.cardsInPack", { count: pack.length })}</span>
         {showAutoPick && (
           <button
             type="button"
             onClick={handleAutoPick}
-            disabled={autoPicking}
+            disabled={autoPicking || activeDraftEffect !== null}
             className="rounded-lg border border-white/15 bg-white/[0.04] px-3 py-1 text-xs font-medium text-white/80 transition-colors hover:border-white/25 hover:bg-white/[0.08] disabled:cursor-not-allowed disabled:opacity-50"
           >
             {autoPicking ? t("pack.picking") : t("pack.autoPick")}
@@ -205,9 +290,10 @@ export function PackDisplay({
                 <PackCard
                   key={card.instance_id}
                   card={card}
-                  isSelected={selectedCard === card.instance_id}
-                  onSelect={selectCard}
-                  onConfirm={confirmPick}
+                  isSelected={selectedCard === card.instance_id || additionalCard === card.instance_id}
+                  onSelect={handleSelectCard}
+                  onConfirm={handleConfirmPick}
+                  confirmDisabled={activeDraftEffect !== null && additionalCard === null}
                   onHover={onCardHover}
                 />
               ))}
diff --git a/client/src/components/draft/SeatStatusRing.tsx b/client/src/components/draft/SeatStatusRing.tsx
index 7b8771e2d0..ecec8b3192 100644
--- a/client/src/components/draft/SeatStatusRing.tsx
+++ b/client/src/components/draft/SeatStatusRing.tsx
@@ -40,29 +40,40 @@ function SeatBadge({ seat, isLocal }: SeatBadgeProps) {
     : isLocal
       ? "border-emerald-400/40"
       : PICK_STATUS_BORDER[seat.pick_status];
+  const faceUpNames = seat.face_up_draft_cards.map((card) => card.name).join(", ");
 
   return (
     <div
-      className={`flex items-center gap-1.5 rounded-[12px] border bg-black/18 px-2 py-1 backdrop-blur-md ${borderColor}`}
+      className={`flex min-w-0 flex-col items-start gap-1 rounded-[12px] border bg-black/18 px-2 py-1 backdrop-blur-md ${borderColor}`}
     >
-      <div
-        className={`h-1.5 w-1.5 rounded-full ${
-          showDisconnected
-            ? "bg-rose-400"
-            : PICK_STATUS_DOT[seat.pick_status]
-        }`}
-        aria-label={
-          showDisconnected ? t("seat.disconnected") : t("seat.connected")
-        }
-      />
-      <span
-        className={`truncate text-xs ${
-          showDisconnected ? "text-white/40 line-through" : "text-white/70"
-        }`}
-      >
-        {seat.display_name || t("seat.label", { number: seat.seat_index + 1 })}
-      </span>
-      {seat.is_bot && <BotIndicator label={botLabel} size="sm" />}
+      <div className="flex min-w-0 items-center gap-1.5">
+        <div
+          className={`h-1.5 w-1.5 rounded-full ${
+            showDisconnected
+              ? "bg-rose-400"
+              : PICK_STATUS_DOT[seat.pick_status]
+          }`}
+          aria-label={
+            showDisconnected ? t("seat.disconnected") : t("seat.connected")
+          }
+        />
+        <span
+          className={`truncate text-xs ${
+            showDisconnected ? "text-white/40 line-through" : "text-white/70"
+          }`}
+        >
+          {seat.display_name || t("seat.label", { number: seat.seat_index + 1 })}
+        </span>
+        {seat.is_bot && <BotIndicator label={botLabel} size="sm" />}
+      </div>
+      {faceUpNames && (
+        <span
+          className="max-w-full break-words text-[10px] leading-tight text-amber-200"
+          title={faceUpNames}
+        >
+          {t("seat.faceUpDraftCards", { cards: faceUpNames })}
+        </span>
+      )}
     </div>
   );
 }
@@ -78,13 +89,14 @@ export function SeatStatusRing() {
 
   if (seats.length === 0) return null;
 
-  // Top row: seats 0-3, Bottom row: seats 4-7
+  // Top row: seats 0-3, Bottom row: seats 4-7. On phones each row uses two
+  // columns so public face-up card names remain readable.
   const topRow = seats.slice(0, 4);
   const bottomRow = seats.slice(4, 8);
 
   return (
     <div className="flex flex-col gap-2 mb-4">
-      <div className="grid grid-cols-4 gap-2">
+      <div className="grid grid-cols-2 gap-2 sm:grid-cols-4">
         {topRow.map((seat) => (
           <SeatBadge
             key={seat.seat_index}
@@ -99,7 +111,7 @@ export function SeatStatusRing() {
           ? t("seat.passingLeft")
           : t("seat.passingRight")}
       </div>
-      <div className="grid grid-cols-4 gap-2">
+      <div className="grid grid-cols-2 gap-2 sm:grid-cols-4">
         {bottomRow.map((seat) => (
           <SeatBadge
             key={seat.seat_index}
diff --git a/client/src/components/draft/__tests__/LimitedDeckBuilder.test.tsx b/client/src/components/draft/__tests__/LimitedDeckBuilder.test.tsx
index 2120fc78ec..f5fd2cdc68 100644
--- a/client/src/components/draft/__tests__/LimitedDeckBuilder.test.tsx
+++ b/client/src/components/draft/__tests__/LimitedDeckBuilder.test.tsx
@@ -48,6 +48,7 @@ const TEST_VIEW: BuilderView = {
       type_line: "Creature - Drake",
     },
   ],
+  draft_effects: [],
   pool_groups: {
     color_groups: [],
     type_groups: [],
diff --git a/client/src/components/draft/__tests__/PackDisplay.pod.test.tsx b/client/src/components/draft/__tests__/PackDisplay.pod.test.tsx
index d6b7efbd17..8bd220e306 100644
--- a/client/src/components/draft/__tests__/PackDisplay.pod.test.tsx
+++ b/client/src/components/draft/__tests__/PackDisplay.pod.test.tsx
@@ -10,6 +10,7 @@ vi.mock("../../../stores/draftStore", () => ({
       selectedCard: null,
       selectCard: vi.fn(),
       confirmPick: vi.fn(),
+      pickCardWithDraftEffect: vi.fn(),
       autoPickCard: vi.fn(),
     }),
 }));
@@ -39,6 +40,7 @@ const view: DraftPlayerView = {
     },
   ],
   pool: [],
+  draft_effects: [],
   pool_groups: {
     color_groups: [],
     type_groups: [],
@@ -115,4 +117,96 @@ describe("PackDisplay pod state", () => {
 
     expect(onAutoPick).toHaveBeenCalledTimes(1);
   });
+
+  it("shows draft effects only when the engine provides drafted effect cards", () => {
+    const effectView: DraftPlayerView = {
+      ...view,
+      current_pack: [
+        view.current_pack![0],
+        { ...view.current_pack![0], instance_id: "card-2", name: "Island" },
+      ],
+      draft_effects: [
+        {
+          instance_id: "cogwork-1",
+          name: "Cogwork Librarian",
+          set_code: "cns",
+          collector_number: "58",
+          rarity: "common",
+          colors: [],
+          cmc: 4,
+          type_line: "Artifact Creature — Construct",
+          draft_effect: "additional_pick",
+        },
+      ],
+    };
+
+    const { rerender } = render(
+      <PackDisplay
+        view={effectView}
+        enableDraftEffects
+        onCardHover={vi.fn()}
+      />,
+    );
+
+    expect(screen.getByText("Draft effects:")).toBeInTheDocument();
+    expect(screen.getByRole("checkbox", { name: "Cogwork Librarian" })).toBeInTheDocument();
+
+    rerender(
+      <PackDisplay
+        view={{ ...effectView, draft_effects: [] }}
+        enableDraftEffects
+        onCardHover={vi.fn()}
+      />,
+    );
+
+    expect(screen.queryByText("Draft effects:")).not.toBeInTheDocument();
+  });
+
+  it("dispatches a pod draft-effect pick through its injected callback", () => {
+    const onPickWithDraftEffect = vi.fn();
+    const effectView: DraftPlayerView = {
+      ...view,
+      current_pack: [
+        view.current_pack![0],
+        { ...view.current_pack![0], instance_id: "card-2", name: "Island" },
+      ],
+      draft_effects: [
+        {
+          instance_id: "cogwork-1",
+          name: "Cogwork Librarian",
+          set_code: "cns",
+          collector_number: "58",
+          rarity: "common",
+          colors: [],
+          cmc: 4,
+          type_line: "Artifact Creature — Construct",
+          draft_effect: "additional_pick",
+        },
+      ],
+    };
+    const { rerender } = render(
+      <PackDisplay
+        view={effectView}
+        selectedCard={null}
+        enableDraftEffects
+        onPickWithDraftEffect={onPickWithDraftEffect}
+        onCardHover={vi.fn()}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("checkbox", { name: "Cogwork Librarian" }));
+    rerender(
+      <PackDisplay
+        view={effectView}
+        selectedCard="card-1"
+        enableDraftEffects
+        onPickWithDraftEffect={onPickWithDraftEffect}
+        onCardHover={vi.fn()}
+      />,
+    );
+    fireEvent.click(screen.getByRole("button", { name: "Island" }));
+    fireEvent.click(screen.getAllByRole("button", { name: "Confirm Pick" })[0]);
+
+    expect(onPickWithDraftEffect).toHaveBeenCalledWith("cogwork-1", ["card-1", "card-2"]);
+  });
 });
diff --git a/client/src/components/draft/__tests__/SealedPackOpening.test.tsx b/client/src/components/draft/__tests__/SealedPackOpening.test.tsx
index 9ec752417b..df3775b1fd 100644
--- a/client/src/components/draft/__tests__/SealedPackOpening.test.tsx
+++ b/client/src/components/draft/__tests__/SealedPackOpening.test.tsx
@@ -37,6 +37,7 @@ const VIEW: DraftPlayerView = {
       type_line: "Instant",
     },
   ],
+  draft_effects: [],
   pool_groups: {
     color_groups: [],
     type_groups: [
diff --git a/client/src/components/draft/__tests__/SeatStatusRing.test.tsx b/client/src/components/draft/__tests__/SeatStatusRing.test.tsx
new file mode 100644
index 0000000000..f8d30f64cb
--- /dev/null
+++ b/client/src/components/draft/__tests__/SeatStatusRing.test.tsx
@@ -0,0 +1,56 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { cleanup, render, screen } from "@testing-library/react";
+
+vi.mock("../../../stores/multiplayerDraftStore", () => ({
+  useMultiplayerDraftStore: (selector: (state: Record<string, unknown>) => unknown) =>
+    selector({
+      seatIndex: 0,
+      view: {
+        pass_direction: "Left",
+        seats: [
+          {
+            seat_index: 0,
+            display_name: "Drafter",
+            is_bot: false,
+            connected: true,
+            has_submitted_deck: false,
+            pick_status: "Pending",
+            face_up_draft_cards: [],
+          },
+          {
+            seat_index: 1,
+            display_name: "Opponent",
+            is_bot: false,
+            connected: true,
+            has_submitted_deck: false,
+            pick_status: "Picked",
+            face_up_draft_cards: [
+              {
+                instance_id: "cogwork-1",
+                name: "Cogwork Librarian",
+                set_code: "CNS",
+                collector_number: "58",
+                rarity: "common",
+                colors: [],
+                cmc: 4,
+                type_line: "Artifact Creature - Construct",
+                draft_effect: "additional_pick",
+              },
+            ],
+          },
+        ],
+      },
+    }),
+}));
+
+import { SeatStatusRing } from "../SeatStatusRing";
+
+describe("SeatStatusRing", () => {
+  afterEach(cleanup);
+
+  it("shows other drafters' face-up draft cards", () => {
+    render(<SeatStatusRing />);
+
+    expect(screen.getByText("Face-up: Cogwork Librarian")).toBeInTheDocument();
+  });
+});
\ No newline at end of file
diff --git a/client/src/i18n/locales/de/draft.json b/client/src/i18n/locales/de/draft.json
index ab871af69e..c03ec3fd07 100644
--- a/client/src/i18n/locales/de/draft.json
+++ b/client/src/i18n/locales/de/draft.json
@@ -59,7 +59,8 @@
     "passingLeft": "→ Nach links geben →",
     "passingRight": "← Nach rechts geben ←",
     "connected": "Connected",
-    "disconnected": "Disconnected"
+    "disconnected": "Disconnected",
+    "faceUpDraftCards": "Aufgedeckt: {{cards}}"
   },
   "setSelector": {
     "botDifficulty": "Bot-Schwierigkeit",
@@ -77,6 +78,7 @@
   },
   "pack": {
     "confirmPick": "Pick bestätigen",
+    "draftEffects": "Draft-Effekte:",
     "waitingNext": "Warten auf nächsten Booster...",
     "cardsInPack": "{{count}} Karten im Booster",
     "picking": "Wird ausgewählt…",
diff --git a/client/src/i18n/locales/en/draft.json b/client/src/i18n/locales/en/draft.json
index 58c87cc82a..963ee63b84 100644
--- a/client/src/i18n/locales/en/draft.json
+++ b/client/src/i18n/locales/en/draft.json
@@ -59,7 +59,8 @@
     "passingLeft": "→ Passing Left →",
     "passingRight": "← Passing Right ←",
     "connected": "Connected",
-    "disconnected": "Disconnected"
+    "disconnected": "Disconnected",
+    "faceUpDraftCards": "Face-up: {{cards}}"
   },
   "setSelector": {
     "botDifficulty": "Bot Difficulty",
@@ -77,6 +78,7 @@
   },
   "pack": {
     "confirmPick": "Confirm Pick",
+    "draftEffects": "Draft effects:",
     "waitingNext": "Waiting for next pack...",
     "cardsInPack": "{{count}} cards in pack",
     "picking": "Picking…",
diff --git a/client/src/i18n/locales/es/draft.json b/client/src/i18n/locales/es/draft.json
index dc31c30b4c..f75f611afe 100644
--- a/client/src/i18n/locales/es/draft.json
+++ b/client/src/i18n/locales/es/draft.json
@@ -59,7 +59,8 @@
     "passingLeft": "→ Pasando a la izquierda →",
     "passingRight": "← Pasando a la derecha ←",
     "connected": "Conectado",
-    "disconnected": "Desconectado"
+    "disconnected": "Desconectado",
+    "faceUpDraftCards": "Boca arriba: {{cards}}"
   },
   "setSelector": {
     "botDifficulty": "Dificultad de los bots",
@@ -77,6 +78,7 @@
   },
   "pack": {
     "confirmPick": "Confirmar elección",
+    "draftEffects": "Efectos de draft:",
     "waitingNext": "Esperando el siguiente sobre...",
     "cardsInPack": "{{count}} cartas en el sobre",
     "picking": "Eligiendo…",
diff --git a/client/src/i18n/locales/fr/draft.json b/client/src/i18n/locales/fr/draft.json
index 456a9fc74e..6a09cb8d78 100644
--- a/client/src/i18n/locales/fr/draft.json
+++ b/client/src/i18n/locales/fr/draft.json
@@ -59,7 +59,8 @@
     "passingLeft": "→ Passage à gauche →",
     "passingRight": "← Passage à droite ←",
     "connected": "Connected",
-    "disconnected": "Disconnected"
+    "disconnected": "Disconnected",
+    "faceUpDraftCards": "Face visible : {{cards}}"
   },
   "setSelector": {
     "botDifficulty": "Difficulté des bots",
@@ -77,6 +78,7 @@
   },
   "pack": {
     "confirmPick": "Confirmer le choix",
+    "draftEffects": "Effets de draft :",
     "waitingNext": "En attente du booster suivant...",
     "cardsInPack": "{{count}} cartes dans le booster",
     "picking": "Sélection…",
diff --git a/client/src/i18n/locales/it/draft.json b/client/src/i18n/locales/it/draft.json
index b70e7e0f83..137416a177 100644
--- a/client/src/i18n/locales/it/draft.json
+++ b/client/src/i18n/locales/it/draft.json
@@ -59,7 +59,8 @@
     "passingLeft": "→ Passaggio a sinistra →",
     "passingRight": "← Passaggio a destra ←",
     "connected": "Connected",
-    "disconnected": "Disconnected"
+    "disconnected": "Disconnected",
+    "faceUpDraftCards": "A faccia in su: {{cards}}"
   },
   "setSelector": {
     "botDifficulty": "Difficoltà bot",
@@ -77,6 +78,7 @@
   },
   "pack": {
     "confirmPick": "Conferma scelta",
+    "draftEffects": "Effetti del draft:",
     "waitingNext": "In attesa della prossima busta...",
     "cardsInPack": "{{count}} carte nella busta",
     "picking": "Scelta…",
diff --git a/client/src/i18n/locales/pl/draft.json b/client/src/i18n/locales/pl/draft.json
index 5fc02033aa..c883a5926c 100644
--- a/client/src/i18n/locales/pl/draft.json
+++ b/client/src/i18n/locales/pl/draft.json
@@ -59,7 +59,8 @@
     "passingLeft": "→ Przekazywanie w lewo →",
     "passingRight": "← Przekazywanie w prawo ←",
     "connected": "Connected",
-    "disconnected": "Disconnected"
+    "disconnected": "Disconnected",
+    "faceUpDraftCards": "Odkryte: {{cards}}"
   },
   "setSelector": {
     "botDifficulty": "Poziom trudności botów",
@@ -77,6 +78,7 @@
   },
   "pack": {
     "confirmPick": "Potwierdź wybór",
+    "draftEffects": "Efekty draftu:",
     "waitingNext": "Oczekiwanie na następny booster...",
     "cardsInPack": "{{count}} kart w boosterze",
     "picking": "Wybieranie…",
diff --git a/client/src/i18n/locales/pt/draft.json b/client/src/i18n/locales/pt/draft.json
index 96672f5996..72030ced2d 100644
--- a/client/src/i18n/locales/pt/draft.json
+++ b/client/src/i18n/locales/pt/draft.json
@@ -59,7 +59,8 @@
     "passingLeft": "→ Passando para a Esquerda →",
     "passingRight": "← Passando para a Direita ←",
     "connected": "Connected",
-    "disconnected": "Disconnected"
+    "disconnected": "Disconnected",
+    "faceUpDraftCards": "Virada para cima: {{cards}}"
   },
   "setSelector": {
     "botDifficulty": "Dificuldade dos Bots",
@@ -77,6 +78,7 @@
   },
   "pack": {
     "confirmPick": "Confirmar Escolha",
+    "draftEffects": "Efeitos do draft:",
     "waitingNext": "Aguardando o próximo booster...",
     "cardsInPack": "{{count}} cartas no booster",
     "picking": "Escolhendo…",
diff --git a/client/src/network/__tests__/draftProtocol.test.ts b/client/src/network/__tests__/draftProtocol.test.ts
index 27ef27db6e..a9be984bb5 100644
--- a/client/src/network/__tests__/draftProtocol.test.ts
+++ b/client/src/network/__tests__/draftProtocol.test.ts
@@ -10,8 +10,8 @@ import type { DraftP2PMessage } from "../draftProtocol";
 
 describe("draftProtocol", () => {
   describe("DRAFT_PROTOCOL_VERSION", () => {
-    it("is version 9", () => {
-      expect(DRAFT_PROTOCOL_VERSION).toBe(9);
+    it("is version 10", () => {
+      expect(DRAFT_PROTOCOL_VERSION).toBe(10);
     });
   });
 
@@ -26,6 +26,38 @@ describe("draftProtocol", () => {
       expect(msg.type).toBe("draft_pick");
     });
 
+    it("accepts a draft-effect pick message", () => {
+      const msg = validateDraftMessage({
+        type: "draft_pick_with_draft_effect",
+        effectCardInstanceId: "cogwork-1",
+        cardInstanceIds: ["card-001", "card-002"],
+      });
+      expect(msg).toMatchObject({
+        type: "draft_pick_with_draft_effect",
+        effectCardInstanceId: "cogwork-1",
+        cardInstanceIds: ["card-001", "card-002"],
+      });
+    });
+
+    it.each([
+      { effectCardInstanceId: null, cardInstanceIds: ["card-001", "card-002"] },
+      { effectCardInstanceId: {}, cardInstanceIds: ["card-001", "card-002"] },
+      { effectCardInstanceId: "", cardInstanceIds: ["card-001", "card-002"] },
+      { effectCardInstanceId: "x".repeat(257), cardInstanceIds: ["card-001", "card-002"] },
+      { effectCardInstanceId: "cogwork-1", cardInstanceIds: null },
+      { effectCardInstanceId: "cogwork-1", cardInstanceIds: {} },
+      { effectCardInstanceId: "cogwork-1", cardInstanceIds: ["card-001"] },
+      { effectCardInstanceId: "cogwork-1", cardInstanceIds: ["card-001", "card-002", "card-003"] },
+      { effectCardInstanceId: "cogwork-1", cardInstanceIds: ["card-001", "card-001"] },
+      { effectCardInstanceId: "cogwork-1", cardInstanceIds: [null, "card-002"] },
+      { effectCardInstanceId: "cogwork-1", cardInstanceIds: ["x".repeat(257), "card-002"] },
+    ])("rejects malformed draft-effect pick payloads", (payload) => {
+      expect(() => validateDraftMessage({
+        type: "draft_pick_with_draft_effect",
+        ...payload,
+      })).toThrow("Invalid draft-effect pick");
+    });
+
     it("accepts valid draft_welcome message", () => {
       const msg = validateDraftMessage({
         type: "draft_welcome",
@@ -38,6 +70,45 @@ describe("draftProtocol", () => {
       expect(msg.type).toBe("draft_welcome");
     });
 
+    it("normalizes missing face-up draft arrays in received player views", () => {
+      const msg = validateDraftMessage({
+        type: "draft_state_update",
+        view: {
+          seats: [{ seat_index: 1, display_name: "Alex" }],
+        },
+      });
+
+      expect(msg.type).toBe("draft_state_update");
+      if (msg.type === "draft_state_update") {
+        expect(msg.view.draft_effects).toEqual([]);
+        expect(msg.view.seats[0].face_up_draft_cards).toEqual([]);
+      }
+    });
+
+    it.each([null, {}])("rejects present non-array draft_effects values", (draftEffects) => {
+      expect(() => validateDraftMessage({
+        type: "draft_state_update",
+        view: { draft_effects: draftEffects, seats: [] },
+      })).toThrow("draft_effects must be an array");
+    });
+
+    it.each([null, {}])("rejects present non-array seats values", (seats) => {
+      expect(() => validateDraftMessage({
+        type: "draft_state_update",
+        view: { draft_effects: [], seats },
+      })).toThrow("seats must be an array");
+    });
+
+    it.each([null, {}])("rejects present non-array face-up draft cards", (faceUpCards) => {
+      expect(() => validateDraftMessage({
+        type: "draft_state_update",
+        view: {
+          draft_effects: [],
+          seats: [{ face_up_draft_cards: faceUpCards }],
+        },
+      })).toThrow("face_up_draft_cards must be an array");
+    });
+
     it("rejects missing type field", () => {
       expect(() => validateDraftMessage({})).toThrow("missing type field");
     });
@@ -58,6 +129,7 @@ describe("draftProtocol", () => {
       "draft_join",
       "draft_reconnect",
       "draft_pick",
+      "draft_pick_with_draft_effect",
       "draft_submit_deck",
       "draft_welcome",
       "draft_reconnect_ack",
@@ -89,7 +161,15 @@ describe("draftProtocol", () => {
       "draft_bo3_score_update",
       "draft_bo3_match_complete",
     ])("accepts message type '%s'", (msgType) => {
-      const msg = validateDraftMessage({ type: msgType });
+      const msg = validateDraftMessage(
+        msgType === "draft_pick_with_draft_effect"
+          ? {
+              type: msgType,
+              effectCardInstanceId: "cogwork-1",
+              cardInstanceIds: ["card-001", "card-002"],
+            }
+          : { type: msgType },
+      );
       expect(msg.type).toBe(msgType);
     });
   });
@@ -145,6 +225,7 @@ describe("draftProtocol", () => {
             type_line: "Instant",
           },
         ],
+        draft_effects: [],
         pool_groups: {
           color_groups: [
             { kind: "white", total: 1, cards: [{ card: {
diff --git a/client/src/network/draftProtocol.ts b/client/src/network/draftProtocol.ts
index 8cfea18f8f..53f191b6b6 100644
--- a/client/src/network/draftProtocol.ts
+++ b/client/src/network/draftProtocol.ts
@@ -40,8 +40,9 @@ import type {
  *   7 — forward authenticated match-host between-games observations
  *   8 — add Sealed event kind and deckbuilding-first start flow
  *   9 — add engine-owned limited-pool presentation groups
+ *  10 — add authenticated draft-effect pick actions
  */
-export const DRAFT_PROTOCOL_VERSION = 9 as const;
+export const DRAFT_PROTOCOL_VERSION = 10 as const;
 
 /**
  * Typed reason for a draft pause, used over the wire and on the i18n key path.
@@ -141,7 +142,7 @@ export type DraftMatchLaunch =
  * Discriminated union of all draft-specific P2P messages.
  *
  * Flow:
- *   Guest → Host: `draft_join`, `draft_reconnect`, `draft_pick`, `draft_submit_deck`,
+ *   Guest → Host: `draft_join`, `draft_reconnect`, `draft_pick`, `draft_pick_with_draft_effect`, `draft_submit_deck`,
  *                 `draft_request_advance`
  *   Host → Guest: `draft_welcome`, `draft_reconnect_ack`, `draft_reconnect_rejected`,
  *                 `draft_state_update`, `draft_pick_ack`, `draft_error`,
@@ -163,6 +164,11 @@ export type DraftP2PMessage =
       type: "draft_pick";
       cardInstanceId: string;
     }
+  | {
+      type: "draft_pick_with_draft_effect";
+      effectCardInstanceId: string;
+      cardInstanceIds: string[];
+    }
   | {
       type: "draft_submit_deck";
       mainDeck: string[];
@@ -354,6 +360,7 @@ const VALID_DRAFT_TYPES = new Set([
   "draft_join",
   "draft_reconnect",
   "draft_pick",
+  "draft_pick_with_draft_effect",
   "draft_submit_deck",
   "draft_welcome",
   "draft_reconnect_ack",
@@ -386,6 +393,76 @@ const VALID_DRAFT_TYPES = new Set([
   "draft_bo3_match_complete",
 ]);
 
+const MAX_DRAFT_CARD_INSTANCE_ID_LENGTH = 256;
+
+function requireDraftCardInstanceId(value: unknown, field: string): string {
+  if (
+    typeof value !== "string"
+    || value.length === 0
+    || value.length > MAX_DRAFT_CARD_INSTANCE_ID_LENGTH
+  ) {
+    throw new Error(`Invalid draft-effect pick: ${field} must be a bounded string`);
+  }
+  return value;
+}
+
+function validateDraftEffectPick(raw: Record<string, unknown>): DraftP2PMessage {
+  const effectCardInstanceId = requireDraftCardInstanceId(
+    raw.effectCardInstanceId,
+    "effectCardInstanceId",
+  );
+  if (!Array.isArray(raw.cardInstanceIds) || raw.cardInstanceIds.length !== 2) {
+    throw new Error("Invalid draft-effect pick: cardInstanceIds must contain exactly two cards");
+  }
+  const cardInstanceIds = raw.cardInstanceIds.map((cardId, index) =>
+    requireDraftCardInstanceId(cardId, `cardInstanceIds[${index}]`),
+  );
+  if (cardInstanceIds[0] === cardInstanceIds[1]) {
+    throw new Error("Invalid draft-effect pick: cardInstanceIds must be distinct");
+  }
+  return {
+    ...raw,
+    type: "draft_pick_with_draft_effect",
+    effectCardInstanceId,
+    cardInstanceIds,
+  } as DraftP2PMessage;
+}
+
+function normalizeArrayField<T>(record: Record<string, unknown>, field: string): T[] {
+  if (!(field in record)) return [];
+  const value = record[field];
+  if (!Array.isArray(value)) {
+    throw new Error(`Invalid draft message: ${field} must be an array`);
+  }
+  return value as T[];
+}
+
+function normalizeSeatPublicView(raw: unknown): SeatPublicView {
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error("Invalid draft message: malformed public seat");
+  }
+  const seat = raw as Record<string, unknown>;
+  return {
+    ...seat,
+    face_up_draft_cards: normalizeArrayField(seat, "face_up_draft_cards"),
+  } as SeatPublicView;
+}
+
+function normalizeDraftPlayerView(raw: unknown): DraftPlayerView {
+  if (raw === undefined) {
+    return { draft_effects: [], seats: [] } as unknown as DraftPlayerView;
+  }
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error("Invalid draft message: malformed player view");
+  }
+  const view = raw as Record<string, unknown>;
+  return {
+    ...view,
+    draft_effects: normalizeArrayField(view, "draft_effects"),
+    seats: normalizeArrayField(view, "seats").map(normalizeSeatPublicView),
+  } as DraftPlayerView;
+}
+
 /** Validate a parsed object as a DraftP2PMessage. Throws on malformed data. */
 export function validateDraftMessage(raw: unknown): DraftP2PMessage {
   if (typeof raw !== "object" || raw === null || !("type" in raw)) {
@@ -395,6 +472,23 @@ export function validateDraftMessage(raw: unknown): DraftP2PMessage {
   if (!VALID_DRAFT_TYPES.has(msg.type)) {
     throw new Error(`Invalid draft message type: ${msg.type}`);
   }
+  if (msg.type === "draft_pick_with_draft_effect") {
+    return validateDraftEffectPick(raw as Record<string, unknown>);
+  }
+  const viewMessage = raw as { type: string; view?: unknown; seats?: unknown };
+  if (["draft_welcome", "draft_reconnect_ack", "draft_state_update", "draft_pick_ack"].includes(msg.type)) {
+    return {
+      ...viewMessage,
+      view: normalizeDraftPlayerView(viewMessage.view),
+    } as DraftP2PMessage;
+  }
+  if (msg.type === "draft_lobby_update") {
+    const lobby = raw as Record<string, unknown>;
+    return {
+      ...viewMessage,
+      seats: normalizeArrayField(lobby, "seats").map(normalizeSeatPublicView),
+    } as DraftP2PMessage;
+  }
   return raw as DraftP2PMessage;
 }
 
diff --git a/client/src/pages/DraftPage.tsx b/client/src/pages/DraftPage.tsx
index f7f5ac6d75..b4a0135568 100644
--- a/client/src/pages/DraftPage.tsx
+++ b/client/src/pages/DraftPage.tsx
@@ -463,7 +463,11 @@ export function DraftPage() {
               <div className="mb-4">
                 <DraftProgress />
               </div>
-              <PackDisplay onCardHover={setHoveredCard} showAutoPick />
+              <PackDisplay
+                onCardHover={setHoveredCard}
+                showAutoPick
+                enableDraftEffects
+              />
             </div>
             <PoolPanel onCardHover={setHoveredCard} />
           </div>
diff --git a/client/src/pages/DraftPodPage.tsx b/client/src/pages/DraftPodPage.tsx
index 4a22ac58f3..aaee35fdc2 100644
--- a/client/src/pages/DraftPodPage.tsx
+++ b/client/src/pages/DraftPodPage.tsx
@@ -639,6 +639,7 @@ function DraftingPhaseContent() {
   const selectedCard = useMultiplayerDraftStore((s) => s.selectedCard);
   const selectCard = useMultiplayerDraftStore((s) => s.selectCard);
   const confirmPick = useMultiplayerDraftStore((s) => s.confirmPick);
+  const submitPickWithDraftEffect = useMultiplayerDraftStore((s) => s.submitPickWithDraftEffect);
   const autoPickCard = useMultiplayerDraftStore((s) => s.autoPickCard);
   const paused = useMultiplayerDraftStore((s) => s.paused);
   const pauseReason = useMultiplayerDraftStore((s) => s.pauseReason);
@@ -662,7 +663,7 @@ function DraftingPhaseContent() {
           ⚠ {t(`podPhaseView.pauseReason.${pauseKey}`)}
         </div>
       )}
-      <div className="flex gap-4">
+      <div className="flex flex-col gap-4 lg:flex-row">
         <div className="flex min-w-0 flex-1 flex-col">
           <SeatStatusRing />
           <PickTimer />
@@ -672,6 +673,8 @@ function DraftingPhaseContent() {
             selectedCard={selectedCard}
             onSelectCard={selectCard}
             onConfirmPick={confirmPick}
+            onPickWithDraftEffect={submitPickWithDraftEffect}
+            enableDraftEffects
             showAutoPick
             onAutoPick={autoPickCard}
             onCardHover={setHoveredCard}
diff --git a/client/src/stores/__tests__/multiplayerDraftStore.test.ts b/client/src/stores/__tests__/multiplayerDraftStore.test.ts
index 695366bd3a..d16e88a9fa 100644
--- a/client/src/stores/__tests__/multiplayerDraftStore.test.ts
+++ b/client/src/stores/__tests__/multiplayerDraftStore.test.ts
@@ -24,6 +24,7 @@ const mockHostAdapter = {
   initialize: vi.fn(async () => {}),
   startDraft: vi.fn(async () => {}),
   submitPick: vi.fn(async () => mockView("Drafting")),
+  submitPickWithDraftEffect: vi.fn(async () => mockView("Drafting")),
   submitDeck: vi.fn(async () => mockView("Deckbuilding")),
   getHostView: vi.fn(async () => mockView("Lobby")),
   kickPlayer: vi.fn(),
@@ -47,6 +48,7 @@ const mockGuestAdapter = {
   }),
   initialize: vi.fn(async () => {}),
   submitPick: vi.fn(async () => {}),
+  submitPickWithDraftEffect: vi.fn(async () => {}),
   submitDeck: vi.fn(async () => {}),
   submitAuthorized: vi.fn(),
   acknowledgeAuthorized: vi.fn(),
@@ -80,6 +82,7 @@ function mockView(status: string): DraftPlayerView {
     pass_direction: "Left",
     current_pack: null,
     pool: [],
+    draft_effects: [],
     pool_groups: {
       color_groups: [],
       type_groups: [],
@@ -425,6 +428,27 @@ describe("multiplayerDraftStore", () => {
   });
 
   describe("shared actions", () => {
+    it("submits a draft-effect pick through the host adapter", async () => {
+      await useMultiplayerDraftStore.getState().hostDraft({
+        poolInput: { type: "Set", data: { set_pool_json: "{}" } },
+        kind: "Premier",
+        podSize: 8,
+        hostDisplayName: "Host",
+        tournamentFormat: "Swiss",
+        podPolicy: "Competitive",
+      });
+
+      await useMultiplayerDraftStore.getState().submitPickWithDraftEffect(
+        "cogwork-1",
+        ["card-1", "card-2"],
+      );
+
+      expect(mockHostAdapter.submitPickWithDraftEffect).toHaveBeenCalledWith(
+        "cogwork-1",
+        ["card-1", "card-2"],
+      );
+    });
+
     it("selectCard and confirmPick work together", async () => {
       await useMultiplayerDraftStore.getState().hostDraft({
         poolInput: { type: "Set", data: { set_pool_json: "{}" } },
diff --git a/client/src/stores/draftStore.ts b/client/src/stores/draftStore.ts
index 2e9f5789d2..36ab126610 100644
--- a/client/src/stores/draftStore.ts
+++ b/client/src/stores/draftStore.ts
@@ -57,6 +57,7 @@ interface DraftStoreActions {
   resumeDraft: () => Promise<void>;
   abandonDraft: () => Promise<void>;
   pickCard: (cardInstanceId: string) => Promise<void>;
+  pickCardWithDraftEffect: (effectCardInstanceId: string, cardInstanceIds: string[]) => Promise<void>;
   autoPickCard: () => Promise<void>;
   selectCard: (cardInstanceId: string | null) => void;
   confirmPick: () => Promise<void>;
@@ -421,6 +422,14 @@ export const useDraftStore = create<DraftStoreState & DraftStoreActions>()(
       applyPickResult(await adapter.submitPick(cardInstanceId));
     },
 
+    pickCardWithDraftEffect: async (effectCardInstanceId, cardInstanceIds) => {
+      const { adapter } = get();
+      if (!adapter) return;
+      applyPickResult(
+        await adapter.submitPickWithDraftEffect(effectCardInstanceId, cardInstanceIds),
+      );
+    },
+
     autoPickCard: async () => {
       const { adapter } = get();
       if (!adapter) return;
diff --git a/client/src/stores/multiplayerDraftStore.ts b/client/src/stores/multiplayerDraftStore.ts
index 3dc0344acc..b7318aa057 100644
--- a/client/src/stores/multiplayerDraftStore.ts
+++ b/client/src/stores/multiplayerDraftStore.ts
@@ -142,6 +142,8 @@ interface MultiplayerDraftActions {
   startDraft: (botFillEmptySeats?: boolean) => Promise<void>;
   /** Both: submit a pick. */
   submitPick: (cardInstanceId: string) => Promise<void>;
+  /** Both: submit a pick using a drafted card's draft-time effect. */
+  submitPickWithDraftEffect: (effectCardInstanceId: string, cardInstanceIds: string[]) => Promise<void>;
   /** Both: select a card (UI highlight before confirming pick). */
   selectCard: (cardInstanceId: string | null) => void;
   /** Both: confirm the currently selected card as pick. */
@@ -582,6 +584,20 @@ export const useMultiplayerDraftStore = create<
     }
   },
 
+  submitPickWithDraftEffect: async (effectCardInstanceId, cardInstanceIds) => {
+    const { role } = get();
+    if (role === "host" && activeHostAdapter) {
+      const view = await activeHostAdapter.submitPickWithDraftEffect(
+        effectCardInstanceId,
+        cardInstanceIds,
+      );
+      set({ view, selectedCard: null });
+    } else if (role === "guest" && activeGuestAdapter) {
+      await activeGuestAdapter.submitPickWithDraftEffect(effectCardInstanceId, cardInstanceIds);
+      set({ selectedCard: null });
+    }
+  },
+
   selectCard: (cardInstanceId) => {
     set({ selectedCard: cardInstanceId });
   },
diff --git a/client/src/wasm/draft_wasm.d.ts b/client/src/wasm/draft_wasm.d.ts
index 407b67a966..3c7db9a9bc 100644
--- a/client/src/wasm/draft_wasm.d.ts
+++ b/client/src/wasm/draft_wasm.d.ts
@@ -173,6 +173,19 @@ export function submit_pick(card_instance_id: string): any;
  */
 export function submit_pick_for_seat(seat: number, card_instance_id: string): any;
 
+/**
+ * Submit an additional pick using a drafted card's draft-time effect, then
+ * resolve all bot picks.
+ */
+export function submit_pick_with_draft_effect(effect_card_instance_id: string, card_instance_ids_json: string): any;
+
+/**
+ * Submit a draft-effect pick for any seat (host proxies guest picks).
+ *
+ * Returns the filtered DraftPlayerView for the specified seat after the pick.
+ */
+export function submit_pick_with_draft_effect_for_seat(seat: number, effect_card_instance_id: string, card_instance_ids_json: string): any;
+
 /**
  * Auto-suggest a playable Limited deck from the human's pool.
  *
@@ -214,6 +227,8 @@ export interface InitOutput {
     readonly submit_deck_for_seat: (a: number, b: number, c: number) => [number, number, number];
     readonly submit_pick: (a: number, b: number) => [number, number, number];
     readonly submit_pick_for_seat: (a: number, b: number, c: number) => [number, number, number];
+    readonly submit_pick_with_draft_effect: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly submit_pick_with_draft_effect_for_seat: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
     readonly suggest_deck: () => [number, number, number];
     readonly suggest_lands: (a: number, b: number) => [number, number, number];
     readonly init_panic_hook: () => void;
diff --git a/crates/draft-core/src/cube.rs b/crates/draft-core/src/cube.rs
index f999a5da8e..900b07faa9 100644
--- a/crates/draft-core/src/cube.rs
+++ b/crates/draft-core/src/cube.rs
@@ -2,6 +2,7 @@ use rand::seq::SliceRandom;
 use serde::Serialize;
 
 use engine::database::CardDatabase;
+use engine::parser::oracle::draft_effect_from_oracle_text;
 use engine::types::card::CardFace;
 use engine::types::card_type::CoreType;
 use engine::types::mana::ManaColor;
@@ -161,6 +162,10 @@ fn card_instance_from_face(face: &CardFace, index: usize, copy: u32) -> DraftCar
         colors: face.color_identity.iter().map(mana_color_letter).collect(),
         cmc: face.mana_cost.mana_value().min(u32::from(u8::MAX)) as u8,
         type_line: type_line(face),
+        draft_effect: face
+            .oracle_text
+            .as_deref()
+            .and_then(draft_effect_from_oracle_text),
     }
 }
 
@@ -301,6 +306,7 @@ mod tests {
                 colors: Vec::new(),
                 cmc: 0,
                 type_line: String::new(),
+                draft_effect: None,
             })
             .collect();
         let source = CubePackSource::new(cards);
diff --git a/crates/draft-core/src/extraction.rs b/crates/draft-core/src/extraction.rs
index 58bcb4e145..5feac93c9a 100644
--- a/crates/draft-core/src/extraction.rs
+++ b/crates/draft-core/src/extraction.rs
@@ -3,6 +3,8 @@ use std::path::Path;
 
 use serde::Deserialize;
 
+use engine::parser::oracle::draft_effect_from_oracle_text;
+
 use crate::set_pool::{
     LimitedCardPrint, LimitedSetPool, PackSlot, PackVariant, Rarity, SheetCard, SheetDefinition,
     WeightedSheetChoice,
@@ -125,6 +127,8 @@ struct MtgjsonCard {
     /// Full type line (e.g. "Creature — Human Wizard"). Used for frontend sorting.
     #[serde(default, rename = "type")]
     type_line: String,
+    #[serde(default)]
+    text: Option<String>,
 }
 
 // ---------------------------------------------------------------------------
@@ -200,6 +204,7 @@ fn extract_set_pool_indexed(
                     colors: card.colors.clone(),
                     cmc: card.mana_value as u8,
                     type_line: card.type_line.clone(),
+                    draft_effect: card.text.as_deref().and_then(draft_effect_from_oracle_text),
                 });
             } else {
                 eprintln!(
diff --git a/crates/draft-core/src/pack_generator.rs b/crates/draft-core/src/pack_generator.rs
index b39bc1696d..84ecb727f5 100644
--- a/crates/draft-core/src/pack_generator.rs
+++ b/crates/draft-core/src/pack_generator.rs
@@ -128,6 +128,7 @@ impl PackSource for PackGenerator {
                 colors: card.colors.clone(),
                 cmc: card.cmc,
                 type_line: card.type_line.clone(),
+                draft_effect: card.draft_effect,
             })
             .collect();
 
@@ -267,6 +268,7 @@ mod tests {
                 colors: Vec::new(),
                 cmc: 0,
                 type_line: String::new(),
+                draft_effect: None,
             })
             .collect()
     }
@@ -686,6 +688,7 @@ mod tests {
                     colors: vec![],
                     cmc: 0,
                     type_line: String::new(),
+                    draft_effect: None,
                 },
                 SheetCard {
                     name: "Single".to_string(),
@@ -696,6 +699,7 @@ mod tests {
                     colors: vec![],
                     cmc: 0,
                     type_line: String::new(),
+                    draft_effect: None,
                 },
             ],
             total_weight: 3,
@@ -719,6 +723,7 @@ mod tests {
                 colors: vec![],
                 cmc: 0,
                 type_line: String::new(),
+                draft_effect: None,
             }],
             total_weight: 1,
             allow_duplicates: true,
diff --git a/crates/draft-core/src/pack_source.rs b/crates/draft-core/src/pack_source.rs
index ceed8ac46b..4039ef559c 100644
--- a/crates/draft-core/src/pack_source.rs
+++ b/crates/draft-core/src/pack_source.rs
@@ -48,6 +48,7 @@ impl PackSource for FixturePackSource {
                 colors: Vec::new(),
                 cmc: 0,
                 type_line: String::new(),
+                draft_effect: None,
             })
             .collect();
         DraftPack(cards)
diff --git a/crates/draft-core/src/pick_pass.rs b/crates/draft-core/src/pick_pass.rs
index 86a61c90a0..4c079f7a38 100644
--- a/crates/draft-core/src/pick_pass.rs
+++ b/crates/draft-core/src/pick_pass.rs
@@ -6,6 +6,32 @@ pub fn apply_pick(
     session: &mut DraftSession,
     seat: u8,
     card_instance_id: String,
+) -> Result<Vec<DraftDelta>, DraftError> {
+    apply_pick_inner(session, seat, card_instance_id)
+}
+
+/// CR 905.1a + CR 905.2: Draft two cards from the current booster in exchange
+/// for returning the face-up effect card to that booster.
+pub fn apply_pick_with_draft_effect(
+    session: &mut DraftSession,
+    seat: u8,
+    effect_card_instance_id: String,
+    card_instance_ids: Vec<String>,
+) -> Result<Vec<DraftDelta>, DraftError> {
+    if card_instance_ids.len() != 2 {
+        return Err(DraftError::InvalidDraftEffectSelection {
+            expected_cards: 2,
+            actual_cards: card_instance_ids.len(),
+        });
+    }
+
+    apply_pick_with_effect_inner(session, seat, effect_card_instance_id, card_instance_ids)
+}
+
+fn apply_pick_inner(
+    session: &mut DraftSession,
+    seat: u8,
+    card_instance_id: String,
 ) -> Result<Vec<DraftDelta>, DraftError> {
     if session.status != DraftStatus::Drafting {
         return Err(DraftError::InvalidTransition {
@@ -31,26 +57,124 @@ pub fn apply_pick(
         return Err(DraftError::SeatAlreadyPickedThisRound { seat });
     }
 
+    let picked = {
+        let pack = session.current_pack[seat as usize]
+            .as_mut()
+            .ok_or(DraftError::NoPendingPack { seat })?;
+
+        let card_index = pack
+            .0
+            .iter()
+            .position(|c| c.instance_id == card_instance_id)
+            .ok_or_else(|| DraftError::CardNotInPack {
+                card_instance_id: card_instance_id.clone(),
+            })?;
+
+        pack.0.remove(card_index)
+    };
+
+    session.pools[seat as usize].push(picked);
+
+    finish_pick(session, seat, vec![card_instance_id])
+}
+
+fn apply_pick_with_effect_inner(
+    session: &mut DraftSession,
+    seat: u8,
+    effect_card_instance_id: String,
+    card_instance_ids: Vec<String>,
+) -> Result<Vec<DraftDelta>, DraftError> {
+    if session.status != DraftStatus::Drafting {
+        return Err(DraftError::InvalidTransition {
+            from: session.status,
+            action: "PickWithDraftEffect".to_string(),
+        });
+    }
+
+    let pod_size = session.seats.len() as u8;
+    if seat >= pod_size {
+        return Err(DraftError::SeatOutOfRange { seat, pod_size });
+    }
+    session.seats_picked_this_round.ensure_len(pod_size, false);
+    session.connected_seats.ensure_len(pod_size, true);
+    if session.seats_picked_this_round.get(seat) {
+        return Err(DraftError::SeatAlreadyPickedThisRound { seat });
+    }
+    if card_instance_ids[0] == card_instance_ids[1] {
+        return Err(DraftError::InvalidDraftEffectSelection {
+            expected_cards: 2,
+            actual_cards: 1,
+        });
+    }
+
+    let effect_index = session.pools[seat as usize]
+        .iter()
+        .position(|card| {
+            card.instance_id == effect_card_instance_id
+                && matches!(
+                    card.draft_effect,
+                    Some(engine::types::card::DraftEffect::AdditionalPick)
+                )
+        })
+        .ok_or_else(|| DraftError::DraftEffectCardNotInPool {
+            card_instance_id: effect_card_instance_id.clone(),
+        })?;
+
     let pack = session.current_pack[seat as usize]
-        .as_mut()
+        .as_ref()
         .ok_or(DraftError::NoPendingPack { seat })?;
+    let missing_card = card_instance_ids
+        .iter()
+        .find(|card_id| !pack.0.iter().any(|card| card.instance_id == **card_id));
+    if let Some(missing_card) = missing_card {
+        return Err(DraftError::CardNotInPack {
+            card_instance_id: missing_card.clone(),
+        });
+    }
+
+    let picked_cards = {
+        let pack = session.current_pack[seat as usize]
+            .as_mut()
+            .expect("pack was present during draft-effect validation");
+        card_instance_ids
+            .iter()
+            .map(|card_id| {
+                let index = pack
+                    .0
+                    .iter()
+                    .position(|card| card.instance_id == *card_id)
+                    .expect("validated draft-effect card must remain in the pack");
+                pack.0.remove(index)
+            })
+            .collect::<Vec<_>>()
+    };
 
-    let card_index = pack
+    let effect_card = session.pools[seat as usize].remove(effect_index);
+    session.pools[seat as usize].extend(picked_cards);
+    session.current_pack[seat as usize]
+        .as_mut()
+        .expect("pack was present while selecting the extra cards")
         .0
-        .iter()
-        .position(|c| c.instance_id == card_instance_id)
-        .ok_or_else(|| DraftError::CardNotInPack {
-            card_instance_id: card_instance_id.clone(),
-        })?;
+        .push(effect_card);
 
-    let picked = pack.0.remove(card_index);
-    session.pools[seat as usize].push(picked);
+    finish_pick(session, seat, card_instance_ids)
+}
+
+fn finish_pick(
+    session: &mut DraftSession,
+    seat: u8,
+    card_instance_ids: Vec<String>,
+) -> Result<Vec<DraftDelta>, DraftError> {
+    let pod_size = session.seats.len() as u8;
     session.seats_picked_this_round.set(seat, true);
 
-    let mut deltas = vec![DraftDelta::CardPicked {
-        seat,
-        card_instance_id,
-    }];
+    let mut deltas: Vec<DraftDelta> = card_instance_ids
+        .into_iter()
+        .map(|card_instance_id| DraftDelta::CardPicked {
+            seat,
+            card_instance_id,
+        })
+        .collect();
 
     // Round complete when every seat that still owes a pick has picked.
     // A seat owes a pick iff its current_pack is Some and non-empty. Seats
@@ -242,6 +366,68 @@ mod tests {
         assert!(matches!(result, Err(DraftError::CardNotInPack { .. })));
     }
 
+    #[test]
+    fn draft_effect_pick_returns_effect_card_to_pack() {
+        let (mut session, source) = test_session(2);
+        start_draft(&mut session, &source);
+
+        let effect_card = DraftCardInstance {
+            instance_id: "cogwork-1".to_string(),
+            name: "Cogwork Librarian".to_string(),
+            set_code: "CNS".to_string(),
+            collector_number: "58".to_string(),
+            rarity: "common".to_string(),
+            colors: Vec::new(),
+            cmc: 4,
+            type_line: "Artifact Creature — Construct".to_string(),
+            draft_effect: Some(engine::types::card::DraftEffect::AdditionalPick),
+        };
+        session.pools[0].push(effect_card.clone());
+        let first_card_id = session.current_pack[0].as_ref().unwrap().0[0]
+            .instance_id
+            .clone();
+        let second_card_id = session.current_pack[0].as_ref().unwrap().0[1]
+            .instance_id
+            .clone();
+        let pack_len = session.current_pack[0].as_ref().unwrap().0.len();
+
+        let deltas = session::apply(
+            &mut session,
+            DraftAction::PickWithDraftEffect {
+                seat: 0,
+                effect_card_instance_id: effect_card.instance_id.clone(),
+                card_instance_ids: vec![first_card_id.clone(), second_card_id.clone()],
+            },
+            None,
+        )
+        .unwrap();
+
+        let pack = session.current_pack[0].as_ref().unwrap();
+        assert_eq!(pack.0.len(), pack_len - 1);
+        assert!(pack
+            .0
+            .iter()
+            .any(|card| card.instance_id == effect_card.instance_id));
+        assert!(!session.pools[0]
+            .iter()
+            .any(|card| card.instance_id == effect_card.instance_id));
+        assert!(session.pools[0]
+            .iter()
+            .any(|card| card.instance_id == first_card_id));
+        assert!(session.pools[0]
+            .iter()
+            .any(|card| card.instance_id == second_card_id));
+        assert!(deltas.contains(&DraftDelta::CardPicked {
+            seat: 0,
+            card_instance_id: first_card_id,
+        }));
+        assert!(deltas.contains(&DraftDelta::CardPicked {
+            seat: 0,
+            card_instance_id: second_card_id,
+        }));
+        assert!(!deltas.contains(&DraftDelta::PackPassed));
+    }
+
     #[test]
     fn pick_no_pending_pack_returns_error() {
         let (mut session, source) = test_session(8);
diff --git a/crates/draft-core/src/session.rs b/crates/draft-core/src/session.rs
index 79160dc951..9c4196e507 100644
--- a/crates/draft-core/src/session.rs
+++ b/crates/draft-core/src/session.rs
@@ -134,6 +134,16 @@ pub fn apply(
             seat,
             card_instance_id,
         } => pick_pass::apply_pick(session, seat, card_instance_id),
+        DraftAction::PickWithDraftEffect {
+            seat,
+            effect_card_instance_id,
+            card_instance_ids,
+        } => pick_pass::apply_pick_with_draft_effect(
+            session,
+            seat,
+            effect_card_instance_id,
+            card_instance_ids,
+        ),
         DraftAction::SubmitDeck { seat, main_deck } => apply_submit_deck(session, seat, main_deck),
         DraftAction::GeneratePairings { round } => apply_generate_pairings(session, round),
         DraftAction::ReportMatchResult {
@@ -1062,6 +1072,7 @@ mod tests {
                 colors: Vec::new(),
                 cmc: 0,
                 type_line: String::new(),
+                draft_effect: None,
             })
             .collect();
 
@@ -1093,6 +1104,7 @@ mod tests {
                 colors: Vec::new(),
                 cmc: 0,
                 type_line: String::new(),
+                draft_effect: None,
             })
             .collect();
 
@@ -1146,6 +1158,7 @@ mod tests {
                 colors: Vec::new(),
                 cmc: 0,
                 type_line: String::new(),
+                draft_effect: None,
             })
             .collect();
 
@@ -1180,6 +1193,7 @@ mod tests {
                     colors: Vec::new(),
                     cmc: 0,
                     type_line: String::new(),
+                    draft_effect: None,
                 })
                 .collect();
         }
diff --git a/crates/draft-core/src/set_pool.rs b/crates/draft-core/src/set_pool.rs
index 49974f7bbd..4f722156e7 100644
--- a/crates/draft-core/src/set_pool.rs
+++ b/crates/draft-core/src/set_pool.rs
@@ -2,6 +2,8 @@ use std::collections::BTreeMap;
 
 use serde::{Deserialize, Serialize};
 
+use engine::types::card::DraftEffect;
+
 /// Rarity of a card printing.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
@@ -46,6 +48,9 @@ pub struct SheetCard {
     /// Full type line, e.g. "Creature — Human Wizard". Populated from MTGJSON at extraction.
     #[serde(default)]
     pub type_line: String,
+    /// Draft-time effect parsed from the card's Oracle text.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub draft_effect: Option<DraftEffect>,
 }
 
 /// A named sheet of cards (e.g., "common", "uncommon", "rareMythic").
diff --git a/crates/draft-core/src/types.rs b/crates/draft-core/src/types.rs
index 2f027031d5..066a0c0f52 100644
--- a/crates/draft-core/src/types.rs
+++ b/crates/draft-core/src/types.rs
@@ -2,11 +2,11 @@ use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
 
+use crate::validation::{LimitedDeckError, STANDARD_BASIC_LANDS};
+use engine::types::card::DraftEffect;
 use engine::types::match_config::{MatchConfig, MatchType};
 use engine::types::player::PlayerId;
 
-use crate::validation::{LimitedDeckError, STANDARD_BASIC_LANDS};
-
 /// Tournament pairing format for the draft event.
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
 pub enum TournamentFormat {
@@ -231,6 +231,9 @@ pub struct DraftCardInstance {
     /// Full type line, e.g. "Creature — Human Wizard". Populated at pack generation from set pool data.
     #[serde(default)]
     pub type_line: String,
+    /// Draft-time effect parsed from the card's Oracle text.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub draft_effect: Option<DraftEffect>,
 }
 
 /// A pack of cards, newtype wrapper over Vec<DraftCardInstance>.
@@ -344,6 +347,11 @@ pub enum DraftAction {
         seat: u8,
         card_instance_id: String,
     },
+    PickWithDraftEffect {
+        seat: u8,
+        effect_card_instance_id: String,
+        card_instance_ids: Vec<String>,
+    },
     SubmitDeck {
         seat: u8,
         main_deck: Vec<String>,
@@ -418,6 +426,13 @@ pub enum DraftError {
     SeatOutOfRange { seat: u8, pod_size: u8 },
     #[error("card '{card_instance_id}' not found in pack")]
     CardNotInPack { card_instance_id: String },
+    #[error("draft effect card '{card_instance_id}' is not in the player's pool")]
+    DraftEffectCardNotInPool { card_instance_id: String },
+    #[error("draft effect requires {expected_cards} cards, got {actual_cards}")]
+    InvalidDraftEffectSelection {
+        expected_cards: usize,
+        actual_cards: usize,
+    },
     #[error("seat {seat} has no pending pack")]
     NoPendingPack { seat: u8 },
     #[error("deck validation failed")]
diff --git a/crates/draft-core/src/view.rs b/crates/draft-core/src/view.rs
index b5ce3a4a8a..eebcb33599 100644
--- a/crates/draft-core/src/view.rs
+++ b/crates/draft-core/src/view.rs
@@ -42,6 +42,8 @@ pub struct SeatPublicView {
     pub connected: bool,
     pub has_submitted_deck: bool,
     pub pick_status: PickStatus,
+    /// CR 905.2c: Draft cards that remain face up are visible to every player.
+    pub face_up_draft_cards: Vec<DraftCardInstance>,
 }
 
 /// A stable, engine-defined category for a limited pool display group.
@@ -139,6 +141,8 @@ pub struct DraftPlayerView {
     pub current_pack: Option<Vec<DraftCardInstance>>,
     /// The viewer's drafted pool
     pub pool: Vec<DraftCardInstance>,
+    /// Drafted cards whose effects can be activated during a later pick.
+    pub draft_effects: Vec<DraftCardInstance>,
     /// Engine-defined groups for displaying the viewer's pool without client-side
     /// card classification, ordering, or deduplication.
     pub pool_groups: DraftPoolGroups,
@@ -255,6 +259,7 @@ pub fn filter_for_spectator(
                     .map(|pid| session.submitted_decks.contains_key(&pid))
                     .unwrap_or(false),
                 pick_status,
+                face_up_draft_cards: face_up_draft_cards(&session.pools[i]),
             }
         })
         .collect();
@@ -322,6 +327,7 @@ pub fn filter_for_player(session: &DraftSession, seat_index: u8) -> DraftPlayerV
         .map(|p| p.0.clone());
 
     let pool = session.pools.get(idx).cloned().unwrap_or_default();
+    let draft_effects = face_up_draft_cards(&pool);
     let sealed_packs = (session.kind == DraftKind::Sealed).then(|| {
         pool.chunks(usize::from(session.config.cards_per_pack))
             .map(ToOwned::to_owned)
@@ -370,6 +376,7 @@ pub fn filter_for_player(session: &DraftSession, seat_index: u8) -> DraftPlayerV
                     .map(|pid| session.submitted_decks.contains_key(&pid))
                     .unwrap_or(false),
                 pick_status,
+                face_up_draft_cards: face_up_draft_cards(&session.pools[i]),
             }
         })
         .collect();
@@ -388,6 +395,7 @@ pub fn filter_for_player(session: &DraftSession, seat_index: u8) -> DraftPlayerV
         pass_direction: session.pass_direction,
         current_pack,
         pool,
+        draft_effects,
         pool_groups,
         sealed_packs,
         seats,
@@ -405,6 +413,13 @@ pub fn filter_for_player(session: &DraftSession, seat_index: u8) -> DraftPlayerV
     }
 }
 
+fn face_up_draft_cards(pool: &[DraftCardInstance]) -> Vec<DraftCardInstance> {
+    pool.iter()
+        .filter(|card| card.draft_effect.is_some())
+        .cloned()
+        .collect()
+}
+
 const COLOR_GROUP_ORDER: [DraftPoolGroupKind; 7] = [
     DraftPoolGroupKind::White,
     DraftPoolGroupKind::Blue,
@@ -714,6 +729,7 @@ mod tests {
             colors: colors.iter().map(ToString::to_string).collect(),
             cmc,
             type_line: type_line.to_string(),
+            draft_effect: None,
         }
     }
 
@@ -743,6 +759,33 @@ mod tests {
         assert_eq!(view.pool[0].instance_id, session.pools[0][0].instance_id);
     }
 
+    #[test]
+    fn view_exposes_other_players_face_up_draft_cards_without_their_pool() {
+        let (mut session, source) = test_session(2);
+        session::apply(&mut session, DraftAction::StartDraft, Some(&source)).unwrap();
+
+        let face_up = DraftCardInstance {
+            instance_id: "cogwork-1".to_string(),
+            name: "Cogwork Librarian".to_string(),
+            set_code: "CNS".to_string(),
+            collector_number: "58".to_string(),
+            rarity: "common".to_string(),
+            colors: Vec::new(),
+            cmc: 4,
+            type_line: "Artifact Creature — Construct".to_string(),
+            draft_effect: Some(engine::types::card::DraftEffect::AdditionalPick),
+        };
+        let hidden = draft_card("Hidden Pool Card", &[], 2, "Creature");
+        session.pools[1] = vec![face_up.clone(), hidden.clone()];
+
+        let view = filter_for_player(&session, 0);
+
+        assert_eq!(view.seats[1].face_up_draft_cards, vec![face_up]);
+        assert!(view.draft_effects.is_empty());
+        let json = serde_json::to_string(&view).unwrap();
+        assert!(!json.contains(&hidden.instance_id));
+    }
+
     #[test]
     fn sealed_view_preserves_the_viewers_pack_boundaries() {
         let (mut session, source) = test_session(2);
@@ -940,6 +983,7 @@ mod tests {
                 colors: Vec::new(),
                 cmc: 0,
                 type_line: String::new(),
+                draft_effect: None,
             })
             .collect();
         session.pools[1] = session.pools[0].clone();
diff --git a/crates/draft-wasm/src/lib.rs b/crates/draft-wasm/src/lib.rs
index 1408ca5467..0d4bf51c39 100644
--- a/crates/draft-wasm/src/lib.rs
+++ b/crates/draft-wasm/src/lib.rs
@@ -387,21 +387,27 @@ fn apply_human_pick_and_resolve_bots(
     draft_session: &mut DraftSession,
     human_card_id: String,
 ) -> Result<(), JsValue> {
-    if !matches!(draft_session.config.kind, DraftKind::Quick) {
-        return Err(JsValue::from_str(
-            "apply_human_pick_and_resolve_bots is only valid for Quick Draft",
-        ));
-    }
-
-    session::apply(
+    apply_human_pick_and_resolve_bots_with_action(
         draft_session,
         DraftAction::Pick {
             seat: 0,
             card_instance_id: human_card_id,
         },
-        None,
     )
-    .map_err(|e| JsValue::from_str(&format!("Human pick failed: {}", e)))?;
+}
+
+fn apply_human_pick_and_resolve_bots_with_action(
+    draft_session: &mut DraftSession,
+    human_action: DraftAction,
+) -> Result<(), JsValue> {
+    if !matches!(draft_session.config.kind, DraftKind::Quick) {
+        return Err(JsValue::from_str(
+            "apply_human_pick_and_resolve_bots is only valid for Quick Draft",
+        ));
+    }
+
+    session::apply(draft_session, human_action, None)
+        .map_err(|e| JsValue::from_str(&format!("Human pick failed: {}", e)))?;
 
     let difficulty = DIFFICULTY.with(|cell| cell.get());
     let mut rng = RNG
@@ -459,6 +465,29 @@ pub fn submit_pick(card_instance_id: &str) -> Result<JsValue, JsValue> {
     })
 }
 
+/// Submit an additional pick using a drafted card's draft-time effect, then
+/// resolve all bot picks.
+#[wasm_bindgen]
+pub fn submit_pick_with_draft_effect(
+    effect_card_instance_id: &str,
+    card_instance_ids_json: &str,
+) -> Result<JsValue, JsValue> {
+    let effect_card_instance_id = effect_card_instance_id.to_string();
+    let card_instance_ids: Vec<String> = serde_json::from_str(card_instance_ids_json)
+        .map_err(|e| JsValue::from_str(&format!("Failed to parse draft-effect cards: {e}")))?;
+    with_draft_mut(|draft_session| {
+        apply_human_pick_and_resolve_bots_with_action(
+            draft_session,
+            DraftAction::PickWithDraftEffect {
+                seat: 0,
+                effect_card_instance_id,
+                card_instance_ids,
+            },
+        )?;
+        Ok(to_js(&filter_for_player(draft_session, 0)))
+    })
+}
+
 /// Auto-pick the best card from the human's current pack using the same AI the
 /// bots use (at the active difficulty), then resolve all bot picks.
 ///
@@ -596,6 +625,37 @@ pub fn submit_pick_for_seat(seat: u8, card_instance_id: &str) -> Result<JsValue,
     })
 }
 
+/// Submit a draft-effect pick for any seat (host proxies guest picks).
+///
+/// Returns the filtered DraftPlayerView for the specified seat after the pick.
+#[wasm_bindgen]
+pub fn submit_pick_with_draft_effect_for_seat(
+    seat: u8,
+    effect_card_instance_id: &str,
+    card_instance_ids_json: &str,
+) -> Result<JsValue, JsValue> {
+    let effect_card_instance_id = effect_card_instance_id.to_string();
+    let card_instance_ids: Vec<String> = serde_json::from_str(card_instance_ids_json)
+        .map_err(|e| JsValue::from_str(&format!("Failed to parse draft-effect cards: {e}")))?;
+
+    with_draft_mut(|draft_session| {
+        session::apply(
+            draft_session,
+            DraftAction::PickWithDraftEffect {
+                seat,
+                effect_card_instance_id,
+                card_instance_ids,
+            },
+            None,
+        )
+        .map_err(|e| {
+            JsValue::from_str(&format!("Draft-effect pick failed for seat {seat}: {e}"))
+        })?;
+
+        Ok(to_js(&filter_for_player(draft_session, seat)))
+    })
+}
+
 /// Mark a human seat as connected or disconnected. The host adapter calls
 /// this on guest disconnect/reconnect so `DraftPlayerView.seats[*].connected`
 /// reflects the runtime state. Rejects bot seats with `SeatIsBot`.
diff --git a/crates/draft-wasm/src/suggest.rs b/crates/draft-wasm/src/suggest.rs
index 4f0b2fd64b..28d7ca4b71 100644
--- a/crates/draft-wasm/src/suggest.rs
+++ b/crates/draft-wasm/src/suggest.rs
@@ -430,6 +430,7 @@ mod tests {
             colors: colors.iter().map(|s| s.to_string()).collect(),
             cmc,
             type_line: type_line.to_string(),
+            draft_effect: None,
         }
     }
 
diff --git a/crates/engine/src/game/coverage.rs b/crates/engine/src/game/coverage.rs
index d4a2cb0a9b..d36317026f 100644
--- a/crates/engine/src/game/coverage.rs
+++ b/crates/engine/src/game/coverage.rs
@@ -6992,6 +6992,7 @@ fn count_effective_oracle_lines(oracle_text: &str) -> usize {
         if is_deck_construction_copy_limit_sentence(stripped) {
             continue;
         }
+
         // Draft-time "draft matters" lines (CR 905) are consumed as no-ops by
         // the parser, so they produce no parse item — don't count them as
         // effective Oracle lines either, or the silent-drop guard would flag
@@ -9224,6 +9225,12 @@ fn audit_card_lines(oracle_text: &str, face: &CardFace) -> Vec<SemanticFinding>
             continue;
         }
 
+        // CR 905.1a + CR 905.2: Draft-procedure lines are handled by the
+        // Draft engine, not by constructed-game card abilities.
+        if is_draft_matters_sentence(stripped) {
+            continue;
+        }
+
         // Skip very short lines (single keywords, type lines)
         if lower.len() < 5 {
             continue;
@@ -13552,6 +13559,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_audit_skips_draft_procedure_lines() {
+        let face = make_face();
+        let oracle = "Draft this card face up.\nAs you draft a card, you may draft an additional card from that booster pack.\nIf you do, put this card into that booster pack.";
+
+        let findings = audit_card_lines(oracle, &face);
+
+        assert!(
+            findings.is_empty(),
+            "draft-procedure lines are owned by CR 905 draft handling: {findings:?}"
+        );
+    }
+
     #[test]
     fn test_audit_per_line_detects_unimplemented_stub() {
         let mut face = make_face();
diff --git a/crates/engine/src/parser/oracle.rs b/crates/engine/src/parser/oracle.rs
index 96e6f30279..8edb802c04 100644
--- a/crates/engine/src/parser/oracle.rs
+++ b/crates/engine/src/parser/oracle.rs
@@ -20,6 +20,7 @@ use crate::types::ability::{
     TapStateChange, TargetFilter, TriggerCondition, TriggerDefinition, TypedFilter,
 };
 use crate::types::ability_visit::{visit_ability_def_scoped, ResolutionScope};
+use crate::types::card::DraftEffect;
 use crate::types::format::DeckCopyLimit;
 use crate::types::keywords::{EscapeCost, FlashbackCost, Keyword, KeywordKind};
 use crate::types::mana::ManaCost;
@@ -400,6 +401,7 @@ pub(crate) fn is_draft_matters_sentence(line: &str) -> bool {
     let lower = line.trim().to_ascii_lowercase();
     lower_starts_with(&lower, "draft this card face up")
         || lower_starts_with(&lower, "as you draft ")
+        || lower_starts_with(&lower, "if you do, put this card into that booster pack")
         || lower_starts_with(&lower, "during the draft")
         || lower_starts_with(&lower, "immediately after the draft")
         || lower_starts_with(&lower, "instead of drafting ")
@@ -407,6 +409,43 @@ pub(crate) fn is_draft_matters_sentence(line: &str) -> bool {
         || lower_starts_with(&lower, "each player passes the last card")
 }
 
+/// CR 905.1a + CR 905.2: Identify a draft-time ability that changes the
+/// booster-draft procedure rather than constructed-game resolution.
+pub fn draft_effect_from_oracle_text(oracle_text: &str) -> Option<DraftEffect> {
+    let lower = oracle_text.to_lowercase();
+    let pair = TextPair::new(oracle_text, &lower);
+    let parsed = nom_on_lower(pair.original, pair.lower, |input| {
+        all_consuming(terminated(
+            (
+                terminated(
+                    value((), tag("draft this card face up")),
+                    tag("."),
+                ),
+                preceded(
+                    multispace0,
+                    terminated(
+                        value(
+                            (),
+                            tag("as you draft a card, you may draft an additional card from that booster pack"),
+                        ),
+                        tag("."),
+                    ),
+                ),
+                preceded(
+                    multispace0,
+                    terminated(
+                        value((), tag("if you do, put this card into that booster pack")),
+                        opt(tag(".")),
+                    ),
+                ),
+            ),
+            multispace0,
+        ))
+        .parse(input)
+    });
+    parsed.is_some().then_some(DraftEffect::AdditionalPick)
+}
+
 /// Whether Oracle text explicitly permits this card to be a commander.
 pub fn oracle_text_allows_commander(oracle_text: &str, card_name: &str) -> bool {
     let normalized = normalize_card_name_refs(oracle_text, card_name);
diff --git a/crates/engine/src/parser/oracle_tests.rs b/crates/engine/src/parser/oracle_tests.rs
index 160732365e..75bf3826ec 100644
--- a/crates/engine/src/parser/oracle_tests.rs
+++ b/crates/engine/src/parser/oracle_tests.rs
@@ -5758,6 +5758,9 @@ fn draft_matters_sentence_positive_cases() {
         "As long as this card is face up during the draft, you can't look at booster packs \
              and must draft cards at random."
     ));
+    assert!(is_draft_matters_sentence(
+        "If you do, put this card into that booster pack."
+    ));
     assert!(is_draft_matters_sentence(
         "Each player passes the last card from each booster pack to a player who drafted a \
              card named Canal Dredger."
@@ -5789,6 +5792,34 @@ fn draft_matters_sentence_negative_cases() {
     ));
 }
 
+#[test]
+fn draft_effect_from_oracle_text_recognizes_additional_pick() {
+    assert_eq!(
+        draft_effect_from_oracle_text(
+            "Draft this card face up.\nAs you draft a card, you may draft an additional card from that booster pack.\nIf you do, put this card into that booster pack."
+        ),
+        Some(crate::types::card::DraftEffect::AdditionalPick)
+    );
+    assert_eq!(
+        draft_effect_from_oracle_text(
+            "Draft this card face up.\nAs you draft a card, you may draft an additional card from that booster pack. If you do, put this card into that booster pack."
+        ),
+        Some(crate::types::card::DraftEffect::AdditionalPick)
+    );
+    assert_eq!(
+        draft_effect_from_oracle_text(
+            "As you draft a card, you may draft an additional card from that booster pack."
+        ),
+        None
+    );
+    assert_eq!(
+        draft_effect_from_oracle_text(
+            "As you draft a card, you may draft an additional card from that booster pack. If you do, put this card into that booster pack."
+        ),
+        None
+    );
+}
+
 #[test]
 fn tempest_hawk_oracle_text_produces_no_unimplemented_static() {
     // Full Oracle text fixture for Tempest Hawk — the bug surface from
diff --git a/crates/engine/src/types/card.rs b/crates/engine/src/types/card.rs
index 718eb8b9ac..9115a52215 100644
--- a/crates/engine/src/types/card.rs
+++ b/crates/engine/src/types/card.rs
@@ -91,6 +91,13 @@ pub struct PrintedCardRef {
     pub face_name: String,
 }
 
+/// A card ability that changes how the booster draft proceeds.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum DraftEffect {
+    AdditionalPick,
+}
+
 /// Exact image reference for a printed token.
 ///
 /// This is display metadata only. It is deliberately separate from
diff --git a/crates/phase-server/src/main.rs b/crates/phase-server/src/main.rs
index 40a85ea7af..9505420668 100644
--- a/crates/phase-server/src/main.rs
+++ b/crates/phase-server/src/main.rs
@@ -1078,6 +1078,7 @@ fn client_forbidden_draft_action_reason(action: &draft_core::types::DraftAction)
         }
         DraftAction::StartDraft
         | DraftAction::Pick { .. }
+        | DraftAction::PickWithDraftEffect { .. }
         | DraftAction::SubmitDeck { .. }
         | DraftAction::ReportMatchResult { .. }
         | DraftAction::AdvanceRound
@@ -9795,6 +9796,11 @@ mod handshake_tests {
                 seat: 0,
                 card_instance_id: "x".into(),
             },
+            draft_core::types::DraftAction::PickWithDraftEffect {
+                seat: 0,
+                effect_card_instance_id: "effect".into(),
+                card_instance_ids: vec!["x".into(), "y".into()],
+            },
             draft_core::types::DraftAction::SubmitDeck {
                 seat: 0,
                 main_deck: vec![],
diff --git a/crates/server-core/src/draft_action_payload_guard.rs b/crates/server-core/src/draft_action_payload_guard.rs
index d628885048..0c152602c8 100644
--- a/crates/server-core/src/draft_action_payload_guard.rs
+++ b/crates/server-core/src/draft_action_payload_guard.rs
@@ -18,6 +18,30 @@ pub fn guard_draft_action_payload(action: &DraftAction) -> Result<(), String> {
         } => {
             validate_token("Pick.card_instance_id", card_instance_id, MAX_TOKEN_LEN)?;
         }
+        DraftAction::PickWithDraftEffect {
+            effect_card_instance_id,
+            card_instance_ids,
+            ..
+        } => {
+            validate_token(
+                "PickWithDraftEffect.effect_card_instance_id",
+                effect_card_instance_id,
+                MAX_TOKEN_LEN,
+            )?;
+            if card_instance_ids.len() != 2 {
+                return Err("PickWithDraftEffect requires exactly two card IDs".to_string());
+            }
+            if card_instance_ids[0] == card_instance_ids[1] {
+                return Err("PickWithDraftEffect requires distinct card IDs".to_string());
+            }
+            for card_instance_id in card_instance_ids {
+                validate_token(
+                    "PickWithDraftEffect.card_instance_id",
+                    card_instance_id,
+                    MAX_TOKEN_LEN,
+                )?;
+            }
+        }
         DraftAction::SubmitDeck { main_deck, .. } => {
             validate_deck_list("SubmitDeck.main_deck", main_deck, MAX_MAIN_DECK_ENTRIES)?;
         }
@@ -63,6 +87,49 @@ mod tests {
         assert!(err.contains("card_instance_id"));
     }
 
+    #[test]
+    fn draft_effect_pick_accepts_two_distinct_card_ids() {
+        let action = DraftAction::PickWithDraftEffect {
+            seat: 0,
+            effect_card_instance_id: "cogwork-1".to_string(),
+            card_instance_ids: vec!["card-1".to_string(), "card-2".to_string()],
+        };
+        assert!(guard_draft_action_payload(&action).is_ok());
+    }
+
+    #[test]
+    fn draft_effect_pick_rejects_wrong_card_count() {
+        let action = DraftAction::PickWithDraftEffect {
+            seat: 0,
+            effect_card_instance_id: "cogwork-1".to_string(),
+            card_instance_ids: vec!["card-1".to_string()],
+        };
+        let err = guard_draft_action_payload(&action).unwrap_err();
+        assert!(err.contains("exactly two"));
+    }
+
+    #[test]
+    fn draft_effect_pick_rejects_duplicate_card_ids() {
+        let action = DraftAction::PickWithDraftEffect {
+            seat: 0,
+            effect_card_instance_id: "cogwork-1".to_string(),
+            card_instance_ids: vec!["card-1".to_string(), "card-1".to_string()],
+        };
+        let err = guard_draft_action_payload(&action).unwrap_err();
+        assert!(err.contains("distinct"));
+    }
+
+    #[test]
+    fn draft_effect_pick_rejects_oversized_card_id() {
+        let action = DraftAction::PickWithDraftEffect {
+            seat: 0,
+            effect_card_instance_id: "cogwork-1".to_string(),
+            card_instance_ids: vec!["card-1".to_string(), "x".repeat(MAX_TOKEN_LEN + 1)],
+        };
+        let err = guard_draft_action_payload(&action).unwrap_err();
+        assert!(err.contains("card_instance_id"));
+    }
+
     #[test]
     fn submit_deck_rejects_oversized_main() {
         let action = DraftAction::SubmitDeck {
diff --git a/crates/server-core/src/draft_session.rs b/crates/server-core/src/draft_session.rs
index 41a2530455..931e79c312 100644
--- a/crates/server-core/src/draft_session.rs
+++ b/crates/server-core/src/draft_session.rs
@@ -768,6 +768,15 @@ fn authorize_client_draft_action(seat: usize, action: DraftAction) -> Result<Dra
             seat: seat as u8,
             card_instance_id,
         }),
+        DraftAction::PickWithDraftEffect {
+            effect_card_instance_id,
+            card_instance_ids,
+            ..
+        } => Ok(DraftAction::PickWithDraftEffect {
+            seat: seat as u8,
+            effect_card_instance_id,
+            card_instance_ids,
+        }),
         DraftAction::SubmitDeck { main_deck, .. } => Ok(DraftAction::SubmitDeck {
             seat: seat as u8,
             main_deck,
@@ -1350,6 +1359,27 @@ mod tests {
         );
     }
 
+    #[test]
+    fn authorize_rebinds_draft_effect_pick_seat_to_authenticated_seat() {
+        let action = authorize_client_draft_action(
+            2,
+            DraftAction::PickWithDraftEffect {
+                seat: 0,
+                effect_card_instance_id: "cogwork-1".to_string(),
+                card_instance_ids: vec!["card-1".to_string(), "card-2".to_string()],
+            },
+        )
+        .expect("seat-scoped action is allowed for any seat");
+        assert_eq!(
+            action,
+            DraftAction::PickWithDraftEffect {
+                seat: 2,
+                effect_card_instance_id: "cogwork-1".to_string(),
+                card_instance_ids: vec!["card-1".to_string(), "card-2".to_string()],
+            }
+        );
+    }
+
     #[test]
     fn authorize_rebinds_submit_deck_seat() {
         let action = authorize_client_draft_action(
diff --git a/crates/server-core/src/protocol.rs b/crates/server-core/src/protocol.rs
index acbf5b5fea..115af10106 100644
--- a/crates/server-core/src/protocol.rs
+++ b/crates/server-core/src/protocol.rs
@@ -2115,6 +2115,7 @@ mod tests {
             colors: vec!["W".to_string()],
             cmc: 1,
             type_line: "Creature — Test".to_string(),
+            draft_effect: None,
         };
         let second_pull = DraftCardInstance {
             instance_id: "pack-2-card-1".to_string(),
@@ -2125,6 +2126,7 @@ mod tests {
             colors: vec!["U".to_string()],
             cmc: 2,
             type_line: "Instant".to_string(),
+            draft_effect: None,
         };
         let pool = vec![first_pull.clone(), second_pull.clone()];
         let pool_groups = DraftPoolGroups::from_pool(&pool);
@@ -2136,6 +2138,7 @@ mod tests {
             pass_direction: PassDirection::Left,
             current_pack: None,
             pool,
+            draft_effects: vec![first_pull.clone()],
             pool_groups,
             sealed_packs: Some(vec![vec![first_pull], vec![second_pull]]),
             seats: Vec::new(),
@@ -2160,6 +2163,7 @@ mod tests {
                 assert_eq!(v.pick_number, 2);
                 assert_eq!(v.timer_remaining_ms, Some(5000));
                 assert_eq!(v.pool_groups, view.pool_groups);
+                assert_eq!(v.draft_effects, view.draft_effects);
                 assert_eq!(
                     v.sealed_packs
                         .as_ref()
diff --git a/docs/screenshots/draft-effects-desktop.png b/docs/screenshots/draft-effects-desktop.png
new file mode 100644
index 0000000000..94dd194d7e
Binary files /dev/null and b/docs/screenshots/draft-effects-desktop.png differ
diff --git a/docs/screenshots/draft-effects-mobile.png b/docs/screenshots/draft-effects-mobile.png
new file mode 100644
index 0000000000..8f05346f55
Binary files /dev/null and b/docs/screenshots/draft-effects-mobile.png differ
diff --git a/docs/screenshots/draft-effects-tablet-landscape.png b/docs/screenshots/draft-effects-tablet-landscape.png
new file mode 100644
index 0000000000..460053963a
Binary files /dev/null and b/docs/screenshots/draft-effects-tablet-landscape.png differ
diff --git a/docs/screenshots/draft-effects-tablet-portrait.png b/docs/screenshots/draft-effects-tablet-portrait.png
new file mode 100644
index 0000000000..0412896093
Binary files /dev/null and b/docs/screenshots/draft-effects-tablet-portrait.png differ