diff --git a/apps/extension/src/tools/__tests__/wheel.test.ts b/apps/extension/src/tools/__tests__/wheel.test.ts
new file mode 100644
index 00000000..03372a22
--- /dev/null
+++ b/apps/extension/src/tools/__tests__/wheel.test.ts
@@ -0,0 +1,149 @@
+import { describe, expect, it, vi } from "vitest";
+import { SessionManager } from "@/session-manager/manager";
+import type { CdpRunner } from "@/tools/shared";
+import { handleWheel } from "../wheel";
+
+function fakeAgentWindow(ids: number[]) {
+  let index = 0;
+  return {
+    create: vi.fn(async () => {
+      const id = ids[index++];
+      if (id === undefined) throw new Error("ran out of fake ids");
+      return id;
+    }),
+    remove: vi.fn(async () => {}),
+    ensureActiveTab: vi.fn(async () => {}),
+  };
+}
+
+function makeFakeCdp(handlers: Record<string, (params: unknown) => unknown> = {}) {
+  const sent: Array<{ tabId: number; method: string; params?: object }> = [];
+  const cdp: CdpRunner = {
+    send: vi.fn(async (tabId: number, method: string, params?: object) => {
+      sent.push({ tabId, method, params });
+      const handler = handlers[method];
+      if (handler) return handler(params);
+      if (method === "Page.getLayoutMetrics") {
+        return { cssLayoutViewport: { clientWidth: 1000, clientHeight: 800 } };
+      }
+      if (method === "Input.dispatchMouseEvent") return {};
+      throw new Error(`unexpected CDP call ${method}`);
+    }) as unknown as CdpRunner["send"],
+    trackSessionTab: vi.fn(),
+  };
+  const tabsApi = {
+    get: vi.fn(
+      async (tabId: number) => ({ id: tabId, windowId: 100, active: true }) as chrome.tabs.Tab,
+    ),
+    query: vi.fn(async () => [{ id: 4, windowId: 100, active: true } as chrome.tabs.Tab]),
+  };
+  return { cdp, tabsApi, sent };
+}
+
+describe("handleWheel", () => {
+  it("dispatches a native mouseWheel event at the viewport centre", async () => {
+    const manager = new SessionManager({ agentWindow: fakeAgentWindow([100]) });
+    await manager.start("aa11");
+    const fake = makeFakeCdp();
+    const bypassOverlay = vi.fn(async () => {});
+
+    const result = await handleWheel(
+      manager,
+      {
+        session_id: "aa11",
+        delta_y: 600,
+        delta_x: -20,
+        modifiers: ["ctrl", "shift"],
+      },
+      { cdp: fake.cdp, tabsApi: fake.tabsApi, bypassOverlay },
+    );
+
+    if ("code" in result) throw new Error(`unexpected error: ${JSON.stringify(result)}`);
+    expect(result).toMatchObject({
+      tab_id: 4,
+      x: 500,
+      y: 400,
+      delta_x: -20,
+      delta_y: 600,
+    });
+    expect(fake.sent).toEqual([
+      { tabId: 4, method: "Page.getLayoutMetrics", params: {} },
+      {
+        tabId: 4,
+        method: "Input.dispatchMouseEvent",
+        params: { type: "mouseMoved", x: 500, y: 400, modifiers: 10 },
+      },
+      {
+        tabId: 4,
+        method: "Input.dispatchMouseEvent",
+        params: {
+          type: "mouseWheel",
+          x: 500,
+          y: 400,
+          deltaX: -20,
+          deltaY: 600,
+          modifiers: 10,
+        },
+      },
+    ]);
+    expect(bypassOverlay.mock.calls).toEqual([
+      [4, true],
+      [4, false],
+    ]);
+  });
+
+  it("uses an element's visible action point for targeted wheel input", async () => {
+    const manager = new SessionManager({ agentWindow: fakeAgentWindow([100]) });
+    const ctx = await manager.start("aa11");
+    ctx.refStore.set("e3", 1234, { tabId: 4 });
+    const fake = makeFakeCdp({
+      "DOM.scrollIntoViewIfNeeded": () => ({}),
+      "DOM.getContentQuads": () => ({ quads: [[10, 20, 110, 20, 110, 60, 10, 60]] }),
+    });
+
+    const result = await handleWheel(
+      manager,
+      { session_id: "aa11", ref: "@e3", delta_y: 120 },
+      { cdp: fake.cdp, tabsApi: fake.tabsApi },
+    );
+
+    if ("code" in result) throw new Error(`unexpected error: ${JSON.stringify(result)}`);
+    expect(result).toMatchObject({ used_ref: "e3", x: 60, y: 40, delta_y: 120 });
+    expect(fake.sent.at(-1)).toMatchObject({
+      method: "Input.dispatchMouseEvent",
+      params: { type: "mouseWheel", x: 60, y: 40, deltaY: 120 },
+    });
+  });
+
+  it("rejects a zero-distance wheel without issuing CDP calls", async () => {
+    const manager = new SessionManager({ agentWindow: fakeAgentWindow([100]) });
+    await manager.start("aa11");
+    const fake = makeFakeCdp();
+
+    const result = await handleWheel(
+      manager,
+      { session_id: "aa11", delta_x: 0, delta_y: 0 },
+      { cdp: fake.cdp, tabsApi: fake.tabsApi },
+    );
+
+    expect(result).toMatchObject({ code: "invalid_params" });
+    expect(fake.cdp.send).not.toHaveBeenCalled();
+  });
+
+  it("does not issue CDP calls after an early cancellation", async () => {
+    const manager = new SessionManager({ agentWindow: fakeAgentWindow([100]) });
+    await manager.start("aa11");
+    const fake = makeFakeCdp();
+    const abort = new AbortController();
+    abort.abort();
+
+    const result = await handleWheel(
+      manager,
+      { session_id: "aa11", delta_y: 120 },
+      { cdp: fake.cdp, tabsApi: fake.tabsApi, signal: abort.signal },
+    );
+
+    expect(result).toMatchObject({ code: "cancelled" });
+    expect(fake.cdp.send).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/extension/src/tools/dispatcher.ts b/apps/extension/src/tools/dispatcher.ts
index 25b5f3ac..9183134f 100644
--- a/apps/extension/src/tools/dispatcher.ts
+++ b/apps/extension/src/tools/dispatcher.ts
@@ -29,6 +29,7 @@ import type {
   SelectParams,
   SnapshotParams,
   WaitForNavigationParams,
+  WheelParams,
 } from "@/transport/types";
 import { isRequestFrame } from "@/transport/types";
 import { handleConsole } from "./console";
@@ -75,6 +76,7 @@ import {
   type TabSelectParams,
 } from "./tabs";
 import { handleWaitForNavigation } from "./waits";
+import { handleWheel } from "./wheel";
 import { handleWindowResize, type WindowResizeParams } from "./window";
 
 type DispatcherCdpRunner = CdpRunner &
@@ -471,6 +473,20 @@ export class ToolDispatcher {
         );
         return this.rememberHover((req.params as HoverParams).session_id, result);
       }
+      case "tool.wheel":
+        return this.withHoverReassert(
+          req.params as WheelParams,
+          () =>
+            handleWheel(
+              this.sessions,
+              req.params as WheelParams,
+              this.cdp
+                ? { cdp: this.cdp, tabsApi: chromeTabsApi, signal, bypassOverlay }
+                : undefined,
+            ),
+          { releaseAfter: true },
+          signal,
+        );
       case "tool.fill":
         return this.withHoverReleaseForRequest(
           req.params as FillParams,
@@ -718,6 +734,7 @@ function sessionIdForBrowserControlMethod(req: RequestFrame): string | null {
     case "tool.reload":
     case "tool.click":
     case "tool.hover":
+    case "tool.wheel":
     case "tool.fill":
     case "tool.press":
     case "tool.select":
diff --git a/apps/extension/src/tools/interaction.ts b/apps/extension/src/tools/interaction.ts
index 182cabdf..3ea1373a 100644
--- a/apps/extension/src/tools/interaction.ts
+++ b/apps/extension/src/tools/interaction.ts
@@ -128,7 +128,7 @@ async function wait(ms: number, signal?: AbortSignal): Promise<void> {
  * `RpcError` if the caller supplied neither (or both), or if neither
  * lookup matched.
  */
-async function resolveBackendNode(
+export async function resolveBackendNode(
   cdp: CdpRunner,
   ctx: SessionContext,
   target: { tabId: number },
diff --git a/apps/extension/src/tools/wheel.ts b/apps/extension/src/tools/wheel.ts
new file mode 100644
index 00000000..7466e6a3
--- /dev/null
+++ b/apps/extension/src/tools/wheel.ts
@@ -0,0 +1,180 @@
+import { ChromiumCdp } from "@/browser-driver/chromium-cdp";
+import type { SessionContext, SessionManager } from "@/session-manager/manager";
+import type { RpcError, WheelParams, WheelResult } from "@/transport/types";
+import { attachDialogs, markDialogCursor } from "./dialogs";
+import { resolveNodeGeometry } from "./frame-geometry";
+import { modifiersBitfield, resolveBackendNode } from "./interaction";
+import {
+  type CdpRunner,
+  type ChromeTabsApi,
+  chromeTabsApi,
+  enforceAgentWindow,
+  isRpcError,
+  lookupSession,
+  resolveTargetTab,
+} from "./shared";
+
+export interface WheelDeps {
+  cdp: CdpRunner;
+  tabsApi: ChromeTabsApi;
+  signal?: AbortSignal;
+  /** Temporarily disable the Agent Window overlay's input blocker. */
+  bypassOverlay?: (tabId: number, enabled: boolean) => Promise<void>;
+}
+
+interface WheelPoint {
+  x: number;
+  y: number;
+  usedRef?: string;
+  usedSelector?: string;
+}
+
+let defaultDeps: { cdp: ChromiumCdp; tabsApi: ChromeTabsApi } | null = null;
+function getDefaultDeps(): { cdp: ChromiumCdp; tabsApi: ChromeTabsApi } {
+  if (!defaultDeps) defaultDeps = { cdp: new ChromiumCdp(), tabsApi: chromeTabsApi };
+  return defaultDeps;
+}
+
+export async function handleWheel(
+  manager: SessionManager,
+  params: WheelParams,
+  deps: WheelDeps = getDefaultDeps(),
+): Promise<WheelResult | RpcError> {
+  const ctxOrErr = lookupSession(manager, params, "wheel");
+  if (isRpcError(ctxOrErr)) return ctxOrErr;
+  const ctx = ctxOrErr;
+  const deltaX = params.delta_x ?? 0;
+  const deltaY = params.delta_y;
+  if (!Number.isFinite(deltaX) || !Number.isFinite(deltaY)) {
+    return { code: "invalid_params", message: "wheel deltas must be finite numbers" };
+  }
+  if (deltaX === 0 && deltaY === 0) {
+    return { code: "invalid_params", message: "at least one wheel delta must be non-zero" };
+  }
+  if (deps.signal?.aborted) return cancelled();
+
+  const target = await resolveTargetTab(manager, ctx, params.tab_id, deps.tabsApi);
+  if (isRpcError(target)) return target;
+  const denied = enforceAgentWindow(ctx, target, "wheel");
+  if (denied) return denied;
+  const dialogCursor = markDialogCursor(deps.cdp, target.tabId);
+  deps.cdp.trackSessionTab?.(ctx.sessionId, target.tabId);
+
+  const point = await resolveWheelPoint(deps.cdp, ctx, target, params);
+  if (isRpcError(point)) return point;
+  if (deps.signal?.aborted) return cancelled();
+
+  let bypassEnabled = false;
+  if (deps.bypassOverlay) {
+    try {
+      await deps.bypassOverlay(target.tabId, true);
+      bypassEnabled = true;
+    } catch (error) {
+      console.debug("[bsk wheel] overlay bypass enable failed", error);
+    }
+  }
+
+  try {
+    if (deps.signal?.aborted) return cancelled();
+    const modifiers = modifiersBitfield(params.modifiers);
+    await deps.cdp.send(target.tabId, "Input.dispatchMouseEvent", {
+      type: "mouseMoved",
+      x: point.x,
+      y: point.y,
+      modifiers,
+    });
+    if (deps.signal?.aborted) return cancelled();
+    await deps.cdp.send(target.tabId, "Input.dispatchMouseEvent", {
+      type: "mouseWheel",
+      x: point.x,
+      y: point.y,
+      deltaX,
+      deltaY,
+      modifiers,
+    });
+  } catch (error) {
+    return {
+      code: "cdp_failed",
+      message: error instanceof Error ? error.message : String(error),
+    };
+  } finally {
+    if (bypassEnabled && deps.bypassOverlay) {
+      try {
+        await deps.bypassOverlay(target.tabId, false);
+      } catch (error) {
+        console.debug("[bsk wheel] overlay bypass disable failed", error);
+      }
+    }
+  }
+
+  return attachDialogs(deps.cdp, target.tabId, dialogCursor, {
+    tab_id: target.tabId,
+    used_ref: point.usedRef,
+    used_selector: point.usedSelector,
+    x: point.x,
+    y: point.y,
+    delta_x: deltaX,
+    delta_y: deltaY,
+  });
+}
+
+async function resolveWheelPoint(
+  cdp: CdpRunner,
+  ctx: SessionContext,
+  target: { tabId: number },
+  params: WheelParams,
+): Promise<WheelPoint | RpcError> {
+  const hasRef = typeof params.ref === "string" && params.ref.length > 0;
+  const hasSelector = typeof params.selector === "string" && params.selector.length > 0;
+  if (hasRef || hasSelector) {
+    const node = await resolveBackendNode(cdp, ctx, target, params, "wheel");
+    if (isRpcError(node)) return node;
+    const geometry = await resolveNodeGeometry(
+      cdp,
+      target.tabId,
+      {
+        target: node.cdpTarget,
+        backendNodeId: node.backendNodeId,
+        ...(node.frameId ? { frameId: node.frameId } : {}),
+      },
+      { scrollIntoView: true },
+    );
+    if (isRpcError(geometry)) return geometry;
+    return {
+      x: geometry.actionPoint.x,
+      y: geometry.actionPoint.y,
+      usedRef: node.usedRef,
+      usedSelector: node.usedSelector,
+    };
+  }
+
+  try {
+    const metrics = await cdp.send<{
+      cssLayoutViewport?: { clientWidth?: number; clientHeight?: number };
+      layoutViewport?: { clientWidth?: number; clientHeight?: number };
+    }>(target.tabId, "Page.getLayoutMetrics", {});
+    const viewport = metrics.cssLayoutViewport ?? metrics.layoutViewport ?? {};
+    const width = viewport.clientWidth;
+    const height = viewport.clientHeight;
+    if (
+      typeof width !== "number" ||
+      typeof height !== "number" ||
+      !Number.isFinite(width) ||
+      !Number.isFinite(height) ||
+      width <= 0 ||
+      height <= 0
+    ) {
+      return { code: "cdp_failed", message: "Page.getLayoutMetrics returned no viewport size" };
+    }
+    return { x: width / 2, y: height / 2 };
+  } catch (error) {
+    return {
+      code: "cdp_failed",
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function cancelled(): RpcError {
+  return { code: "cancelled", message: "wheel aborted" };
+}
diff --git a/apps/extension/src/transport/types.ts b/apps/extension/src/transport/types.ts
index d53825a1..065a338f 100644
--- a/apps/extension/src/transport/types.ts
+++ b/apps/extension/src/transport/types.ts
@@ -444,6 +444,28 @@ export interface HoverResult {
   dialogs?: JavaScriptDialogInfo[];
 }
 
+export interface WheelParams {
+  session_id: string;
+  ref?: string;
+  selector?: string;
+  tab_id?: number;
+  delta_x?: number;
+  delta_y: number;
+  modifiers?: KeyModifier[];
+  timeout_ms?: number;
+}
+
+export interface WheelResult {
+  tab_id: number;
+  used_ref?: string;
+  used_selector?: string;
+  x: number;
+  y: number;
+  delta_x: number;
+  delta_y: number;
+  dialogs?: JavaScriptDialogInfo[];
+}
+
 export interface FillParams {
   session_id: string;
   value: string;
diff --git a/crates/bsk-cli/skill/SKILL.md b/crates/bsk-cli/skill/SKILL.md
index e1cffb92..eea194ee 100644
--- a/crates/bsk-cli/skill/SKILL.md
+++ b/crates/bsk-cli/skill/SKILL.md
@@ -202,6 +202,7 @@ Both capture from the moment the tab is attached and read a bounded per-tab buff
 |---------|---------|
 | `bsk click <ref-or-selector>` | Click element (`--button`, `--click-count`, `--modifiers`) |
 | `bsk hover <ref-or-selector>` | Move the mouse to an element and wait for hover UI to settle (`--settle`, `--modifiers`) |
+| `bsk wheel --delta-y <pixels> [ref-or-selector]` | Dispatch a real mouse-wheel event at the viewport centre or an element (`--delta-x`, `--modifiers`) |
 | `bsk fill <ref-or-selector> --value <text>` | Clear and type into input |
 | `bsk select <ref-or-selector> --value <v>` | Set `<select>` option(s) by `value` (repeat `--value` for multi-select) |
 | `bsk press <key>` | Key/combo (`Enter`, `Ctrl+A`, …; optional `--ref` to focus first) |
diff --git a/crates/bsk-cli/src/cli/mod.rs b/crates/bsk-cli/src/cli/mod.rs
index 9b7644e7..6b2d4966 100644
--- a/crates/bsk-cli/src/cli/mod.rs
+++ b/crates/bsk-cli/src/cli/mod.rs
@@ -31,6 +31,7 @@ pub mod status;
 pub mod tab;
 pub mod update;
 pub mod waits;
+pub mod wheel;
 pub mod window;
 
 use clap::{Args, Parser, Subcommand};
@@ -53,6 +54,7 @@ use crate::cli::snapshot::SnapshotArgs;
 use crate::cli::tab::TabCmd;
 use crate::cli::update::UpdateArgs;
 use crate::cli::waits::{WaitForNavigationArgs, WaitMsArgs};
+use crate::cli::wheel::WheelArgs;
 use crate::cli::window::WindowCmd;
 
 /// Tool calls wait slightly longer than the daemon's 30s tool timeout so
@@ -167,6 +169,9 @@ pub enum Command {
     /// Hover a snapshot ref or CSS selector.
     Hover(HoverArgs),
 
+    /// Dispatch a native mouse-wheel event at the viewport centre or an element.
+    Wheel(WheelArgs),
+
     /// Fill an input / textarea / contenteditable.
     Fill(FillArgs),
 
diff --git a/crates/bsk-cli/src/cli/wheel.rs b/crates/bsk-cli/src/cli/wheel.rs
new file mode 100644
index 00000000..ffaa115e
--- /dev/null
+++ b/crates/bsk-cli/src/cli/wheel.rs
@@ -0,0 +1,171 @@
+//! `bsk wheel` — dispatch a native Chromium mouse-wheel event.
+
+use std::time::Duration;
+
+use anyhow::Context;
+use bsk_protocol::Method;
+use bsk_protocol::tools::{WheelParams, WheelResult};
+use clap::Args;
+
+use crate::cli::dialogs::print_dialog_summaries;
+use crate::cli::ensure_daemon::ensure_daemon;
+use crate::cli::error::{CliError, Format};
+use crate::cli::interaction::{looks_like_ref, parse_modifiers};
+use crate::cli::navigate::parse_timeout_ms;
+
+#[derive(Debug, Clone, Args)]
+pub struct WheelArgs {
+    /// Optional snapshot ref (`@e3`, `e3`) or CSS selector used as the wheel hit-test point.
+    pub target: Option<String>,
+
+    #[arg(long = "ref")]
+    pub ref_: Option<String>,
+
+    #[arg(long = "selector")]
+    pub selector: Option<String>,
+
+    #[arg(long)]
+    pub session: String,
+
+    #[arg(long = "tab-id")]
+    pub tab_id: Option<i64>,
+
+    /// Horizontal wheel distance in CSS pixels (positive moves right).
+    #[arg(long = "delta-x", default_value = "0", value_parser = parse_finite_delta)]
+    pub delta_x: f64,
+
+    /// Vertical wheel distance in CSS pixels (positive moves down).
+    #[arg(long = "delta-y", value_parser = parse_finite_delta)]
+    pub delta_y: f64,
+
+    /// Comma-separated modifiers (`alt,ctrl,shift,meta`).
+    #[arg(long, default_value = "")]
+    pub modifiers: String,
+
+    #[arg(long, default_value = "30s", value_parser = parse_timeout_ms)]
+    pub timeout: u32,
+}
+
+pub fn dispatch(args: WheelArgs, format: Format) -> Result<(), CliError> {
+    validate_deltas(args.delta_x, args.delta_y)?;
+    let info = ensure_daemon().context("ensure daemon is running")?;
+    let (ref_, selector) = split_optional_target(args.target, args.ref_, args.selector)?;
+    let modifiers = parse_modifiers(&args.modifiers)
+        .map_err(|e| CliError::Local(anyhow::anyhow!("--modifiers: {e}")))?;
+    let params = WheelParams {
+        session_id: args.session,
+        ref_,
+        selector,
+        tab_id: args.tab_id,
+        delta_x: args.delta_x,
+        delta_y: args.delta_y,
+        modifiers: if modifiers.is_empty() {
+            None
+        } else {
+            Some(modifiers)
+        },
+        timeout_ms: Some(args.timeout),
+    };
+    let reply: WheelResult = crate::cli::business_rpc::call(
+        info.sock_path,
+        "wheel-1",
+        Method::ToolWheel,
+        Some(params),
+        ipc_timeout(args.timeout),
+    )?;
+    match format {
+        Format::Json => println!(
+            "{}",
+            serde_json::to_string_pretty(&reply)
+                .map_err(|e| CliError::Local(anyhow::anyhow!(e)))?
+        ),
+        Format::Human => {
+            let target =
+                format_used_target(reply.used_ref.as_deref(), reply.used_selector.as_deref());
+            println!(
+                "wheel ok tab={} target={target} at=({}, {}) delta=({}, {})",
+                reply.tab_id, reply.x, reply.y, reply.delta_x, reply.delta_y
+            );
+            print_dialog_summaries(&reply.dialogs);
+        }
+    }
+    Ok(())
+}
+
+fn parse_finite_delta(value: &str) -> Result<f64, String> {
+    let parsed = value
+        .parse::<f64>()
+        .map_err(|_| format!("'{value}' is not a valid number"))?;
+    if !parsed.is_finite() {
+        return Err("wheel deltas must be finite numbers".into());
+    }
+    Ok(parsed)
+}
+
+fn validate_deltas(delta_x: f64, delta_y: f64) -> Result<(), CliError> {
+    if delta_x == 0.0 && delta_y == 0.0 {
+        return Err(CliError::Local(anyhow::anyhow!(
+            "at least one of --delta-x or --delta-y must be non-zero"
+        )));
+    }
+    Ok(())
+}
+
+fn split_optional_target(
+    positional: Option<String>,
+    explicit_ref: Option<String>,
+    explicit_selector: Option<String>,
+) -> Result<(Option<String>, Option<String>), CliError> {
+    match (positional, explicit_ref, explicit_selector) {
+        (None, None, None) => Ok((None, None)),
+        (None, Some(r), None) => Ok((Some(r), None)),
+        (None, None, Some(s)) => Ok((None, Some(s))),
+        (Some(target), None, None) if looks_like_ref(&target) => Ok((Some(target), None)),
+        (Some(target), None, None) => Ok((None, Some(target))),
+        _ => Err(CliError::Local(anyhow::anyhow!(
+            "pass at most one of: <target>, --ref, or --selector"
+        ))),
+    }
+}
+
+fn format_used_target(used_ref: Option<&str>, used_selector: Option<&str>) -> String {
+    used_ref
+        .map(|r| format!("@{r}"))
+        .or_else(|| used_selector.map(str::to_string))
+        .unwrap_or_else(|| "viewport-center".into())
+}
+
+fn ipc_timeout(timeout_ms: u32) -> Duration {
+    Duration::from_millis(u64::from(timeout_ms))
+        .checked_add(Duration::from_secs(15))
+        .unwrap_or(Duration::from_secs(u64::from(timeout_ms / 1_000) + 15))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn optional_target_supports_viewport_refs_and_selectors() {
+        assert_eq!(
+            split_optional_target(None, None, None).unwrap(),
+            (None, None)
+        );
+        assert_eq!(
+            split_optional_target(Some("@e3".into()), None, None).unwrap(),
+            (Some("@e3".into()), None)
+        );
+        assert_eq!(
+            split_optional_target(Some("#panel".into()), None, None).unwrap(),
+            (None, Some("#panel".into()))
+        );
+    }
+
+    #[test]
+    fn finite_nonzero_deltas_are_required() {
+        assert!(parse_finite_delta("600").is_ok());
+        assert!(parse_finite_delta("NaN").is_err());
+        assert!(validate_deltas(0.0, 0.0).is_err());
+        assert!(validate_deltas(0.0, -120.0).is_ok());
+    }
+}
diff --git a/crates/bsk-cli/src/daemon/ipc.rs b/crates/bsk-cli/src/daemon/ipc.rs
index 722342c0..71d725df 100644
--- a/crates/bsk-cli/src/daemon/ipc.rs
+++ b/crates/bsk-cli/src/daemon/ipc.rs
@@ -243,6 +243,7 @@ pub fn full_handler(status: DaemonStatus, state: Arc<DaemonState>) -> RpcHandler
                 | Method::ToolReload
                 | Method::ToolClick
                 | Method::ToolHover
+                | Method::ToolWheel
                 | Method::ToolFill
                 | Method::ToolPress
                 | Method::ToolSelect
diff --git a/crates/bsk-cli/src/main.rs b/crates/bsk-cli/src/main.rs
index 86c1451c..13be85cb 100644
--- a/crates/bsk-cli/src/main.rs
+++ b/crates/bsk-cli/src/main.rs
@@ -94,6 +94,7 @@ fn dispatch(cli: Cli, format: Format) -> Result<(), CliError> {
         Command::Reload(args) => cli::navigate::dispatch_reload(args, format),
         Command::Click(args) => cli::interaction::dispatch_click(args, format),
         Command::Hover(args) => cli::interaction::dispatch_hover(args, format),
+        Command::Wheel(args) => cli::wheel::dispatch(args, format),
         Command::Fill(args) => cli::interaction::dispatch_fill(args, format),
         Command::Press(args) => cli::interaction::dispatch_press(args, format),
         Command::Select(args) => cli::interaction::dispatch_select(args, format),
diff --git a/crates/bsk-cli/tests/cli_parse.rs b/crates/bsk-cli/tests/cli_parse.rs
index f8cb0f21..94d36511 100644
--- a/crates/bsk-cli/tests/cli_parse.rs
+++ b/crates/bsk-cli/tests/cli_parse.rs
@@ -206,6 +206,27 @@ fn parses_hover_with_settle() {
     assert_eq!(args.settle, 300);
 }
 
+#[test]
+fn parses_wheel_with_target_and_deltas() {
+    let cli = parse(&[
+        "bsk",
+        "wheel",
+        "#panel",
+        "--delta-x",
+        "12.5",
+        "--delta-y",
+        "600",
+        "--session",
+        "s1",
+    ]);
+    let Command::Wheel(args) = cli.command else {
+        panic!("expected wheel command");
+    };
+    assert_eq!(args.target.as_deref(), Some("#panel"));
+    assert_eq!(args.delta_x, 12.5);
+    assert_eq!(args.delta_y, 600.0);
+}
+
 #[test]
 fn rejects_zero_click_count() {
     assert!(
diff --git a/crates/bsk-cli/tests/tools_m7_ipc.rs b/crates/bsk-cli/tests/tools_m7_ipc.rs
index ee74b5e5..07c22a96 100644
--- a/crates/bsk-cli/tests/tools_m7_ipc.rs
+++ b/crates/bsk-cli/tests/tools_m7_ipc.rs
@@ -16,7 +16,7 @@ use bsk_protocol::tools::{
     ClickParams, ClickResult, FillParams, FillResult, KeyModifier, MouseButton, NavigateBackParams,
     NavigateBackResult, NavigateForwardParams, NavigateForwardResult, NavigateParams,
     NavigateResult, PressParams, PressResult, ReloadParams, ReloadResult, SelectParams,
-    SelectResult, SessionStartParams, SessionStartResult, WaitUntil,
+    SelectResult, SessionStartParams, SessionStartResult, WaitUntil, WheelParams, WheelResult,
 };
 use bsk_protocol::{
     BrowserPeerInfo, ErrorCode, Frame, Method, RequestFrame, ResponseBody, ResponseFrame, RpcError,
@@ -382,6 +382,55 @@ async fn click_round_trips_ref_and_modifiers() {
     handle.shutdown().await;
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn wheel_round_trips_native_deltas_and_point() {
+    let (handle, sock) = spawn_daemon().await;
+    let mut ws = connect_ext(handle.ws_addr()).await;
+    let _ = do_handshake(&mut ws).await;
+
+    run_extension(ws, |req| {
+        assert_eq!(req.method, Method::ToolWheel);
+        let params: WheelParams = serde_json::from_value(req.params.clone().unwrap()).unwrap();
+        assert_eq!(params.selector.as_deref(), Some("#panel"));
+        assert_eq!(params.delta_x, 10.0);
+        assert_eq!(params.delta_y, 600.0);
+        ResponseBody::Ok(
+            serde_json::to_value(WheelResult {
+                tab_id: 9,
+                used_ref: None,
+                used_selector: Some("#panel".into()),
+                x: 320.0,
+                y: 240.0,
+                delta_x: 10.0,
+                delta_y: 600.0,
+                dialogs: vec![],
+            })
+            .unwrap(),
+        )
+    });
+
+    let session_id = ipc_session_start(&sock).await;
+    let result: WheelResult = ipc_tool_call(
+        &sock,
+        Method::ToolWheel,
+        WheelParams {
+            session_id,
+            ref_: None,
+            selector: Some("#panel".into()),
+            tab_id: None,
+            delta_x: 10.0,
+            delta_y: 600.0,
+            modifiers: None,
+            timeout_ms: Some(5_000),
+        },
+    )
+    .await
+    .expect("wheel ok");
+    assert_eq!(result.used_selector.as_deref(), Some("#panel"));
+    assert_eq!((result.delta_x, result.delta_y), (10.0, 600.0));
+    handle.shutdown().await;
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn fill_round_trips_clear_before_default() {
     let (handle, sock) = spawn_daemon().await;
diff --git a/crates/bsk-protocol/schema/tool_wheel_params.json b/crates/bsk-protocol/schema/tool_wheel_params.json
new file mode 100644
index 00000000..e3976cfa
--- /dev/null
+++ b/crates/bsk-protocol/schema/tool_wheel_params.json
@@ -0,0 +1,75 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "WheelParams",
+  "type": "object",
+  "required": [
+    "delta_y",
+    "session_id"
+  ],
+  "properties": {
+    "delta_x": {
+      "description": "Horizontal wheel distance in CSS pixels. Positive values move right.",
+      "default": 0.0,
+      "type": "number",
+      "format": "double"
+    },
+    "delta_y": {
+      "description": "Vertical wheel distance in CSS pixels. Positive values move down.",
+      "type": "number",
+      "format": "double"
+    },
+    "modifiers": {
+      "type": [
+        "array",
+        "null"
+      ],
+      "items": {
+        "$ref": "#/definitions/KeyModifier"
+      }
+    },
+    "ref": {
+      "description": "Optional `@e<N>` ref used as the wheel event's hit-test point. Mutually exclusive with `selector`. When neither is supplied, the event is dispatched at the viewport centre.",
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "selector": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "session_id": {
+      "type": "string"
+    },
+    "tab_id": {
+      "description": "Target tab. Defaults to the Agent Window's active tab.",
+      "type": [
+        "integer",
+        "null"
+      ],
+      "format": "int64"
+    },
+    "timeout_ms": {
+      "type": [
+        "integer",
+        "null"
+      ],
+      "format": "uint32",
+      "minimum": 1.0
+    }
+  },
+  "definitions": {
+    "KeyModifier": {
+      "description": "Keyboard modifier flags. Multiple flags may be combined; the extension folds them into CDP's bitfield (`alt=1, ctrl=2, meta=4, shift=8`).",
+      "type": "string",
+      "enum": [
+        "alt",
+        "ctrl",
+        "meta",
+        "shift"
+      ]
+    }
+  }
+}
diff --git a/crates/bsk-protocol/schema/tool_wheel_result.json b/crates/bsk-protocol/schema/tool_wheel_result.json
new file mode 100644
index 00000000..955fd117
--- /dev/null
+++ b/crates/bsk-protocol/schema/tool_wheel_result.json
@@ -0,0 +1,123 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "WheelResult",
+  "type": "object",
+  "required": [
+    "delta_x",
+    "delta_y",
+    "tab_id",
+    "x",
+    "y"
+  ],
+  "properties": {
+    "delta_x": {
+      "type": "number",
+      "format": "double"
+    },
+    "delta_y": {
+      "type": "number",
+      "format": "double"
+    },
+    "dialogs": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/JavaScriptDialogInfo"
+      }
+    },
+    "tab_id": {
+      "type": "integer",
+      "format": "int64"
+    },
+    "used_ref": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "used_selector": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "x": {
+      "description": "Top-level viewport coordinates where the real wheel event was dispatched.",
+      "type": "number",
+      "format": "double"
+    },
+    "y": {
+      "type": "number",
+      "format": "double"
+    }
+  },
+  "definitions": {
+    "JavaScriptDialogHandledAction": {
+      "description": "How the extension resolved the dialog so CDP could continue.",
+      "type": "string",
+      "enum": [
+        "accepted",
+        "dismissed"
+      ]
+    },
+    "JavaScriptDialogInfo": {
+      "description": "One observed + handled JavaScript dialog during a tool call.",
+      "type": "object",
+      "required": [
+        "handled",
+        "message",
+        "sequence",
+        "tab_id",
+        "type"
+      ],
+      "properties": {
+        "default_prompt": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "handled": {
+          "$ref": "#/definitions/JavaScriptDialogHandledAction"
+        },
+        "has_browser_handler": {
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "message": {
+          "type": "string"
+        },
+        "sequence": {
+          "description": "Monotonic per-tab sequence for ordering within a session.",
+          "type": "integer",
+          "format": "uint64",
+          "minimum": 0.0
+        },
+        "tab_id": {
+          "type": "integer",
+          "format": "int64"
+        },
+        "type": {
+          "$ref": "#/definitions/JavaScriptDialogType"
+        },
+        "url": {
+          "type": [
+            "string",
+            "null"
+          ]
+        }
+      }
+    },
+    "JavaScriptDialogType": {
+      "description": "Native JS dialog kind reported by CDP.",
+      "type": "string",
+      "enum": [
+        "alert",
+        "confirm",
+        "prompt",
+        "beforeunload"
+      ]
+    }
+  }
+}
diff --git a/crates/bsk-protocol/src/bin/dump-schema.rs b/crates/bsk-protocol/src/bin/dump-schema.rs
index de9b7f25..b8a1cb42 100644
--- a/crates/bsk-protocol/src/bin/dump-schema.rs
+++ b/crates/bsk-protocol/src/bin/dump-schema.rs
@@ -79,6 +79,8 @@ fn main() {
     dump!(ClickResult, "tool_click_result");
     dump!(HoverParams, "tool_hover_params");
     dump!(HoverResult, "tool_hover_result");
+    dump!(WheelParams, "tool_wheel_params");
+    dump!(WheelResult, "tool_wheel_result");
     dump!(FillParams, "tool_fill_params");
     dump!(FillResult, "tool_fill_result");
     dump!(PressParams, "tool_press_params");
diff --git a/crates/bsk-protocol/src/method.rs b/crates/bsk-protocol/src/method.rs
index 75f8b4d5..6b47375a 100644
--- a/crates/bsk-protocol/src/method.rs
+++ b/crates/bsk-protocol/src/method.rs
@@ -72,6 +72,8 @@ pub enum Method {
     ToolClick,
     #[serde(rename = "tool.hover")]
     ToolHover,
+    #[serde(rename = "tool.wheel")]
+    ToolWheel,
     #[serde(rename = "tool.fill")]
     ToolFill,
     #[serde(rename = "tool.press")]
@@ -153,6 +155,7 @@ impl Method {
             | Method::ToolNavigateForward
             | Method::ToolReload
             | Method::ToolClick
+            | Method::ToolWheel
             | Method::ToolFill
             | Method::ToolPress
             | Method::ToolSelect
@@ -283,6 +286,7 @@ mod tests {
         assert!(Method::ToolNavigateForward.is_mutating());
         assert!(Method::ToolReload.is_mutating());
         assert!(Method::ToolClick.is_mutating());
+        assert!(Method::ToolWheel.is_mutating());
         assert!(Method::ToolFill.is_mutating());
         assert!(Method::ToolPress.is_mutating());
         assert!(Method::ToolSelect.is_mutating());
@@ -327,6 +331,7 @@ mod tests {
         assert_eq!(Method::ToolHover.effect(), MethodEffect::TransientInput);
         assert_eq!(Method::ToolObserve.effect(), MethodEffect::TransientInput);
         assert_eq!(Method::ToolClick.effect(), MethodEffect::BrowserMutation);
+        assert_eq!(Method::ToolWheel.effect(), MethodEffect::BrowserMutation);
         assert_eq!(Method::Cancel.effect(), MethodEffect::ControlPlane);
     }
 
@@ -336,6 +341,7 @@ mod tests {
         assert!(Method::ToolHover.requires_interrupt_gate());
         assert!(Method::ToolObserve.requires_interrupt_gate());
         assert!(Method::ToolClick.requires_interrupt_gate());
+        assert!(Method::ToolWheel.requires_interrupt_gate());
         assert!(!Method::Cancel.requires_interrupt_gate());
     }
 }
diff --git a/crates/bsk-protocol/src/tools/mod.rs b/crates/bsk-protocol/src/tools/mod.rs
index a9c04dbb..4ec65b05 100644
--- a/crates/bsk-protocol/src/tools/mod.rs
+++ b/crates/bsk-protocol/src/tools/mod.rs
@@ -13,6 +13,7 @@ pub mod script;
 pub mod session;
 pub mod tabs;
 pub mod waits;
+pub mod wheel;
 pub mod window;
 
 pub use console::*;
@@ -28,4 +29,5 @@ pub use script::*;
 pub use session::*;
 pub use tabs::*;
 pub use waits::*;
+pub use wheel::*;
 pub use window::*;
diff --git a/crates/bsk-protocol/src/tools/wheel.rs b/crates/bsk-protocol/src/tools/wheel.rs
new file mode 100644
index 00000000..78c9b110
--- /dev/null
+++ b/crates/bsk-protocol/src/tools/wheel.rs
@@ -0,0 +1,73 @@
+//! Native mouse-wheel input primitive (`tool.wheel`).
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use super::{JavaScriptDialogInfo, KeyModifier};
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
+pub struct WheelParams {
+    pub session_id: String,
+    /// Optional `@e<N>` ref used as the wheel event's hit-test point.
+    /// Mutually exclusive with `selector`. When neither is supplied,
+    /// the event is dispatched at the viewport centre.
+    #[serde(
+        rename = "ref",
+        alias = "ref_",
+        default,
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub ref_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub selector: Option<String>,
+    /// Target tab. Defaults to the Agent Window's active tab.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tab_id: Option<i64>,
+    /// Horizontal wheel distance in CSS pixels. Positive values move right.
+    #[serde(default)]
+    pub delta_x: f64,
+    /// Vertical wheel distance in CSS pixels. Positive values move down.
+    pub delta_y: f64,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub modifiers: Option<Vec<KeyModifier>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[schemars(range(min = 1))]
+    pub timeout_ms: Option<u32>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
+pub struct WheelResult {
+    pub tab_id: i64,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub used_ref: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub used_selector: Option<String>,
+    /// Top-level viewport coordinates where the real wheel event was dispatched.
+    pub x: f64,
+    pub y: f64,
+    pub delta_x: f64,
+    pub delta_y: f64,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub dialogs: Vec<JavaScriptDialogInfo>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn params_accept_missing_horizontal_delta_and_serialise_ref() {
+        let value = serde_json::json!({
+            "session_id": "abcd",
+            "ref": "@e3",
+            "delta_y": 600.0
+        });
+        let params: WheelParams = serde_json::from_value(value).unwrap();
+        assert_eq!(params.delta_x, 0.0);
+        assert_eq!(params.ref_.as_deref(), Some("@e3"));
+
+        let round = serde_json::to_value(params).unwrap();
+        assert_eq!(round.get("ref").and_then(|v| v.as_str()), Some("@e3"));
+        assert!(round.get("ref_").is_none());
+    }
+}
diff --git a/skill/SKILL.md b/skill/SKILL.md
index e1cffb92..eea194ee 100644
--- a/skill/SKILL.md
+++ b/skill/SKILL.md
@@ -202,6 +202,7 @@ Both capture from the moment the tab is attached and read a bounded per-tab buff
 |---------|---------|
 | `bsk click <ref-or-selector>` | Click element (`--button`, `--click-count`, `--modifiers`) |
 | `bsk hover <ref-or-selector>` | Move the mouse to an element and wait for hover UI to settle (`--settle`, `--modifiers`) |
+| `bsk wheel --delta-y <pixels> [ref-or-selector]` | Dispatch a real mouse-wheel event at the viewport centre or an element (`--delta-x`, `--modifiers`) |
 | `bsk fill <ref-or-selector> --value <text>` | Clear and type into input |
 | `bsk select <ref-or-selector> --value <v>` | Set `<select>` option(s) by `value` (repeat `--value` for multi-select) |
 | `bsk press <key>` | Key/combo (`Enter`, `Ctrl+A`, …; optional `--ref` to focus first) |