@@ -38,7 +38,9 @@ use datafusion::logical_expr::expr::AggregateFunction;
 use datafusion::logical_expr::expr_rewriter::FunctionRewrite;
 use datafusion::logical_expr::{
     self, lit, AggregateUDF, Case, Distinct, Expr, JoinType, LogicalPlan, ScalarUDF, ScalarUDFImpl,
-    Signature, SimpleAggregateUDF, TypeSignature, Volatility, WindowFunctionDefinition,
+    Signature, SimpleAggregateUDF, TypeSignature, Volatility,
+    WindowFrameBound as DfWindowFrameBound, WindowFrameUnits as DfWindowFrameUnits,
+    WindowFunctionDefinition,
 };
 use datafusion::optimizer::analyzer::function_rewrite::ApplyFunctionRewrites;
 use datafusion::optimizer::{AnalyzerRule, OptimizerConfig};
@@ -48,7 +50,7 @@ use asap_sql_function_catalog::{AggSemantic, Arity, RewriteKind};
 use asap_types::pre_asap::agg_intent::AggIntent;
 use asap_types::pre_asap::query_expr::{
     GroupKeys, Predicate, ProjectItem, Reduction, SortKey, Source,
-    UnresolvedQueryExpr as Unresolved,
+    UnresolvedQueryExpr as Unresolved, WindowFrame, WindowFrameBound, WindowFrameUnits,
 };
 use asap_types::pre_asap::schema::{DataType, Schema};
 use asap_types::pre_asap::{
@@ -65,7 +67,7 @@ mod types;
 pub use types::SqlCatalog;
 
 use self::expr::df_expr_to_unresolved;
-use self::types::{arrow_to_dtype, schema_to_arrow};
+use self::types::{arrow_to_dtype, scalar_value_to_asap, schema_to_arrow};
 
 std::thread_local! {
     static ACCURACY: std::cell::RefCell<AccuracyTarget> =
@@ -545,8 +547,8 @@ impl<'a> SqlLowerer<'a> {
         })
     }
 
-    /// `func(args) OVER (PARTITION BY … ORDER BY …)`. One window function per
-    /// plan node; window frames are not modelled yet (default frame assumed).
+    /// `func(args) OVER (PARTITION BY … ORDER BY … ROWS/RANGE BETWEEN …)`. One
+    /// window function per plan node.
     fn lower_window(&self, window: &logical_expr::Window) -> Result<Unresolved, LoweringError> {
         if window.window_expr.len() > 1 {
             return Err(LoweringError::UnsupportedFeature(format!(
@@ -601,6 +603,7 @@ impl<'a> SqlLowerer<'a> {
                 })
             })
             .collect::<Result<Vec<_>, _>>()?;
+        let frame = lower_window_frame(&wf.window_frame)?;
         // The window plan's schema is `[input fields …, window output]`; the last
         // field is the window column's name (what an enclosing Project references).
         let output_name = window
@@ -614,6 +617,7 @@ impl<'a> SqlLowerer<'a> {
             args,
             partition_by: partition_by.into(),
             order_by,
+            frame,
             output_name,
             child,
         })
@@ -1665,6 +1669,43 @@ fn lower_window_func_kind(fun: &WindowFunctionDefinition) -> Result<WindowFuncKi
     }
 }
 
+/// Map DataFusion's resolved `WindowFrame` (issue #268) to the canonical
+/// [`WindowFrame`]. DataFusion's planner always fills in the SQL-standard
+/// default frame before the logical plan is built, so this never sees an
+/// "absent" frame — only `ROWS`/`RANGE`/`GROUPS` with concrete bounds.
+/// `GROUPS` is rejected: no query in this repo's SQL corpora uses it, and
+/// nothing downstream interprets frame semantics yet, so it isn't worth
+/// modelling untested.
+fn lower_window_frame(
+    frame: &datafusion::logical_expr::WindowFrame,
+) -> Result<WindowFrame, LoweringError> {
+    let units = match frame.units {
+        DfWindowFrameUnits::Rows => WindowFrameUnits::Rows,
+        DfWindowFrameUnits::Range => WindowFrameUnits::Range,
+        DfWindowFrameUnits::Groups => {
+            return Err(LoweringError::UnsupportedFeature(
+                "window frame unit: GROUPS".into(),
+            ))
+        }
+    };
+    let bound = |b: &DfWindowFrameBound| -> Result<WindowFrameBound, LoweringError> {
+        Ok(match b {
+            DfWindowFrameBound::Preceding(v) => {
+                WindowFrameBound::Preceding(scalar_value_to_asap(v)?)
+            }
+            DfWindowFrameBound::CurrentRow => WindowFrameBound::CurrentRow,
+            DfWindowFrameBound::Following(v) => {
+                WindowFrameBound::Following(scalar_value_to_asap(v)?)
+            }
+        })
+    };
+    Ok(WindowFrame {
+        units,
+        start_bound: bound(&frame.start_bound)?,
+        end_bound: bound(&frame.end_bound)?,
+    })
+}
+
 // ── Issue #225, item 3: DataFusion registry drift detection ────────────────
 //
 // `asap_sql_function_catalog::NATIVE_FUNCTIONS` is hand-maintained data
 
@@ -9,7 +9,7 @@ use asap_frontend_sql::{lower_sql, lower_sql_dialect, SqlCatalog};
 use asap_types::pre_asap::schema::{Column, DataType, Schema};
 use asap_types::pre_asap::{
     AggIntent, CompareOpKind, GroupKeys, JoinKind, QueryExpr, Reduction, ScalarValue, Source,
-    WindowFuncKind,
+    WindowFrameBound, WindowFrameUnits, WindowFuncKind,
 };
 use asap_types::types::AccuracyTarget;
 use asap_types::workload::SqlDialect;
@@ -722,6 +722,72 @@ async fn window_aggregate_lowers_to_windowfunc() {
     assert_eq!(args, &vec![QueryExpr::Column(3)], "SUM(bytes) → arg col 3");
 }
 
+// ── Window frames (issue #268) ───────────────────────────────────────────────
+
+/// The frame clause must actually reach the IR, not just the display string:
+/// three window frames that differ semantically must lower to different
+/// `SQLWindowFunc.frame` values.
+#[tokio::test]
+async fn window_frame_is_captured_not_dropped() {
+    let default_frame =
+        lower("SELECT service, SUM(latency) OVER (PARTITION BY service ORDER BY ts) FROM metrics")
+            .await;
+    let two_preceding = lower(
+        "SELECT service, SUM(latency) OVER (PARTITION BY service ORDER BY ts \
+         ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) FROM metrics",
+    )
+    .await;
+    let unbounded_following = lower(
+        "SELECT service, SUM(latency) OVER (PARTITION BY service ORDER BY ts \
+         ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM metrics",
+    )
+    .await;
+
+    let frame_of = |qe: &QueryExpr| {
+        let QueryExpr::SQLWindowFunc { frame, .. } = find_windowfunc(qe).unwrap() else {
+            unreachable!();
+        };
+        frame.clone()
+    };
+    let (a, b, c) = (
+        frame_of(&default_frame),
+        frame_of(&two_preceding),
+        frame_of(&unbounded_following),
+    );
+    assert_ne!(a, b, "default frame vs ROWS 2 PRECEDING must differ");
+    assert_ne!(
+        a, c,
+        "default frame vs ROWS CURRENT..UNBOUNDED FOLLOWING must differ"
+    );
+    assert_ne!(b, c);
+
+    assert_eq!(b.units, WindowFrameUnits::Rows);
+    assert_eq!(
+        b.start_bound,
+        WindowFrameBound::Preceding(ScalarValue::Int64(2))
+    );
+    assert_eq!(b.end_bound, WindowFrameBound::CurrentRow);
+
+    assert_eq!(c.start_bound, WindowFrameBound::CurrentRow);
+    assert_eq!(c.end_bound, WindowFrameBound::Following(ScalarValue::Null));
+}
+
+/// `GROUPS` frames aren't in this repo's SQL corpora and nothing downstream
+/// interprets frame semantics yet — rejected explicitly rather than silently
+/// mis-lowered.
+#[tokio::test]
+async fn groups_frame_is_rejected() {
+    let err = lower_sql(
+        "SELECT service, SUM(latency) OVER (PARTITION BY service ORDER BY ts \
+         GROUPS BETWEEN 2 PRECEDING AND CURRENT ROW) FROM metrics",
+        &catalog(),
+        AccuracyTarget::Exact,
+    )
+    .await
+    .expect_err("GROUPS frame unit must be rejected");
+    assert!(format!("{err}").contains("GROUPS"), "got {err}");
+}
+
 // ── Nested query functions: derived tables / inline views (issue #27) ───────────
 
 /// Collect every `AggIntent` in the tree, root-to-leaf.
 
@@ -440,6 +440,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
             args,
             partition_by,
             order_by,
+            frame,
             output_name,
             child,
         } => {
@@ -449,6 +450,7 @@ fn build(expr: &QueryExpr, nodes: &mut Vec<DagNode>, cache: &mut HashCache) -> u
                 "args": args,
                 "partition_by": partition_by,
                 "order_by": order_by,
+                "frame": frame,
                 "output_name": output_name,
             });
             push_node(
 
@@ -294,7 +294,9 @@ fn try_rewrite_rownumber_topk(expr: &QueryExpr) -> Option<QueryExpr> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::pre_asap::query_expr::{GroupKeys, ProjectItem, Source};
+    use crate::pre_asap::query_expr::{
+        GroupKeys, ProjectItem, Source, WindowFrame, WindowFrameBound, WindowFrameUnits,
+    };
     use crate::pre_asap::schema::{Column, DataType, Schema};
     use crate::types::AccuracyTarget;
 
@@ -473,6 +475,16 @@ mod tests {
         }
     }
 
+    /// `ROW_NUMBER` ignores its frame clause, so the top-k rewrite doesn't care
+    /// what's in it; any concrete frame works as fixture data.
+    fn rownumber_frame() -> WindowFrame {
+        WindowFrame {
+            units: WindowFrameUnits::Rows,
+            start_bound: WindowFrameBound::Preceding(ScalarValue::Null),
+            end_bound: WindowFrameBound::Following(ScalarValue::Null),
+        }
+    }
+
     /// `Filter{ rn(3) <= 5 } { SQLWindowFunc{ RowNumber, PARTITION BY region(2),
     /// ORDER BY col(2) DESC } { agg } }`.
     fn rownumber_topk(agg: QueryExpr) -> QueryExpr {
@@ -485,6 +497,7 @@ mod tests {
                 ascending: false,
                 nulls_first: true,
             }],
+            frame: rownumber_frame(),
             output_name: "rn".into(),
             child: Rc::new(agg),
         };
@@ -567,6 +580,7 @@ mod tests {
                 ascending: false,
                 nulls_first: true,
             }],
+            frame: rownumber_frame(),
             output_name: "rn".into(),
             child: Rc::new(grouped(AggIntent::Count {
                 accuracy: AccuracyTarget::Exact,
 
@@ -350,6 +350,7 @@ pub(crate) fn structural_hash(node: &QueryExpr, cache: &mut HashCache) -> u64 {
             args,
             partition_by,
             order_by,
+            frame,
             output_name,
             child,
         } => {
@@ -361,6 +362,7 @@ pub(crate) fn structural_hash(node: &QueryExpr, cache: &mut HashCache) -> u64 {
                     args,
                     partition_by,
                     order_by,
+                    frame,
                     output_name,
                 ),
             );
@@ -666,13 +668,15 @@ fn rebuild_children(table: &mut InternTable, expr: QueryExpr) -> QueryExpr {
             args,
             partition_by,
             order_by,
+            frame,
             output_name,
             child,
         } => SQLWindowFunc {
             func,
             args,
             partition_by,
             order_by,
+            frame,
             output_name,
             child: intern_child(table, child),
         },
 
@@ -56,7 +56,8 @@ pub use query_expr::{
     aggregate_output_schema, AtModifier, BinaryOpKind, ColState, DataModel, GroupKeys, GroupSide,
     InfoMatcher, JoinKind, Predicate, ProjectItem, QueryExpr, QueryExprError, Reduction,
     ResolvedQueryExpr, SampleKind, SetOpKind, SortKey, Source, TimeShift, UnresolvedQueryExpr,
-    VectorGrouping, VectorMatch, VectorMatchKind, WindowFuncKind,
+    VectorGrouping, VectorMatch, VectorMatchKind, WindowFrame, WindowFrameBound, WindowFrameUnits,
+    WindowFuncKind,
 };
 pub use resolve::{resolve_root, ResolveTreeError};
 pub use schema::{Column, ColumnId, DataType, Schema};
@@ -332,6 +332,42 @@ pub enum WindowFuncKind {
     Max,
 }
 
+/// A window's frame-spec (`ROWS`/`RANGE BETWEEN … AND …`) — which rows around
+/// the current one an analytic window function reads. `GROUPS` is rejected at
+/// lowering time (issue #268): every SQL corpus in this repo uses only `ROWS`,
+/// and nothing downstream interprets frame semantics yet, so it isn't worth
+/// modelling untested.
+///
+/// Meaningless (but harmless) on the rank-only and navigation functions
+/// (`ROW_NUMBER`/`RANK`/`DENSE_RANK`/`LAG`/`LEAD`), which ignore the frame per
+/// SQL semantics — DataFusion still attaches one, stored here verbatim.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct WindowFrame {
+    pub units: WindowFrameUnits,
+    pub start_bound: WindowFrameBound,
+    pub end_bound: WindowFrameBound,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum WindowFrameUnits {
+    /// Boundaries count physical rows: `ROWS BETWEEN 2 PRECEDING AND CURRENT ROW`.
+    Rows,
+    /// Boundaries count by value-distance on the (single) `ORDER BY` column:
+    /// `RANGE BETWEEN INTERVAL '1' HOUR PRECEDING AND CURRENT ROW`.
+    Range,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum WindowFrameBound {
+    /// `UNBOUNDED PRECEDING` is `Preceding(ScalarValue::Null)`.
+    Preceding(ScalarValue),
+    CurrentRow,
+    /// `UNBOUNDED FOLLOWING` is `Following(ScalarValue::Null)`.
+    Following(ScalarValue),
+}
+
 /// A symbolic label matcher on the **info metric** side of an
 /// [`QueryExpr::PromqlInfoEnrich`] (issue #84). Unlike a `Scan` predicate it is not
 /// resolved positionally — it references the info metric's labels (`__name__`
@@ -729,16 +765,17 @@ pub enum QueryExpr<C: ColState = ColumnId> {
         child: Rc<QueryExpr<C>>,
     },
 
-    /// SQL analytic window function: `func(args) OVER (PARTITION BY … ORDER BY …)`.
-    /// Output schema = child schema + one column named `output_name` (the name
-    /// the enclosing `Project` references). Window frames are not modelled yet.
+    /// SQL analytic window function: `func(args) OVER (PARTITION BY … ORDER BY …
+    /// ROWS/RANGE BETWEEN …)`. Output schema = child schema + one column named
+    /// `output_name` (the name the enclosing `Project` references).
     SQLWindowFunc {
         func: WindowFuncKind,
         /// Operand expressions (`LAG(value)` → `[Column(value_id)]`); empty for
         /// the rank-only functions (`ROW_NUMBER`/`RANK`/`DENSE_RANK`).
         args: Vec<QueryExpr<C>>,
         partition_by: GroupKeys<C>,
         order_by: Vec<SortKey<C>>,
+        frame: WindowFrame,
         /// The output column's name — DataFusion's window-expr field name, so a
         /// `Project` above resolves it (cf. `Aggregate.output_names`).
         output_name: String,
 
@@ -337,6 +337,7 @@ fn resolve(
             args,
             partition_by,
             order_by,
+            frame,
             output_name,
             child,
         } => {
@@ -362,6 +363,7 @@ fn resolve(
                 args,
                 partition_by,
                 order_by,
+                frame: frame.clone(),
                 output_name: output_name.clone(),
                 child: Rc::new(child),
             }