diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 520f4e2ec..d0a6b5e0b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -43,7 +43,7 @@ jobs:
             | jq -r '[.packages[].rust_version | select(. != null)] | unique | .[0]')" --profile minimal
           rustup default stable
 
-      - uses: taiki-e/install-action@ab6895351a88b908e96a4697860d4ffea5e57dbe # v2.87.27
+      - uses: taiki-e/install-action@8cca0918f8471c33515202b73f56ab27f2bed283 # v2.87.29
         with:
           tool: cargo-nextest,cargo-hack@0.6.45
 
diff --git a/crates/algeon-datafusion/src/native/expression_contract/join_residual.rs b/crates/algeon-datafusion/src/native/expression_contract/join_residual.rs
index 909995c75..7c8e56d68 100644
--- a/crates/algeon-datafusion/src/native/expression_contract/join_residual.rs
+++ b/crates/algeon-datafusion/src/native/expression_contract/join_residual.rs
@@ -16,26 +16,34 @@ use query_engine::rapids_backend::rapids_backend;
 use query_planning::{datatypes::is_supported_ast_cast, validation::is_integral_type};
 
 use super::{
-    ExpressionCapability, ExpressionRejection, ExpressionRejectionSubject, ScalarFunctionKind, ValidatedPhysicalExpr,
-    binary_operator_subject, is_checked_temporal_arithmetic, is_decimal_division, physical_expr_data_type,
-    validate_physical_expr_contract,
+    ExpressionCapability, ExpressionRejection, ExpressionRejectionSubject, ValidatedPhysicalExpr,
+    binary_operator_subject, contains_fallible_operation, fallible_operand, is_checked_temporal_arithmetic,
+    is_decimal_division, physical_expr_data_type, validate_physical_expr_contract,
 };
 
-/// Representation selected by the join-residual-specific cast contract.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(in crate::native) enum JoinResidualCastMode {
-    Ast,
-    Materialize,
-}
-
 /// Proof that a join filter satisfies both the general physical-expression
-/// contract and the stricter native join residual vocabulary.
+/// contract and the native join residual contract.
+///
+/// The residual keeps the operators the cuDF join AST evaluates. Each other
+/// subexpression that reads one input and cannot fail is a
+/// [`JoinResidualMaterializationSite`]: lowering evaluates it on every row of
+/// that input before the join and the residual reads the result as a column.
 #[derive(Debug)]
 pub(in crate::native) struct ValidatedJoinResidual<'a> {
     filter: &'a JoinFilter,
     expression: ValidatedPhysicalExpr,
     left_schema: SchemaRef,
     right_schema: SchemaRef,
+    materializations: Vec<JoinResidualMaterializationSite>,
+}
+
+/// A residual subexpression that lowering evaluates on one join input before
+/// the join. Sites are distinct `Arc`s in residual pre-order, and lowering
+/// substitutes each by pointer identity.
+#[derive(Debug)]
+pub(in crate::native) struct JoinResidualMaterializationSite {
+    pub(in crate::native) expr: Arc<dyn PhysicalExpr>,
+    pub(in crate::native) side: JoinSide,
 }
 
 impl<'a> ValidatedJoinResidual<'a> {
@@ -56,15 +64,11 @@ impl<'a> ValidatedJoinResidual<'a> {
     }
 
     pub(in crate::native) fn contains_decimal_division(&self) -> bool {
-        fn contains(expr: &Arc<dyn PhysicalExpr>, schema: &SchemaRef) -> bool {
-            expr.downcast_ref::<BinaryExpr>().is_some_and(|binary| is_decimal_division(binary, schema))
-                || expr.children().into_iter().any(|child| contains(child, schema))
-        }
-        contains(self.filter.expression(), self.filter.schema())
+        contains_decimal_division(self.filter.expression(), self.filter.schema())
     }
 
-    pub(in crate::native) fn single_side(&self, expr: &Arc<dyn PhysicalExpr>) -> Result<JoinSide, ExpressionRejection> {
-        join_filter_expr_single_side(expr, self.filter)
+    pub(in crate::native) fn materializations(&self) -> &[JoinResidualMaterializationSite] {
+        &self.materializations
     }
 }
 
@@ -74,17 +78,19 @@ pub(in crate::native) fn validate_join_residual<'a>(
     right_schema: &SchemaRef,
 ) -> Result<ValidatedJoinResidual<'a>, ExpressionRejection> {
     let expression = validate_physical_expr_contract(filter.expression(), filter.schema())?;
-    validate_join_residual_expr(filter.expression(), filter)?;
     let residual = filter.expression();
+    let mut shape = ResidualShape {
+        filter,
+        post_join: contains_decimal_division(residual, filter.schema()),
+        materializations: Vec::new(),
+    };
+    shape.visit(residual)?;
     validate_join_residual_side_indices(residual, filter, left_schema, right_schema)
         .map_err(|rejection| rejection.at_expression(residual))?;
 
-    let mut side = None;
-    let mut saw_left = false;
-    let mut saw_right = false;
-    collect_join_filter_expr_sides(residual, filter, &mut side, &mut saw_left, &mut saw_right, false)
-        .map_err(|rejection| rejection.at_expression(residual))?;
-    if !saw_left || !saw_right {
+    let (reads_left, reads_right) =
+        join_filter_expr_sides(residual, filter).map_err(|rejection| rejection.at_expression(residual))?;
+    if !reads_left || !reads_right {
         return Err(ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualSides)
             .at_expression(residual));
     }
@@ -94,9 +100,177 @@ pub(in crate::native) fn validate_join_residual<'a>(
         expression,
         left_schema: Arc::clone(left_schema),
         right_schema: Arc::clone(right_schema),
+        materializations: shape.materializations,
     })
 }
 
+fn contains_decimal_division(expr: &Arc<dyn PhysicalExpr>, schema: &SchemaRef) -> bool {
+    expr.downcast_ref::<BinaryExpr>().is_some_and(|binary| is_decimal_division(binary, schema))
+        || expr.children().into_iter().any(|child| contains_decimal_division(child, schema))
+}
+
+/// Walk of a residual that admits its shape and records its materialization
+/// sites.
+struct ResidualShape<'f> {
+    filter: &'f JoinFilter,
+    /// Whether lowering runs the residual as the checked filter over
+    /// key-matched rows, which it does for a decimal `/`. That filter
+    /// evaluates a fallible operation only on matched pairs, as DataFusion
+    /// does, and the operation stays in the residual.
+    post_join: bool,
+    materializations: Vec<JoinResidualMaterializationSite>,
+}
+
+impl ResidualShape<'_> {
+    fn visit(&mut self, expr: &Arc<dyn PhysicalExpr>) -> Result<(), ExpressionRejection> {
+        self.visit_shape(expr).map_err(|rejection| rejection.at_expression(expr))
+    }
+
+    fn visit_children(&mut self, expr: &Arc<dyn PhysicalExpr>) -> Result<(), ExpressionRejection> {
+        expr.children().into_iter().try_for_each(|child| self.visit(child))
+    }
+
+    fn visit_shape(&mut self, expr: &Arc<dyn PhysicalExpr>) -> Result<(), ExpressionRejection> {
+        if expr.downcast_ref::<Column>().is_some() || expr.downcast_ref::<Literal>().is_some() {
+            return Ok(());
+        }
+        let schema = self.filter.schema();
+        if is_inline_operator(expr, schema) {
+            return self.visit_children(expr);
+        }
+        let Some(side) = join_filter_expr_single_side(expr, self.filter) else {
+            return self.visit_cross_input(expr);
+        };
+        // A pre-join value is computed for every row of its input, including
+        // rows that match no key and that DataFusion never filters. Only an
+        // expression that cannot fail moves before the join.
+        if !contains_fallible_operation(expr, schema) {
+            if !self.materializations.iter().any(|site| Arc::ptr_eq(&site.expr, expr)) {
+                self.materializations.push(JoinResidualMaterializationSite { expr: Arc::clone(expr), side });
+            }
+            return Ok(());
+        }
+        if self.post_join && !is_unchecked_ast_arithmetic(expr, schema) {
+            return self.visit_children(expr);
+        }
+        Err(fallible_operation_rejection(expr, schema))
+    }
+
+    /// Admits an expression over both inputs that the AST does not evaluate.
+    /// The planner evaluates an inner join residual with `CASE` or null-aware
+    /// comparison as a filter over key-matched pairs.
+    fn visit_cross_input(&mut self, expr: &Arc<dyn PhysicalExpr>) -> Result<(), ExpressionRejection> {
+        let null_aware = expr
+            .downcast_ref::<BinaryExpr>()
+            .is_some_and(|binary| matches!(binary.op(), Operator::IsDistinctFrom | Operator::IsNotDistinctFrom));
+        if null_aware || expr.downcast_ref::<CaseExpr>().is_some() {
+            return self.visit_children(expr);
+        }
+        Err(cross_input_rejection(expr, self.filter.schema()))
+    }
+}
+
+/// Whether the residual keeps `expr` as an operator over its operands: the
+/// cuDF join AST evaluates it, or, for a decimal `/`, the checked post-join
+/// filter does. The AST has no concatenation, null-aware comparison or bit
+/// shift.
+fn is_inline_operator(expr: &Arc<dyn PhysicalExpr>, schema: &SchemaRef) -> bool {
+    if let Some(binary) = expr.downcast_ref::<BinaryExpr>() {
+        return !matches!(
+            binary.op(),
+            Operator::StringConcat
+                | Operator::IsDistinctFrom
+                | Operator::IsNotDistinctFrom
+                | Operator::BitwiseShiftLeft
+                | Operator::BitwiseShiftRight
+        ) && !is_unchecked_ast_arithmetic(expr, schema);
+    }
+    if let Some(cast) = expr.downcast_ref::<CastExpr>() {
+        return physical_expr_data_type(cast.expr(), schema)
+            .is_ok_and(|source| is_supported_ast_cast(&source, cast.cast_type(), rapids_backend()));
+    }
+    expr.downcast_ref::<NotExpr>().is_some()
+        || expr.downcast_ref::<IsNullExpr>().is_some()
+        || expr.downcast_ref::<IsNotNullExpr>().is_some()
+        || expr.downcast_ref::<InListExpr>().is_some()
+}
+
+/// Whether `expr` is arithmetic the cuDF AST would evaluate without the checks
+/// DataFusion applies. The AST has no zero-divisor or overflow checks and no
+/// verified floating-point remainder, and it wraps timestamp arithmetic that
+/// Arrow checks. Decimal division uses the checked post-join filter.
+fn is_unchecked_ast_arithmetic(expr: &Arc<dyn PhysicalExpr>, schema: &SchemaRef) -> bool {
+    let Some(binary) = expr.downcast_ref::<BinaryExpr>() else {
+        return false;
+    };
+    match binary.op() {
+        Operator::Modulo => true,
+        Operator::Plus | Operator::Minus => is_checked_temporal_arithmetic(binary, schema),
+        Operator::Divide => {
+            physical_expr_data_type(binary.left(), schema).map_or(true, |data_type| is_integral_type(&data_type))
+        },
+        _ => false,
+    }
+}
+
+/// The rejection for `expr`, an expression over both inputs that neither the
+/// AST nor the post-join filter evaluates.
+fn cross_input_rejection(expr: &Arc<dyn PhysicalExpr>, schema: &SchemaRef) -> ExpressionRejection {
+    if let Some(binary) = expr.downcast_ref::<BinaryExpr>() {
+        return ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualShape)
+            .named_by_operator(binary_operator_subject(binary, schema));
+    }
+    if let Some(cast) = expr.downcast_ref::<CastExpr>() {
+        return cast_rejection(cast, schema);
+    }
+    if let Some(function) = expr.downcast_ref::<ScalarFunctionExpr>() {
+        return ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualScalarFunction)
+            .with_subject(ExpressionRejectionSubject::ScalarFunction(function.name().to_string()));
+    }
+    ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualShape)
+}
+
+/// The rejection for `expr`, a single-input expression whose evaluation can
+/// fail, naming its first fallible operation.
+fn fallible_operation_rejection(expr: &Arc<dyn PhysicalExpr>, schema: &SchemaRef) -> ExpressionRejection {
+    let operation = first_fallible_operation(expr, schema).unwrap_or(expr);
+    let rejection = if let Some(binary) = operation.downcast_ref::<BinaryExpr>() {
+        ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualShape)
+            .named_by_operator(binary_operator_subject(binary, schema))
+    } else if let Some(cast) = operation.downcast_ref::<CastExpr>() {
+        cast_rejection(cast, schema)
+    } else {
+        ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualShape)
+    };
+    rejection.at_expression(operation)
+}
+
+fn first_fallible_operation<'e>(
+    expr: &'e Arc<dyn PhysicalExpr>,
+    schema: &SchemaRef,
+) -> Option<&'e Arc<dyn PhysicalExpr>> {
+    if fallible_operand(expr, schema).is_some() {
+        return Some(expr);
+    }
+    expr.children().into_iter().find_map(|child| first_fallible_operation(child, schema))
+}
+
+/// A cast the residual cannot evaluate. A cast to an AST target type reports
+/// its type pair; the AST has no other cast target.
+fn cast_rejection(cast: &CastExpr, schema: &SchemaRef) -> ExpressionRejection {
+    let rejection = if matches!(cast.cast_type(), DataType::Int64 | DataType::UInt64 | DataType::Float64) {
+        ExpressionRejection::unsupported_type(ExpressionCapability::CastPair)
+    } else {
+        ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualCastTarget)
+    };
+    match physical_expr_data_type(cast.expr(), schema) {
+        Ok(source) => {
+            rejection.with_subject(ExpressionRejectionSubject::Cast { source, target: cast.cast_type().clone() })
+        },
+        Err(type_rejection) => type_rejection,
+    }
+}
+
 fn validate_join_residual_side_indices(
     expr: &Arc<dyn PhysicalExpr>,
     filter: &JoinFilter,
@@ -133,201 +307,31 @@ fn validate_join_residual_side_indices(
     Ok(())
 }
 
-pub(in crate::native) fn join_residual_cast_mode(
-    target_type: &DataType,
-) -> Result<JoinResidualCastMode, ExpressionRejection> {
-    if matches!(target_type, DataType::Int64 | DataType::UInt64 | DataType::Float64) {
-        return Ok(JoinResidualCastMode::Ast);
-    }
-    if matches!(target_type, DataType::Decimal128(_, _) | DataType::Utf8 | DataType::LargeUtf8 | DataType::Utf8View) {
-        return Ok(JoinResidualCastMode::Materialize);
-    }
-    Err(ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualCastTarget))
-}
-
-pub(in crate::native) fn validate_join_residual_scalar_function(
-    kind: ScalarFunctionKind,
-) -> Result<(), ExpressionRejection> {
-    match kind {
-        ScalarFunctionKind::Substring | ScalarFunctionKind::Lower | ScalarFunctionKind::Upper => Ok(()),
-        _ => Err(ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualScalarFunction)),
-    }
-}
-
-fn validate_join_residual_expr(expr: &Arc<dyn PhysicalExpr>, filter: &JoinFilter) -> Result<(), ExpressionRejection> {
-    validate_join_residual_shape(expr, filter).map_err(|rejection| rejection.at_expression(expr))
-}
-
-fn validate_join_residual_shape(expr: &Arc<dyn PhysicalExpr>, filter: &JoinFilter) -> Result<(), ExpressionRejection> {
-    if expr.downcast_ref::<Column>().is_some() || expr.downcast_ref::<Literal>().is_some() {
-        return Ok(());
-    }
-    if let Some(binary) = expr.downcast_ref::<BinaryExpr>() {
-        // The cudf AST has no zero-divisor or overflow checks and no verified
-        // floating-point remainder, and it wraps timestamp arithmetic that
-        // Arrow checks. Decimal division uses the checked GPU post-join
-        // evaluator, including CASE branch activation.
-        let ast_arithmetic_is_unchecked = match binary.op() {
-            Operator::Modulo => true,
-            Operator::Plus | Operator::Minus => is_checked_temporal_arithmetic(binary, filter.schema()),
-            Operator::Divide => physical_expr_data_type(binary.left(), filter.schema())
-                .map_or(true, |data_type| is_integral_type(&data_type)),
-            _ => false,
-        };
-        if ast_arithmetic_is_unchecked {
-            return Err(ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualShape)
-                .named_by_operator(binary_operator_subject(binary, filter.schema())));
-        }
-        validate_join_residual_expr(binary.left(), filter)?;
-        return validate_join_residual_expr(binary.right(), filter);
-    }
-    if let Some(not) = expr.downcast_ref::<NotExpr>() {
-        return validate_join_residual_expr(not.arg(), filter);
-    }
-    if let Some(is_null) = expr.downcast_ref::<IsNullExpr>() {
-        return validate_join_residual_expr(is_null.arg(), filter);
-    }
-    if let Some(is_not_null) = expr.downcast_ref::<IsNotNullExpr>() {
-        return validate_join_residual_expr(is_not_null.arg(), filter);
-    }
-    if let Some(cast) = expr.downcast_ref::<CastExpr>() {
-        if matches!(join_residual_cast_mode(cast.cast_type())?, JoinResidualCastMode::Materialize) {
-            join_filter_expr_single_side(expr, filter)?;
-        } else {
-            // The AST cast wraps or saturates where DataFusion fails the query,
-            // and it has no cast over temporal values.
-            let source_type = physical_expr_data_type(cast.expr(), filter.schema())?;
-            if !is_supported_ast_cast(&source_type, cast.cast_type(), rapids_backend()) {
-                return Err(ExpressionRejection::unsupported_type(ExpressionCapability::CastPair).with_subject(
-                    ExpressionRejectionSubject::Cast { source: source_type, target: cast.cast_type().clone() },
-                ));
-            }
-        }
-        return validate_join_residual_expr(cast.expr(), filter);
-    }
-    if let Some(in_list) = expr.downcast_ref::<InListExpr>() {
-        validate_join_residual_expr(in_list.expr(), filter)?;
-        for item in in_list.list() {
-            validate_join_residual_expr(item, filter)?;
-        }
-        return Ok(());
-    }
-    if let Some(case) = expr.downcast_ref::<CaseExpr>() {
-        if let Some(base) = case.expr() {
-            validate_join_residual_expr(base, filter)?;
-        }
-        for (when, then) in case.when_then_expr() {
-            validate_join_residual_expr(when, filter)?;
-            validate_join_residual_expr(then, filter)?;
-        }
-        if let Some(else_expr) = case.else_expr() {
-            validate_join_residual_expr(else_expr, filter)?;
-        }
-        return Ok(());
-    }
-    if let Some(function) = expr.downcast_ref::<ScalarFunctionExpr>() {
-        validate_join_residual_scalar_function(ScalarFunctionKind::from_scalar_function(function)?).map_err(
-            |rejection| rejection.with_subject(ExpressionRejectionSubject::ScalarFunction(function.name().to_string())),
-        )?;
-        join_filter_expr_single_side(expr, filter)?;
-        for arg in function.args() {
-            validate_join_residual_expr(arg, filter)?;
-        }
-        return Ok(());
-    }
-    Err(ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualShape))
-}
-
-fn join_filter_expr_single_side(
-    expr: &Arc<dyn PhysicalExpr>,
-    filter: &JoinFilter,
-) -> Result<JoinSide, ExpressionRejection> {
-    let mut side = None;
-    let mut saw_left = false;
-    let mut saw_right = false;
-    collect_join_filter_expr_sides(expr, filter, &mut side, &mut saw_left, &mut saw_right, true)?;
-    side.ok_or_else(|| ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualSides))
-}
-
-fn collect_join_filter_expr_sides(
+/// Which join inputs `expr` reads, as `(left, right)`.
+fn join_filter_expr_sides(
     expr: &Arc<dyn PhysicalExpr>,
     filter: &JoinFilter,
-    side: &mut Option<JoinSide>,
-    saw_left: &mut bool,
-    saw_right: &mut bool,
-    enforce_single_side: bool,
-) -> Result<(), ExpressionRejection> {
+) -> Result<(bool, bool), ExpressionRejection> {
     if let Some(column) = expr.downcast_ref::<Column>() {
-        let column_index = filter
-            .column_indices()
-            .get(column.index())
-            .ok_or_else(|| ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualShape))?;
-        match column_index.side {
-            JoinSide::Left | JoinSide::Right => {
-                *saw_left |= column_index.side == JoinSide::Left;
-                *saw_right |= column_index.side == JoinSide::Right;
-                if enforce_single_side && side.is_some_and(|existing| existing != column_index.side) {
-                    return Err(ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualSides));
-                }
-                *side = Some(column_index.side);
-                return Ok(());
+        return match filter.column_indices().get(column.index()).map(|column_index| column_index.side) {
+            Some(JoinSide::Left) => Ok((true, false)),
+            Some(JoinSide::Right) => Ok((false, true)),
+            Some(JoinSide::None) | None => {
+                Err(ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualShape))
             },
-            JoinSide::None => {
-                return Err(ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualShape));
-            },
-        }
-    }
-    if expr.downcast_ref::<Literal>().is_some() {
-        return Ok(());
-    }
-    if let Some(binary) = expr.downcast_ref::<BinaryExpr>() {
-        collect_join_filter_expr_sides(binary.left(), filter, side, saw_left, saw_right, enforce_single_side)?;
-        return collect_join_filter_expr_sides(binary.right(), filter, side, saw_left, saw_right, enforce_single_side);
-    }
-    if let Some(not) = expr.downcast_ref::<NotExpr>() {
-        return collect_join_filter_expr_sides(not.arg(), filter, side, saw_left, saw_right, enforce_single_side);
-    }
-    if let Some(is_null) = expr.downcast_ref::<IsNullExpr>() {
-        return collect_join_filter_expr_sides(is_null.arg(), filter, side, saw_left, saw_right, enforce_single_side);
-    }
-    if let Some(is_not_null) = expr.downcast_ref::<IsNotNullExpr>() {
-        return collect_join_filter_expr_sides(
-            is_not_null.arg(),
-            filter,
-            side,
-            saw_left,
-            saw_right,
-            enforce_single_side,
-        );
-    }
-    if let Some(cast) = expr.downcast_ref::<CastExpr>() {
-        return collect_join_filter_expr_sides(cast.expr(), filter, side, saw_left, saw_right, enforce_single_side);
-    }
-    if let Some(in_list) = expr.downcast_ref::<InListExpr>() {
-        collect_join_filter_expr_sides(in_list.expr(), filter, side, saw_left, saw_right, enforce_single_side)?;
-        for item in in_list.list() {
-            collect_join_filter_expr_sides(item, filter, side, saw_left, saw_right, enforce_single_side)?;
-        }
-        return Ok(());
-    }
-    if let Some(case) = expr.downcast_ref::<CaseExpr>() {
-        if let Some(base) = case.expr() {
-            collect_join_filter_expr_sides(base, filter, side, saw_left, saw_right, enforce_single_side)?;
-        }
-        for (when, then) in case.when_then_expr() {
-            collect_join_filter_expr_sides(when, filter, side, saw_left, saw_right, enforce_single_side)?;
-            collect_join_filter_expr_sides(then, filter, side, saw_left, saw_right, enforce_single_side)?;
-        }
-        if let Some(else_expr) = case.else_expr() {
-            collect_join_filter_expr_sides(else_expr, filter, side, saw_left, saw_right, enforce_single_side)?;
-        }
-        return Ok(());
+        };
     }
-    if let Some(function) = expr.downcast_ref::<ScalarFunctionExpr>() {
-        for arg in function.args() {
-            collect_join_filter_expr_sides(arg, filter, side, saw_left, saw_right, enforce_single_side)?;
-        }
-        return Ok(());
+    expr.children().into_iter().try_fold((false, false), |(left, right), child| {
+        let (child_left, child_right) = join_filter_expr_sides(child, filter)?;
+        Ok((left || child_left, right || child_right))
+    })
+}
+
+/// The one input `expr` reads, or `None` when it reads both or neither.
+fn join_filter_expr_single_side(expr: &Arc<dyn PhysicalExpr>, filter: &JoinFilter) -> Option<JoinSide> {
+    match join_filter_expr_sides(expr, filter) {
+        Ok((true, false)) => Some(JoinSide::Left),
+        Ok((false, true)) => Some(JoinSide::Right),
+        _ => None,
     }
-    Err(ExpressionRejection::unsupported_expression(ExpressionCapability::JoinResidualShape))
 }
diff --git a/crates/algeon-datafusion/src/native/expression_contract/mod.rs b/crates/algeon-datafusion/src/native/expression_contract/mod.rs
index 63fa221f5..41a6b0b09 100644
--- a/crates/algeon-datafusion/src/native/expression_contract/mod.rs
+++ b/crates/algeon-datafusion/src/native/expression_contract/mod.rs
@@ -14,9 +14,7 @@ pub(in crate::native) use capability::{
     is_decimal128_to_float32_cast_via_float64, is_list_carry_type, is_narrow_decimal_carry, is_numeric_or_decimal_type,
     is_supported_to_timestamp_seconds_cast, is_supported_try_cast_pair, native_aggregate_function_kind,
 };
-pub(in crate::native) use join_residual::{
-    JoinResidualCastMode, ValidatedJoinResidual, join_residual_cast_mode, validate_join_residual,
-};
+pub(in crate::native) use join_residual::{ValidatedJoinResidual, validate_join_residual};
 pub(crate) use rejection::{
     ExpressionCapability, ExpressionRejection, ExpressionRejectionKind, ExpressionRejectionSubject,
 };
diff --git a/crates/algeon-datafusion/src/native/expression_contract/tests.rs b/crates/algeon-datafusion/src/native/expression_contract/tests.rs
index 736fa0132..09484193c 100644
--- a/crates/algeon-datafusion/src/native/expression_contract/tests.rs
+++ b/crates/algeon-datafusion/src/native/expression_contract/tests.rs
@@ -26,8 +26,7 @@ use query_planning::expr::{
 
 use super::{
     ExpressionCapability, ExpressionRejectionSubject, ScalarFunctionKind, SupportedBinaryOperator, fallible_operand,
-    join_residual::validate_join_residual_scalar_function, join_residual_cast_mode, native_aggregate_function_kind,
-    validate_join_residual, validate_physical_expr_contract,
+    native_aggregate_function_kind, validate_join_residual, validate_physical_expr_contract,
 };
 use crate::{capability::CapabilityReason, native::lowering::lower_physical_expr_for_test};
 
@@ -59,22 +58,227 @@ fn binary_capability_rejection_is_structured_and_preserves_public_reason() {
     assert_eq!(rejection.capability_reason(), CapabilityReason::UnsupportedExpression);
 }
 
+/// The left input reads `name`, `n` and `t`, the right input `r` and `label`;
+/// the filter schema lists them in that order.
+fn join_residual_schemas() -> (Arc<Schema>, Arc<Schema>, Arc<Schema>) {
+    let timestamp = DataType::Timestamp(TimeUnit::Millisecond, None);
+    let left = Arc::new(Schema::new(vec![
+        Field::new("name", DataType::Utf8, true),
+        Field::new("n", DataType::Int32, true),
+        Field::new("t", timestamp.clone(), true),
+    ]));
+    let right =
+        Arc::new(Schema::new(vec![Field::new("r", DataType::Int32, true), Field::new("label", DataType::Utf8, true)]));
+    let filter = Arc::new(Schema::new(vec![
+        Field::new("name", DataType::Utf8, true),
+        Field::new("n", DataType::Int32, true),
+        Field::new("t", timestamp, true),
+        Field::new("r", DataType::Int32, true),
+        Field::new("label", DataType::Utf8, true),
+    ]));
+    (left, right, filter)
+}
+
+fn join_residual_filter(expr: Arc<dyn PhysicalExpr>, filter_schema: &Arc<Schema>) -> JoinFilter {
+    JoinFilter::new(
+        expr,
+        vec![
+            ColumnIndex { index: 0, side: JoinSide::Left },
+            ColumnIndex { index: 1, side: JoinSide::Left },
+            ColumnIndex { index: 2, side: JoinSide::Left },
+            ColumnIndex { index: 0, side: JoinSide::Right },
+            ColumnIndex { index: 1, side: JoinSide::Right },
+        ],
+        Arc::clone(filter_schema),
+    )
+}
+
 #[test]
-fn join_residual_cast_targets_are_owned_by_the_contract() {
-    assert_eq!(join_residual_cast_mode(&DataType::Int64).unwrap(), super::JoinResidualCastMode::Ast);
-    assert_eq!(
-        join_residual_cast_mode(&DataType::Decimal128(12, 2)).unwrap(),
-        super::JoinResidualCastMode::Materialize
+fn join_residual_moves_single_input_expressions_outside_the_ast_before_the_join() {
+    let (left_schema, right_schema, schema) = join_residual_schemas();
+    let column = |name: &str| col(name, &schema).unwrap();
+    let text = |value: &str| lit(ScalarValue::Utf8(Some(value.to_string())));
+    let int = |value: i32| lit(ScalarValue::Int32(Some(value)));
+    let like = |negated: bool, expr: Arc<dyn PhysicalExpr>| -> Arc<dyn PhysicalExpr> {
+        Arc::new(LikeExpr::new(negated, false, expr, text("%bar%")))
+    };
+    let abs = scalar_function("abs", math::abs(), vec![column("n")], DataType::Int32);
+    let single_input_case: Arc<dyn PhysicalExpr> = Arc::new(
+        CaseExpr::try_new(
+            None,
+            vec![(binary(column("n"), Operator::Gt, int(0), &schema).unwrap(), column("n"))],
+            Some(int(0)),
+        )
+        .unwrap(),
     );
-    let rejection = join_residual_cast_mode(&DataType::Date32).unwrap_err();
+    let or_right_positive = |site: Arc<dyn PhysicalExpr>| {
+        let right_positive = binary(column("r"), Operator::Gt, int(0), &schema).unwrap();
+        (Arc::clone(&site), binary(site, Operator::Or, right_positive, &schema).unwrap())
+    };
+    let compared = |site: Arc<dyn PhysicalExpr>, operator: Operator, other: Arc<dyn PhysicalExpr>| {
+        (Arc::clone(&site), binary(site, operator, other, &schema).unwrap())
+    };
+    let cases = vec![
+        ("like", or_right_positive(like(false, column("name")))),
+        ("not like", or_right_positive(like(true, column("name")))),
+        (
+            "like over lower",
+            or_right_positive(like(
+                false,
+                scalar_function("lower", string::lower(), vec![column("name")], DataType::Utf8),
+            )),
+        ),
+        (
+            "is distinct from",
+            or_right_positive(binary(column("n"), Operator::IsDistinctFrom, int(5), &schema).unwrap()),
+        ),
+        ("abs", compared(abs, Operator::Gt, column("r"))),
+        (
+            "concatenation",
+            compared(
+                binary(column("name"), Operator::StringConcat, text("!"), &schema).unwrap(),
+                Operator::Eq,
+                column("label"),
+            ),
+        ),
+        ("try cast", compared(Arc::new(TryCastExpr::new(column("name"), DataType::Int32)), Operator::Eq, column("r"))),
+        (
+            "timestamp to bigint",
+            compared(
+                Arc::new(CastExpr::new(column("t"), DataType::Int64, None)),
+                Operator::Gt,
+                Arc::new(CastExpr::new(column("r"), DataType::Int64, None)),
+            ),
+        ),
+        (
+            "integer division by a literal",
+            compared(binary(column("n"), Operator::Divide, int(2), &schema).unwrap(), Operator::Eq, column("r")),
+        ),
+        ("single-input case", compared(single_input_case, Operator::Eq, column("r"))),
+    ];
+    for (label, (site, residual)) in cases {
+        let filter = join_residual_filter(residual, &schema);
+        let validated = validate_join_residual(&filter, &left_schema, &right_schema)
+            .unwrap_or_else(|error| panic!("{label} must validate: {error:?}"));
+        let sites = validated.materializations();
+        assert_eq!(sites.len(), 1, "{label}: {sites:?}");
+        assert!(Arc::ptr_eq(&sites[0].expr, &site), "{label} materializes {:?}", sites[0].expr);
+        assert_eq!(sites[0].side, JoinSide::Left, "{label}");
+    }
+
+    let ast_only = binary(
+        binary(binary(column("n"), Operator::Plus, int(1), &schema).unwrap(), Operator::Gt, column("r"), &schema)
+            .unwrap(),
+        Operator::And,
+        Arc::new(NotExpr::new(Arc::new(IsNullExpr::new(column("n"))))),
+        &schema,
+    )
+    .unwrap();
+    let filter = join_residual_filter(ast_only, &schema);
+    let validated = validate_join_residual(&filter, &left_schema, &right_schema).unwrap();
+    assert!(validated.materializations().is_empty(), "the AST evaluates arithmetic, comparison and NOT");
+}
+
+#[test]
+fn join_residual_keeps_operations_that_can_fail_out_of_pre_join_columns() {
+    let (left_schema, right_schema, schema) = join_residual_schemas();
+    let column = |name: &str| col(name, &schema).unwrap();
+    let to_decimal = |name: &str, precision: u8| -> Arc<dyn PhysicalExpr> {
+        Arc::new(CastExpr::new(column(name), DataType::Decimal128(precision, 0), None))
+    };
+    let narrowing_subject =
+        ExpressionRejectionSubject::Cast { source: DataType::Int32, target: DataType::Decimal128(4, 0) };
+
+    // An Int32 does not always fit four digits, and a pre-join column would
+    // also cast rows that match no key.
+    let narrowing = binary(to_decimal("n", 4), Operator::Eq, to_decimal("r", 10), &schema).unwrap();
+    let rejection =
+        validate_join_residual(&join_residual_filter(narrowing, &schema), &left_schema, &right_schema).unwrap_err();
     assert_eq!(rejection.capability(), ExpressionCapability::JoinResidualCastTarget);
+    assert_eq!(rejection.subject(), &narrowing_subject);
+    assert_eq!(rejection.sql(), Some("CAST(n AS Decimal128(4, 0))"));
+
+    let guarded: Arc<dyn PhysicalExpr> = Arc::new(
+        CaseExpr::try_new(
+            None,
+            vec![(
+                binary(column("n"), Operator::Gt, lit(ScalarValue::Int32(Some(0))), &schema).unwrap(),
+                to_decimal("n", 4),
+            )],
+            None,
+        )
+        .unwrap(),
+    );
+    let guarded = binary(guarded, Operator::Eq, to_decimal("r", 10), &schema).unwrap();
+    let rejection =
+        validate_join_residual(&join_residual_filter(guarded, &schema), &left_schema, &right_schema).unwrap_err();
+    assert_eq!(rejection.subject(), &narrowing_subject, "the rejection names the cast inside the CASE");
+
+    // The checked post-join filter of a decimal division evaluates matched
+    // pairs only, so the narrowing cast stays in the residual there.
+    let left_cast = to_decimal("n", 4);
+    let right_cast = to_decimal("r", 10);
+    let quotient = binary(Arc::clone(&left_cast), Operator::Divide, Arc::clone(&right_cast), &schema).unwrap();
+    let post_join = binary(quotient, Operator::Gt, lit(ScalarValue::Decimal128(Some(1), 10, 0)), &schema).unwrap();
+    let filter = join_residual_filter(post_join, &schema);
+    let validated = validate_join_residual(&filter, &left_schema, &right_schema).unwrap();
+    let sites = validated.materializations();
+    assert_eq!(sites.len(), 1, "{sites:?}");
+    assert!(Arc::ptr_eq(&sites[0].expr, &right_cast), "only the cast that always fits moves before the join");
 }
 
 #[test]
-fn join_residual_scalar_functions_add_a_stricter_contract_layer() {
-    validate_join_residual_scalar_function(ScalarFunctionKind::Substring).unwrap();
-    let rejection = validate_join_residual_scalar_function(ScalarFunctionKind::Abs).unwrap_err();
+fn join_residual_rejects_cross_input_expressions_neither_evaluator_runs() {
+    let (left_schema, right_schema, schema) = join_residual_schemas();
+    let column = |name: &str| col(name, &schema).unwrap();
+    let validate = |expr: Arc<dyn PhysicalExpr>| {
+        validate_join_residual(&join_residual_filter(expr, &schema), &left_schema, &right_schema).map(|_| ())
+    };
+
+    let concatenation = binary(
+        binary(column("name"), Operator::StringConcat, column("label"), &schema).unwrap(),
+        Operator::Eq,
+        lit(ScalarValue::Utf8(Some("x".to_string()))),
+        &schema,
+    )
+    .unwrap();
+    let rejection = validate(concatenation).unwrap_err();
+    assert_eq!(rejection.capability(), ExpressionCapability::JoinResidualShape);
+    assert!(matches!(
+        rejection.subject(),
+        ExpressionRejectionSubject::BinaryOperator { operator: Operator::StringConcat, .. }
+    ));
+
+    let sum = binary(column("n"), Operator::Plus, column("r"), &schema).unwrap();
+    let widened = binary(
+        Arc::new(CastExpr::new(sum, DataType::Decimal128(12, 0), None)),
+        Operator::Gt,
+        lit(ScalarValue::Decimal128(Some(5), 12, 0)),
+        &schema,
+    )
+    .unwrap();
+    let rejection = validate(widened).unwrap_err();
+    assert_eq!(rejection.capability(), ExpressionCapability::JoinResidualCastTarget);
+    assert_eq!(
+        rejection.subject(),
+        &ExpressionRejectionSubject::Cast { source: DataType::Int32, target: DataType::Decimal128(12, 0) }
+    );
+
+    let difference = binary(column("n"), Operator::Minus, column("r"), &schema).unwrap();
+    let distance = binary(
+        scalar_function("abs", math::abs(), vec![difference], DataType::Int32),
+        Operator::Lt,
+        lit(ScalarValue::Int32(Some(5))),
+        &schema,
+    )
+    .unwrap();
+    let rejection = validate(distance).unwrap_err();
     assert_eq!(rejection.capability(), ExpressionCapability::JoinResidualScalarFunction);
+    assert_eq!(rejection.subject(), &ExpressionRejectionSubject::ScalarFunction("abs".to_string()));
+
+    // An inner join runs a null-aware comparison as a post-join filter.
+    validate(binary(column("n"), Operator::IsDistinctFrom, column("r"), &schema).unwrap())
+        .expect("a cross-input IS DISTINCT FROM stays in the residual");
 }
 
 #[test]
@@ -665,11 +869,6 @@ fn join_residual_ast_rejects_integer_division_and_casts_it_cannot_evaluate_or_ch
         binary(elapsed, Operator::Gt, lit(ScalarValue::DurationMillisecond(Some(5))), &filter_schema).unwrap();
     assert_eq!(validate(elapsed_bound).unwrap_err().capability(), ExpressionCapability::JoinResidualShape);
 
-    // The cast cannot fail, but the AST has no cast over temporal values.
-    let temporal_cast =
-        binary(cast("t", DataType::Int64), Operator::Eq, col("r", &filter_schema).unwrap(), &filter_schema).unwrap();
-    assert_eq!(validate(temporal_cast).unwrap_err().capability(), ExpressionCapability::CastPair);
-
     let failing_cast =
         binary(cast("l", DataType::UInt64), Operator::Eq, cast("r", DataType::UInt64), &filter_schema).unwrap();
     assert_eq!(validate(failing_cast).unwrap_err().capability(), ExpressionCapability::CastPair);
diff --git a/crates/algeon-datafusion/src/native/lowering/expr.rs b/crates/algeon-datafusion/src/native/lowering/expr.rs
index 82ff3c646..1e622d816 100644
--- a/crates/algeon-datafusion/src/native/lowering/expr.rs
+++ b/crates/algeon-datafusion/src/native/lowering/expr.rs
@@ -81,13 +81,23 @@ pub(super) fn lower_validated_physical_expr_with_bindings(
     let activation_nodes = Cell::new(0);
     lower_validated_physical_expr(
         validated,
-        LoweringScope { bindings, join_columns: None, activation: None, activation_nodes: &activation_nodes },
+        LoweringScope {
+            bindings,
+            join_columns: None,
+            join_substitutions: &[],
+            activation: None,
+            activation_nodes: &activation_nodes,
+        },
     )
 }
 
+/// Lowers a join filter expression whose column `i` reads `columns[&i]`.
+/// Each subexpression in `substitutions`, matched by pointer identity, lowers
+/// to its paired expression instead.
 pub(super) fn lower_validated_join_residual_expr(
     validated: &ValidatedPhysicalExpr,
     columns: &BTreeMap<usize, ColumnRef>,
+    substitutions: &[(Arc<dyn PhysicalExpr>, NativeExpr)],
 ) -> Result<NativeExpr, LoweringRejection> {
     let activation_nodes = Cell::new(0);
     lower_validated_physical_expr(
@@ -95,6 +105,7 @@ pub(super) fn lower_validated_join_residual_expr(
         LoweringScope {
             bindings: None,
             join_columns: Some(columns),
+            join_substitutions: substitutions,
             activation: None,
             activation_nodes: &activation_nodes,
         },
@@ -106,6 +117,7 @@ pub(super) fn lower_validated_join_residual_expr(
 struct LoweringScope<'a> {
     bindings: Option<&'a [FieldBinding]>,
     join_columns: Option<&'a BTreeMap<usize, ColumnRef>>,
+    join_substitutions: &'a [(Arc<dyn PhysicalExpr>, NativeExpr)],
     /// Set inside a `CASE` branch or the right operand of an `AND` or `OR`,
     /// which DataFusion may evaluate on a subset of rows: the rows where this
     /// boolean is TRUE. Native evaluation visits every row, so an operand that
@@ -150,6 +162,9 @@ fn lower_validated_physical_expr(
 ) -> Result<NativeExpr, LoweringRejection> {
     let expr = validated.expr();
     let input_schema = validated.input_schema();
+    if let Some((_, substitute)) = scope.join_substitutions.iter().find(|(site, _)| Arc::ptr_eq(site, expr)) {
+        return Ok(substitute.clone());
+    }
     if let Some(column) = expr.downcast_ref::<Column>() {
         if let Some(columns) = scope.join_columns {
             let resolved = resolve_column(column, input_schema)?;
diff --git a/crates/algeon-datafusion/src/native/lowering/join.rs b/crates/algeon-datafusion/src/native/lowering/join.rs
index 81e4e1b21..0b37eda98 100644
--- a/crates/algeon-datafusion/src/native/lowering/join.rs
+++ b/crates/algeon-datafusion/src/native/lowering/join.rs
@@ -157,9 +157,9 @@ fn add_join_residual_materializations(
     input: LoweredNativeInput,
     materializations: &[JoinResidualMaterialization],
 ) -> Result<LoweredNativeInput, LoweringFailure> {
-    // Residual casts that cannot live in the predicate AST are appended as
-    // synthetic pre-join projection columns on the original DataFusion side.
-    // Canonical input ordering happens after this step.
+    // Residual subexpressions that the contract moves before the join are
+    // appended as synthetic projection columns on the original DataFusion
+    // side. Canonical input ordering happens after this step.
     if materializations.is_empty() {
         return Ok(input);
     }
diff --git a/crates/algeon-datafusion/src/native/lowering/join_residual.rs b/crates/algeon-datafusion/src/native/lowering/join_residual.rs
index b6d4843aa..60b2b6f1c 100644
--- a/crates/algeon-datafusion/src/native/lowering/join_residual.rs
+++ b/crates/algeon-datafusion/src/native/lowering/join_residual.rs
@@ -1,22 +1,23 @@
-use std::{collections::BTreeSet, sync::Arc};
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    sync::Arc,
+};
 
 use arrow::datatypes::{Field, SchemaRef};
 use datafusion::{
     common::JoinSide as DataFusionJoinSide,
     logical_expr::Operator,
     physical_expr::{
-        PhysicalExpr, ScalarFunctionExpr,
+        PhysicalExpr,
         expressions::{
             BinaryExpr, CaseExpr, CastExpr, Column, InListExpr, IsNotNullExpr, IsNullExpr, Literal, NotExpr,
         },
     },
     physical_plan::joins::utils::JoinFilter,
 };
-use query_planning::{
-    expr::{
-        BinaryOp as NativeBinaryOp, CaseWhen as NativeCaseWhen, Expr as NativeExpr, LiteralValue as NativeLiteralValue,
-    },
-    validation::{is_string_type, substring_stop_position},
+use query_planning::expr::{
+    BinaryOp as NativeBinaryOp, CaseWhen as NativeCaseWhen, ColumnRef as NativeColumnRef, Expr as NativeExpr,
+    LiteralValue as NativeLiteralValue,
 };
 
 use super::{
@@ -32,11 +33,7 @@ use crate::{
     capability::CapabilityReason,
     native::{
         LoweringFailure,
-        expression_contract::{
-            JoinResidualCastMode, ScalarFunctionKind, ValidatedJoinResidual, case_expr_data_type,
-            declared_decimal_divide_output_type, join_residual_cast_mode, physical_expr_data_type,
-        },
-        literal::literal_i32,
+        expression_contract::{ValidatedJoinResidual, case_expr_data_type},
     },
 };
 
@@ -106,8 +103,6 @@ pub(super) fn lower_join_filter(
     canonical: CanonicalJoin,
     bindings: Option<JoinResidualInputBindings<'_>>,
 ) -> Result<LoweredJoinResidual, LoweringFailure> {
-    // Expressions the cuDF join AST cannot represent directly may be materialized
-    // on one input side. The residual predicate must still reference both sides.
     let filter = contract.filter();
     debug_assert!(Arc::ptr_eq(contract.expression().expr(), filter.expression()));
     let mut left_required = BTreeSet::new();
@@ -121,6 +116,23 @@ pub(super) fn lower_join_filter(
         canonical,
         bindings,
     };
+    // Each materialization site becomes a synthetic column of its input, and
+    // the residual reads that column in its place.
+    let substitutions = contract
+        .materializations()
+        .iter()
+        .map(|site| {
+            let column = materialize_join_residual_expr(
+                &site.expr,
+                site.side,
+                context,
+                &mut left_required,
+                &mut right_required,
+                &mut materializations,
+            )?;
+            Ok((Arc::clone(&site.expr), column))
+        })
+        .collect::<Result<Vec<_>, LoweringFailure>>()?;
     let predicate = if contract.contains_decimal_division() {
         // Evaluate checked arithmetic after matching keys. Pre-join
         // materialization would also evaluate rows with no matching key.
@@ -140,15 +152,9 @@ pub(super) fn lower_join_filter(
                 Ok((index, column))
             })
             .collect::<Result<_, LoweringFailure>>()?;
-        lower_validated_join_residual_expr(contract.expression(), &columns)?
+        lower_validated_join_residual_expr(contract.expression(), &columns, &substitutions)?
     } else {
-        lower_join_filter_expr(
-            filter.expression(),
-            context,
-            &mut left_required,
-            &mut right_required,
-            &mut materializations,
-        )?
+        lower_join_filter_expr(filter.expression(), context, &substitutions, &mut left_required, &mut right_required)?
     };
     debug_assert!(
         !left_required.is_empty() && !right_required.is_empty(),
@@ -157,66 +163,53 @@ pub(super) fn lower_join_filter(
     Ok(LoweredJoinResidual { predicate, left_required, right_required, materializations })
 }
 
+/// Lowers the residual operators the cuDF join AST evaluates, or that an
+/// inner join evaluates as a post-join filter. Every other single-input
+/// subexpression is a contract materialization site and arrives here as a
+/// substitution.
 fn lower_join_filter_expr(
     expr: &Arc<dyn PhysicalExpr>,
     context: JoinFilterLoweringContext<'_>,
+    substitutions: &[(Arc<dyn PhysicalExpr>, NativeExpr)],
     left_required: &mut BTreeSet<usize>,
     right_required: &mut BTreeSet<usize>,
-    materializations: &mut JoinResidualMaterializations,
 ) -> Result<NativeExpr, LoweringFailure> {
+    if let Some((_, column)) = substitutions.iter().find(|(site, _)| Arc::ptr_eq(site, expr)) {
+        return Ok(column.clone());
+    }
     if let Some(column) = expr.downcast_ref::<Column>() {
         return lower_join_filter_column(column, context, left_required, right_required);
     }
     if let Some(literal) = expr.downcast_ref::<Literal>() {
         return Ok(lower_literal(literal.value()).expect("validated join-residual literal must lower"));
     }
+    let mut lower = |child: &Arc<dyn PhysicalExpr>| {
+        lower_join_filter_expr(child, context, substitutions, left_required, right_required)
+    };
     if let Some(binary) = expr.downcast_ref::<BinaryExpr>() {
-        return lower_join_filter_binary_expr(
-            binary,
-            context,
-            |expr| lower_join_filter_expr(expr, context, left_required, right_required, materializations),
-            "validated join-residual decimal division must have a supported output type",
-        );
+        let left = lower(binary.left())?;
+        let right = lower(binary.right())?;
+        return Ok(match binary.op() {
+            Operator::IsDistinctFrom => NativeExpr::is_distinct_from(left, right),
+            Operator::IsNotDistinctFrom => NativeExpr::is_not_distinct_from(left, right),
+            op => NativeExpr::binary(left, lower_binary_operator(op), right),
+        });
     }
     if let Some(not) = expr.downcast_ref::<NotExpr>() {
-        return Ok(!lower_join_filter_expr(not.arg(), context, left_required, right_required, materializations)?);
+        return Ok(!lower(not.arg())?);
     }
     if let Some(is_null) = expr.downcast_ref::<IsNullExpr>() {
-        return Ok(NativeExpr::is_null(lower_join_filter_expr(
-            is_null.arg(),
-            context,
-            left_required,
-            right_required,
-            materializations,
-        )?));
+        return Ok(NativeExpr::is_null(lower(is_null.arg())?));
     }
     if let Some(is_not_null) = expr.downcast_ref::<IsNotNullExpr>() {
-        return Ok(NativeExpr::is_not_null(lower_join_filter_expr(
-            is_not_null.arg(),
-            context,
-            left_required,
-            right_required,
-            materializations,
-        )?));
+        return Ok(NativeExpr::is_not_null(lower(is_not_null.arg())?));
     }
     if let Some(cast) = expr.downcast_ref::<CastExpr>() {
-        if matches!(
-            join_residual_cast_mode(cast.cast_type()).expect("validated join-residual cast target"),
-            JoinResidualCastMode::Materialize
-        ) {
-            // Some casts are valid native expressions but not accepted in the
-            // join residual AST. Materialize those on one input side and let
-            // the residual predicate reference the synthetic column.
-            return materialize_join_residual_expr(expr, context, left_required, right_required, materializations);
-        }
-        return Ok(NativeExpr::cast(
-            lower_join_filter_expr(cast.expr(), context, left_required, right_required, materializations)?,
-            cast.cast_type().clone(),
-        ));
+        return Ok(NativeExpr::cast(lower(cast.expr())?, cast.cast_type().clone()));
     }
     if let Some(in_list) = expr.downcast_ref::<InListExpr>() {
         debug_assert!(!in_list.is_empty(), "empty IN list cannot carry a join-residual validation proof");
-        let expr = lower_join_filter_expr(in_list.expr(), context, left_required, right_required, materializations)?;
+        let value = lower(in_list.expr())?;
         let list = in_list
             .list()
             .iter()
@@ -226,76 +219,40 @@ fn lower_join_filter_expr(
                     !literal.value().is_null(),
                     "null IN entry cannot carry a join-residual validation proof"
                 );
-                lower_join_filter_expr(item, context, left_required, right_required, materializations)
+                lower(item)
             })
             .collect::<Result<Vec<_>, LoweringFailure>>()?;
         return Ok(if in_list.negated() {
-            NativeExpr::not_in_list(expr, list)
+            NativeExpr::not_in_list(value, list)
         } else {
-            NativeExpr::in_list(expr, list)
+            NativeExpr::in_list(value, list)
         });
     }
     if let Some(case) = expr.downcast_ref::<CaseExpr>() {
-        if context.contract.single_side(expr).is_ok() {
-            return materialize_join_residual_expr(expr, context, left_required, right_required, materializations);
-        }
-        return lower_join_filter_case_expr(case, context, left_required, right_required, materializations);
-    }
-    if expr.downcast_ref::<ScalarFunctionExpr>().is_some() {
-        return materialize_join_residual_expr(expr, context, left_required, right_required, materializations);
+        return lower_join_filter_case_expr(case, context, &mut lower);
     }
     unreachable!("validated join residual must have a lowering branch")
 }
 
-fn lower_join_filter_binary_expr(
-    binary: &BinaryExpr,
-    context: JoinFilterLoweringContext<'_>,
-    mut lower_child: impl FnMut(&Arc<dyn PhysicalExpr>) -> Result<NativeExpr, LoweringFailure>,
-    decimal_division_expectation: &'static str,
-) -> Result<NativeExpr, LoweringFailure> {
-    let left = lower_child(binary.left())?;
-    let right = lower_child(binary.right())?;
-    let op = lower_binary_operator(binary.op());
-    if matches!(binary.op(), Operator::Divide)
-        && let Some(output_type) =
-            declared_decimal_divide_output_type(binary, context.filter.schema()).expect(decimal_division_expectation)
-    {
-        return Ok(NativeExpr::binary_with_output_type(left, op, right, output_type));
-    }
-    Ok(NativeExpr::binary(left, op, right))
-}
-
 fn lower_join_filter_case_expr(
     case: &CaseExpr,
     context: JoinFilterLoweringContext<'_>,
-    left_required: &mut BTreeSet<usize>,
-    right_required: &mut BTreeSet<usize>,
-    materializations: &mut JoinResidualMaterializations,
+    lower: &mut impl FnMut(&Arc<dyn PhysicalExpr>) -> Result<NativeExpr, LoweringFailure>,
 ) -> Result<NativeExpr, LoweringFailure> {
-    let base_expr = case
-        .expr()
-        .map(|expr| lower_join_filter_expr(expr, context, left_required, right_required, materializations))
-        .transpose()?;
+    let base_expr = case.expr().map(&mut *lower).transpose()?;
     let branches = case
         .when_then_expr()
         .iter()
         .map(|(when, then)| {
             let when = match &base_expr {
-                Some(base_expr) => NativeExpr::binary(
-                    base_expr.clone(),
-                    NativeBinaryOp::Eq,
-                    lower_join_filter_expr(when, context, left_required, right_required, materializations)?,
-                ),
-                None => lower_join_filter_expr(when, context, left_required, right_required, materializations)?,
+                Some(base_expr) => NativeExpr::binary(base_expr.clone(), NativeBinaryOp::Eq, lower(when)?),
+                None => lower(when)?,
             };
-            Ok(NativeCaseWhen::new(
-                when,
-                lower_join_filter_expr(then, context, left_required, right_required, materializations)?,
-            ))
+            Ok(NativeCaseWhen::new(when, lower(then)?))
         })
         .collect::<Result<Vec<_>, LoweringFailure>>()?;
     let else_expr = match case.else_expr() {
-        Some(else_expr) => lower_join_filter_expr(else_expr, context, left_required, right_required, materializations)?,
+        Some(else_expr) => lower(else_expr)?,
         None => {
             let data_type = case_expr_data_type(case, context.filter.schema())
                 .expect("validated join-residual CASE must have an output type");
@@ -305,28 +262,45 @@ fn lower_join_filter_case_expr(
     Ok(NativeExpr::case(branches, else_expr))
 }
 
+/// Appends `expr`, which reads only `side`, to that input as a synthetic
+/// column and returns the residual's reference to it. The general expression
+/// lowering produces the column, as it does for a join key expression.
 fn materialize_join_residual_expr(
     expr: &Arc<dyn PhysicalExpr>,
+    side: DataFusionJoinSide,
     context: JoinFilterLoweringContext<'_>,
     left_required: &mut BTreeSet<usize>,
     right_required: &mut BTreeSet<usize>,
     materializations: &mut JoinResidualMaterializations,
 ) -> Result<NativeExpr, LoweringFailure> {
-    // Materializations are valid only when the whole expression belongs to one
-    // DataFusion side. Cross-side expressions must remain in the residual AST.
-    let side = context.contract.single_side(expr).expect("validated materialized residual must belong to one side");
     let (schema, required) = match side {
         DataFusionJoinSide::Left => (context.left_schema, left_required),
         DataFusionJoinSide::Right => (context.right_schema, right_required),
         DataFusionJoinSide::None => unreachable!("validated materialized residual must belong to left or right"),
     };
-    let native_expr = lower_join_filter_side_expr(expr, context, schema, side, required)?;
+    let mut filter_indices = BTreeSet::new();
+    collect_required_field_indices(expr, context.filter.schema(), &mut filter_indices)?;
+    let mut columns = BTreeMap::new();
+    for filter_index in filter_indices {
+        let column_index = context
+            .filter
+            .column_indices()
+            .get(filter_index)
+            .expect("validated residual column must have a side mapping");
+        debug_assert_eq!(column_index.side, side, "a materialization site reads one input");
+        let field =
+            schema.fields().get(column_index.index).expect("validated residual column must exist in its side schema");
+        required.insert(column_index.index);
+        let native_name = side_native_name(context, side, column_index.index, field.name())?;
+        columns.insert(filter_index, NativeColumnRef::unqualified(native_name));
+    }
+    let validated = context.contract.expression().trusted_descendant(expr);
+    let native_expr = lower_validated_join_residual_expr(&validated, &columns, &[])?;
     let side_materializations =
         materializations.side_mut(side).expect("validated materialization side must be left or right");
     let alias = unique_synthetic_join_residual_alias(side, side_materializations.len(), schema, side_materializations);
-    let field =
-        physical_expr_field_from_validated(&context.contract.expression().trusted_descendant(expr), alias.as_str())
-            .expect("validated materialized residual must have a native field");
+    let field = physical_expr_field_from_validated(&validated, alias.as_str())
+        .expect("validated materialized residual must have a native field");
     side_materializations.push(JoinResidualMaterialization {
         alias: alias.clone(),
         expr: alias_if_needed(native_expr, alias.as_str()),
@@ -339,204 +313,6 @@ fn materialize_join_residual_expr(
     Ok(NativeExpr::input_column(native_input_index, alias.as_str(), alias.as_str()))
 }
 
-fn lower_join_filter_side_expr(
-    expr: &Arc<dyn PhysicalExpr>,
-    context: JoinFilterLoweringContext<'_>,
-    side_schema: &SchemaRef,
-    side: DataFusionJoinSide,
-    required: &mut BTreeSet<usize>,
-) -> Result<NativeExpr, LoweringFailure> {
-    if let Some(column) = expr.downcast_ref::<Column>() {
-        let column_index = context
-            .filter
-            .column_indices()
-            .get(column.index())
-            .expect("validated residual column must have a side mapping");
-        if column_index.side != side {
-            unreachable!("validated single-side residual cannot cross join inputs");
-        }
-        let field = side_schema
-            .fields()
-            .get(column_index.index)
-            .expect("validated residual column must exist in its side schema");
-        required.insert(column_index.index);
-        return Ok(NativeExpr::column(side_native_name(context, side, column_index.index, field.name())?));
-    }
-    if let Some(literal) = expr.downcast_ref::<Literal>() {
-        return Ok(lower_literal(literal.value()).expect("validated materialized literal must lower"));
-    }
-    if let Some(binary) = expr.downcast_ref::<BinaryExpr>() {
-        return lower_join_filter_binary_expr(
-            binary,
-            context,
-            |expr| lower_join_filter_side_expr(expr, context, side_schema, side, required),
-            "validated materialized decimal division must have a supported output type",
-        );
-    }
-    if let Some(not) = expr.downcast_ref::<NotExpr>() {
-        return Ok(!lower_join_filter_side_expr(not.arg(), context, side_schema, side, required)?);
-    }
-    if let Some(is_null) = expr.downcast_ref::<IsNullExpr>() {
-        return Ok(NativeExpr::is_null(lower_join_filter_side_expr(
-            is_null.arg(),
-            context,
-            side_schema,
-            side,
-            required,
-        )?));
-    }
-    if let Some(is_not_null) = expr.downcast_ref::<IsNotNullExpr>() {
-        return Ok(NativeExpr::is_not_null(lower_join_filter_side_expr(
-            is_not_null.arg(),
-            context,
-            side_schema,
-            side,
-            required,
-        )?));
-    }
-    if let Some(cast) = expr.downcast_ref::<CastExpr>() {
-        let source_type = physical_expr_data_type(cast.expr(), context.filter.schema())
-            .expect("validated materialized cast source must have a type");
-        if is_string_type(&source_type) && is_string_type(cast.cast_type()) {
-            return lower_join_filter_side_expr(cast.expr(), context, side_schema, side, required);
-        }
-        return Ok(NativeExpr::cast(
-            lower_join_filter_side_expr(cast.expr(), context, side_schema, side, required)?,
-            cast.cast_type().clone(),
-        ));
-    }
-    if let Some(in_list) = expr.downcast_ref::<InListExpr>() {
-        debug_assert!(!in_list.is_empty(), "empty materialized IN list cannot carry a validation proof");
-        let expr = lower_join_filter_side_expr(in_list.expr(), context, side_schema, side, required)?;
-        let list = in_list
-            .list()
-            .iter()
-            .map(|item| {
-                let literal = item.downcast_ref::<Literal>().expect("validated materialized IN entries are literals");
-                debug_assert!(!literal.value().is_null(), "null materialized IN entry cannot carry a validation proof");
-                lower_join_filter_side_expr(item, context, side_schema, side, required)
-            })
-            .collect::<Result<Vec<_>, LoweringFailure>>()?;
-        return Ok(if in_list.negated() {
-            NativeExpr::not_in_list(expr, list)
-        } else {
-            NativeExpr::in_list(expr, list)
-        });
-    }
-    if let Some(case) = expr.downcast_ref::<CaseExpr>() {
-        return lower_join_filter_side_case_expr(case, context, side_schema, side, required);
-    }
-    if let Some(function) = expr.downcast_ref::<ScalarFunctionExpr>() {
-        return lower_join_filter_side_scalar_function_expr(function, context, side_schema, side, required);
-    }
-    unreachable!("validated materialized residual must have a lowering branch")
-}
-
-fn lower_join_filter_side_case_expr(
-    case: &CaseExpr,
-    context: JoinFilterLoweringContext<'_>,
-    side_schema: &SchemaRef,
-    side: DataFusionJoinSide,
-    required: &mut BTreeSet<usize>,
-) -> Result<NativeExpr, LoweringFailure> {
-    let base_expr =
-        case.expr().map(|expr| lower_join_filter_side_expr(expr, context, side_schema, side, required)).transpose()?;
-    let branches = case
-        .when_then_expr()
-        .iter()
-        .map(|(when, then)| {
-            let when = match &base_expr {
-                Some(base_expr) => NativeExpr::binary(
-                    base_expr.clone(),
-                    NativeBinaryOp::Eq,
-                    lower_join_filter_side_expr(when, context, side_schema, side, required)?,
-                ),
-                None => lower_join_filter_side_expr(when, context, side_schema, side, required)?,
-            };
-            Ok(NativeCaseWhen::new(when, lower_join_filter_side_expr(then, context, side_schema, side, required)?))
-        })
-        .collect::<Result<Vec<_>, LoweringFailure>>()?;
-    let else_expr = match case.else_expr() {
-        Some(else_expr) => lower_join_filter_side_expr(else_expr, context, side_schema, side, required)?,
-        None => {
-            let data_type = case_expr_data_type(case, context.filter.schema())
-                .expect("validated materialized CASE must have an output type");
-            NativeExpr::literal(NativeLiteralValue::Null(data_type))
-        },
-    };
-    Ok(NativeExpr::case(branches, else_expr))
-}
-
-fn lower_join_filter_side_scalar_function_expr(
-    function: &ScalarFunctionExpr,
-    context: JoinFilterLoweringContext<'_>,
-    side_schema: &SchemaRef,
-    side: DataFusionJoinSide,
-    required: &mut BTreeSet<usize>,
-) -> Result<NativeExpr, LoweringFailure> {
-    match ScalarFunctionKind::from_scalar_function(function).expect("validated join residual scalar function") {
-        ScalarFunctionKind::Substring => {
-            lower_join_filter_side_substring_function(function, context, side_schema, side, required)
-        },
-        ScalarFunctionKind::Lower => lower_join_filter_side_string_case_function(
-            function,
-            context,
-            side_schema,
-            side,
-            required,
-            NativeExpr::lower,
-        ),
-        ScalarFunctionKind::Upper => lower_join_filter_side_string_case_function(
-            function,
-            context,
-            side_schema,
-            side,
-            required,
-            NativeExpr::upper,
-        ),
-        _ => unreachable!("join residual proof excludes other scalar functions"),
-    }
-}
-
-fn lower_join_filter_side_substring_function(
-    function: &ScalarFunctionExpr,
-    context: JoinFilterLoweringContext<'_>,
-    side_schema: &SchemaRef,
-    side: DataFusionJoinSide,
-    required: &mut BTreeSet<usize>,
-) -> Result<NativeExpr, LoweringFailure> {
-    let args = function.args();
-    debug_assert!((2..=3).contains(&args.len()), "invalid SUBSTRING arity cannot carry a residual proof");
-    let start = literal_i32(&args[1]).expect("validated residual SUBSTRING start must be an i32 literal");
-    debug_assert!(start >= 1, "invalid residual SUBSTRING start cannot carry a validation proof");
-    let length = if args.len() == 3 {
-        Some(literal_i32(&args[2]).expect("validated residual SUBSTRING length must be an i32 literal"))
-    } else {
-        None
-    };
-    debug_assert!(
-        length.is_none_or(|length| length >= 0 && substring_stop_position(start, length).is_some()),
-        "invalid residual SUBSTRING length cannot carry a validation proof"
-    );
-    Ok(NativeExpr::substring(
-        lower_join_filter_side_expr(&args[0], context, side_schema, side, required)?,
-        start,
-        length,
-    ))
-}
-
-fn lower_join_filter_side_string_case_function(
-    function: &ScalarFunctionExpr,
-    context: JoinFilterLoweringContext<'_>,
-    side_schema: &SchemaRef,
-    side: DataFusionJoinSide,
-    required: &mut BTreeSet<usize>,
-    constructor: fn(NativeExpr) -> NativeExpr,
-) -> Result<NativeExpr, LoweringFailure> {
-    let [expr] = function.args() else { unreachable!("validated residual string case must have one argument") };
-    Ok(constructor(lower_join_filter_side_expr(expr, context, side_schema, side, required)?))
-}
-
 fn unique_synthetic_join_residual_alias(
     side: DataFusionJoinSide,
     index: usize,
@@ -619,7 +395,9 @@ mod tests {
         logical_expr::{Operator, ScalarUDF},
         physical_expr::{
             PhysicalExpr, ScalarFunctionExpr,
-            expressions::{CaseExpr, CastExpr, IsNotNullExpr, IsNullExpr, NotExpr, binary, col, in_list, lit},
+            expressions::{
+                CaseExpr, CastExpr, IsNotNullExpr, IsNullExpr, LikeExpr, NotExpr, binary, col, in_list, lit,
+            },
         },
         physical_plan::joins::utils::{ColumnIndex, JoinFilter},
     };
@@ -659,7 +437,7 @@ mod tests {
         left_schema: &SchemaRef,
         right_schema: &SchemaRef,
         filter_schema: &SchemaRef,
-    ) {
+    ) -> LoweredJoinResidual {
         let filter = JoinFilter::new(
             expr,
             vec![ColumnIndex { index: 0, side: JoinSide::Left }, ColumnIndex { index: 0, side: JoinSide::Right }],
@@ -671,6 +449,24 @@ mod tests {
             .unwrap_or_else(|error| panic!("{label} must lower: {error:?}"));
         assert!(!lowered.left_required.is_empty(), "{label} must retain a left input dependency");
         assert!(!lowered.right_required.is_empty(), "{label} must retain a right input dependency");
+        lowered
+    }
+
+    /// The single left-input materialization of `lowered`, which the residual reads by its alias.
+    fn left_materialization<'l>(label: &str, lowered: &'l LoweredJoinResidual) -> &'l NativeExpr {
+        let [materialization] = lowered.materializations.side(DataFusionJoinSide::Left).unwrap() else {
+            panic!("{label} must materialize one left-input expression");
+        };
+        let alias = materialization.alias.as_str();
+        assert!(
+            lowered.predicate.any(|expr| matches!(expr, NativeExpr::Column(column) if column.name() == alias)),
+            "{label} residual must read {alias}: {}",
+            lowered.predicate
+        );
+        let NativeExpr::Alias { expr, .. } = &materialization.expr else {
+            panic!("{label} materialization must carry its alias: {:?}", materialization.expr);
+        };
+        expr
     }
 
     #[test]
@@ -770,5 +566,59 @@ mod tests {
             let predicate = binary(function, Operator::Eq, right(), &schema).unwrap();
             assert_join_residual_parity(&name, predicate, &left_schema, &right_schema, &schema);
         }
+
+        let text = |value: &str| lit(ScalarValue::Utf8(Some(value.to_string())));
+        let or_right_is_x = |expr| {
+            binary(expr, Operator::Or, binary(right(), Operator::Eq, text("x"), &schema).unwrap(), &schema).unwrap()
+        };
+        let like = Arc::new(LikeExpr::new(false, false, left(), text("a%")));
+        let lowered = assert_join_residual_parity("LIKE", or_right_is_x(like), &left_schema, &right_schema, &schema);
+        assert!(matches!(left_materialization("LIKE", &lowered), NativeExpr::Like { .. }));
+
+        let concatenation = binary(left(), Operator::StringConcat, text("!"), &schema).unwrap();
+        let predicate = binary(concatenation, Operator::Eq, right(), &schema).unwrap();
+        let lowered = assert_join_residual_parity("||", predicate, &left_schema, &right_schema, &schema);
+        assert!(left_materialization("||", &lowered).any(|expr| matches!(expr, NativeExpr::Concat(_))));
+
+        for operator in [Operator::IsDistinctFrom, Operator::IsNotDistinctFrom] {
+            let single_input = binary(left(), operator, text("x"), &schema).unwrap();
+            let label = format!("single-input {operator}");
+            let lowered =
+                assert_join_residual_parity(&label, or_right_is_x(single_input), &left_schema, &right_schema, &schema);
+            assert!(matches!(
+                left_materialization(&label, &lowered),
+                NativeExpr::IsDistinctFrom { .. } | NativeExpr::IsNotDistinctFrom { .. }
+            ));
+
+            let cross_input = binary(left(), operator, right(), &schema).unwrap();
+            let lowered = assert_join_residual_parity(
+                &format!("cross-input {operator}"),
+                cross_input,
+                &left_schema,
+                &right_schema,
+                &schema,
+            );
+            assert!(matches!(
+                lowered.predicate,
+                NativeExpr::IsDistinctFrom { .. } | NativeExpr::IsNotDistinctFrom { .. }
+            ));
+        }
+
+        let (left_schema, right_schema, schema) = residual_schemas(DataType::Int32);
+        let left = || col("left", &schema).unwrap();
+        let right = || col("right", &schema).unwrap();
+        let halved = binary(left(), Operator::Divide, lit(ScalarValue::Int32(Some(2))), &schema).unwrap();
+        let predicate = binary(halved, Operator::Eq, right(), &schema).unwrap();
+        let lowered = assert_join_residual_parity(
+            "integer division by a literal",
+            predicate,
+            &left_schema,
+            &right_schema,
+            &schema,
+        );
+        assert!(matches!(
+            left_materialization("integer division by a literal", &lowered),
+            NativeExpr::Binary { op: NativeBinaryOp::Divide, .. }
+        ));
     }
 }
diff --git a/crates/algeon-datafusion/src/native/lowering_tests.rs b/crates/algeon-datafusion/src/native/lowering_tests.rs
index dbb892247..d4b5684dc 100644
--- a/crates/algeon-datafusion/src/native/lowering_tests.rs
+++ b/crates/algeon-datafusion/src/native/lowering_tests.rs
@@ -453,15 +453,19 @@ fn assert_join_input_materializes_upper_utf8view_cast(
                     if actual_alias == alias
                         && matches!(
                             expr.as_ref(),
-                            Expr::Upper(expr)
+                            Expr::Cast { expr, target_type: DataType::Utf8View }
                                 if matches!(
                                     expr.as_ref(),
-                                    Expr::Column(column) if column.name() == source_column
+                                    Expr::Upper(expr)
+                                        if matches!(
+                                            expr.as_ref(),
+                                            Expr::Column(column) if column.name() == source_column
+                                        )
                                 )
                         )
             )
         }),
-        "join input projection should materialize upper({source_column}) as {alias}: {:?}",
+        "join input projection should materialize CAST(upper({source_column}) AS Utf8View) as {alias}: {:?}",
         projection.expressions().collect::<Vec<_>>()
     );
 }
diff --git a/crates/algeon-datafusion/src/native/lowering_tests/full_gpu_gap_analysis.rs b/crates/algeon-datafusion/src/native/lowering_tests/full_gpu_gap_analysis.rs
index 3bbc872b2..37f0a4b74 100644
--- a/crates/algeon-datafusion/src/native/lowering_tests/full_gpu_gap_analysis.rs
+++ b/crates/algeon-datafusion/src/native/lowering_tests/full_gpu_gap_analysis.rs
@@ -426,6 +426,74 @@ const EXISTING_COVERAGE_CASES: &[GpuGapCase] = &[
     },
 ];
 
+/// Join filters DataFusion keeps on the join because they read both inputs.
+/// Their single-input parts outside the cuDF join AST are computed on that
+/// input before the join, unless they can fail.
+const JOIN_RESIDUAL_CASES: &[GpuGapCase] = &[
+    GpuGapCase {
+        id: "join_residual_like_inner",
+
+        sql: "SELECT b.id, s.id AS sid FROM bench b JOIN bench s ON b.key = s.key \
+              AND (s.name LIKE 'a%' OR b.payload > 10)",
+        expected: ExpectedGpuCoverageOutcome::Selected,
+    },
+    GpuGapCase {
+        id: "join_residual_lower_like_left",
+
+        sql: "SELECT b.id, s.id AS sid FROM bench b LEFT JOIN bench s ON b.key = s.key \
+              AND (LOWER(s.name) LIKE '%a%' OR b.payload > 10)",
+        expected: ExpectedGpuCoverageOutcome::Selected,
+    },
+    GpuGapCase {
+        id: "join_residual_not_like_full",
+
+        sql: "SELECT b.id, s.id AS sid FROM bench b FULL JOIN bench s ON b.key = s.key \
+              AND (s.name NOT LIKE '%a%' OR b.payload > 10)",
+        expected: ExpectedGpuCoverageOutcome::Selected,
+    },
+    GpuGapCase {
+        id: "join_residual_like_semi",
+
+        sql: "SELECT b.id FROM bench b WHERE EXISTS \
+              (SELECT 1 FROM bench s WHERE s.key = b.key AND (s.name LIKE 'a%' OR b.payload > 10))",
+        expected: ExpectedGpuCoverageOutcome::Selected,
+    },
+    GpuGapCase {
+        id: "join_residual_like_anti",
+
+        sql: "SELECT b.id FROM bench b WHERE NOT EXISTS \
+              (SELECT 1 FROM bench s WHERE s.key = b.key AND (s.name LIKE 'a%' OR b.payload > 10))",
+        expected: ExpectedGpuCoverageOutcome::Selected,
+    },
+    GpuGapCase {
+        id: "join_residual_null_aware_comparisons",
+
+        sql: "SELECT b.id, s.id AS sid FROM bench b JOIN bench s ON b.key = s.key \
+              AND ((s.payload IS DISTINCT FROM 5) OR b.name IS NOT DISTINCT FROM s.name)",
+        expected: ExpectedGpuCoverageOutcome::Selected,
+    },
+    GpuGapCase {
+        id: "join_residual_concatenation",
+
+        sql: "SELECT b.id, s.id AS sid FROM bench b JOIN bench s ON b.key = s.key \
+              AND ((s.name || '!') = b.name OR b.payload > 10)",
+        expected: ExpectedGpuCoverageOutcome::Selected,
+    },
+    // The cast fails on a payload above 999. DataFusion casts only key-matched
+    // pairs, and a pre-join column would cast every row.
+    GpuGapCase {
+        id: "join_residual_cast_that_can_fail",
+
+        sql: "SELECT b.id FROM bench b JOIN bench s ON b.key = s.key \
+              AND CAST(s.payload AS DECIMAL(3, 0)) > CAST(b.id AS DECIMAL(10, 0))",
+        expected: ExpectedGpuCoverageOutcome::NotSupported {
+            reason: CapabilityReason::UnsupportedExpression,
+            unsupported_category: "expression",
+            blocking: ("cast", "cast from Int64 to Decimal128(3, 0) in `CAST(payload AS Decimal128(3, 0))`"),
+        },
+    },
+];
+
 #[tokio::test]
 async fn full_gpu_gap_analysis_sql_planning_coverage_is_stable() {
     let dir = unique_temp_dir("algeon-datafusion-full-gpu-gap-analysis");
@@ -468,6 +536,7 @@ fn gpu_gap_cases() -> Vec<GpuGapCase> {
         SCALAR_EXPRESSION_CASES,
         ROOT_SOURCE_CASES,
         EXISTING_COVERAGE_CASES,
+        JOIN_RESIDUAL_CASES,
     ]
     .into_iter()
     .flatten()
diff --git a/crates/algeon-datafusion/src/native/lowering_tests/join_shapes/residual_variants.rs b/crates/algeon-datafusion/src/native/lowering_tests/join_shapes/residual_variants.rs
index dd98df35a..b106183f0 100644
--- a/crates/algeon-datafusion/src/native/lowering_tests/join_shapes/residual_variants.rs
+++ b/crates/algeon-datafusion/src/native/lowering_tests/join_shapes/residual_variants.rs
@@ -490,6 +490,8 @@ fn hash_join_filter_substring_materializes_inputs_before_residual_predicate() {
 
     let result = lower_physical_plan_to_native(plan, &ParquetReadStrategyConfig::default()).unwrap();
 
+    // The plan reads one left SUBSTRING expression in both disjuncts, which
+    // lowers to one pre-join column.
     let join = rewritten_native_join(&result);
     let residual = join.spec.residual_predicate.as_ref().expect("join filter should lower as residual predicate");
     assert!(matches!(
@@ -509,7 +511,7 @@ fn hash_join_filter_substring_materializes_inputs_before_residual_predicate() {
                     Expr::Binary { left, right, op: BinaryOp::NotEq, .. }
                         if matches!(
                             left.as_ref(),
-                            Expr::Column(column) if column.to_string() == "input0.__algeon_native_join_residual_left_1"
+                            Expr::Column(column) if column.to_string() == "input0.__algeon_native_join_residual_left_0"
                         )
                             && matches!(
                                 right.as_ref(),
@@ -523,12 +525,6 @@ fn hash_join_filter_substring_materializes_inputs_before_residual_predicate() {
         "__algeon_native_join_residual_left_0",
         "l_zip",
     );
-    assert_join_input_materializes_substring(
-        result.selected_plan(),
-        join.inputs[0],
-        "__algeon_native_join_residual_left_1",
-        "l_zip",
-    );
     assert_join_input_materializes_substring(
         result.selected_plan(),
         join.inputs[1],
@@ -539,6 +535,64 @@ fn hash_join_filter_substring_materializes_inputs_before_residual_predicate() {
     fs::remove_dir_all(dir).unwrap();
 }
 
+#[tokio::test]
+async fn sql_join_filter_like_is_computed_on_the_input_it_reads() {
+    let dir = unique_temp_dir("algeon-datafusion-native-lowering-sql-join-filter-like");
+    let path = dir.join("bench.parquet");
+    write_full_gpu_gap_analysis_parquet_file(&path);
+
+    for (label, sql, join_type) in [
+        (
+            "inner",
+            "SELECT b.id, s.id AS sid FROM bench b JOIN bench s ON b.key = s.key \
+             AND (s.name LIKE '%a%' OR b.payload > 10)",
+            NativeJoinType::Inner,
+        ),
+        (
+            "left",
+            "SELECT b.id, s.id AS sid FROM bench b LEFT JOIN bench s ON b.key = s.key \
+             AND (s.name LIKE '%a%' OR b.payload > 10)",
+            NativeJoinType::Left,
+        ),
+        (
+            "semi",
+            "SELECT b.id FROM bench b WHERE EXISTS \
+             (SELECT 1 FROM bench s WHERE s.key = b.key AND (s.name LIKE '%a%' OR b.payload > 10))",
+            NativeJoinType::LeftSemi,
+        ),
+    ] {
+        let plan = sql_plan(&path, direct_friendly_sql_session_config(), sql).await;
+        let result = lower_physical_plan_to_native(plan, &ParquetReadStrategyConfig::default()).unwrap();
+        let join = rewritten_native_join(&result);
+        assert_eq!(join.spec.join_type, join_type, "{label}");
+        let residual = join.spec.residual_predicate.as_ref().expect("join filter should lower as residual predicate");
+        let mut synthetic = Vec::new();
+        residual.any(|expr| {
+            if let Expr::Column(column) = expr
+                && column.name().starts_with("__algeon_native_join_residual_")
+            {
+                synthetic.push(column.name().to_string());
+            }
+            false
+        });
+        let [alias] = synthetic.as_slice() else {
+            panic!("{label} residual must read one pre-join column: {residual}");
+        };
+        let materializes_like = join.inputs.iter().any(|input| {
+            matches!(
+                &result.selected_plan().node(*input).expect("join input should exist").kind,
+                PlanNode::Projection(projection) if projection.expressions().any(|expr| matches!(
+                    expr,
+                    Expr::Alias { expr, alias: actual } if actual == alias && matches!(expr.as_ref(), Expr::Like { .. })
+                ))
+            )
+        });
+        assert!(materializes_like, "{label}: the input that reads s.name must compute the LIKE as {alias}");
+    }
+
+    fs::remove_dir_all(dir).unwrap();
+}
+
 #[test]
 fn hash_join_filter_upper_string_cast_materializes_input_before_residual_predicate() {
     let dir = unique_temp_dir("algeon-datafusion-native-lowering-hash-join-filter-upper-cast-materialized");
diff --git a/crates/algeon-datafusion/tests/native_runtime_pruning_tests_gpu/scalar_expressions.rs b/crates/algeon-datafusion/tests/native_runtime_pruning_tests_gpu/scalar_expressions.rs
index 935d99ca2..9035cc2bd 100644
--- a/crates/algeon-datafusion/tests/native_runtime_pruning_tests_gpu/scalar_expressions.rs
+++ b/crates/algeon-datafusion/tests/native_runtime_pruning_tests_gpu/scalar_expressions.rs
@@ -8,7 +8,7 @@ use algeon_datafusion::{
 use arrow::{
     array::{
         Array, AsArray, BooleanArray, Date32Array, Decimal128Array, Float32Array, Float64Array, Int8Array, Int16Array,
-        Int32Array, Int64Array,
+        Int32Array, Int64Array, StringArray,
     },
     compute::{cast, concat_batches},
     datatypes::{Float32Type, Float64Type, TimeUnit},
@@ -1287,6 +1287,13 @@ fn scalar_expressions_cases_3() {
                 .expect("case runtime")
                 .block_on(native_runtime_checked_failures_fail_the_query_like_cpu())
         }),
+        ("native_runtime_join_filters_with_single_input_expressions_match_cpu", || {
+            TestRuntimeBuilder::new_current_thread()
+                .enable_all()
+                .build()
+                .expect("case runtime")
+                .block_on(native_runtime_join_filters_with_single_input_expressions_match_cpu())
+        }),
     ]);
 }
 
@@ -1563,6 +1570,97 @@ async fn native_runtime_decimal_join_residuals_match_cpu_without_host_boundaries
     fs::remove_dir_all(dir).unwrap();
 }
 
+fn write_join_filter_string_input_parquet(path: &std::path::Path) {
+    let schema = Arc::new(Schema::new(vec![
+        Field::new("row_id", DataType::Int32, false),
+        Field::new("key", DataType::Int32, false),
+        Field::new("name", DataType::Utf8, true),
+        Field::new("amount", DataType::Int64, true),
+    ]));
+    // Each key holds two rows, so every row has one partner besides itself. Row 4 has no name and no amount.
+    let batch = RecordBatch::try_new(
+        Arc::clone(&schema),
+        vec![
+            Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5, 6, 7, 8])),
+            Arc::new(Int32Array::from(vec![1, 1, 2, 2, 3, 3, 4, 4])),
+            Arc::new(StringArray::from(vec![
+                Some("Barbie"),
+                Some("ken"),
+                Some("barbie doll"),
+                None,
+                Some("Bar"),
+                Some("alpha"),
+                Some("Barbie"),
+                Some("zed"),
+            ])),
+            Arc::new(Int64Array::from(vec![Some(5), Some(60), Some(7), None, Some(70), Some(-1), Some(7), Some(100)])),
+        ],
+    )
+    .unwrap();
+    let mut writer = ArrowWriter::try_new(File::create(path).unwrap(), schema, None).unwrap();
+    writer.write(&batch).unwrap();
+    writer.close().unwrap();
+}
+
+/// Join filters that read both inputs stay on the join. Their single-input
+/// string predicates and null-aware comparisons are computed on that input
+/// before the join, and a cross-input null-aware comparison filters the matched
+/// pairs of an inner join.
+async fn native_runtime_join_filters_with_single_input_expressions_match_cpu() {
+    let dir = unique_temp_dir("algeon-datafusion-native-runtime-join-filter-strings");
+    let path = dir.join("input.parquet");
+    write_join_filter_string_input_parquet(&path);
+
+    for (name, sql) in [
+        (
+            "inner-lower-like",
+            "SELECT l.row_id, r.row_id AS r_id FROM bench l JOIN bench r ON l.key = r.key \
+             AND (LOWER(r.name) LIKE '%bar%' OR l.amount > 50) ORDER BY l.row_id, r_id",
+        ),
+        (
+            "left-like",
+            "SELECT l.row_id, r.row_id AS r_id FROM bench l LEFT JOIN bench r ON l.key = r.key \
+             AND r.row_id <> l.row_id AND (r.name LIKE 'B%' OR l.amount > 50) ORDER BY l.row_id, r_id",
+        ),
+        (
+            "full-like",
+            "SELECT l.row_id, r.row_id AS r_id FROM bench l FULL JOIN bench r ON l.key = r.key \
+             AND (r.name LIKE '%ie%' OR l.amount > 60) ORDER BY l.row_id, r_id",
+        ),
+        (
+            "semi-not-like",
+            "SELECT row_id FROM bench l WHERE EXISTS (SELECT 1 FROM bench r WHERE r.key = l.key \
+             AND r.row_id <> l.row_id AND (r.name NOT LIKE '%a%' OR l.amount < 0)) ORDER BY row_id",
+        ),
+        (
+            "anti-not-like",
+            "SELECT row_id FROM bench l WHERE NOT EXISTS (SELECT 1 FROM bench r WHERE r.key = l.key \
+             AND r.row_id <> l.row_id AND (r.name NOT LIKE '%a%' OR l.amount < 0)) ORDER BY row_id",
+        ),
+        (
+            "single-input-concatenation-and-is-distinct-from",
+            "SELECT l.row_id, r.row_id AS r_id FROM bench l JOIN bench r ON l.key = r.key \
+             AND ((r.name || '!') = 'Barbie!' OR (l.amount IS DISTINCT FROM 7)) ORDER BY l.row_id, r_id",
+        ),
+        (
+            "cross-input-is-not-distinct-from",
+            "SELECT l.row_id, r.row_id AS r_id FROM bench l JOIN bench r ON l.key = r.key \
+             AND l.row_id <> r.row_id AND ((l.name IS NOT DISTINCT FROM r.name) OR l.amount IS NULL) \
+             ORDER BY l.row_id, r_id",
+        ),
+    ] {
+        let cpu = cpu_sql_output(&path, sql).await;
+        assert!(cpu.iter().map(RecordBatch::num_rows).sum::<usize>() > 0, "{name} must exercise output rows");
+        let plan = sql_plan(&path, SessionConfig::new(), sql).await;
+        let optimization = optimize_with_pruning_template_requiring_native(plan);
+        assert_algeon_native_exec(&optimization.plan, name);
+        let native = collect(optimization.plan, Arc::new(TaskContext::default())).await.unwrap();
+        assert_batches_equal(&cpu, &native);
+    }
+
+    fs::remove_dir_all(dir).unwrap();
+}
+
 async fn native_runtime_decimal_division_failures_fail_the_query_like_cpu() {
     let dir = unique_temp_dir("algeon-datafusion-native-runtime-decimal-division-failures");
     let path = dir.join("input.parquet");
diff --git a/fixture/demo/decision_models/README.md b/fixture/demo/decision_models/README.md
new file mode 100644
index 000000000..9935a0fff
--- /dev/null
+++ b/fixture/demo/decision_models/README.md
@@ -0,0 +1,109 @@
+# Decision models in the loop
+
+Demo of one orchestration pattern over the existing Algeon server: a probe
+query returns a bounded candidate set with its context, a decision model
+answers a fixed question set for each candidate, the typed answers go back
+into Algeon as a Parquet table, and a recompute query runs over the full data
+with the corrected structure. Measured results are not part of the
+repository: each case's `run.py --mode replay` reproduces them from a capture
+file, and the capture files stay local (see "Layout").
+
+## Loop contract
+
+- Probe and recompute are separate Flight SQL queries. No GPU grant is held
+  while the decision backend runs.
+- The probe's row limit (`max_entities` in each case) is the only cost bound.
+- Decisions are cached in a registry keyed by the SHA-256 of the entity state
+  text and of the canonical question JSON. A second run of the same case makes
+  zero backend calls; a new time window calls the backend only for entities
+  the registry has not seen.
+- The recompute joins the typed decision table (`CREATE EXTERNAL TABLE ...
+  STORED AS PARQUET`) and records `host_datafusion_boundary_count` from the
+  query stats together with the `EXPLAIN GPU` summary.
+- Each case has a control that uses no model, and a `policy.json` with the
+  accept, review and reject bands on the action `noul`.
+
+## Layout
+
+```
+fixture/demo/decision_models/
+  README.md
+  scripts/client/      decision_client.py registry.py policy.py capture.py algeon.py case.py
+  scripts/cases/       a_brand_resolution/ b_bridge_purification/ c_complaint_causes/
+                       d_barbie_mechanisms/ e_pokemon_submarkets/ f_import_gate/
+  scripts/tests/       unit tests (no server, no API)
+  scripts/export_website.py   writes website/static/data/merrec-decision-{bridges,twins}.json from the A and B captures
+  registry/            *.parquet registries and *.engine.parquet decision tables (local only)
+  captures/            <case>[_<label>][.<backend>]_<mode>.json (local only)
+  data/ember/          EMBER2024 challenge node tables written by f_import_gate/prepare_tables.py (local only)
+  data/barbie/         bridge rows and exclusion tables written by d_barbie_mechanisms/run.py (local only)
+```
+
+The root `.gitignore` versions only `README.md`, `scripts/` and `*.sh` under a
+demo directory. Registries and captures stay local: the MerRec-derived ones
+carry CC BY-NC text and may be published only under `website/static/data`
+(see `scripts/test-harness.md`, "Third-party data"). `export_website.py`
+writes the two files the MerRec guide and the blog read from the case A and
+B captures; it drops the backend name, model ids and registry hashes, and
+`--check` verifies the files on disk match the captures.
+
+## Backends
+
+| `--backend` | Environment variables | Notes |
+| --- | --- | --- |
+| `jev` (default) | `JEV_API_URL`, `JEV_API_KEY` | TypeSafe `/systemone`: `choice`, `noul` and `score` heads, each question evaluated independently, at most 12 questions per state. |
+| `openai_compatible` | `OPENAI_COMPAT_BASE_URL`, `OPENAI_COMPAT_API_KEY`, `OPENAI_COMPAT_MODEL` | Any chat-completions endpoint that honors `response_format` JSON schemas; used for the cross-model agreement check. |
+| replay (`--mode replay`) | none | Serves recorded responses from the live capture; no network. |
+
+The variables have no defaults. A missing variable stops the run with a
+message that names it. No file under the repository may contain an endpoint
+host, path or token; captures record only `backend` and `model_id`, and the
+capture writer refuses content that contains a bearer token, a JWT-shaped
+string or the configured endpoint host.
+
+## Running a case
+
+Start a server with the MerRec scale configuration (see
+`fixture/demo/merrec/scripts/scale/README.md`) and register the source tables;
+each `run.py` calls the idempotent `CREATE EXTERNAL TABLE IF NOT EXISTS`
+statements for the tables it reads.
+
+```bash
+cd fixture/demo/decision_models/scripts
+python3 cases/b_bridge_purification/run.py --mode live             # probe, decide, recompute, control
+python3 cases/b_bridge_purification/run.py --mode replay           # same numbers, zero API calls
+python3 cases/b_bridge_purification/run.py --mode live --refresh   # decide every entity again (once per run)
+python3 -m unittest discover -s tests -t .
+```
+
+`--refresh` ignores registry rows that existed before the run; a state the
+run has already decided is reused by its later batches. Each case directory
+has a `compare_captures.py` that checks a replay capture against its live
+capture.
+
+Common flags: `--uri` (default `grpc://127.0.0.1:50064`), `--backend`,
+`--model`, `--max-workers`, `--max-entities`, `--label` (capture suffix such
+as a time window) and `--replay-from` (extra captures that serve replay
+responses). Case-specific flags are documented in each `run.py`.
+
+Run order: case B (`--label all`) produces
+`registry/brand_ontology_all.engine.parquet`, which case A reads to exclude
+non-brand entries before pairing; case A produces
+`registry/brand_canonical.engine.parquet`, which case B applies when run with
+`--with-canonical`. Cases C, D, E and F are independent; F needs `prepare_tables.py` once.
+
+## Registry schema
+
+| Column | Type | Meaning |
+| --- | --- | --- |
+| `entity_key` | Utf8 | Case-defined key (`brand_id`, `brand_id_a:brand_id_b`, `review_id`). |
+| `content_hash` | Utf8 | SHA-256 of the state text. |
+| `question_set_hash` | Utf8 | SHA-256 of the canonical question JSON. |
+| `model_id` | Utf8 | Backend-reported model, for example `typesafe/jev-1.13-20260917`. |
+| `decided_at` | Timestamp(us) | UTC. |
+| `<q>`, `<q>_p` | Utf8, Float64 | Choice option and its probability. |
+| `<q>` | Float64 | `noul` probability or `score` expected value. |
+| `input_tokens`, `latency_ms` | Int64 | Per decision. |
+
+The engine-facing `*.engine.parquet` tables carry `entity_key`, the case's
+typed key columns, the answer columns and the policy band.
diff --git a/fixture/demo/decision_models/scripts/cases/a_brand_resolution/01_probe.sql b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/01_probe.sql
new file mode 100644
index 000000000..7c1ff73c8
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/01_probe.sql
@@ -0,0 +1,28 @@
+WITH fans AS (
+  SELECT -(e.user_id + 1) AS src, CAST(i.brand_id AS BIGINT) AS dst
+  FROM merrec_events e JOIN merrec_items i ON i.item_id = e.item_id
+  LEFT JOIN brand_ontology o ON o.brand_id = CAST(i.brand_id AS BIGINT)
+  WHERE e.event_type = 'item_like' AND i.brand_id <> 0
+    AND (o.brand_id IS NULL OR o.band = 'accept')
+  GROUP BY e.user_id, i.brand_id
+), top_brands AS (
+  SELECT dst AS brand_id, COUNT(*) AS fans FROM fans GROUP BY dst ORDER BY fans DESC, dst LIMIT 2000
+), brands AS (
+  SELECT CAST(brand_id AS BIGINT) AS brand_id, MIN(brand_name) AS brand_name
+  FROM merrec_items WHERE brand_id <> 0 GROUP BY brand_id
+)
+SELECT r.first AS brand_id_a, ba.brand_name AS brand_a,
+       r.second AS brand_id_b, bb.brand_name AS brand_b,
+       a.fans AS fans_a, b.fans AS fans_b, r.similarity AS jaccard
+FROM cugraph_jaccard(
+  edges => (SELECT src, dst FROM fans),
+  vertex_pairs => (SELECT a.brand_id AS first, b.brand_id AS second
+                   FROM top_brands a JOIN top_brands b ON a.brand_id < b.brand_id),
+  directed => false
+) r
+JOIN top_brands a ON a.brand_id = r.first
+JOIN top_brands b ON b.brand_id = r.second
+JOIN brands ba ON ba.brand_id = r.first
+JOIN brands bb ON bb.brand_id = r.second
+ORDER BY r.similarity DESC, r.first, r.second
+LIMIT {max_entities}
diff --git a/fixture/demo/decision_models/scripts/cases/a_brand_resolution/02_context.sql b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/02_context.sql
new file mode 100644
index 000000000..2d1643a76
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/02_context.sql
@@ -0,0 +1,31 @@
+WITH target_items AS (
+  SELECT CAST(brand_id AS BIGINT) AS brand_id, category_path, name, price
+  FROM merrec_items
+  WHERE brand_id IN ({brand_ids})
+), stats AS (
+  SELECT brand_id, COUNT(*) AS listings, ROUND(AVG(price), 2) AS avg_price
+  FROM target_items
+  GROUP BY brand_id
+), top_cat AS (
+  SELECT brand_id, category_path,
+         ROW_NUMBER() OVER (PARTITION BY brand_id ORDER BY COUNT(*) DESC, category_path) AS rk
+  FROM target_items
+  WHERE category_path IS NOT NULL
+  GROUP BY brand_id, category_path
+), sample_titles AS (
+  SELECT brand_id, name,
+         ROW_NUMBER() OVER (PARTITION BY brand_id ORDER BY name) AS trk
+  FROM target_items
+  WHERE name IS NOT NULL
+)
+SELECT s.brand_id, s.listings, s.avg_price,
+       MAX(CASE WHEN tc.rk = 1 THEN tc.category_path END) AS top_category,
+       MAX(CASE WHEN tc.rk = 2 THEN tc.category_path END) AS second_category,
+       MAX(CASE WHEN st.trk = 5 THEN st.name END) AS sample_1,
+       MAX(CASE WHEN st.trk = 25 THEN st.name END) AS sample_2,
+       MAX(CASE WHEN st.trk = 50 THEN st.name END) AS sample_3
+FROM stats s
+LEFT JOIN top_cat tc ON tc.brand_id = s.brand_id AND tc.rk <= 2
+LEFT JOIN sample_titles st ON st.brand_id = s.brand_id AND st.trk IN (5, 25, 50)
+GROUP BY s.brand_id, s.listings, s.avg_price
+ORDER BY s.brand_id
diff --git a/fixture/demo/decision_models/scripts/cases/a_brand_resolution/03_recompute.sql b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/03_recompute.sql
new file mode 100644
index 000000000..a7b3b89e4
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/03_recompute.sql
@@ -0,0 +1,29 @@
+WITH likes AS (
+  SELECT c.canonical_id, c.brand_id, e.user_id
+  FROM merrec_events e
+  JOIN merrec_items i ON i.item_id = e.item_id
+  JOIN brand_canonical c ON c.brand_id = CAST(i.brand_id AS BIGINT)
+  WHERE e.event_type = 'item_like'
+), member_fans AS (
+  SELECT canonical_id, brand_id, COUNT(DISTINCT user_id) AS fans
+  FROM likes GROUP BY canonical_id, brand_id
+), union_fans AS (
+  SELECT canonical_id, COUNT(DISTINCT user_id) AS exact_union_fans
+  FROM likes GROUP BY canonical_id
+), brands AS (
+  SELECT CAST(brand_id AS BIGINT) AS brand_id, MIN(brand_name) AS brand_name
+  FROM merrec_items WHERE brand_id <> 0 GROUP BY brand_id
+)
+SELECT m.canonical_id,
+       MIN(cb.brand_name) AS canonical_name,
+       COUNT(*) AS members,
+       MAX(m.fans) AS primary_fans,
+       SUM(m.fans) AS naive_sum_fans,
+       MAX(u.exact_union_fans) AS exact_union_fans,
+       ROUND(100.0 * (MAX(u.exact_union_fans) - MAX(m.fans)) / MAX(m.fans), 1) AS gain_pct,
+       ROUND(100.0 * (SUM(m.fans) - MAX(u.exact_union_fans)) / SUM(m.fans), 1) AS double_count_pct
+FROM member_fans m
+JOIN union_fans u ON u.canonical_id = m.canonical_id
+JOIN brands cb ON cb.brand_id = m.canonical_id
+GROUP BY m.canonical_id
+ORDER BY exact_union_fans DESC, m.canonical_id
diff --git a/fixture/demo/decision_models/scripts/cases/a_brand_resolution/03a_canonical.sql b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/03a_canonical.sql
new file mode 100644
index 000000000..04c06e62e
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/03a_canonical.sql
@@ -0,0 +1,6 @@
+SELECT vertex AS brand_id, component AS canonical_id
+FROM cugraph_weakly_connected_components(
+  edges => (SELECT brand_id_a AS src, brand_id_b AS dst FROM brand_pairs WHERE band = 'accept'),
+  directed => false
+)
+ORDER BY canonical_id, brand_id
diff --git a/fixture/demo/decision_models/scripts/cases/a_brand_resolution/compare_captures.py b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/compare_captures.py
new file mode 100644
index 000000000..577498df7
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/compare_captures.py
@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""Compare a live capture with its replay; exit 1 on the first difference.
+
+Ignored keys: timestamps, timings, query ids, the environment block, the mode
+and the replay sources. Keys ending in `elapsed_s` or `wall_s` and keys starting
+with `latency_` are timings. The decision batches and totals depend on how
+many answers came from the registry, so their counters (`registry_hits`,
+`hit_rate`, `backend_calls`, `api_calls`, `backend`, `output_tokens`,
+`cost_usd`) are not compared; every replay batch must report zero API calls.
+Each recorded response is compared on its entity key, model id, answers and
+input tokens, as in cases B and C: `source`, the raw `response`,
+`output_tokens` and `cost_usd` are null for a registry-served decision. The
+top-level `model` is skipped because the replay backend reports no model name,
+and the cost and token fields of `full_pairwise_cost_estimate` are skipped
+because they scale the live run's mean cost per call.
+
+Usage: compare_captures.py LIVE.json REPLAY.json
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import sys
+
+IGNORED = {"decided_at", "started_at", "finished_at", "admission_wait_ms", "query_id", "environment", "mode",
+           "replay_sources"}
+TIMING_SUFFIXES = ("elapsed_s", "wall_s")
+COUNTERS = {"registry_hits", "hit_rate", "backend_calls", "api_calls", "backend", "input_tokens", "output_tokens",
+            "cost_usd"}
+RESPONSE_UNCOMPARED = {"source", "response", "output_tokens", "cost_usd"}
+# The full-pairwise estimate scales this run's mean cost and tokens per backend call; a replay has no cost.
+ESTIMATE_UNCOMPARED = {"mean_cost_usd_per_decision", "estimated_cost_usd", "mean_input_tokens_per_decision",
+                       "estimated_input_tokens"}
+
+
+def ignored(key: str, path: tuple) -> bool:
+    if key in IGNORED or key.startswith("latency_") or key.endswith(TIMING_SUFFIXES):
+        return True
+    if key == "model":
+        return path == ()
+    if path[:1] in (("decisions",), ("totals",)):
+        return key in COUNTERS
+    if path == ("results", "full_pairwise_cost_estimate"):
+        return key in ESTIMATE_UNCOMPARED
+    return len(path) == 2 and path[0] == "responses" and key in RESPONSE_UNCOMPARED
+
+
+def first_difference(live, replay, path: tuple = ()) -> str | None:
+    if isinstance(live, dict) and isinstance(replay, dict):
+        for key in sorted(set(live) | set(replay)):
+            if ignored(key, path):
+                continue
+            if key not in live or key not in replay:
+                return f"{'/'.join(map(str, path + (key,)))}: present only in {'live' if key in live else 'replay'}"
+            difference = first_difference(live[key], replay[key], path + (key,))
+            if difference:
+                return difference
+        return None
+    if isinstance(live, list) and isinstance(replay, list):
+        if len(live) != len(replay):
+            return f"{'/'.join(map(str, path))}: length {len(live)} != {len(replay)}"
+        for index, (left, right) in enumerate(zip(live, replay)):
+            difference = first_difference(left, right, path + (index,))
+            if difference:
+                return difference
+        return None
+    if live != replay:
+        return f"{'/'.join(map(str, path))}: {live!r} != {replay!r}"
+    return None
+
+
+def replay_problems(replay: dict) -> str | None:
+    for batch in replay.get("decisions", []):
+        if batch.get("api_calls") != 0:
+            return f"replay batch {batch.get('name')!r} reports api_calls={batch.get('api_calls')}"
+    if (replay.get("totals") or {}).get("api_calls") != 0:
+        return f"replay totals report api_calls={replay['totals'].get('api_calls')}"
+    return None
+
+
+def main() -> int:
+    if len(sys.argv) != 3:
+        print(__doc__.strip().splitlines()[-1], file=sys.stderr)
+        return 2
+    live, replay = (json.loads(Path(name).read_text(encoding="utf-8")) for name in sys.argv[1:])
+    if live.get("mode") != "live" or replay.get("mode") != "replay":
+        print(f"expected a live and a replay capture, got {live.get('mode')!r} and {replay.get('mode')!r}")
+        return 2
+    problem = replay_problems(replay) or first_difference(live, replay)
+    if problem:
+        print(f"captures differ: {problem}")
+        return 1
+    print(f"captures match: {len(live.get('responses', {}))} responses, {len(live.get('stages', []))} stages, "
+          f"{len(live.get('results', {}))} result entries")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/fixture/demo/decision_models/scripts/cases/a_brand_resolution/control_trigram.py b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/control_trigram.py
new file mode 100644
index 000000000..5388109cd
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/control_trigram.py
@@ -0,0 +1,133 @@
+"""Trigram blocking control: brand-name similarity without behavior or a decision model.
+
+Names are lowercased, punctuation is deleted, and each word contributes
+pg_trgm-style trigrams (two leading spaces, one trailing space). Two brands
+form a candidate pair when the Jaccard similarity of their trigram sets is at
+least `THRESHOLD`, 0.5 here, stricter than the pg_trgm default of 0.3: at
+0.5 "NCT" and "NCT 127" still pair (similarity 0.5) while "Dior" and
+"Christian Dior" (0.33) do not.
+
+Candidate generation uses prefix filtering over a global trigram order
+(rarest first): if J(x, y) >= t then the first |x| - ceil(t |x|) + 1 trigrams
+of x and the first |y| - ceil(t |y|) + 1 trigrams of y share a trigram, so the
+inverted index over prefixes finds every qualifying pair and each candidate is
+then verified exactly.
+"""
+
+from __future__ import annotations
+
+from collections import Counter, defaultdict
+import math
+import time
+import unicodedata
+
+THRESHOLD = 0.5
+NAMES_SQL = """SELECT CAST(brand_id AS BIGINT) AS brand_id, MIN(brand_name) AS brand_name
+FROM merrec_items WHERE brand_id <> 0 GROUP BY brand_id ORDER BY brand_id"""
+
+
+def normalize(name: str) -> str:
+    text = unicodedata.normalize("NFKC", name or "").lower()
+    kept = "".join(ch if ch.isalnum() or ch.isspace() else "" for ch in text)
+    return " ".join(kept.split())
+
+
+def trigrams(name: str) -> frozenset[str]:
+    grams = set()
+    for word in normalize(name).split():
+        padded = f"  {word} "
+        grams.update(padded[i:i + 3] for i in range(len(padded) - 2))
+    return frozenset(grams)
+
+
+def similarity(a: frozenset[str], b: frozenset[str]) -> float:
+    if not a or not b:
+        return 0.0
+    shared = len(a & b)
+    return shared / (len(a) + len(b) - shared)
+
+
+def candidate_pairs(grams: dict[int, frozenset[str]], threshold: float = THRESHOLD) -> dict[tuple[int, int], float]:
+    """All brand pairs with trigram Jaccard >= threshold, keyed by (smaller id, larger id)."""
+    frequency = Counter(gram for value in grams.values() for gram in value)
+    index: dict[str, list[int]] = defaultdict(list)
+    for brand_id in sorted(grams):
+        ordered = sorted(grams[brand_id], key=lambda gram: (frequency[gram], gram))
+        prefix = len(ordered) - math.ceil(threshold * len(ordered) - 1e-9) + 1
+        for gram in ordered[:prefix]:
+            index[gram].append(brand_id)
+    seen: set[tuple[int, int]] = set()
+    pairs: dict[tuple[int, int], float] = {}
+    for posting in index.values():
+        for i, first in enumerate(posting):
+            size = len(grams[first])
+            for second in posting[i + 1:]:
+                key = (first, second)
+                if key in seen:
+                    continue
+                seen.add(key)
+                other = len(grams[second])
+                if other < threshold * size or size < threshold * other:
+                    continue
+                value = similarity(grams[first], grams[second])
+                if value >= threshold:
+                    pairs[key] = value
+    return pairs
+
+
+def pair_view(pair: dict, value: float) -> dict:
+    return {"brand_id_a": pair["brand_id_a"], "brand_a": pair["brand_a"], "brand_id_b": pair["brand_id_b"],
+            "brand_b": pair["brand_b"], "trigram_similarity": round(value, 4),
+            "relationship_type": pair["relationship_type"], "should_merge_brand_id": pair["should_merge_brand_id"],
+            "band": pair["band"]}
+
+
+def run_control(names: list[dict], probe_pairs: list[dict], threshold: float = THRESHOLD) -> dict:
+    """Run the control over every brand name and compare it with the model's bands on the probe pairs.
+
+    `probe_pairs` rows carry `brand_id_a`, `brand_id_b`, their names, the model
+    answers and the policy `band`; each row gains `trigram_similarity`.
+    """
+    started = time.perf_counter()
+    grams = {row["brand_id"]: trigrams(row["brand_name"]) for row in names}
+    empty = sum(1 for value in grams.values() if not value)
+    grams = {key: value for key, value in grams.items() if value}
+    pairs = candidate_pairs(grams, threshold)
+    name_of = {row["brand_id"]: row["brand_name"] for row in names}
+
+    found, missed, wrong = [], [], []
+    for pair in probe_pairs:
+        value = similarity(grams.get(pair["brand_id_a"], frozenset()), grams.get(pair["brand_id_b"], frozenset()))
+        pair["trigram_similarity"] = round(value, 4)
+        key = (min(pair["brand_id_a"], pair["brand_id_b"]), max(pair["brand_id_a"], pair["brand_id_b"]))
+        proposed = key in pairs
+        if proposed != (value >= threshold):
+            raise AssertionError(f"prefix filter missed probe pair {key}")
+        if pair["band"] == "accept":
+            (found if proposed else missed).append(pair_view(pair, value))
+        elif proposed:
+            wrong.append(pair_view(pair, value))
+
+    wrong_by_relationship = Counter(row["relationship_type"] for row in wrong)
+    top = sorted(pairs.items(), key=lambda item: (-item[1], item[0]))[:20]
+    return {
+        "threshold": threshold,
+        "normalization": "NFKC, lowercase, punctuation deleted, pg_trgm word trigrams",
+        "brand_names": len(names),
+        "names_without_trigrams": empty,
+        "pairs_proposed_all_brands": len(pairs),
+        "examples_all_brands": [
+            {"brand_id_a": a, "brand_a": name_of[a], "brand_id_b": b, "brand_b": name_of[b],
+             "trigram_similarity": round(value, 4)} for (a, b), value in top],
+        "probe_pairs": len(probe_pairs),
+        "probe_pairs_proposed": sum(1 for pair in probe_pairs if pair["trigram_similarity"] >= threshold),
+        "accepted_aliases": len(found) + len(missed),
+        "accepted_found": len(found),
+        "accepted_missed": len(missed),
+        "wrongly_proposed": len(wrong),
+        "wrongly_proposed_by_relationship": dict(sorted(wrong_by_relationship.items())),
+        "found": found,
+        "missed": missed,
+        "wrongly_proposed_pairs": wrong,
+        "elapsed_s": time.perf_counter() - started,
+    }
diff --git a/fixture/demo/decision_models/scripts/cases/a_brand_resolution/policy.json b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/policy.json
new file mode 100644
index 000000000..3be026d4f
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/policy.json
@@ -0,0 +1,6 @@
+{
+  "action_question": "should_merge_brand_id",
+  "accept_min": 0.70,
+  "review_min": 0.30,
+  "require": {"relationship_type": ["same_entity_alias"]}
+}
diff --git a/fixture/demo/decision_models/scripts/cases/a_brand_resolution/questions.json b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/questions.json
new file mode 100644
index 000000000..e0b1ead56
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/questions.json
@@ -0,0 +1,30 @@
+{
+  "relationship_type": {
+    "type": "choice",
+    "instructions": "Determine the exact catalog relationship between Brand A and Brand B, which share high behavioral fan overlap in a peer-to-peer marketplace.",
+    "criteria": {
+      "same_entity_alias": "Exact same brand, artist group, or company entered under two different names, abbreviations, acronyms, or historical rebrands (e.g., 'Tomorrow X Together' = 'TXT', 'A Bathing Ape' = 'Bape', 'Mugler' = 'Thierry Mugler', 'Dior' = 'Christian Dior', 'Good Smile' = 'Good Smile Company', 'Jeffree Star Cosmetics' = 'JSC')",
+      "sub_brand_or_diffusion_line": "One is a direct sub-brand, diffusion line, or division of the other parent fashion/footwear brand (e.g., 'Victoria\\'s Secret' and 'PINK', 'Free People' and 'We The Free', 'Nike' and 'Air Jordan'/'Jordan', 'NCT' and sub-unit 'NCT 127' or 'NCT Dream')",
+      "ip_franchise_and_owner_maker": "One is a character IP / game / anime franchise and the other is its parent studio, publisher, or toy manufacturer (e.g., 'Hello Kitty'/'My Melody'/'Kuromi'/'Cinnamoroll' and 'Sanrio', 'Rilakkuma' and 'San-X', 'Yu-Gi-Oh!' and 'Konami', 'Pokemon' and 'Nintendo', 'Gundam' and 'Bandai')",
+      "distinct_co_liked_peers": "Two distinct competing brands, separate music artists/groups, or sister characters that merely appeal to the same fan demographic (e.g., 'Ateez' vs 'Stray Kids', 'Panini' vs 'Topps', 'My Melody' vs 'Kuromi')"
+    }
+  },
+  "should_merge_brand_id": {
+    "type": "noul",
+    "instructions": "In a master brand catalog deduplication pipeline, should Brand A and Brand B be merged into a single canonical `brand_id` because they denote the exact same brand entity (acronym, abbreviation, spelling variant, or rebrand)?",
+    "criteria": {
+      "true": "Yes: Brand A and Brand B are synonymous names/abbreviations/rebrands for the exact same entity and splitting them is a catalog duplication bug",
+      "false": "No: They are distinct brands, character vs parent company, parent vs sub-brand, or separate artists/characters"
+    }
+  },
+  "alignment_score": {
+    "type": "score",
+    "instructions": "Rate the ontological equivalence between Brand A and Brand B.",
+    "criteria": [
+      "0 - Separate competing brands, separate musical artists, or distinct sister characters",
+      "1 - Franchise/character IP paired with its manufacturer or publisher (e.g., Hello Kitty & Sanrio)",
+      "2 - Parent brand paired with an official sub-brand, division, or group sub-unit (e.g., Victoria's Secret & PINK)",
+      "3 - Identical brand entity split across two catalog strings (e.g., TXT & Tomorrow X Together, Bape & A Bathing Ape)"
+    ]
+  }
+}
diff --git a/fixture/demo/decision_models/scripts/cases/a_brand_resolution/run.py b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/run.py
new file mode 100644
index 000000000..613872310
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/a_brand_resolution/run.py
@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""Case A (Resolve): MerRec brand entity resolution.
+
+The probe projects the top 2,000 standalone brands (case B's all-window
+`brand_ontology_all.engine.parquet` removes entries whose band is not `accept`) on the like bipartite graph and
+keeps the pairs with the highest fan Jaccard. The decision model judges each
+pair; accepted alias pairs feed weakly connected components, which writes
+`registry/brand_canonical.engine.parquet` for case B, and the dedup statement
+recomputes exact fan unions over every like. A trigram name-similarity control
+runs over all brand names.
+
+Commands, from `fixture/demo/decision_models/scripts`; every GPU run holds the
+shared lock, and a live run needs `JEV_API_URL` and `JEV_API_KEY` in the
+environment:
+
+    flock /tmp/decision-demo-gpu.lock python3 cases/a_brand_resolution/run.py --mode live
+    flock /tmp/decision-demo-gpu.lock python3 cases/a_brand_resolution/run.py --mode replay
+    python3 cases/a_brand_resolution/compare_captures.py \\
+        ../captures/a_brand_resolution_live.json ../captures/a_brand_resolution_replay.json
+
+A replay with the shared registry serves every decision from the registry and
+falls back to the live capture for anything the registry lacks; the comparator
+checks the answers, not the hit counters.
+
+Case flags: `--ontology` (case B's decision table, default
+`<registry-dir>/brand_ontology_all.engine.parquet`).
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from pathlib import Path
+import sys
+
+CASE_DIR = Path(__file__).resolve().parent
+sys.path.insert(0, str(CASE_DIR.parents[1]))
+
+import pyarrow as pa  # noqa: E402
+import pyarrow.compute as pc  # noqa: E402
+import pyarrow.parquet as pq  # noqa: E402
+
+from client.capture import merrec_license  # noqa: E402
+from client.case import Case, build_parser  # noqa: E402
+from client.decision_client import Entity  # noqa: E402
+import control_trigram  # noqa: E402
+
+DEFAULT_MAX_ENTITIES = 120
+GPU_STAGES = ("probe", "canonical", "dedup")
+CANONICAL_SCHEMA = pa.schema([("entity_key", pa.string()), ("brand_id", pa.int64()), ("canonical_id", pa.int64())])
+
+
+def require_native(case: Case, stage) -> None:
+    """Stop when a recompute-path stage crossed into DataFusion on the host."""
+    boundaries = (stage.execution or {}).get("host_datafusion_boundary_count")
+    if boundaries != 0:
+        case.capture.note(f"stage {stage.name} reported host_datafusion_boundary_count={boundaries}; "
+                          f"EXPLAIN summary {stage.explain}")
+        case.finish()
+        raise SystemExit(f"stage {stage.name} has host_datafusion_boundary_count={boundaries}; "
+                         f"EXPLAIN summary {stage.explain}")
+
+
+def brand_text(brand_id: int, name: str, fans: int, context: dict) -> str:
+    titles = [context[f"sample_{i}"] for i in (1, 2, 3) if context.get(f"sample_{i}")]
+    return (f"{name} (brand_id={brand_id}, fans={fans}, listings={context['listings']}, "
+            f"avg_price=${context['avg_price']:.2f})\n"
+            f"  Top Categories: {context['top_category']} | {context['second_category']}\n"
+            f"  Sample Titles: {' // '.join(titles)}")
+
+
+def pair_state(pair: dict, context: dict[int, dict]) -> str:
+    return (f"Behavioral Fan Overlap: Jaccard Similarity = {pair['jaccard']:.4f}\n"
+            f"Brand A: {brand_text(pair['brand_id_a'], pair['brand_a'], pair['fans_a'], context[pair['brand_id_a']])}\n"
+            f"Brand B: {brand_text(pair['brand_id_b'], pair['brand_b'], pair['fans_b'], context[pair['brand_id_b']])}")
+
+
+def ontology_summary(path: Path) -> dict:
+    table = pq.read_table(path, columns=["brand_id", "band"])
+    excluded = table.filter(pc.not_equal(table["band"], "accept"))
+    return {"rows": table.num_rows, "excluded_brand_ids": len(set(excluded["brand_id"].to_pylist()))}
+
+
+def main() -> None:
+    parser = build_parser(__doc__.splitlines()[0])
+    parser.add_argument("--ontology", type=Path, default=None,
+                        help="case B decision table; default <registry-dir>/brand_ontology_all.engine.parquet")
+    args = parser.parse_args()
+    max_entities = args.max_entities or DEFAULT_MAX_ENTITIES
+    ontology = args.ontology or args.registry_dir / "brand_ontology_all.engine.parquet"
+    if not ontology.exists():
+        raise SystemExit(f"{ontology} is missing; run case B (b_bridge_purification) first")
+
+    case = Case(CASE_DIR, args, license=merrec_license())
+    case.capture.data["max_entities"] = max_entities
+    case.algeon.register_merrec()
+    case.algeon.register_parquet("brand_ontology", ontology)
+    case.capture.result("ontology", ontology_summary(ontology))
+
+    probe = case.run_stage("probe", case.sql("01_probe.sql").replace("{max_entities}", str(max_entities)))
+    require_native(case, probe)
+    pairs = probe.table.to_pylist()
+    brand_ids = sorted({pair["brand_id_a"] for pair in pairs} | {pair["brand_id_b"] for pair in pairs})
+    context_stage = case.run_stage(
+        "context", case.sql("02_context.sql").replace("{brand_ids}", ", ".join(str(b) for b in brand_ids)))
+    context = {row["brand_id"]: row for row in context_stage.table.to_pylist()}
+
+    entities = [Entity(f"{pair['brand_id_a']}:{pair['brand_id_b']}", pair_state(pair, context)) for pair in pairs]
+    registry = case.registry("brand_pairs")
+    batch = case.decide(registry, entities)
+    by_key = batch.by_key()
+    decisions = [by_key[entity.key] for entity in entities]
+    bands, band_counts = case.policy.apply(decisions)
+
+    engine = registry.engine_table(decisions, {
+        "brand_id_a": pa.array([pair["brand_id_a"] for pair in pairs], pa.int64()),
+        "brand_id_b": pa.array([pair["brand_id_b"] for pair in pairs], pa.int64()),
+    })
+    engine = engine.append_column("band", pa.array([bands[entity.key] for entity in entities], pa.string()))
+    case.decision_table("brand_pairs", engine)
+
+    records = []
+    for rank, (pair, decision) in enumerate(zip(pairs, decisions), start=1):
+        records.append({
+            "rank": rank, **pair,
+            "relationship_type": decision.value("relationship_type"),
+            "relationship_type_p": decision.probability("relationship_type"),
+            "should_merge_brand_id": decision.value("should_merge_brand_id"),
+            "alignment_score": decision.value("alignment_score"),
+            "band": bands[decision.entity_key],
+        })
+
+    accepted = [record for record in records if record["band"] == "accept"]
+    clusters = []
+    if accepted:
+        canonical = case.run_stage("canonical", case.sql("03a_canonical.sql"))
+        require_native(case, canonical)
+        rows = canonical.table.to_pylist()
+        canonical_table = pa.table({
+            "entity_key": [str(row["brand_id"]) for row in rows],
+            "brand_id": pa.array([row["brand_id"] for row in rows], pa.int64()),
+            "canonical_id": pa.array([row["canonical_id"] for row in rows], pa.int64()),
+        }, schema=CANONICAL_SCHEMA)
+        case.decision_table("brand_canonical", canonical_table)
+
+        dedup = case.run_stage("dedup", case.sql("03_recompute.sql"))
+        require_native(case, dedup)
+        names = {}
+        for record in records:
+            names[record["brand_id_a"]] = (record["brand_a"], record["fans_a"])
+            names[record["brand_id_b"]] = (record["brand_b"], record["fans_b"])
+        members: dict[int, list[int]] = {}
+        for row in rows:
+            members.setdefault(row["canonical_id"], []).append(row["brand_id"])
+        for row in dedup.table.to_pylist():
+            ordered = sorted(members[row["canonical_id"]], key=lambda brand_id: (-names[brand_id][1], brand_id))
+            clusters.append({**row, "member_ids": ordered, "member_names": [names[brand_id][0] for brand_id in ordered]})
+    else:
+        case.decision_table("brand_canonical", CANONICAL_SCHEMA.empty_table())
+        case.capture.note("no pair reached the accept band; brand_canonical is empty and the dedup stage did not run")
+
+    names_stage = case.run_stage("brand_names", control_trigram.NAMES_SQL)
+    control = control_trigram.run_control(names_stage.table.to_pylist(), records)
+
+    summary = batch.summary
+    brands = names_stage.rows
+    all_pairs = brands * (brands - 1) // 2
+    per_decision = summary["cost_usd"] / summary["backend_calls"] \
+        if summary["backend_calls"] and summary["cost_usd"] is not None else None
+    tokens_per_decision = summary["input_tokens"] / summary["backend_calls"] if summary["backend_calls"] else None
+    case.capture.result("full_pairwise_cost_estimate", {
+        "brands": brands,
+        "pairs": all_pairs,
+        "probe_decisions": len(records),
+        "pairs_per_probe_decision": all_pairs / len(records) if records else None,
+        "mean_cost_usd_per_decision": per_decision,
+        "mean_input_tokens_per_decision": tokens_per_decision,
+        "estimated_cost_usd": per_decision * all_pairs if per_decision is not None else None,
+        "estimated_input_tokens": tokens_per_decision * all_pairs if tokens_per_decision is not None else None,
+        "basis": "this run's backend calls; not executed",
+    })
+
+    case.capture.result("pairs", records)
+    case.capture.result("band_counts", band_counts)
+    case.capture.result("relationship_counts", dict(sorted(Counter(r["relationship_type"] for r in records).items())))
+    case.capture.result("accepted_pairs", accepted)
+    case.capture.result("review_queue", sorted((r for r in records if r["band"] == "review"),
+                                               key=lambda r: (-r["should_merge_brand_id"], r["rank"])))
+    case.capture.result("clusters", clusters)
+    case.capture.result("trigram_control", control)
+    case.capture.result("gpu_stages", {stage["name"]: {
+        "elapsed_s": stage["elapsed_s"],
+        "host_datafusion_boundary_count": (stage["execution"] or {}).get("host_datafusion_boundary_count"),
+    } for stage in case.capture.data["stages"] if stage["name"] in GPU_STAGES})
+    case.finish()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/fixture/demo/decision_models/scripts/cases/b_bridge_purification/01_probe.sql b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/01_probe.sql
new file mode 100644
index 000000000..2dc315ffa
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/01_probe.sql
@@ -0,0 +1,45 @@
+WITH fans AS (
+  SELECT -(e.user_id + 1) AS src, CAST(i.brand_id AS BIGINT) AS dst
+  FROM merrec_events e JOIN merrec_items i ON i.item_id = e.item_id
+  WHERE e.event_type = 'item_like' AND i.brand_id <> 0
+    AND e.event_time >= TIMESTAMP '{window_start}' AND e.event_time < TIMESTAMP '{window_end}'
+  GROUP BY e.user_id, i.brand_id
+), top_brands AS (
+  SELECT dst AS brand_id, COUNT(*) AS fans FROM fans GROUP BY dst ORDER BY fans DESC, dst LIMIT 5000
+), similar AS (
+  SELECT first, second, similarity
+  FROM cugraph_jaccard(
+    edges => (SELECT src, dst FROM fans),
+    vertex_pairs => (SELECT a.brand_id AS first, b.brand_id AS second
+                     FROM top_brands a JOIN top_brands b ON a.brand_id < b.brand_id),
+    directed => false)
+  WHERE similarity >= 0.02
+), worlds AS (
+  SELECT vertex AS brand_id, community AS world
+  FROM cugraph_leiden(
+    edges => (SELECT first AS src, second AS dst, CAST(similarity AS DOUBLE) AS weight FROM similar),
+    directed => false, resolution => 3, seed => 42)
+), bridges AS (
+  SELECT vertex AS brand_id, value AS betweenness
+  FROM cugraph_betweenness_centrality(
+    edges => (SELECT first AS src, second AS dst FROM similar),
+    directed => false, normalized => true)
+), neighbors AS (
+  SELECT first AS brand_id, second AS neighbor FROM similar
+  UNION ALL SELECT second, first FROM similar
+), reach AS (
+  SELECT n.brand_id, COUNT(*) AS neighbors, COUNT(DISTINCT w.world) AS worlds_reached
+  FROM neighbors n JOIN worlds w ON w.brand_id = n.neighbor
+  GROUP BY n.brand_id
+), brands AS (
+  SELECT CAST(brand_id AS BIGINT) AS brand_id, MIN(brand_name) AS brand_name
+  FROM merrec_items WHERE brand_id <> 0 GROUP BY brand_id
+)
+SELECT br.brand_id, b.brand_name, t.fans, w.world, r.neighbors, r.worlds_reached, br.betweenness
+FROM bridges br
+JOIN worlds w ON w.brand_id = br.brand_id
+JOIN reach r ON r.brand_id = br.brand_id
+JOIN top_brands t ON t.brand_id = br.brand_id
+JOIN brands b ON b.brand_id = br.brand_id
+ORDER BY br.betweenness DESC, b.brand_name
+LIMIT 120
diff --git a/fixture/demo/decision_models/scripts/cases/b_bridge_purification/02_context.sql b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/02_context.sql
new file mode 100644
index 000000000..7a29a08de
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/02_context.sql
@@ -0,0 +1,40 @@
+WITH target_items AS (
+  SELECT CAST(brand_id AS BIGINT) AS brand_id, c0_name, c1_name, category_path, name, price
+  FROM merrec_items
+  WHERE brand_id IN ({brand_ids})
+), brand_stats AS (
+  SELECT brand_id,
+         COUNT(*) AS total_listings,
+         COUNT(DISTINCT c0_name) AS distinct_c0,
+         COUNT(DISTINCT c1_name) AS distinct_c1,
+         ROUND(AVG(price), 2) AS avg_price
+  FROM target_items
+  GROUP BY brand_id
+), top_cats AS (
+  SELECT brand_id, category_path, COUNT(*) AS listings,
+         ROW_NUMBER() OVER (PARTITION BY brand_id ORDER BY COUNT(*) DESC, category_path) AS rk
+  FROM target_items
+  WHERE category_path IS NOT NULL
+  GROUP BY brand_id, category_path
+), sample_titles AS (
+  SELECT brand_id, name,
+         ROW_NUMBER() OVER (PARTITION BY brand_id ORDER BY name) AS trk
+  FROM target_items
+  WHERE name IS NOT NULL
+)
+SELECT bs.brand_id, bs.total_listings, bs.distinct_c0, bs.distinct_c1, bs.avg_price,
+       MAX(CASE WHEN tc.rk = 1 THEN tc.category_path END) AS cat1,
+       MAX(CASE WHEN tc.rk = 1 THEN tc.listings END) AS cat1_listings,
+       MAX(CASE WHEN tc.rk = 2 THEN tc.category_path END) AS cat2,
+       MAX(CASE WHEN tc.rk = 2 THEN tc.listings END) AS cat2_listings,
+       MAX(CASE WHEN tc.rk = 3 THEN tc.category_path END) AS cat3,
+       MAX(CASE WHEN tc.rk = 3 THEN tc.listings END) AS cat3_listings,
+       MAX(CASE WHEN st.trk = 10 THEN st.name END) AS title1,
+       MAX(CASE WHEN st.trk = 50 THEN st.name END) AS title2,
+       MAX(CASE WHEN st.trk = 100 THEN st.name END) AS title3,
+       MAX(CASE WHEN st.trk = 200 THEN st.name END) AS title4
+FROM brand_stats bs
+LEFT JOIN top_cats tc ON tc.brand_id = bs.brand_id AND tc.rk <= 3
+LEFT JOIN sample_titles st ON st.brand_id = bs.brand_id AND st.trk IN (10, 50, 100, 200)
+GROUP BY bs.brand_id, bs.total_listings, bs.distinct_c0, bs.distinct_c1, bs.avg_price
+ORDER BY bs.brand_id
diff --git a/fixture/demo/decision_models/scripts/cases/b_bridge_purification/03_recompute.sql b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/03_recompute.sql
new file mode 100644
index 000000000..77faa6f3a
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/03_recompute.sql
@@ -0,0 +1,47 @@
+WITH fans AS (
+  SELECT -(e.user_id + 1) AS src, CAST(i.brand_id AS BIGINT) AS dst
+  FROM merrec_events e JOIN merrec_items i ON i.item_id = e.item_id
+  LEFT JOIN {ontology_table} o ON o.brand_id = CAST(i.brand_id AS BIGINT)
+  WHERE e.event_type = 'item_like' AND i.brand_id <> 0
+    AND (o.brand_id IS NULL OR o.band = 'accept')
+    AND e.event_time >= TIMESTAMP '{window_start}' AND e.event_time < TIMESTAMP '{window_end}'
+  GROUP BY e.user_id, i.brand_id
+), top_brands AS (
+  SELECT dst AS brand_id, COUNT(*) AS fans FROM fans GROUP BY dst ORDER BY fans DESC, dst LIMIT 5000
+), similar AS (
+  SELECT first, second, similarity
+  FROM cugraph_jaccard(
+    edges => (SELECT src, dst FROM fans),
+    vertex_pairs => (SELECT a.brand_id AS first, b.brand_id AS second
+                     FROM top_brands a JOIN top_brands b ON a.brand_id < b.brand_id),
+    directed => false)
+  WHERE similarity >= 0.02
+), worlds AS (
+  SELECT vertex AS brand_id, community AS world
+  FROM cugraph_leiden(
+    edges => (SELECT first AS src, second AS dst, CAST(similarity AS DOUBLE) AS weight FROM similar),
+    directed => false, resolution => 3, seed => 42)
+), bridges AS (
+  SELECT vertex AS brand_id, value AS betweenness
+  FROM cugraph_betweenness_centrality(
+    edges => (SELECT first AS src, second AS dst FROM similar),
+    directed => false, normalized => true)
+), neighbors AS (
+  SELECT first AS brand_id, second AS neighbor FROM similar
+  UNION ALL SELECT second, first FROM similar
+), reach AS (
+  SELECT n.brand_id, COUNT(*) AS neighbors, COUNT(DISTINCT w.world) AS worlds_reached
+  FROM neighbors n JOIN worlds w ON w.brand_id = n.neighbor
+  GROUP BY n.brand_id
+), brands AS (
+  SELECT CAST(brand_id AS BIGINT) AS brand_id, MIN(brand_name) AS brand_name
+  FROM merrec_items WHERE brand_id <> 0 GROUP BY brand_id
+)
+SELECT br.brand_id, b.brand_name, t.fans, w.world, r.neighbors, r.worlds_reached, br.betweenness
+FROM bridges br
+JOIN worlds w ON w.brand_id = br.brand_id
+JOIN reach r ON r.brand_id = br.brand_id
+JOIN top_brands t ON t.brand_id = br.brand_id
+JOIN brands b ON b.brand_id = br.brand_id
+ORDER BY br.betweenness DESC, b.brand_name
+LIMIT 120
diff --git a/fixture/demo/decision_models/scripts/cases/b_bridge_purification/04_recompute_canonical.sql b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/04_recompute_canonical.sql
new file mode 100644
index 000000000..c7f2da0c4
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/04_recompute_canonical.sql
@@ -0,0 +1,48 @@
+WITH fans AS (
+  SELECT -(e.user_id + 1) AS src, COALESCE(c.canonical_id, CAST(i.brand_id AS BIGINT)) AS dst
+  FROM merrec_events e JOIN merrec_items i ON i.item_id = e.item_id
+  LEFT JOIN {ontology_table} o ON o.brand_id = CAST(i.brand_id AS BIGINT)
+  LEFT JOIN brand_canonical c ON c.brand_id = CAST(i.brand_id AS BIGINT)
+  WHERE e.event_type = 'item_like' AND i.brand_id <> 0
+    AND (o.brand_id IS NULL OR o.band = 'accept')
+    AND e.event_time >= TIMESTAMP '{window_start}' AND e.event_time < TIMESTAMP '{window_end}'
+  GROUP BY 1, 2
+), top_brands AS (
+  SELECT dst AS brand_id, COUNT(*) AS fans FROM fans GROUP BY dst ORDER BY fans DESC, dst LIMIT 5000
+), similar AS (
+  SELECT first, second, similarity
+  FROM cugraph_jaccard(
+    edges => (SELECT src, dst FROM fans),
+    vertex_pairs => (SELECT a.brand_id AS first, b.brand_id AS second
+                     FROM top_brands a JOIN top_brands b ON a.brand_id < b.brand_id),
+    directed => false)
+  WHERE similarity >= 0.02
+), worlds AS (
+  SELECT vertex AS brand_id, community AS world
+  FROM cugraph_leiden(
+    edges => (SELECT first AS src, second AS dst, CAST(similarity AS DOUBLE) AS weight FROM similar),
+    directed => false, resolution => 3, seed => 42)
+), bridges AS (
+  SELECT vertex AS brand_id, value AS betweenness
+  FROM cugraph_betweenness_centrality(
+    edges => (SELECT first AS src, second AS dst FROM similar),
+    directed => false, normalized => true)
+), neighbors AS (
+  SELECT first AS brand_id, second AS neighbor FROM similar
+  UNION ALL SELECT second, first FROM similar
+), reach AS (
+  SELECT n.brand_id, COUNT(*) AS neighbors, COUNT(DISTINCT w.world) AS worlds_reached
+  FROM neighbors n JOIN worlds w ON w.brand_id = n.neighbor
+  GROUP BY n.brand_id
+), brands AS (
+  SELECT CAST(brand_id AS BIGINT) AS brand_id, MIN(brand_name) AS brand_name
+  FROM merrec_items WHERE brand_id <> 0 GROUP BY brand_id
+)
+SELECT br.brand_id, b.brand_name, t.fans, w.world, r.neighbors, r.worlds_reached, br.betweenness
+FROM bridges br
+JOIN worlds w ON w.brand_id = br.brand_id
+JOIN reach r ON r.brand_id = br.brand_id
+JOIN top_brands t ON t.brand_id = br.brand_id
+JOIN brands b ON b.brand_id = br.brand_id
+ORDER BY br.betweenness DESC, b.brand_name
+LIMIT 120
diff --git a/fixture/demo/decision_models/scripts/cases/b_bridge_purification/compare_captures.py b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/compare_captures.py
new file mode 100644
index 000000000..03382d3dc
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/compare_captures.py
@@ -0,0 +1,88 @@
+"""Compare each label's replay capture with its live capture; exit 1 on the first difference.
+
+    python3 cases/b_bridge_purification/compare_captures.py all sep_oct
+
+Timestamps, timings, query ids and run provenance are ignored. A live run
+calls the backend and a replay is served from the registry, so the per-batch
+decision summaries and totals are left out, and `registry_hits` and
+`api_calls` are ignored wherever they appear, including the per-pass records.
+Each recorded response is compared on its entity key, model id, answers and
+input tokens; `source`, the raw `response`, `output_tokens` and `cost_usd` are
+null for a registry-served decision and present for a fetched one.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+CASE = Path(__file__).resolve().parent.name
+CAPTURES_DIR = Path(__file__).resolve().parents[3] / "captures"
+IGNORED = {"decided_at", "started_at", "finished_at", "elapsed_s", "wall_s", "admission_wait_ms", "query_id",
+           "environment", "mode", "replay_sources", "registry_hits", "api_calls"}
+IGNORED_PREFIXES = ("latency_",)
+UNCOMPARED = {"decisions", "responses", "totals", "model"}
+BATCH_FIELDS = ("name", "entities", "distinct_states", "model_ids")
+RESPONSE_FIELDS = ("entity_key", "model_id", "answers", "input_tokens")
+
+
+def ignored(key: str) -> bool:
+    return key in IGNORED or key.startswith(IGNORED_PREFIXES)
+
+
+def first_difference(left, right, path: str = "$") -> str | None:
+    if isinstance(left, dict) and isinstance(right, dict):
+        for key in sorted(set(left) | set(right)):
+            if ignored(key):
+                continue
+            if key not in left or key not in right:
+                return f"{path}.{key}: present only in {'live' if key in left else 'replay'}"
+            found = first_difference(left[key], right[key], f"{path}.{key}")
+            if found:
+                return found
+        return None
+    if isinstance(left, list) and isinstance(right, list):
+        if len(left) != len(right):
+            return f"{path}: length {len(left)} vs {len(right)}"
+        for index, (a, b) in enumerate(zip(left, right)):
+            found = first_difference(a, b, f"{path}[{index}]")
+            if found:
+                return found
+        return None
+    if left != right:
+        return f"{path}: {json.dumps(left, default=str)[:200]} vs {json.dumps(right, default=str)[:200]}"
+    return None
+
+
+def comparable(capture: dict) -> dict:
+    view = {key: value for key, value in capture.items() if key not in UNCOMPARED}
+    view["decision_batches"] = [{key: batch.get(key) for key in BATCH_FIELDS} for batch in capture.get("decisions", [])]
+    view["responses"] = {key: {field: record.get(field) for field in RESPONSE_FIELDS}
+                         for key, record in (capture.get("responses") or {}).items()}
+    return view
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("labels", nargs="+", help="capture labels, for example all sep_oct")
+    parser.add_argument("--captures-dir", type=Path, default=CAPTURES_DIR)
+    args = parser.parse_args()
+    status = 0
+    for label in args.labels:
+        paths = [args.captures_dir / f"{CASE}_{label}_{mode}.json" for mode in ("live", "replay")]
+        missing = [path.name for path in paths if not path.exists()]
+        if missing:
+            print(f"{label}: missing {', '.join(missing)}")
+            status = 1
+            continue
+        live, replay = (comparable(json.loads(path.read_text(encoding="utf-8"))) for path in paths)
+        difference = first_difference(live, replay)
+        print(f"{label}: {'identical' if difference is None else 'differs at ' + difference}")
+        status |= difference is not None
+    return status
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/fixture/demo/decision_models/scripts/cases/b_bridge_purification/control_denylist.json b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/control_denylist.json
new file mode 100644
index 000000000..bb9b81490
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/control_denylist.json
@@ -0,0 +1,17 @@
+{
+  "multi_brand_retailer": [
+    "Bed Bath & Beyond", "Cabela's", "Cato", "Charming Charlie", "Claire's", "Hobby Lobby", "Hot Topic",
+    "JCPenney", "Kohl's", "Loot Crate", "Macy's", "Nordstrom", "Pier 1 Imports", "Pier One", "Rue21",
+    "Spencer's", "Ulta", "Walmart", "World Market"
+  ],
+  "superstore_house_brand": [
+    "Better Homes & Gardens", "Cherokee", "Circo", "Faded Glory", "Hyper Tough", "INC International Concepts",
+    "Mainstays", "No Boundaries", "Room Essentials", "SO", "Secret Treasures", "Sonoma", "Style & Co",
+    "Wonder Nation", "Xhilaration", "a.n.a"
+  ],
+  "generic_catchall_or_category": [
+    "American Vintage", "ART", "Army", "As Seen on TV", "Authentic Original Vintage Style",
+    "Customized & Personalized", "Eyeshadow", "Independent", "Indie", "Lot", "Original Vintage Style", "Rare",
+    "The Unbranded Brand", "US Vintage"
+  ]
+}
diff --git a/fixture/demo/decision_models/scripts/cases/b_bridge_purification/policy.json b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/policy.json
new file mode 100644
index 000000000..ea55384c0
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/policy.json
@@ -0,0 +1 @@
+{"action_question": "is_standalone_brand", "accept_min": 0.70, "review_min": 0.30, "require": {"entity_kind": ["standalone_brand"]}}
diff --git a/fixture/demo/decision_models/scripts/cases/b_bridge_purification/questions.json b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/questions.json
new file mode 100644
index 000000000..cdc69dbc2
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/questions.json
@@ -0,0 +1,30 @@
+{
+  "entity_kind": {
+    "type": "choice",
+    "instructions": "In a peer-to-peer marketplace (Mercari), sellers select a `brand_name` from a dropdown. Some entries are real standalone brands, while others are generic catch-all tags, product categories, multi-brand department stores/retailers, or mass-retailer private labels. Classify this `brand_name` entry.",
+    "criteria": {
+      "standalone_brand": "A genuine standalone consumer brand, fashion label, cosmetics brand, electronics/toy manufacturer, or entertainment IP (e.g., H&M, ZARA, Anthropologie, Nike, Free People, Urban Outfitters, Morphe, Tarte, Disney)",
+      "multi_brand_retailer": "A department store, big-box superstore, specialty retail chain, or mall store that sells many third-party or licensed franchises under one roof (e.g., Walmart, Macy's, JCPenney, Target, Sephora, Claire's, Hot Topic, BoxLunch, Spencer's, Kohl's, Nordstrom, Costco)",
+      "superstore_house_brand": "A private-label / house brand owned by a mass big-box superstore (Walmart, Target, Costco, Amazon) spanning home/apparel/general merchandise (e.g., Mainstays, Better Homes & Gardens, THRESHOLD, Time and Tru, No Boundaries, Wild Fable, Universal Thread, Cat & Jack, Room Essentials, Kirkland Signature)",
+      "generic_catchall_or_category": "Not a brand at all, but a generic seller descriptor, vintage tag, infomercial label, or product type mistakenly listed as a brand (e.g., Customized & Personalized, US Vintage, American Vintage, As Seen on TV, Eyeshadow, Handmade, Boutique)"
+    }
+  },
+  "is_standalone_brand": {
+    "type": "noul",
+    "instructions": "Is this entry a genuine standalone consumer brand rather than a generic descriptor, category name, department store, or big-box private label?",
+    "criteria": {
+      "true": "Distinct standalone brand or creator label with its own brand identity",
+      "false": "Generic catch-all tag, product category, department store/superstore, or big-box house label"
+    }
+  },
+  "wormhole_pollution": {
+    "type": "score",
+    "instructions": "How severely does this entry act as an artificial cross-community 'wormhole' that conflates unrelated shopping communities in a brand co-liking graph?",
+    "criteria": [
+      "0 - Cohesive standalone brand representing a real, specific brand affinity",
+      "1 - Broad lifestyle/fashion retailer or specialty store with moderately diverse categories",
+      "2 - Mass-market superstore house label or department store spanning unrelated household and apparel verticals",
+      "3 - Severe graph pollutant: generic non-brand catch-all tag (e.g. 'Customized & Personalized', 'As Seen on TV', 'US Vintage', 'Eyeshadow') or universal big-box superstore ('Walmart')"
+    ]
+  }
+}
diff --git a/fixture/demo/decision_models/scripts/cases/b_bridge_purification/run.py b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/run.py
new file mode 100644
index 000000000..cb2320eea
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/b_bridge_purification/run.py
@@ -0,0 +1,316 @@
+"""Case B (Purify): remove non-brand hubs from the MerRec brand graph before Jaccard, Leiden and betweenness.
+
+The probe ranks the top 120 bridge brands of `31_world_bridges.sql` for one
+time window, the decision model classifies each entry into `brand_ontology`,
+and the recompute rebuilds the graph without the entries outside the `accept`
+band. Two controls run beside it: the original ranking filtered after the fact
+to accepted entries, and the same recompute driven by the hand-written
+`control_denylist.json`.
+
+Run from `fixture/demo/decision_models/scripts`, one GPU run at a time, with a
+distinct `--label` per window (it names the capture and the engine tables):
+
+    eval "$(grep -E '^export (JEV_API_URL|JEV_API_KEY)=' ~/.bashrc)"
+    flock /tmp/decision-demo-gpu.lock python3 cases/b_bridge_purification/run.py --mode live --label all --passes 2
+    flock /tmp/decision-demo-gpu.lock python3 cases/b_bridge_purification/run.py --mode live --label sep_oct --passes 2 \\
+        --window-start 2023-09-01 --window-end 2023-11-01
+
+Replay serves every decision from the registry or the live capture with zero
+API calls; pass the same window flags as the live run:
+
+    flock /tmp/decision-demo-gpu.lock python3 cases/b_bridge_purification/run.py --mode replay --label all --passes 2
+    flock /tmp/decision-demo-gpu.lock python3 cases/b_bridge_purification/run.py --mode replay --label sep_oct --passes 2 \\
+        --window-start 2023-09-01 --window-end 2023-11-01
+    python3 cases/b_bridge_purification/compare_captures.py all sep_oct
+
+`--passes N` repeats the loop: the recompute of pass k-1 is the probe of
+pass k (the same `03_recompute.sql` statement over all decisions so far), its
+top 120 entries not decided yet go to the backend, and the engine table holds
+the bands of every pass. Pass the same `--passes` to the replay. The denylist
+control uses pass 1; the review queue, band counts and kind counts cover
+every pass. `--with-canonical` adds the
+recompute through case A's `registry/brand_canonical.engine.parquet` when that
+file exists.
+
+The entity state holds only window-invariant catalog context (name, footprint,
+top categories, sample titles). Graph metrics stay out of it so that the same
+brand hashes to the same registry key in every window, and a new window calls
+the backend only for brands no earlier window has decided.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from datetime import datetime
+import json
+from pathlib import Path
+import sys
+
+import pyarrow as pa
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+from client.capture import merrec_license  # noqa: E402
+from client.case import Case, build_parser  # noqa: E402
+from client.decision_client import Entity  # noqa: E402
+from client.policy import BANDS  # noqa: E402
+
+CASE_DIR = Path(__file__).resolve().parent
+ONTOLOGY_TABLE = "brand_ontology"
+DENYLIST_TABLE = "brand_denylist"
+CANONICAL_TABLE = "brand_canonical"
+NATIVE_STAGES = ("probe", "recompute", "recompute_denylist", "recompute_canonical")
+
+
+def parse_args():
+    parser = build_parser(__doc__.splitlines()[0])
+    parser.add_argument("--window-start", default="2023-05-01", help="inclusive event_time lower bound")
+    parser.add_argument("--window-end", default="2023-11-01", help="exclusive event_time upper bound")
+    parser.add_argument("--passes", type=int, default=1,
+                        help="probe, decide and recompute rounds; pass k probes the graph purified by passes before it")
+    parser.add_argument("--with-canonical", action="store_true",
+                        help="also recompute through case A's brand_canonical table when it exists")
+    args = parser.parse_args()
+    try:
+        start, end = datetime.fromisoformat(args.window_start), datetime.fromisoformat(args.window_end)
+    except ValueError as error:
+        parser.error(f"window bounds must be ISO dates or timestamps: {error}")
+    if args.passes < 1:
+        parser.error("--passes must be at least 1")
+    if start >= end:
+        parser.error("--window-start must be before --window-end")
+    return args
+
+
+def render(sql: str, **values: str) -> str:
+    for name, value in values.items():
+        sql = sql.replace("{" + name + "}", value)
+    return sql
+
+
+def require_native(stage) -> None:
+    boundaries = (stage.execution or {}).get("host_datafusion_boundary_count")
+    if boundaries != 0:
+        print(json.dumps({"stage": stage.name, "host_datafusion_boundary_count": boundaries,
+                          "explain": stage.explain, "execution": stage.execution}), file=sys.stderr)
+        raise SystemExit(f"stage {stage.name} did not run fully native; see the EXPLAIN summary above")
+
+
+def check_replay_run(case: Case, window: dict) -> None:
+    live = case.capture_path("live")
+    if case.args.mode != "replay" or not live.exists():
+        return
+    with open(live, encoding="utf-8") as handle:
+        results = json.load(handle).get("results") or {}
+    recorded = results.get("window")
+    if recorded and recorded != window:
+        raise SystemExit(f"live capture {live.name} used window {recorded}; pass the same --window-start/--window-end")
+    passes = results.get("passes_requested", 1)
+    if passes != case.args.passes:
+        raise SystemExit(f"live capture {live.name} requested {passes} pass(es); pass --passes {passes}")
+
+
+def state_text(row: dict, context: dict) -> str:
+    categories = [f"{context[f'cat{i}']} ({context[f'cat{i}_listings']})" for i in range(1, 4) if context.get(f"cat{i}")]
+    titles = [context[f"title{i}"] for i in range(1, 5) if context.get(f"title{i}")]
+    avg_price = context.get("avg_price")
+    return (
+        f"Brand Entry Name: {row['brand_name']} (brand_id={row['brand_id']})\n"
+        f"Catalog Footprint: {context.get('total_listings', 0)} listings across "
+        f"{context.get('distinct_c0', 0)} top-level categories and {context.get('distinct_c1', 0)} subcategories "
+        f"(avg price=${0.0 if avg_price is None else avg_price:.2f})\n"
+        f"Top Categories: {'; '.join(categories)}\n"
+        f"Sample Item Titles: {' | '.join(titles)}"
+    )
+
+
+def ranks(rows: list[dict]) -> dict[int, int]:
+    return {row["brand_id"]: rank for rank, row in enumerate(rows, 1)}
+
+
+def ranking_rows(original: list[dict], purified: list[dict], denied: list[dict], decisions: dict, bands: dict) -> list:
+    original_rank = ranks(original)
+    postfilter_rank = ranks([row for row in original if bands[str(row["brand_id"])] == "accept"])
+    purified_rank = ranks(purified)
+    denylist_rank = ranks(denied)
+    original_by_id = {row["brand_id"]: row for row in original}
+    purified_by_id = {row["brand_id"]: row for row in purified}
+    names = {row["brand_id"]: row["brand_name"] for row in (*denied, *purified, *original)}
+    table = []
+    for brand_id in names:
+        decision = decisions.get(str(brand_id))
+        before = original_by_id.get(brand_id, {}).get("betweenness")
+        after = purified_by_id.get(brand_id, {}).get("betweenness")
+        table.append({
+            "brand_id": brand_id,
+            "name": names[brand_id],
+            "band": bands.get(str(brand_id)),
+            "entity_kind": decision.value("entity_kind") if decision else None,
+            "is_standalone_brand": decision.value("is_standalone_brand") if decision else None,
+            "wormhole_pollution": decision.value("wormhole_pollution") if decision else None,
+            "original_rank": original_rank.get(brand_id),
+            "original_betweenness": before,
+            "postfilter_rank": postfilter_rank.get(brand_id),
+            "purified_rank": purified_rank.get(brand_id),
+            "purified_betweenness": after,
+            "betweenness_multiplier": after / before if before and after is not None else None,
+            "denylist_rank": denylist_rank.get(brand_id),
+        })
+    unranked = float("inf")
+    table.sort(key=lambda row: tuple(unranked if row[key] is None else row[key]
+                                     for key in ("purified_rank", "original_rank", "denylist_rank")))
+    return table
+
+
+def context_summary(context: dict) -> dict:
+    return {key: context.get(key) for key in (
+        "total_listings", "distinct_c0", "distinct_c1", "avg_price", "cat1", "cat1_listings")}
+
+
+def band_counts(bands: dict, keys) -> dict[str, int]:
+    counts = {band: 0 for band in BANDS}
+    for key in keys:
+        counts[bands[key]] += 1
+    return counts
+
+
+def main() -> None:
+    args = parse_args()
+    window = {"start": args.window_start, "end": args.window_end}
+    case = Case(CASE_DIR, args, license=merrec_license())
+    check_replay_run(case, window)
+    case.capture.result("window", window)
+    case.capture.result("passes_requested", args.passes)
+    case.algeon.register_merrec()
+    suffix = f"_{args.label}" if args.label else ""
+    window_values = {"window_start": args.window_start, "window_end": args.window_end}
+    recompute_sql = case.sql("03_recompute.sql")
+    registry = case.registry(ONTOLOGY_TABLE)
+
+    probe = case.run_stage("probe", render(case.sql("01_probe.sql"), **window_values))
+    require_native(probe)
+    original = probe.table.to_pylist()[:args.max_entities]
+    candidates = original
+    decisions = {}
+    bands: dict[str, str] = {}
+    ids_in_order: list[int] = []
+    judged_in: dict[int, tuple[int, int]] = {}
+    contexts_all: dict = {}
+    names_all: dict[int, str] = {}
+    passes = []
+    first_bands: dict[str, str] = {}
+    denied: list[dict] = []
+    for number in range(1, args.passes + 1):
+        tag = "" if number == 1 else f"_pass{number}"
+        ids = [row["brand_id"] for row in candidates]
+        new_ids = [brand_id for brand_id in ids if str(brand_id) not in decisions]
+        if not new_ids:
+            case.capture.note(f"pass {number}: every probe entry was decided in an earlier pass; stopped")
+            break
+        context_stage = case.run_stage(f"context{tag}", render(
+            case.sql("02_context.sql"), brand_ids=", ".join(str(brand_id) for brand_id in ids)))
+        contexts = {row["brand_id"]: row for row in context_stage.table.to_pylist()}
+        contexts_all.update(contexts)
+        names_all.update({row["brand_id"]: row["brand_name"] for row in candidates})
+        probe_rank = ranks(candidates)
+        entities = [Entity(str(row["brand_id"]), state_text(row, contexts.get(row["brand_id"], {})))
+                    for row in candidates]
+        batch = case.decide(registry, entities, name=f"decide{tag}")
+        pass_bands, _ = case.policy.apply(batch.decisions)
+        for decision in batch.decisions:
+            if decision.entity_key not in decisions:
+                ids_in_order.append(int(decision.entity_key))
+                judged_in[int(decision.entity_key)] = (number, probe_rank[int(decision.entity_key)])
+            decisions[decision.entity_key] = decision
+        bands.update(pass_bands)
+
+        union = [decisions[str(brand_id)] for brand_id in ids_in_order]
+        ontology = registry.engine_table(union, {"brand_id": pa.array(ids_in_order, pa.int64())})
+        ontology = ontology.append_column(
+            "band", pa.array([bands[str(brand_id)] for brand_id in ids_in_order], pa.string()))
+        case.decision_table(ONTOLOGY_TABLE, ontology, f"{ONTOLOGY_TABLE}{suffix}.engine.parquet")
+
+        purified_stage = case.run_stage(f"recompute{tag}", render(
+            recompute_sql, ontology_table=ONTOLOGY_TABLE, **window_values))
+        require_native(purified_stage)
+        purified = purified_stage.table.to_pylist()
+
+        if number == 1:
+            first_bands = pass_bands
+            denylist_spec = case.load_json("control_denylist.json")
+            denylist = {name for names in denylist_spec.values() for name in names}
+            denylist_table = pa.table({
+                "brand_id": pa.array(ids, pa.int64()),
+                "band": pa.array(["reject" if row["brand_name"] in denylist else "accept" for row in original],
+                                 pa.string()),
+            })
+            case.decision_table(DENYLIST_TABLE, denylist_table, f"{DENYLIST_TABLE}{suffix}.engine.parquet")
+            denied_stage = case.run_stage("recompute_denylist",
+                                          render(recompute_sql, ontology_table=DENYLIST_TABLE, **window_values))
+            require_native(denied_stage)
+            denied = denied_stage.table.to_pylist()
+
+        passes.append({
+            "pass": number,
+            "probe": [{"rank": rank, "brand_id": row["brand_id"], "name": row["brand_name"],
+                       "betweenness": row["betweenness"]} for rank, row in enumerate(candidates, 1)],
+            "new_entries": len(new_ids),
+            "new_band_counts": band_counts(bands, (str(brand_id) for brand_id in new_ids)),
+            "registry_hits": batch.summary["registry_hits"],
+            "api_calls": batch.summary["api_calls"],
+            "ranking": ranking_rows(original, purified, denied, decisions, bands),
+        })
+        candidates = purified[:args.max_entities]
+
+    canonical_path = args.registry_dir / f"{CANONICAL_TABLE}.engine.parquet"
+    if args.with_canonical and canonical_path.exists():
+        case.algeon.register_parquet(CANONICAL_TABLE, canonical_path)
+        canonical_stage = case.run_stage("recompute_canonical", render(
+            case.sql("04_recompute_canonical.sql"), ontology_table=ONTOLOGY_TABLE, **window_values))
+        require_native(canonical_stage)
+        case.capture.result("canonical_ranking", [
+            {"canonical_rank": rank, "brand_id": row["brand_id"], "name": row["brand_name"],
+             "betweenness": row["betweenness"], "neighbors": row["neighbors"], "worlds_reached": row["worlds_reached"]}
+            for rank, row in enumerate(canonical_stage.table.to_pylist(), 1)])
+    elif args.with_canonical:
+        case.capture.note(f"canonical recompute skipped: {canonical_path.name} does not exist (case A has not run)")
+    else:
+        case.capture.note("canonical recompute not requested (--with-canonical)")
+
+    names = {str(row["brand_id"]): row["brand_name"] for row in original}
+    original_rank = ranks(original)
+    model_excluded = {names[key] for key, band in first_bands.items() if band != "accept"}
+    denylist_excluded = {row["brand_name"] for row in original if row["brand_name"] in denylist}
+    case.capture.result("ranking", passes[-1]["ranking"])
+    case.capture.result("passes", passes)
+    case.capture.result("band_counts", band_counts(bands, bands))
+    case.capture.result("kind_counts", dict(sorted(Counter(
+        decision.value("entity_kind") for decision in decisions.values()).items())))
+    case.capture.result("review_queue", [
+        {"brand_id": brand_id, "name": names_all[brand_id], "pass": judged_in[brand_id][0],
+         "probe_rank": judged_in[brand_id][1], "original_rank": original_rank.get(brand_id),
+         "entity_kind": decisions[str(brand_id)].value("entity_kind"),
+         "entity_kind_p": decisions[str(brand_id)].probability("entity_kind"),
+         "is_standalone_brand": decisions[str(brand_id)].value("is_standalone_brand"),
+         "wormhole_pollution": decisions[str(brand_id)].value("wormhole_pollution"),
+         "context": context_summary(contexts_all.get(brand_id, {}))}
+        for brand_id in ids_in_order if bands[str(brand_id)] == "review"])
+    case.capture.result("denylist_vs_model", {
+        "denylist_size": len(denylist),
+        "denylist_matched": len(denylist_excluded),
+        "denylist_unmatched": sorted(denylist - denylist_excluded),
+        "model_excluded": len(model_excluded),
+        "overlap": len(model_excluded & denylist_excluded),
+        "only_denylist": sorted(denylist_excluded - model_excluded),
+        "only_model": sorted(model_excluded - denylist_excluded),
+    })
+    case.capture.result("decisions", [
+        {"brand_id": brand_id, "name": names_all[brand_id], "pass": judged_in[brand_id][0],
+         "band": bands[str(brand_id)], "content_hash": decisions[str(brand_id)].content_hash,
+         "model_id": decisions[str(brand_id)].model_id, "answers": decisions[str(brand_id)].answers}
+        for brand_id in ids_in_order])
+    case.finish()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/01_probe.sql b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/01_probe.sql
new file mode 100644
index 000000000..834afa177
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/01_probe.sql
@@ -0,0 +1,47 @@
+WITH assignments AS (
+  -- The cluster id rides in the dataset id (id * 32 + cluster_id) so the kmeans CTE is read once;
+  -- a second reference would be inlined and refit, and refits can assign rows differently.
+  SELECT id, cluster_id
+  FROM cuvs_kmeans(
+    input => (SELECT v.id, v.vector
+      FROM semantic_reviews_vectors v
+      JOIN semantic_reviews_text r ON r.id = v.id
+      WHERE r.category_l3 = 'Headphones & Earbuds'
+      ORDER BY v.id),
+    n_clusters => 24, n_init => 5, max_iter => 100, tol => 0.0001)
+), neighbors AS (
+  SELECT query_id, neighbor_id / 32 AS neighbor_review, neighbor_id % 32 AS neighbor_cluster, distance
+  FROM cuvs_brute_force_knn(
+    dataset => (SELECT a.id * 32 + a.cluster_id AS id, v.vector
+      FROM assignments a
+      JOIN semantic_reviews_vectors v ON v.id = a.id),
+    queries => (SELECT v.id, v.vector
+      FROM semantic_reviews_vectors v
+      JOIN semantic_reviews_text r ON r.id = v.id
+      WHERE r.category_l3 = 'Headphones & Earbuds'
+      ORDER BY v.id),
+    k => 64, metric => 'l2_expanded')
+), labeled AS (
+  SELECT query_id, neighbor_review, neighbor_cluster, distance,
+         MAX(CASE WHEN neighbor_review = query_id THEN neighbor_cluster END)
+           OVER (PARTITION BY query_id) AS own_cluster
+  FROM neighbors
+), density AS (
+  SELECT query_id AS id, CAST(own_cluster AS INT) AS cluster_id,
+         SUM(CASE WHEN neighbor_cluster = own_cluster AND neighbor_review <> query_id THEN 1 ELSE 0 END)
+           AS same_cluster_neighbors,
+         AVG(CASE WHEN neighbor_cluster = own_cluster AND neighbor_review <> query_id THEN distance END)
+           AS mean_distance
+  FROM labeled
+  GROUP BY query_id, own_cluster
+), ranked AS (
+  -- Centroids are not returned by cuvs_kmeans, so the densest same-cluster region stands in for the
+  -- center; a review needs half of its 64 neighbors in its own cluster to count as interior.
+  SELECT id, cluster_id, same_cluster_neighbors, mean_distance,
+         CASE WHEN same_cluster_neighbors >= 32 THEN 0 ELSE 1 END AS border
+  FROM density
+)
+SELECT id, cluster_id, same_cluster_neighbors, mean_distance,
+       ROW_NUMBER() OVER (PARTITION BY cluster_id ORDER BY border, mean_distance, id) AS density_rank
+FROM ranked
+ORDER BY cluster_id, density_rank
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/02_context.sql b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/02_context.sql
new file mode 100644
index 000000000..4ac0a1c1b
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/02_context.sql
@@ -0,0 +1,15 @@
+WITH cluster_stats AS (
+  SELECT c.cluster_id, COUNT(*) AS cluster_size, COUNT(DISTINCT r.product_id) AS cluster_products
+  FROM review_clusters c
+  JOIN semantic_reviews_text r ON r.id = c.id
+  GROUP BY c.cluster_id
+)
+SELECT r.id, c.cluster_id, p.title AS product_title, r.rating, r.verified_purchase,
+       r.title AS review_title, SUBSTR(r.text, 1, 1500) AS review_text,
+       CHARACTER_LENGTH(r.text) AS text_chars, s.cluster_size, s.cluster_products
+FROM semantic_reviews_text r
+JOIN review_clusters c ON c.id = r.id
+JOIN cluster_stats s ON s.cluster_id = c.cluster_id
+JOIN products p ON p.product_id = r.product_id
+WHERE r.id IN ({review_ids})
+ORDER BY r.id
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/03_recompute.sql b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/03_recompute.sql
new file mode 100644
index 000000000..c17e4c40b
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/03_recompute.sql
@@ -0,0 +1,25 @@
+WITH labeled AS (
+  -- Per-review labels escalated from mixed clusters take precedence over the cluster label.
+  SELECT s.id, s.product_id, EXTRACT(YEAR FROM s.review_time) AS review_year,
+         COALESCE(e.defect_actionable, l.defect_actionable) AS defect_actionable
+  FROM review_clusters c
+  JOIN semantic_reviews_text s ON s.id = c.id
+  JOIN cluster_labels l ON l.cluster_id = c.cluster_id
+  LEFT JOIN review_causes e ON e.id = c.id AND e.label_source = 'escalated'
+), per_product AS (
+  SELECT product_id,
+         SUM(CASE WHEN review_year = 2021 AND defect_actionable THEN 1 ELSE 0 END) AS n2021,
+         SUM(CASE WHEN review_year = 2021 THEN 1 ELSE 0 END) AS total2021,
+         SUM(CASE WHEN review_year = 2022 AND defect_actionable THEN 1 ELSE 0 END) AS n2022,
+         SUM(CASE WHEN review_year = 2022 THEN 1 ELSE 0 END) AS total2022
+  FROM labeled
+  GROUP BY product_id
+)
+SELECT t.product_id, p.title, t.n2021, t.total2021, t.n2022, t.total2022,
+       100.0 * t.n2021 / t.total2021 AS share2021_pct,
+       100.0 * t.n2022 / t.total2022 AS share2022_pct,
+       100.0 * t.n2022 / t.total2022 - 100.0 * t.n2021 / t.total2021 AS change_pp
+FROM per_product t
+JOIN products p ON p.product_id = t.product_id
+WHERE t.total2021 >= 30 AND t.total2022 >= 30 AND t.n2022 >= 10
+ORDER BY change_pp DESC, t.product_id
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/04_product_cause_shares.sql b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/04_product_cause_shares.sql
new file mode 100644
index 000000000..10bab87a9
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/04_product_cause_shares.sql
@@ -0,0 +1,25 @@
+WITH labeled AS (
+  SELECT s.id, s.product_id, EXTRACT(YEAR FROM s.review_time) AS review_year,
+         COALESCE(e.complaint_cause, l.label) AS cause
+  FROM review_clusters c
+  JOIN semantic_reviews_text s ON s.id = c.id
+  JOIN cluster_labels l ON l.cluster_id = c.cluster_id
+  LEFT JOIN review_causes e ON e.id = c.id AND e.label_source = 'escalated'
+), per_cause AS (
+  SELECT product_id, cause,
+         SUM(CASE WHEN review_year = 2021 THEN 1 ELSE 0 END) AS n2021,
+         SUM(CASE WHEN review_year = 2022 THEN 1 ELSE 0 END) AS n2022
+  FROM labeled
+  GROUP BY product_id, cause
+), totals AS (
+  SELECT *, SUM(n2021) OVER (PARTITION BY product_id) AS total2021,
+            SUM(n2022) OVER (PARTITION BY product_id) AS total2022
+  FROM per_cause
+)
+SELECT product_id, cause, n2021, total2021, n2022, total2022,
+       100.0 * n2021 / total2021 AS share2021_pct,
+       100.0 * n2022 / total2022 AS share2022_pct,
+       100.0 * n2022 / total2022 - 100.0 * n2021 / total2021 AS change_pp
+FROM totals
+WHERE total2021 >= 30 AND total2022 >= 30
+ORDER BY product_id, cause
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/05_cause_shares.sql b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/05_cause_shares.sql
new file mode 100644
index 000000000..ed839efae
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/05_cause_shares.sql
@@ -0,0 +1,22 @@
+WITH labeled AS (
+  SELECT s.id, EXTRACT(YEAR FROM s.review_time) AS review_year,
+         COALESCE(e.complaint_cause, l.label) AS cause,
+         CASE WHEN e.id IS NULL THEN 'cluster' ELSE 'escalated' END AS label_source
+  FROM review_clusters c
+  JOIN semantic_reviews_text s ON s.id = c.id
+  JOIN cluster_labels l ON l.cluster_id = c.cluster_id
+  LEFT JOIN review_causes e ON e.id = c.id AND e.label_source = 'escalated'
+), per_cause AS (
+  SELECT cause,
+         SUM(CASE WHEN review_year = 2021 THEN 1 ELSE 0 END) AS n2021,
+         SUM(CASE WHEN review_year = 2022 THEN 1 ELSE 0 END) AS n2022,
+         SUM(CASE WHEN label_source = 'escalated' THEN 1 ELSE 0 END) AS escalated_reviews
+  FROM labeled
+  GROUP BY cause
+)
+SELECT cause, n2021, 100.0 * n2021 / SUM(n2021) OVER () AS share2021_pct,
+       n2022, 100.0 * n2022 / SUM(n2022) OVER () AS share2022_pct,
+       100.0 * n2022 / SUM(n2022) OVER () - 100.0 * n2021 / SUM(n2021) OVER () AS change_pp,
+       escalated_reviews
+FROM per_cause
+ORDER BY cause
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/06_anonymous_ranking.sql b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/06_anonymous_ranking.sql
new file mode 100644
index 000000000..b23b06068
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/06_anonymous_ranking.sql
@@ -0,0 +1,28 @@
+WITH assignments AS (
+  -- 03_headphone_emerging.sql with the kmeans call replaced by the saved assignment table.
+  SELECT id, cluster_id FROM review_clusters
+), issues AS (
+  SELECT r.product_id, a.cluster_id,
+         SUM(CASE WHEN EXTRACT(YEAR FROM r.review_time) = 2021 THEN 1 ELSE 0 END) AS n2021,
+         SUM(CASE WHEN EXTRACT(YEAR FROM r.review_time) = 2022 THEN 1 ELSE 0 END) AS n2022,
+         MIN(CASE WHEN EXTRACT(YEAR FROM r.review_time) = 2022 THEN r.id END) AS example_id
+  FROM assignments a JOIN semantic_reviews_text r ON r.id = a.id
+  GROUP BY r.product_id, a.cluster_id
+), totals AS (
+  SELECT *, SUM(n2021) OVER (PARTITION BY product_id) AS total2021,
+            SUM(n2022) OVER (PARTITION BY product_id) AS total2022
+  FROM issues
+)
+SELECT p.product_id, p.title, t.cluster_id,
+       t.n2021, t.total2021, t.n2022, t.total2022,
+       100.0 * t.n2021 / t.total2021 AS share2021_pct,
+       100.0 * t.n2022 / t.total2022 AS share2022_pct,
+       100.0 * t.n2022 / t.total2022 - 100.0 * t.n2021 / t.total2021 AS change_pp,
+       t.example_id, r.embedding_text AS example_review
+FROM totals t
+JOIN products p ON p.product_id = t.product_id
+JOIN semantic_reviews_text r ON r.id = t.example_id
+WHERE t.total2021 >= 30 AND t.total2022 >= 30 AND t.n2022 >= 10
+  AND 1.0 * t.n2022 / t.total2022 - 1.0 * t.n2021 / t.total2021 > 0.10
+ORDER BY change_pp DESC, p.product_id, t.cluster_id
+LIMIT 10
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/07_low_rating_ranking.sql b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/07_low_rating_ranking.sql
new file mode 100644
index 000000000..6631754e8
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/07_low_rating_ranking.sql
@@ -0,0 +1,27 @@
+WITH qualifying AS (
+  -- Star ratings only: share of rating <= 2 among all reviews of each qualifying product.
+  SELECT s.product_id
+  FROM review_clusters c
+  JOIN semantic_reviews_text s ON s.id = c.id
+  GROUP BY s.product_id
+  HAVING SUM(CASE WHEN EXTRACT(YEAR FROM s.review_time) = 2021 THEN 1 ELSE 0 END) >= 30
+     AND SUM(CASE WHEN EXTRACT(YEAR FROM s.review_time) = 2022 THEN 1 ELSE 0 END) >= 30
+), yearly AS (
+  SELECT r.product_id,
+         SUM(CASE WHEN r.review_time < TIMESTAMP '2022-01-01 00:00:00' AND r.rating <= 2 THEN 1 ELSE 0 END) AS low2021,
+         SUM(CASE WHEN r.review_time < TIMESTAMP '2022-01-01 00:00:00' THEN 1 ELSE 0 END) AS reviews2021,
+         SUM(CASE WHEN r.review_time >= TIMESTAMP '2022-01-01 00:00:00' AND r.rating <= 2 THEN 1 ELSE 0 END) AS low2022,
+         SUM(CASE WHEN r.review_time >= TIMESTAMP '2022-01-01 00:00:00' THEN 1 ELSE 0 END) AS reviews2022
+  FROM reviews r
+  JOIN qualifying q ON q.product_id = r.product_id
+  WHERE r.review_time >= TIMESTAMP '2021-01-01 00:00:00'
+    AND r.review_time < TIMESTAMP '2023-01-01 00:00:00'
+  GROUP BY r.product_id
+)
+SELECT y.product_id, p.title, y.low2021, y.reviews2021, y.low2022, y.reviews2022,
+       100.0 * y.low2021 / y.reviews2021 AS share2021_pct,
+       100.0 * y.low2022 / y.reviews2022 AS share2022_pct,
+       100.0 * y.low2022 / y.reviews2022 - 100.0 * y.low2021 / y.reviews2021 AS change_pp
+FROM yearly y
+JOIN products p ON p.product_id = y.product_id
+ORDER BY change_pp DESC, y.product_id
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/08_helpful_weighted.sql b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/08_helpful_weighted.sql
new file mode 100644
index 000000000..c241da454
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/08_helpful_weighted.sql
@@ -0,0 +1,31 @@
+WITH labeled AS (
+  -- 03_recompute.sql with each review weighted by 1 + helpful_vote; sample ids are reviews.review_id.
+  SELECT s.id, s.product_id, EXTRACT(YEAR FROM s.review_time) AS review_year,
+         COALESCE(e.defect_actionable, l.defect_actionable) AS defect_actionable,
+         1 + v.helpful_vote AS weight
+  FROM review_clusters c
+  JOIN semantic_reviews_text s ON s.id = c.id
+  JOIN reviews v ON v.review_id = s.id
+  JOIN cluster_labels l ON l.cluster_id = c.cluster_id
+  LEFT JOIN review_causes e ON e.id = c.id AND e.label_source = 'escalated'
+), per_product AS (
+  SELECT product_id,
+         SUM(CASE WHEN review_year = 2021 AND defect_actionable THEN 1 ELSE 0 END) AS n2021,
+         SUM(CASE WHEN review_year = 2021 THEN 1 ELSE 0 END) AS total2021,
+         SUM(CASE WHEN review_year = 2022 AND defect_actionable THEN 1 ELSE 0 END) AS n2022,
+         SUM(CASE WHEN review_year = 2022 THEN 1 ELSE 0 END) AS total2022,
+         SUM(CASE WHEN review_year = 2021 AND defect_actionable THEN weight ELSE 0 END) AS w2021,
+         SUM(CASE WHEN review_year = 2021 THEN weight ELSE 0 END) AS wtotal2021,
+         SUM(CASE WHEN review_year = 2022 AND defect_actionable THEN weight ELSE 0 END) AS w2022,
+         SUM(CASE WHEN review_year = 2022 THEN weight ELSE 0 END) AS wtotal2022
+  FROM labeled
+  GROUP BY product_id
+)
+SELECT t.product_id, p.title, t.n2022, t.total2021, t.total2022, t.w2021, t.wtotal2021, t.w2022, t.wtotal2022,
+       100.0 * t.w2021 / t.wtotal2021 AS share2021_pct,
+       100.0 * t.w2022 / t.wtotal2022 AS share2022_pct,
+       100.0 * t.w2022 / t.wtotal2022 - 100.0 * t.w2021 / t.wtotal2021 AS change_pp
+FROM per_product t
+JOIN products p ON p.product_id = t.product_id
+WHERE t.total2021 >= 30 AND t.total2022 >= 30 AND t.n2022 >= 10
+ORDER BY change_pp DESC, t.product_id
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/09_safety_clusters.sql b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/09_safety_clusters.sql
new file mode 100644
index 000000000..b7567bf6e
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/09_safety_clusters.sql
@@ -0,0 +1,21 @@
+WITH members AS (
+  SELECT c.cluster_id, s.product_id
+  FROM review_clusters c
+  JOIN semantic_reviews_text s ON s.id = c.id
+  JOIN cluster_labels l ON l.cluster_id = c.cluster_id
+  WHERE l.mean_safety_hazard >= 0.50
+), per_product AS (
+  SELECT cluster_id, product_id, COUNT(*) AS reviews
+  FROM members
+  GROUP BY cluster_id, product_id
+), ranked AS (
+  SELECT *, ROW_NUMBER() OVER (PARTITION BY cluster_id ORDER BY reviews DESC, product_id) AS product_rank
+  FROM per_product
+)
+SELECT l.cluster_id, l.label, l.consistency, l.size, l.mean_safety_hazard, l.mean_severity,
+       r.product_rank, r.product_id, p.title, r.reviews
+FROM ranked r
+JOIN cluster_labels l ON l.cluster_id = r.cluster_id
+JOIN products p ON p.product_id = r.product_id
+WHERE r.product_rank <= 3
+ORDER BY l.mean_safety_hazard DESC, l.cluster_id, r.product_rank
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/compare_captures.py b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/compare_captures.py
new file mode 100644
index 000000000..1a5f9e3d3
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/compare_captures.py
@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""Compare a live and a replay capture of case C; exit 1 at the first difference.
+
+Usage: python3 compare_captures.py <live.json> <replay.json>
+
+Ignored: timestamps, timings, query ids, the environment, the mode and the
+replay sources. The top-level requested `model` is skipped (replay has none;
+the answered `model_ids` are still compared). The decision batches' counters
+(`backend`, `api_calls`, `registry_hits`, `hit_rate`, `backend_calls`,
+`input_tokens`, `output_tokens`, `cost_usd`) depend on how many answers the registry served,
+so they are not compared, as in cases A and B; every replay batch must still
+report zero API calls. Each recorded response is compared on its entity key,
+model id, answers and input tokens; `source`, the raw `response`,
+`output_tokens` and `cost_usd` are null for a registry-served decision.
+
+Stages are matched by name. A stage missing from one capture is accepted only
+when that capture lists it in `results.skipped_stages`, which `--reuse-clusters`
+does for the kmeans probe.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+
+IGNORED_KEYS = {
+    "decided_at", "started_at", "finished_at", "elapsed_s", "wall_s", "admission_wait_ms", "query_id",
+    "environment", "mode", "replay_sources",
+}
+MODE_KEYS = {("model",)}
+# A live run counts registry hits, backend calls, tokens and cost against the backend it used; a replay
+# counts them against the replay backend and its own fresh registry, so the batch counters are not compared.
+COUNTER_KEYS = {"backend", "api_calls", "registry_hits", "hit_rate", "backend_calls", "input_tokens", "output_tokens", "cost_usd"}
+RESPONSE_UNCOMPARED = {"source", "response", "output_tokens", "cost_usd"}
+
+
+class Difference(Exception):
+    pass
+
+
+def ignored(path: tuple, key: str) -> bool:
+    if key in IGNORED_KEYS or key.startswith("latency_") or key.endswith(("_elapsed_s", "_wall_s")):
+        return True
+    if len(path) == 2 and path[0] == "responses" and key in RESPONSE_UNCOMPARED:
+        return True
+    if path[:1] in (("decisions",), ("totals",)) and key in COUNTER_KEYS:
+        return True
+    generic = tuple("*" if isinstance(part, int) else part for part in (*path, key))
+    return generic in MODE_KEYS
+
+
+def compare(left, right, path: tuple = ()) -> None:
+    where = "/".join(map(str, path)) or "<root>"
+    if isinstance(left, dict) and isinstance(right, dict):
+        for key in sorted(set(left) | set(right)):
+            if ignored(path, key):
+                continue
+            if key not in left or key not in right:
+                raise Difference(f"{where}/{key}: present only in the {'live' if key in left else 'replay'} capture")
+            compare(left[key], right[key], (*path, key))
+    elif isinstance(left, list) and isinstance(right, list):
+        if len(left) != len(right):
+            raise Difference(f"{where}: {len(left)} items in live, {len(right)} in replay")
+        for index, (a, b) in enumerate(zip(left, right)):
+            compare(a, b, (*path, index))
+    elif left != right:
+        raise Difference(f"{where}: live {left!r} != replay {right!r}")
+
+
+def compare_stages(live: dict, replay: dict) -> list[str]:
+    left = {stage["name"]: stage for stage in live["stages"]}
+    right = {stage["name"]: stage for stage in replay["stages"]}
+    notes = []
+    for name in sorted(set(left) | set(right)):
+        if name not in right:
+            if name not in (replay.get("results") or {}).get("skipped_stages", []):
+                raise Difference(f"stages/{name}: missing from the replay capture")
+            notes.append(f"stage {name} skipped in replay")
+        elif name not in left:
+            if name not in (live.get("results") or {}).get("skipped_stages", []):
+                raise Difference(f"stages/{name}: missing from the live capture")
+            notes.append(f"stage {name} skipped in live")
+        else:
+            compare(left[name], right[name], ("stages", name))
+    return notes
+
+
+def main() -> int:
+    if len(sys.argv) != 3:
+        print(__doc__.splitlines()[2], file=sys.stderr)
+        return 2
+    with open(sys.argv[1], encoding="utf-8") as handle:
+        live = json.load(handle)
+    with open(sys.argv[2], encoding="utf-8") as handle:
+        replay = json.load(handle)
+    try:
+        for batch in replay.get("decisions", []):
+            if batch.get("api_calls") != 0:
+                raise Difference(f"replay batch {batch.get('name')!r} reports api_calls={batch.get('api_calls')}")
+        notes = compare_stages(live, replay)
+        rest = lambda capture: {key: value for key, value in capture.items() if key != "stages"}
+        live_rest, replay_rest = rest(live), rest(replay)
+        for capture in (live_rest, replay_rest):
+            capture["results"] = {key: value for key, value in capture["results"].items() if key != "skipped_stages"}
+        compare(live_rest, replay_rest)
+    except Difference as difference:
+        print(f"DIFFERENT {difference}")
+        return 1
+    print(f"SAME stages={len(replay['stages'])} decisions={sum(batch['entities'] for batch in replay['decisions'])} "
+          f"results={len(replay['results'])} " + "; ".join(notes))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/control_keywords.sql b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/control_keywords.sql
new file mode 100644
index 000000000..e103aa699
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/control_keywords.sql
@@ -0,0 +1,62 @@
+WITH texts AS (
+  -- Keyword dimensions of 04_inline_kmeans_topk.sql. A review takes the dimension with the most
+  -- matching patterns, ties go to the earlier dimension, and no match gives 'unclassified'.
+  SELECT c.id, LOWER(s.text) AS body
+  FROM review_clusters c
+  JOIN semantic_reviews_text s ON s.id = c.id
+), hits AS (
+  SELECT id, 1 AS position, 'battery' AS dimension,
+         CASE WHEN body LIKE '%battery%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 2 AS position, 'connection' AS dimension,
+         CASE WHEN body LIKE '%connect%' THEN 1 ELSE 0 END
+           + CASE WHEN body LIKE '%bluetooth%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 3 AS position, 'sound' AS dimension,
+         CASE WHEN body LIKE '%sound%' THEN 1 ELSE 0 END
+           + CASE WHEN body LIKE '%volume%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 4 AS position, 'comfort' AS dimension,
+         CASE WHEN body LIKE '%comfort%' THEN 1 ELSE 0 END
+           + CASE WHEN body LIKE '%fit%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 5 AS position, 'durability' AS dimension,
+         CASE WHEN body LIKE '%broke%' THEN 1 ELSE 0 END
+           + CASE WHEN body LIKE '%stopped working%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 6 AS position, 'charging' AS dimension,
+         CASE WHEN body LIKE '%charg%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 7 AS position, 'microphone' AS dimension,
+         CASE WHEN body LIKE '%microphone%' THEN 1 ELSE 0 END
+           + CASE WHEN body LIKE '%mic %' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 8 AS position, 'returns' AS dimension,
+         CASE WHEN body LIKE '%return%' THEN 1 ELSE 0 END
+           + CASE WHEN body LIKE '%refund%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+), ranked AS (
+  SELECT id, dimension, hits, ROW_NUMBER() OVER (PARTITION BY id ORDER BY hits DESC, position) AS place
+  FROM hits
+), keyword AS (
+  SELECT id, CASE WHEN hits = 0 THEN 'unclassified' ELSE dimension END AS keyword_cause
+  FROM ranked
+  WHERE place = 1
+), model AS (
+  SELECT c.id, COALESCE(e.complaint_cause, l.label) AS model_cause
+  FROM review_clusters c
+  JOIN cluster_labels l ON l.cluster_id = c.cluster_id
+  LEFT JOIN review_causes e ON e.id = c.id AND e.label_source = 'escalated'
+)
+SELECT k.keyword_cause, m.model_cause, COUNT(*) AS reviews
+FROM keyword k
+JOIN model m ON m.id = k.id
+GROUP BY k.keyword_cause, m.model_cause
+ORDER BY k.keyword_cause, m.model_cause
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/control_keywords_products.sql b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/control_keywords_products.sql
new file mode 100644
index 000000000..0c64d5cf1
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/control_keywords_products.sql
@@ -0,0 +1,90 @@
+WITH qualifying AS (
+  -- Dominant 2022 keyword dimension (rule of control_keywords.sql, classified reviews only) and
+  -- dominant model cause for each product that passes the 2021 and 2022 volume thresholds.
+  SELECT s.product_id
+  FROM review_clusters c
+  JOIN semantic_reviews_text s ON s.id = c.id
+  GROUP BY s.product_id
+  HAVING SUM(CASE WHEN EXTRACT(YEAR FROM s.review_time) = 2021 THEN 1 ELSE 0 END) >= 30
+     AND SUM(CASE WHEN EXTRACT(YEAR FROM s.review_time) = 2022 THEN 1 ELSE 0 END) >= 30
+), texts AS (
+  SELECT c.id, LOWER(s.text) AS body
+  FROM review_clusters c
+  JOIN semantic_reviews_text s ON s.id = c.id
+  JOIN qualifying q ON q.product_id = s.product_id
+  WHERE EXTRACT(YEAR FROM s.review_time) = 2022
+), hits AS (
+  SELECT id, 1 AS position, 'battery' AS dimension,
+         CASE WHEN body LIKE '%battery%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 2 AS position, 'connection' AS dimension,
+         CASE WHEN body LIKE '%connect%' THEN 1 ELSE 0 END
+           + CASE WHEN body LIKE '%bluetooth%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 3 AS position, 'sound' AS dimension,
+         CASE WHEN body LIKE '%sound%' THEN 1 ELSE 0 END
+           + CASE WHEN body LIKE '%volume%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 4 AS position, 'comfort' AS dimension,
+         CASE WHEN body LIKE '%comfort%' THEN 1 ELSE 0 END
+           + CASE WHEN body LIKE '%fit%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 5 AS position, 'durability' AS dimension,
+         CASE WHEN body LIKE '%broke%' THEN 1 ELSE 0 END
+           + CASE WHEN body LIKE '%stopped working%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 6 AS position, 'charging' AS dimension,
+         CASE WHEN body LIKE '%charg%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 7 AS position, 'microphone' AS dimension,
+         CASE WHEN body LIKE '%microphone%' THEN 1 ELSE 0 END
+           + CASE WHEN body LIKE '%mic %' THEN 1 ELSE 0 END AS hits
+  FROM texts
+  UNION ALL
+  SELECT id, 8 AS position, 'returns' AS dimension,
+         CASE WHEN body LIKE '%return%' THEN 1 ELSE 0 END
+           + CASE WHEN body LIKE '%refund%' THEN 1 ELSE 0 END AS hits
+  FROM texts
+), ranked AS (
+  SELECT id, dimension, hits, ROW_NUMBER() OVER (PARTITION BY id ORDER BY hits DESC, position) AS place
+  FROM hits
+), keyword AS (
+  SELECT id, CASE WHEN hits = 0 THEN 'unclassified' ELSE dimension END AS keyword_cause
+  FROM ranked
+  WHERE place = 1
+), labeled AS (
+  SELECT s.product_id, k.keyword_cause, COALESCE(e.complaint_cause, l.label) AS model_cause
+  FROM keyword k
+  JOIN review_clusters c ON c.id = k.id
+  JOIN semantic_reviews_text s ON s.id = k.id
+  JOIN cluster_labels l ON l.cluster_id = c.cluster_id
+  LEFT JOIN review_causes e ON e.id = k.id AND e.label_source = 'escalated'
+), product_totals AS (
+  SELECT product_id, COUNT(*) AS reviews2022,
+         SUM(CASE WHEN keyword_cause = 'unclassified' THEN 1 ELSE 0 END) AS keyword_unclassified
+  FROM labeled
+  GROUP BY product_id
+), keyword_top AS (
+  SELECT product_id, keyword_cause, reviews,
+         ROW_NUMBER() OVER (PARTITION BY product_id ORDER BY reviews DESC, keyword_cause) AS place
+  FROM (SELECT product_id, keyword_cause, COUNT(*) AS reviews
+        FROM labeled WHERE keyword_cause <> 'unclassified'
+        GROUP BY product_id, keyword_cause) keyword_counts
+), model_top AS (
+  SELECT product_id, model_cause, reviews,
+         ROW_NUMBER() OVER (PARTITION BY product_id ORDER BY reviews DESC, model_cause) AS place
+  FROM (SELECT product_id, model_cause, COUNT(*) AS reviews
+        FROM labeled GROUP BY product_id, model_cause) model_counts
+)
+SELECT t.product_id, t.reviews2022, t.keyword_unclassified,
+       k.keyword_cause, k.reviews AS keyword_reviews, m.model_cause, m.reviews AS model_reviews
+FROM product_totals t
+JOIN model_top m ON m.product_id = t.product_id AND m.place = 1
+LEFT JOIN keyword_top k ON k.product_id = t.product_id AND k.place = 1
+ORDER BY t.product_id
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/policy.json b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/policy.json
new file mode 100644
index 000000000..c84eadb8e
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/policy.json
@@ -0,0 +1,7 @@
+{
+  "action_question": "manufacturer_actionable",
+  "accept_min": 0.70,
+  "review_min": 0.30,
+  "cluster_consistency_min": 0.60,
+  "escalation_cap": 2000
+}
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/questions.json b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/questions.json
new file mode 100644
index 000000000..3f2b06a47
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/questions.json
@@ -0,0 +1,40 @@
+{
+  "complaint_cause": {
+    "type": "choice",
+    "instructions": "The state is one low-rating (1 or 2 star) Amazon review of a headphone or earbud product, with the product title and the size of the group of similar complaints it belongs to. Choose the primary cause of the complaint: the single problem that, had it not occurred, would most likely have kept the reviewer from giving a low rating. Judge from what the reviewer reports, not from the product title.",
+    "criteria": {
+      "product_defect_or_failure": "The unit is broken or failed: dead on arrival, one side or the microphone stopped working, it no longer charges or powers on, a part snapped or peeled, the battery died after weeks, or pairing stopped working after it had worked before.",
+      "performance_below_spec": "The unit works as designed but performs poorly from the start: weak or distorted sound, low volume, short battery life, weak noise cancelling, Bluetooth range or lag problems, or a poor microphone, without a breakdown.",
+      "shipping_packaging_or_delivery": "The problem arose in delivery: the package was late, lost, damaged in transit, previously opened or used, or arrived with parts missing from the box.",
+      "wrong_or_counterfeit_item": "The reviewer received something other than what was listed: a fake or counterfeit of the advertised brand, a different model, version or color, or a refurbished unit sold as new.",
+      "expectation_or_usability_mismatch": "The unit works and performs as advertised but does not suit the reviewer: uncomfortable or poor fit, wrong size, confusing controls or app, incompatibility with the reviewer's device, or features the reviewer misunderstood.",
+      "price_or_service": "The complaint is about value for money, a price change, the seller's or manufacturer's customer service, warranty handling, or the return and refund process."
+    }
+  },
+  "manufacturer_actionable": {
+    "type": "noul",
+    "instructions": "Could the manufacturer of this product prevent the cause of this complaint by changing the product's design, components, factory quality control, firmware, packaging inside the retail box, or documentation?",
+    "criteria": {
+      "true": "The cause lies in the product itself or its documentation, and a change in design, components, quality control, firmware or the manual would prevent it for future buyers.",
+      "false": "The cause lies with the carrier, a marketplace seller, a counterfeiter, the price, or a personal preference the product was never designed to meet; changing the product would not prevent it."
+    }
+  },
+  "safety_hazard": {
+    "type": "noul",
+    "instructions": "Does the review describe a risk of physical harm to a person or property: overheating, burning, smoke, fire, a swollen or leaking battery, electric shock, burns, rashes or allergic reactions, or hearing damage from sudden loud output?",
+    "criteria": {
+      "true": "The review reports such an event or a concrete risk of one.",
+      "false": "No risk of physical harm is described; discomfort from fit or ordinary ear fatigue does not count."
+    }
+  },
+  "severity": {
+    "type": "score",
+    "instructions": "How severe is the impact of the problem on the reviewer?",
+    "criteria": [
+      "0 - minor annoyance; the product remains usable for its purpose",
+      "1 - a main function is impaired but the product is still usable",
+      "2 - the product is unusable for the reviewer or had to be returned or replaced",
+      "3 - physical harm, a safety incident, or damage to another device or property"
+    ]
+  }
+}
diff --git a/fixture/demo/decision_models/scripts/cases/c_complaint_causes/run.py b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/run.py
new file mode 100644
index 000000000..7ef3b9fe1
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/c_complaint_causes/run.py
@@ -0,0 +1,428 @@
+#!/usr/bin/env python3
+"""Case C (Project): complaint causes for the 99,539 low-rating headphone reviews.
+
+The probe fits the 24 kmeans clusters of `03_headphone_emerging.sql`, runs a
+64-neighbor brute-force kNN over the same vectors and ranks each cluster's
+reviews by mean distance to their same-cluster neighbors, all in one statement.
+The full assignment table is saved as `registry/review_clusters.engine.parquet`.
+The 8 densest reviews per cluster (192) are decided on four questions; the
+majority `complaint_cause` labels the cluster. A cluster whose majority share is
+below `cluster_consistency_min` is mixed, and up to `escalation_cap` of its
+densest reviews are decided one by one. Cluster labels, overridden by per-review
+labels for escalated reviews, are joined back onto every review for the
+recompute, the rankings and the keyword control. A holdout of 100 other reviews
+is decided individually to measure agreement with the cluster labels.
+
+Commands, from fixture/demo/decision_models/scripts:
+
+    eval "$(grep -E '^export (JEV_API_URL|JEV_API_KEY)=' ~/.bashrc)"
+    flock /tmp/decision-demo-gpu.lock python3 cases/c_complaint_causes/run.py --mode live
+
+    # second backend on the same 192 representatives, compared with the jev registry
+    flock /tmp/decision-demo-gpu.lock python3 cases/c_complaint_causes/run.py --mode live \\
+        --backend openai_compatible --reuse-clusters --representatives-only
+
+    # replay: an empty registry directory makes every decision come from the live capture
+    flock /tmp/decision-demo-gpu.lock python3 cases/c_complaint_causes/run.py --mode replay \\
+        --reuse-clusters --clusters ../registry/review_clusters.engine.parquet --registry-dir "$(mktemp -d)"
+    python3 cases/c_complaint_causes/compare_captures.py \\
+        ../captures/c_complaint_causes_live.json ../captures/c_complaint_causes_replay.json
+
+Case flags:
+
+    --reuse-clusters        Skip the kmeans and kNN probe and read the saved assignment table. kmeans
+                            cluster sizes drift slightly between fits and cluster ids are query-local,
+                            so a run that must reproduce earlier states (replay, second backend) has to
+                            reuse the saved assignments.
+    --clusters PATH         Assignment table for --reuse-clusters
+                            (default: <registry-dir>/review_clusters.engine.parquet).
+    --representatives-only  Decide the representatives, label the clusters and stop. Required for a
+                            backend other than jev, so its engine tables never replace the jev ones;
+                            that run reports agreement with the jev registry.
+    --holdout-size N        Reviews in the individual holdout check (default 100).
+
+Incremental design (not implemented): cuvs_kmeans returns no centroids, so a new
+month of reviews would be assigned by running cuvs_brute_force_knn with the new
+review vectors as queries against the saved clustered vectors and taking the
+majority cluster id among the k neighbors. Reviews whose neighbor vote is weak,
+or whose nearest distance exceeds the cluster's usual neighbor distance, are
+outliers; only those, and clusters that the vote cannot fill, go to the decision
+backend, and every other new review inherits its cluster label at no API cost.
+"""
+
+from __future__ import annotations
+
+from collections import Counter, defaultdict
+import math
+from pathlib import Path
+import random
+import sys
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+from client.case import Case, build_parser  # noqa: E402
+from client.decision_client import Entity  # noqa: E402
+from client.registry import Registry  # noqa: E402
+
+CASE_DIR = Path(__file__).resolve().parent
+
+
+def native_stage(case: Case, name: str, sql: str):
+    """Run one statement and stop the case when it crossed into DataFusion on the host."""
+    stage = case.run_stage(name, sql)
+    boundaries = (stage.execution or {}).get("host_datafusion_boundary_count")
+    if boundaries != 0:
+        case.capture.note(f"stage {name} reported host_datafusion_boundary_count={boundaries}; "
+                          f"EXPLAIN summary {stage.explain}")
+        case.finish()
+        raise SystemExit(f"stage {name} has host_datafusion_boundary_count={boundaries}; "
+                         f"EXPLAIN summary {stage.explain}")
+    return stage
+REGISTRY = "review_causes"
+DEFECT = "product_defect_or_failure"
+REPRESENTATIVES_PER_CLUSTER = 8
+HOLDOUT_SEED = 20261019
+CONTEXT_CHUNK = 2000
+NUMERIC_QUESTIONS = ("manufacturer_actionable", "safety_hazard", "severity")
+# Coarse mapping used only to score the keyword control against model labels.
+KEYWORD_TO_CAUSE = {
+    "durability": DEFECT,
+    "charging": DEFECT,
+    "connection": DEFECT,
+    "battery": "performance_below_spec",
+    "sound": "performance_below_spec",
+    "microphone": "performance_below_spec",
+    "comfort": "expectation_or_usability_mismatch",
+    "returns": "price_or_service",
+}
+CLUSTER_SCHEMA = pa.schema([
+    ("id", pa.int64()), ("cluster_id", pa.int32()), ("same_cluster_neighbors", pa.int64()),
+    ("mean_distance", pa.float64()), ("density_rank", pa.int64()),
+])
+
+
+def wilson(successes: int, total: int, z: float = 1.959963984540054) -> list[float] | None:
+    if total == 0:
+        return None
+    p = successes / total
+    denominator = 1 + z * z / total
+    center = (p + z * z / (2 * total)) / denominator
+    half = z * math.sqrt(p * (1 - p) / total + z * z / (4 * total * total)) / denominator
+    return [center - half, center + half]
+
+
+def mean(values) -> float | None:
+    values = list(values)
+    return sum(values) / len(values) if values else None
+
+
+def load_clusters(case: Case) -> list[dict]:
+    args = case.args
+    if args.reuse_clusters:
+        path = Path(args.clusters or args.registry_dir / "review_clusters.engine.parquet")
+        table = pq.read_table(path).select(CLUSTER_SCHEMA.names).cast(CLUSTER_SCHEMA)
+        case.algeon.register_parquet("review_clusters", path)
+        case.capture.result("skipped_stages", ["probe"])
+    else:
+        stage = native_stage(case, "probe", case.sql("01_probe.sql"))
+        table = stage.table.select(CLUSTER_SCHEMA.names).cast(CLUSTER_SCHEMA)
+        case.decision_table("review_clusters", table)
+        case.capture.result("skipped_stages", [])
+    rows = table.to_pylist()
+    if any(row["cluster_id"] is None for row in rows):
+        raise SystemExit("probe returned reviews without a cluster; a review lost its self neighbor in the kNN")
+    return rows
+
+
+def fetch_context(case: Case, name: str, ids: list[int]) -> dict[int, dict]:
+    template = case.sql("02_context.sql")
+    ordered = sorted(ids)
+    contexts = {}
+    for start in range(0, len(ordered), CONTEXT_CHUNK):
+        chunk = ordered[start:start + CONTEXT_CHUNK]
+        stage_name = name if len(ordered) <= CONTEXT_CHUNK else f"{name}_{start // CONTEXT_CHUNK + 1}"
+        stage = native_stage(case, stage_name, template.replace("{review_ids}", ", ".join(map(str, chunk))))
+        contexts.update({row["id"]: row for row in stage.table.to_pylist()})
+    missing = set(ordered) - set(contexts)
+    if missing:
+        raise SystemExit(f"context query returned no row for {len(missing)} reviews")
+    return contexts
+
+
+def state(row: dict) -> str:
+    text = row["review_text"] or ""
+    if (row["text_chars"] or 0) > len(text):
+        text += " [truncated]"
+    return "\n".join([
+        f"Product: {row['product_title'] or 'unknown'}",
+        f"Rating: {row['rating']} of 5 stars",
+        f"Verified purchase: {'yes' if row['verified_purchase'] else 'no'}",
+        f"Review title: {row['review_title'] or ''}",
+        f"Review text: {text}",
+        f"Similar complaints: this review belongs to a group of {row['cluster_size']:,} similar low-rating "
+        f"headphone reviews covering {row['cluster_products']:,} products.",
+    ])
+
+
+def decide_reviews(case: Case, registry: Registry, name: str, ids: list[int]):
+    contexts = fetch_context(case, f"context_{name}", ids)
+    entities = [Entity(str(review_id), state(contexts[review_id])) for review_id in sorted(ids)]
+    return case.decide(registry, entities, name=f"decide_{name}")
+
+
+def label_clusters(case: Case, decisions_by_cluster: dict[int, list], sizes: Counter) -> dict[int, dict]:
+    spec = case.policy.spec
+    options = list(case.questions["complaint_cause"]["criteria"])
+    labels = {}
+    for cluster_id in sorted(sizes):
+        decisions = decisions_by_cluster.get(cluster_id, [])
+        counts = Counter(decision.value("complaint_cause") for decision in decisions)
+        probability = defaultdict(float)
+        for decision in decisions:
+            probability[decision.value("complaint_cause")] += decision.probability("complaint_cause")
+        label = max(options, key=lambda option: (counts[option], probability[option], -options.index(option)))
+        consistency = counts[label] / len(decisions) if decisions else 0.0
+        actionable = mean(decision.value("manufacturer_actionable") for decision in decisions)
+        labels[cluster_id] = {
+            "cluster_id": cluster_id,
+            "label": label,
+            "consistency": consistency,
+            "size": sizes[cluster_id],
+            "mixed": consistency < spec["cluster_consistency_min"],
+            "representatives": len(decisions),
+            "mean_manufacturer_actionable": actionable,
+            "mean_safety_hazard": mean(decision.value("safety_hazard") for decision in decisions),
+            "mean_severity": mean(decision.value("severity") for decision in decisions),
+            "defect_actionable": label == DEFECT and actionable is not None and actionable >= case.policy.accept_min,
+            "cause_counts": dict(sorted(counts.items())),
+        }
+    return labels
+
+
+def cluster_label_table(labels: dict[int, dict]) -> pa.Table:
+    rows = [{key: value for key, value in label.items() if key != "cause_counts"} for label in labels.values()]
+    return pa.Table.from_pylist(rows, schema=pa.schema([
+        ("cluster_id", pa.int32()), ("label", pa.string()), ("consistency", pa.float64()), ("size", pa.int64()),
+        ("mixed", pa.bool_()), ("representatives", pa.int64()), ("mean_manufacturer_actionable", pa.float64()),
+        ("mean_safety_hazard", pa.float64()), ("mean_severity", pa.float64()), ("defect_actionable", pa.bool_()),
+    ]))
+
+
+def backend_agreement(case: Case, batch, clusters_of: dict[int, int], labels: dict[int, dict]) -> dict:
+    """Compare these representative decisions with the jev registry's decisions of the same states."""
+    reference = Registry(case.args.registry_dir / f"{REGISTRY}.parquet", case.questions)
+    pairs = []
+    for decision in batch.decisions:
+        other = reference.lookup(decision.content_hash, decision.question_set_hash)
+        if other is not None:
+            pairs.append((decision, other))
+    same = sum(mine.value("complaint_cause") == theirs.value("complaint_cause") for mine, theirs in pairs)
+    by_cluster = defaultdict(list)
+    for _, theirs in pairs:
+        by_cluster[clusters_of[int(theirs.entity_key)]].append(theirs)
+    reference_labels = label_clusters(case, by_cluster, Counter({cluster: labels[cluster]["size"] for cluster in labels}))
+    confusion = Counter((theirs.value("complaint_cause"), mine.value("complaint_cause")) for mine, theirs in pairs)
+    return {
+        "compared": len(pairs),
+        "complaint_cause_agreement": same / len(pairs) if pairs else None,
+        "complaint_cause_agreement_wilson95": wilson(same, len(pairs)),
+        "mean_absolute_difference": {
+            name: mean(abs(mine.value(name) - theirs.value(name)) for mine, theirs in pairs) for name in NUMERIC_QUESTIONS},
+        "cluster_label_agreement": sum(
+            reference_labels[cluster]["label"] == labels[cluster]["label"] for cluster in labels) / len(labels),
+        "confusion_jev_vs_this_backend": [
+            {"jev": key[0], "this_backend": key[1], "reviews": count} for key, count in sorted(confusion.items())],
+    }
+
+
+def rows(stage) -> list[dict]:
+    return stage.table.to_pylist()
+
+
+def keyword_comparison(crosstab: list[dict], per_product: list[dict], model_ranking: list[dict]) -> dict:
+    total = sum(row["reviews"] for row in crosstab)
+    unclassified = sum(row["reviews"] for row in crosstab if row["keyword_cause"] == "unclassified")
+    classified = [row for row in crosstab if row["keyword_cause"] != "unclassified"]
+    agree = sum(row["reviews"] for row in classified if KEYWORD_TO_CAUSE[row["keyword_cause"]] == row["model_cause"])
+    classified_total = sum(row["reviews"] for row in classified)
+    by_product = {row["product_id"]: row for row in per_product}
+    top = []
+    for rank, product in enumerate(model_ranking[:10], 1):
+        control = by_product.get(product["product_id"], {})
+        keyword = control.get("keyword_cause")
+        top.append({
+            "rank": rank, "product_id": product["product_id"], "title": product["title"],
+            "model_cause_2022": control.get("model_cause"), "model_reviews": control.get("model_reviews"),
+            "keyword_cause_2022": keyword, "keyword_reviews": control.get("keyword_reviews"),
+            "keyword_unclassified": control.get("keyword_unclassified"), "reviews2022": control.get("reviews2022"),
+            "mapped_agrees": keyword is not None and KEYWORD_TO_CAUSE[keyword] == control.get("model_cause"),
+        })
+    return {
+        "reviews": total,
+        "unclassified": unclassified,
+        "unclassified_share": unclassified / total if total else None,
+        "mapping": KEYWORD_TO_CAUSE,
+        "classified_agreement_under_mapping": agree / classified_total if classified_total else None,
+        "top10_products": top,
+    }
+
+
+def holdout(case: Case, registry: Registry, clusters: list[dict], excluded: set[int], labels: dict[int, dict]) -> dict:
+    pool = sorted(row["id"] for row in clusters if row["id"] not in excluded)
+    sample = random.Random(HOLDOUT_SEED).sample(pool, case.args.holdout_size)
+    clusters_of = {row["id"]: row["cluster_id"] for row in clusters}
+    batch = decide_reviews(case, registry, "holdout", sample)
+    outcomes = []
+    for decision in batch.decisions:
+        cluster_id = clusters_of[int(decision.entity_key)]
+        outcomes.append({
+            "id": int(decision.entity_key), "cluster_id": cluster_id, "mixed": labels[cluster_id]["mixed"],
+            "cluster_label": labels[cluster_id]["label"], "review_label": decision.value("complaint_cause"),
+            "agrees": decision.value("complaint_cause") == labels[cluster_id]["label"],
+        })
+
+    def summary(subset):
+        agree = sum(outcome["agrees"] for outcome in subset)
+        return {"reviews": len(subset), "agree": agree, "agreement": agree / len(subset) if subset else None,
+                "wilson95": wilson(agree, len(subset))}
+
+    return {
+        "seed": HOLDOUT_SEED,
+        "pool": len(pool),
+        "all": summary(outcomes),
+        "consistent_clusters": summary([outcome for outcome in outcomes if not outcome["mixed"]]),
+        "mixed_clusters": summary([outcome for outcome in outcomes if outcome["mixed"]]),
+        "reviews": outcomes,
+    }
+
+
+def main() -> None:
+    parser = build_parser(__doc__.splitlines()[0])
+    parser.add_argument("--reuse-clusters", action="store_true",
+                        help="skip the kmeans probe and read the saved assignment table")
+    parser.add_argument("--clusters", type=Path, default=None,
+                        help="assignment table for --reuse-clusters (default <registry-dir>/review_clusters.engine.parquet)")
+    parser.add_argument("--representatives-only", action="store_true",
+                        help="decide the representatives, label clusters and stop")
+    parser.add_argument("--holdout-size", type=int, default=100)
+    args = parser.parse_args()
+    if args.backend != "jev" and not args.representatives_only:
+        parser.error("a backend other than jev runs only with --representatives-only")
+
+    case = Case(CASE_DIR, args)
+    case.algeon.register_amazon()
+    spec = case.policy.spec
+    clusters = load_clusters(case)
+    sizes = Counter(row["cluster_id"] for row in clusters)
+    clusters_of = {row["id"]: row["cluster_id"] for row in clusters}
+    per_cluster = (args.max_entities or REPRESENTATIVES_PER_CLUSTER * len(sizes)) // len(sizes)
+    representative_ids = [row["id"] for row in clusters if row["density_rank"] <= per_cluster]
+    case.capture.result("probe", {
+        "reviews": len(clusters), "clusters": len(sizes), "representatives": len(representative_ids),
+        "interior_reviews": sum(row["same_cluster_neighbors"] >= 32 for row in clusters),
+    })
+
+    registry = case.registry(REGISTRY)
+    representatives = decide_reviews(case, registry, "representatives", representative_ids)
+    by_cluster = defaultdict(list)
+    for decision in representatives.decisions:
+        by_cluster[clusters_of[int(decision.entity_key)]].append(decision)
+    labels = label_clusters(case, by_cluster, sizes)
+    case.capture.result("cluster_labels", list(labels.values()))
+    case.capture.result("representatives", [
+        {"id": int(decision.entity_key), "cluster_id": clusters_of[int(decision.entity_key)],
+         **{name: decision.value(name) for name in case.questions}} for decision in representatives.decisions])
+
+    if args.representatives_only:
+        if args.backend != "jev":
+            case.capture.result("backend_agreement", backend_agreement(case, representatives, clusters_of, labels))
+        case.finish()
+        return
+
+    mixed = [cluster_id for cluster_id, label in labels.items() if label["mixed"]]
+    escalated_ids = [row["id"] for row in clusters
+                     if labels[row["cluster_id"]]["mixed"] and row["density_rank"] <= spec["escalation_cap"]]
+    escalated = decide_reviews(case, registry, "escalation", escalated_ids) if escalated_ids else None
+    escalation = {"mixed_clusters": mixed, "reviews": len(escalated_ids), "per_cluster": []}
+    if escalated is not None:
+        escalation["extra_cost_usd"] = escalated.summary["cost_usd"]
+        escalation["extra_backend_calls"] = escalated.summary["backend_calls"]
+        escalation["wall_s"] = escalated.summary["wall_s"]
+        for cluster_id in mixed:
+            counts = Counter(decision.value("complaint_cause") for decision in escalated.decisions
+                             if clusters_of[int(decision.entity_key)] == cluster_id)
+            decided = sum(counts.values())
+            escalation["per_cluster"].append({
+                "cluster_id": cluster_id, "size": sizes[cluster_id], "decided": decided,
+                "representative_label": labels[cluster_id]["label"],
+                "per_review_causes": dict(sorted(counts.items())),
+                "per_review_majority_share": max(counts.values()) / decided if decided else None,
+            })
+    case.capture.result("escalation", escalation)
+
+    engine_decisions = [decision for decision in representatives.decisions
+                        if not labels[clusters_of[int(decision.entity_key)]]["mixed"]]
+    sources = ["representative"] * len(engine_decisions)
+    if escalated is not None:
+        engine_decisions += escalated.decisions
+        sources += ["escalated"] * len(escalated.decisions)
+    bands, band_counts = case.policy.apply(engine_decisions)
+    review_ids = [int(decision.entity_key) for decision in engine_decisions]
+    engine = registry.engine_table(engine_decisions, {
+        "id": pa.array(review_ids, pa.int64()),
+        "cluster_id": pa.array([clusters_of[review_id] for review_id in review_ids], pa.int32()),
+        "label_source": sources,
+        "band": [bands[decision.entity_key] for decision in engine_decisions],
+        "defect_actionable": pa.array([decision.value("complaint_cause") == DEFECT
+                                       and bands[decision.entity_key] == "accept" for decision in engine_decisions]),
+    })
+    case.decision_table("review_causes", engine)
+    case.decision_table("cluster_labels", cluster_label_table(labels))
+    case.capture.result("bands", band_counts)
+
+    ranking = rows(native_stage(case, "recompute", case.sql("03_recompute.sql")))
+    case.capture.result("defect_actionable_ranking", ranking)
+    case.capture.result("product_cause_shares", rows(native_stage(case, 
+        "product_cause_shares", case.sql("04_product_cause_shares.sql"))))
+    case.capture.result("cause_shares", rows(native_stage(case, "cause_shares", case.sql("05_cause_shares.sql"))))
+    anonymous = rows(native_stage(case, "anonymous_ranking", case.sql("06_anonymous_ranking.sql")))
+    case.capture.result("anonymous_ranking", anonymous)
+    low_rating = rows(native_stage(case, "low_rating_ranking", case.sql("07_low_rating_ranking.sql")))
+    case.capture.result("low_rating_ranking", low_rating)
+    weighted = rows(native_stage(case, "helpful_weighted", case.sql("08_helpful_weighted.sql")))
+    unweighted_totals = {row["product_id"]: (row["total2021"], row["total2022"]) for row in ranking}
+    case.capture.result("helpful_weighted", {
+        "join": "semantic_reviews_text.id = reviews.review_id",
+        "products_with_complete_join": sum(
+            unweighted_totals.get(row["product_id"]) == (row["total2021"], row["total2022"]) for row in weighted),
+        "products": len(ranking),
+        "ranking": weighted,
+    })
+    case.capture.result("safety_clusters", rows(native_stage(case, "safety_clusters", case.sql("09_safety_clusters.sql"))))
+    case.capture.result("rankings_top10", [
+        {"rank": index + 1,
+         "defect_actionable": (ranking[index]["product_id"], ranking[index]["title"], ranking[index]["change_pp"])
+         if index < len(ranking) else None,
+         "anonymous_cluster": (anonymous[index]["product_id"], anonymous[index]["title"], anonymous[index]["cluster_id"],
+                               anonymous[index]["change_pp"]) if index < len(anonymous) else None,
+         "low_rating": (low_rating[index]["product_id"], low_rating[index]["title"], low_rating[index]["change_pp"])
+         if index < len(low_rating) else None,
+         "helpful_weighted": (weighted[index]["product_id"], weighted[index]["title"], weighted[index]["change_pp"])
+         if index < len(weighted) else None}
+        for index in range(10)])
+
+    crosstab = rows(native_stage(case, "control_keywords", case.sql("control_keywords.sql")))
+    per_product = rows(native_stage(case, "control_keywords_products", case.sql("control_keywords_products.sql")))
+    case.capture.result("control_keywords", {"crosstab": crosstab, **keyword_comparison(crosstab, per_product, ranking)})
+    case.capture.result("control_keywords_products", per_product)
+
+    excluded = set(representative_ids) | set(escalated_ids)
+    case.capture.result("holdout", holdout(case, registry, clusters, excluded, labels))
+    case.finish()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/01_probe.sql b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/01_probe.sql
new file mode 100644
index 000000000..1bfbde10a
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/01_probe.sql
@@ -0,0 +1,45 @@
+-- Copy of fixture/demo/merrec/scripts/scale/10_barbie_tie_ins.sql; run.py checks that the statements match.
+WITH likes AS (
+  SELECT DISTINCT -(e.user_id + 1) AS src, CAST(i.brand_id AS BIGINT) AS dst,
+         e.event_time >= TIMESTAMP '2023-07-01 00:00:00' AS after_release
+  FROM merrec_events e JOIN merrec_items i ON i.item_id = e.item_id
+  WHERE e.event_type = 'item_like' AND i.brand_id <> 0
+    AND e.event_time >= TIMESTAMP '2023-05-01 00:00:00'
+    AND e.event_time < TIMESTAMP '2023-09-01 00:00:00'
+), lift_before AS (
+  SELECT p.vertex, p.value / r.value AS lift
+  FROM cugraph_personalized_pagerank(
+    edges => (SELECT src, dst FROM likes WHERE NOT after_release),
+    personalization => (SELECT 2595 AS vertex, 1.0 AS value),
+    directed => false) p
+  JOIN cugraph_pagerank(
+    edges => (SELECT src, dst FROM likes WHERE NOT after_release), directed => false) r
+    ON r.vertex = p.vertex
+), lift_after AS (
+  SELECT p.vertex, p.value / r.value AS lift
+  FROM cugraph_personalized_pagerank(
+    edges => (SELECT src, dst FROM likes WHERE after_release),
+    personalization => (SELECT 2595 AS vertex, 1.0 AS value),
+    directed => false) p
+  JOIN cugraph_pagerank(
+    edges => (SELECT src, dst FROM likes WHERE after_release), directed => false) r
+    ON r.vertex = p.vertex
+), fans AS (
+  SELECT dst AS brand_id,
+         SUM(CASE WHEN after_release THEN 0 ELSE 1 END) AS fans_before,
+         SUM(CASE WHEN after_release THEN 1 ELSE 0 END) AS fans_after
+  FROM likes GROUP BY dst
+), brands AS (
+  SELECT CAST(brand_id AS BIGINT) AS brand_id, MIN(brand_name) AS brand_name
+  FROM merrec_items WHERE brand_id <> 0 GROUP BY brand_id
+)
+SELECT b.brand_name, f.fans_before, f.fans_after,
+       lb.lift AS lift_before, la.lift AS lift_after, la.lift / lb.lift AS lift_change
+FROM lift_after la
+JOIN lift_before lb ON lb.vertex = la.vertex
+JOIN fans f ON f.brand_id = la.vertex
+JOIN brands b ON b.brand_id = la.vertex
+WHERE la.vertex > 0 AND la.vertex <> 2595
+  AND f.fans_before >= 1000 AND f.fans_after >= 1000
+ORDER BY lift_change DESC, b.brand_name
+LIMIT 25;
diff --git a/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/02_bridge_items.sql b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/02_bridge_items.sql
new file mode 100644
index 000000000..668739bd7
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/02_bridge_items.sql
@@ -0,0 +1,39 @@
+-- Bridge items: for each brand in {brand_ids}, the 25 items most liked by Barbie fans in July and August 2023.
+-- A Barbie fan liked a Barbie (brand_id 2595) item between 2023-05-01 and 2023-09-01. Likes count events;
+-- fan users count distinct fans. An item qualifies with at least 2 Barbie-fan likes, or with 'barbie' in its
+-- title and at least 3 likes in total, so that keyword items Barbie fans ignored stay visible to the control.
+WITH catalog AS (
+  SELECT item_id, CAST(brand_id AS BIGINT) AS brand_id, brand_name, name, category_path, color, price
+  FROM merrec_items WHERE brand_id IN ({brand_ids})
+), barbie_fans AS (
+  SELECT DISTINCT e.user_id
+  FROM merrec_events e JOIN merrec_items i ON i.item_id = e.item_id
+  WHERE e.event_type = 'item_like' AND i.brand_id = 2595
+    AND e.event_time >= TIMESTAMP '2023-05-01 00:00:00'
+    AND e.event_time < TIMESTAMP '2023-09-01 00:00:00'
+), after_likes AS (
+  SELECT e.user_id, e.item_id, c.brand_id
+  FROM merrec_events e JOIN catalog c ON c.item_id = e.item_id
+  WHERE e.event_type = 'item_like'
+    AND e.event_time >= TIMESTAMP '2023-07-01 00:00:00'
+    AND e.event_time < TIMESTAMP '2023-09-01 00:00:00'
+), item_likes AS (
+  SELECT a.item_id, a.brand_id, COUNT(*) AS likes_after,
+         SUM(CASE WHEN f.user_id IS NULL THEN 0 ELSE 1 END) AS fan_likes_after,
+         COUNT(DISTINCT f.user_id) AS fan_users_after
+  FROM after_likes a LEFT JOIN barbie_fans f ON f.user_id = a.user_id
+  GROUP BY a.item_id, a.brand_id
+), ranked AS (
+  SELECT l.brand_id, c.brand_name, l.item_id, c.name AS item_name, c.category_path, c.color, c.price,
+         LOWER(c.name) LIKE '%barbie%' AS keyword_barbie,
+         l.likes_after, l.fan_likes_after, l.fan_users_after,
+         ROW_NUMBER() OVER (PARTITION BY l.brand_id
+                            ORDER BY l.fan_likes_after DESC, l.likes_after DESC, l.item_id) AS item_rank
+  FROM item_likes l JOIN catalog c ON c.item_id = l.item_id
+  WHERE l.fan_likes_after >= 2 OR (LOWER(c.name) LIKE '%barbie%' AND l.likes_after >= 3)
+)
+SELECT brand_id, brand_name, item_id, item_name, category_path, color, price, keyword_barbie,
+       likes_after, fan_likes_after, fan_users_after, item_rank
+FROM ranked
+WHERE item_rank <= 25
+ORDER BY brand_id, item_rank;
diff --git a/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/03_counterfactual.sql b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/03_counterfactual.sql
new file mode 100644
index 000000000..1707dc54d
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/03_counterfactual.sql
@@ -0,0 +1,49 @@
+-- The published lift query (10_barbie_tie_ins.sql) with like events on {excluded_items} removed from the
+-- bipartite graph. The output adds brand_id and drops LIMIT 25 so every brand of the probe keeps a row
+-- after the exclusion reorders the ranking. The exclusion is a LEFT JOIN with an IS NULL filter inside the
+-- edge CTE: that shape runs natively, while an anti-join under the sorted limited join does not.
+WITH likes AS (
+  SELECT DISTINCT -(e.user_id + 1) AS src, CAST(i.brand_id AS BIGINT) AS dst,
+         e.event_time >= TIMESTAMP '2023-07-01 00:00:00' AS after_release
+  FROM merrec_events e JOIN merrec_items i ON i.item_id = e.item_id
+  LEFT JOIN {excluded_items} x ON x.item_id = e.item_id
+  WHERE e.event_type = 'item_like' AND i.brand_id <> 0
+    AND e.event_time >= TIMESTAMP '2023-05-01 00:00:00'
+    AND e.event_time < TIMESTAMP '2023-09-01 00:00:00'
+    AND x.item_id IS NULL
+), lift_before AS (
+  SELECT p.vertex, p.value / r.value AS lift
+  FROM cugraph_personalized_pagerank(
+    edges => (SELECT src, dst FROM likes WHERE NOT after_release),
+    personalization => (SELECT 2595 AS vertex, 1.0 AS value),
+    directed => false) p
+  JOIN cugraph_pagerank(
+    edges => (SELECT src, dst FROM likes WHERE NOT after_release), directed => false) r
+    ON r.vertex = p.vertex
+), lift_after AS (
+  SELECT p.vertex, p.value / r.value AS lift
+  FROM cugraph_personalized_pagerank(
+    edges => (SELECT src, dst FROM likes WHERE after_release),
+    personalization => (SELECT 2595 AS vertex, 1.0 AS value),
+    directed => false) p
+  JOIN cugraph_pagerank(
+    edges => (SELECT src, dst FROM likes WHERE after_release), directed => false) r
+    ON r.vertex = p.vertex
+), fans AS (
+  SELECT dst AS brand_id,
+         SUM(CASE WHEN after_release THEN 0 ELSE 1 END) AS fans_before,
+         SUM(CASE WHEN after_release THEN 1 ELSE 0 END) AS fans_after
+  FROM likes GROUP BY dst
+), brands AS (
+  SELECT CAST(brand_id AS BIGINT) AS brand_id, MIN(brand_name) AS brand_name
+  FROM merrec_items WHERE brand_id <> 0 GROUP BY brand_id
+)
+SELECT la.vertex AS brand_id, b.brand_name, f.fans_before, f.fans_after,
+       lb.lift AS lift_before, la.lift AS lift_after, la.lift / lb.lift AS lift_change
+FROM lift_after la
+JOIN lift_before lb ON lb.vertex = la.vertex
+JOIN fans f ON f.brand_id = la.vertex
+JOIN brands b ON b.brand_id = la.vertex
+WHERE la.vertex > 0 AND la.vertex <> 2595
+  AND f.fans_before >= 1000 AND f.fans_after >= 1000
+ORDER BY lift_change DESC, b.brand_name;
diff --git a/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/04_decomposition.sql b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/04_decomposition.sql
new file mode 100644
index 000000000..3fc602a69
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/04_decomposition.sql
@@ -0,0 +1,22 @@
+-- Share of each brand's July to August Barbie-fan likes on its audited bridge items, split by the model's
+-- mechanism, by the policy band and by the title keyword. Shares divide by the brand's audited fan likes.
+SELECT b.brand_id, b.brand_name,
+       COUNT(*) AS items,
+       SUM(b.fan_likes_after) AS fan_likes,
+       SUM(CASE WHEN d.mechanism = 'official_barbie_collab' THEN b.fan_likes_after ELSE 0 END)
+         / CAST(SUM(b.fan_likes_after) AS DOUBLE) AS official_share,
+       SUM(CASE WHEN d.mechanism = 'barbiecore_pink_aesthetic' THEN b.fan_likes_after ELSE 0 END)
+         / CAST(SUM(b.fan_likes_after) AS DOUBLE) AS pink_aesthetic_share,
+       SUM(CASE WHEN d.mechanism = 'eras_tour_or_pop_fandom' THEN b.fan_likes_after ELSE 0 END)
+         / CAST(SUM(b.fan_likes_after) AS DOUBLE) AS pop_fandom_share,
+       SUM(CASE WHEN d.mechanism = 'general_brand_staple' THEN b.fan_likes_after ELSE 0 END)
+         / CAST(SUM(b.fan_likes_after) AS DOUBLE) AS staple_share,
+       SUM(CASE WHEN d.band = 'accept' THEN b.fan_likes_after ELSE 0 END)
+         / CAST(SUM(b.fan_likes_after) AS DOUBLE) AS accept_share,
+       SUM(CASE WHEN d.band = 'review' THEN b.fan_likes_after ELSE 0 END)
+         / CAST(SUM(b.fan_likes_after) AS DOUBLE) AS review_share,
+       SUM(CASE WHEN d.keyword_barbie THEN b.fan_likes_after ELSE 0 END)
+         / CAST(SUM(b.fan_likes_after) AS DOUBLE) AS keyword_share
+FROM {bridge_items} b JOIN {decisions} d ON d.item_id = b.item_id
+GROUP BY b.brand_id, b.brand_name
+ORDER BY b.brand_id;
diff --git a/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/compare_captures.py b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/compare_captures.py
new file mode 100644
index 000000000..1867e4e8d
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/compare_captures.py
@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""Compare a live capture with its replay; exit 1 on the first difference.
+
+Ignored keys: timestamps, timings, query ids, the environment block, the mode
+and the replay sources. Keys ending in `elapsed_s` or `wall_s` and keys starting
+with `latency_` are timings. The decision batches and totals depend on how
+many answers came from the registry, so their counters (`registry_hits`,
+`hit_rate`, `backend_calls`, `api_calls`, `backend`, `output_tokens`,
+`cost_usd`) are not compared; every replay batch must report zero API calls.
+Each recorded response is compared on its entity key, model id, answers and
+input tokens, as in cases B and C: `source`, the raw `response`,
+`output_tokens` and `cost_usd` are null for a registry-served decision. The
+top-level `model` is skipped because the replay backend reports no model name.
+
+Usage: python3 cases/d_barbie_mechanisms/compare_captures.py LIVE.json REPLAY.json
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import sys
+
+IGNORED = {"decided_at", "started_at", "finished_at", "admission_wait_ms", "query_id", "environment", "mode",
+           "replay_sources"}
+TIMING_SUFFIXES = ("elapsed_s", "wall_s")
+COUNTERS = {"registry_hits", "hit_rate", "backend_calls", "api_calls", "backend", "input_tokens", "output_tokens",
+            "cost_usd"}
+RESPONSE_UNCOMPARED = {"source", "response", "output_tokens", "cost_usd"}
+
+
+def ignored(key: str, path: tuple) -> bool:
+    if key in IGNORED or key.startswith("latency_") or key.endswith(TIMING_SUFFIXES):
+        return True
+    if key == "model":
+        return path == ()
+    if path[:1] in (("decisions",), ("totals",)):
+        return key in COUNTERS
+    return len(path) == 2 and path[0] == "responses" and key in RESPONSE_UNCOMPARED
+
+
+def first_difference(live, replay, path: tuple = ()) -> str | None:
+    if isinstance(live, dict) and isinstance(replay, dict):
+        for key in sorted(set(live) | set(replay)):
+            if ignored(key, path):
+                continue
+            if key not in live or key not in replay:
+                return f"{'/'.join(map(str, path + (key,)))}: present only in {'live' if key in live else 'replay'}"
+            difference = first_difference(live[key], replay[key], path + (key,))
+            if difference:
+                return difference
+        return None
+    if isinstance(live, list) and isinstance(replay, list):
+        if len(live) != len(replay):
+            return f"{'/'.join(map(str, path))}: length {len(live)} != {len(replay)}"
+        for index, (left, right) in enumerate(zip(live, replay)):
+            difference = first_difference(left, right, path + (index,))
+            if difference:
+                return difference
+        return None
+    if live != replay:
+        return f"{'/'.join(map(str, path))}: {live!r} != {replay!r}"
+    return None
+
+
+def replay_problems(replay: dict) -> str | None:
+    for batch in replay.get("decisions", []):
+        if batch.get("api_calls") != 0:
+            return f"replay batch {batch.get('name')!r} reports api_calls={batch.get('api_calls')}"
+    if (replay.get("totals") or {}).get("api_calls") != 0:
+        return f"replay totals report api_calls={replay['totals'].get('api_calls')}"
+    return None
+
+
+def main() -> int:
+    if len(sys.argv) != 3:
+        print(__doc__.strip().splitlines()[-1], file=sys.stderr)
+        return 2
+    live, replay = (json.loads(Path(name).read_text(encoding="utf-8")) for name in sys.argv[1:])
+    if live.get("mode") != "live" or replay.get("mode") != "replay":
+        print(f"expected a live and a replay capture, got {live.get('mode')!r} and {replay.get('mode')!r}")
+        return 2
+    problem = replay_problems(replay) or first_difference(live, replay)
+    if problem:
+        print(f"captures differ: {problem}")
+        return 1
+    print(f"captures match: {len(live.get('responses', {}))} responses, {len(live.get('stages', []))} stages, "
+          f"{len(live.get('results', {}))} result entries")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/policy.json b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/policy.json
new file mode 100644
index 000000000..b3ef7d269
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/policy.json
@@ -0,0 +1 @@
+{"action_question": "official_license", "accept_min": 0.70, "review_min": 0.30, "require": {"mechanism": ["official_barbie_collab"]}}
diff --git a/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/questions.json b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/questions.json
new file mode 100644
index 000000000..e073c32ed
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/questions.json
@@ -0,0 +1,28 @@
+{
+  "mechanism": {
+    "type": "choice",
+    "instructions": "In a peer-to-peer marketplace (Mercari, US), this listing was liked by many shoppers who also liked Barbie-brand items around the July 2023 release of the Barbie movie. Classify why the listing draws those shoppers.",
+    "criteria": {
+      "official_barbie_collab": "An officially licensed Barbie product or Barbie movie tie-in made by the listed brand with Mattel (e.g., Barbie x ALDO shoes and bags, NYX Barbie makeup collection, AMC Barbie Corvette popcorn vessel, OPI Barbie nail polish collection, Primark or Forever 21 Barbie capsule apparel, Stoney Clover Lane Barbie patches and pouches)",
+      "barbiecore_pink_aesthetic": "Not a licensed Barbie product but a pink or 'Barbiecore' styled item that matches the movie's look, sometimes with 'Barbie' added to the title by the seller as a search tag (e.g., a pink ZARA dress a seller titles 'Barbie dress', a pink Stanley tumbler, hot pink heels)",
+      "eras_tour_or_pop_fandom": "Merchandise or outfits of another pop-culture fandom popular with the same summer 2023 audience and unrelated to Barbie (e.g., Taylor Swift Eras Tour merchandise, tour outfits, friendship bracelets, concert posters, albums)",
+      "general_brand_staple": "A regular product of the brand with no Barbie, pink-aesthetic or pop-fandom link (e.g., a neutral-color staple, a core bestseller, a basic everyday item)"
+    }
+  },
+  "official_license": {
+    "type": "noul",
+    "instructions": "Is this listing an officially licensed Mattel Barbie collaboration product or a Barbie movie promotional item?",
+    "criteria": {
+      "true": "Licensed Barbie collaboration or official Barbie movie promotion, co-branded with Barbie or Mattel by the brand or by a cinema chain",
+      "false": "No Barbie license: an unlicensed item, a pink item the seller describes as Barbie, or an unrelated product"
+    }
+  },
+  "pink_aesthetic": {
+    "type": "noul",
+    "instructions": "Does the title or the color field indicate a pink color family: pink, rose, magenta, fuchsia, blush, or 'Barbie' used as a color?",
+    "criteria": {
+      "true": "The title or color names pink, hot pink, rose, magenta, fuchsia, blush or 'Barbie pink'",
+      "false": "Neither the title nor the color field carries a pink color signal"
+    }
+  }
+}
diff --git a/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/run.py b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/run.py
new file mode 100644
index 000000000..6f284ea98
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/d_barbie_mechanisms/run.py
@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+"""Case D (Explain): which mechanisms carry the Barbie affinity shift of the top MerRec brands.
+
+The probe is the published lift query `10_barbie_tie_ins.sql`. For the probe's
+top 10 brands, `02_bridge_items.sql` returns the 25 items Barbie fans liked
+most in July and August 2023; the decision model labels each item's mechanism,
+whether it is an official Barbie license, and whether it carries a pink color
+signal. `03_counterfactual.sql` recomputes the lift with the like events of an
+exclusion table removed from the graph, four times: an empty table (baseline),
+every non-Barbie item whose title contains 'barbie' (keyword control), the
+bridge items in the accept band (model), and every bridge item whose
+`mechanism` is `official_barbie_collab` regardless of band (model_mechanism).
+The model_mechanism run exists to show the gap between the choice head and the
+action noul on this question: the choice labels most audited collab items
+official while `official_license` leaves most of them in the review band. The
+policy is unchanged; `official_license_by_band` records the license
+probabilities of the official-labelled items per band. `04_decomposition.sql`
+splits each brand's audited Barbie-fan likes by mechanism, band and keyword.
+
+Commands, from fixture/demo/decision_models/scripts:
+
+    eval "$(grep -E '^export (JEV_API_URL|JEV_API_KEY)=' ~/.bashrc)"
+    flock /tmp/decision-demo-gpu.lock python3 cases/d_barbie_mechanisms/run.py --mode live
+    flock /tmp/decision-demo-gpu.lock python3 cases/d_barbie_mechanisms/run.py --mode replay
+    python3 cases/d_barbie_mechanisms/compare_captures.py \\
+        ../captures/d_barbie_mechanisms_live.json ../captures/d_barbie_mechanisms_replay.json
+
+Decisions the specification left open:
+
+- `01_probe.sql` is a copy of the published query; the run stops when its
+  statement differs from `merrec/scripts/scale/10_barbie_tie_ins.sql`. The
+  published output has no `brand_id`, so the brand ids come from the baseline
+  counterfactual, whose first 25 rows must equal the probe's rows exactly
+  (brand name, fan counts and the three lift values).
+- `03_counterfactual.sql` adds `brand_id` and drops `LIMIT 25`, so every probe
+  brand keeps a row when an exclusion reorders the ranking. The fan thresholds
+  (1,000 before and after) stay, so a brand whose fans fall below them under an
+  exclusion reports a null counterfactual lift.
+- The keyword control excludes items whose title contains 'barbie' and whose
+  brand is not Barbie (2595), as in the earlier counterfactual study. Removing
+  the Barbie brand's own items would change the seed's neighborhood and measure
+  a different graph. The two model exclusions touch only audited bridge items,
+  none of which belong to brand 2595.
+- `excess_retained_pct = 100 * (cf_lift_change - 1) / (base_lift_change - 1)`;
+  it is null when the base lift change is 1 or the counterfactual row is missing.
+- Likes count `item_like` events; Barbie-fan users count distinct fans. The
+  second admission rule ("a title containing 'barbie' with at least 3 likes")
+  counts all likes, so keyword items that Barbie fans ignored stay visible.
+- `--max-entities` (default 250) caps the bridge rows taken in probe rank, then
+  item rank.
+- `keyword_barbie` in the decision table is `'barbie' in title.lower()` in
+  Python. The bridge SQL computes the same flag with `LOWER(name) LIKE`; the
+  capture records how many rows disagree (`keyword_flag_mismatches`).
+- "The model calls an item official" means the accept band (official_license
+  >= 0.70 with mechanism official_barbie_collab). A pink item is one with
+  `pink_aesthetic >= 0.70`.
+- The behavioral signal for the reject examples is the item's Barbie-fan share
+  of its July to August likes. A reject-band item counts as a behavioral false
+  collab when that share reaches the median share of the accept-band items.
+- The bridge rows and the exclusion tables are written under `data/barbie/`
+  (local only, CC BY-NC like the other MerRec-derived files).
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+import json
+from pathlib import Path
+import statistics
+import sys
+
+import pyarrow as pa
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+from client.algeon import DEMO_ROOT, statement_body  # noqa: E402
+from client.capture import merrec_license  # noqa: E402
+from client.case import DEMO_DIR, Case, build_parser  # noqa: E402
+from client.decision_client import Entity  # noqa: E402
+from client.policy import BANDS  # noqa: E402
+
+CASE_DIR = Path(__file__).resolve().parent
+PUBLISHED_PROBE = DEMO_ROOT / "merrec/scripts/scale/10_barbie_tie_ins.sql"
+DATA_DIR = DEMO_DIR / "data/barbie"
+REGISTRY = "barbie_items"
+BRIDGE_TABLE = "barbie_bridge_items"
+BARBIE_BRAND_ID = 2595
+AUDITED_BRANDS = 10
+PINK_MIN = 0.70
+EXAMPLES = 5
+KEYWORD_ITEMS_SQL = (
+    f"SELECT item_id FROM merrec_items WHERE LOWER(name) LIKE '%barbie%' AND brand_id <> {BARBIE_BRAND_ID}")
+COUNTERFACTUALS = ("keyword", "model", "model_mechanism")
+OFFICIAL = "official_barbie_collab"
+PROBE_COLUMNS = ("brand_name", "fans_before", "fans_after", "lift_before", "lift_after", "lift_change")
+# Figures of the earlier keyword counterfactual on the same query: expectations, never inputs.
+PRIOR = {
+    "NYX": {"base_lift_change": 2.133, "keyword_lift_change": 1.075, "keyword_retained_pct": 6.6},
+    "Stanley": {"base_lift_change": 1.396, "keyword_lift_change": 1.417, "keyword_retained_pct": 105.3},
+}
+
+
+def native_stage(case: Case, name: str, sql: str):
+    """Run one statement and stop the case when it crossed into DataFusion on the host."""
+    stage = case.run_stage(name, sql)
+    boundaries = (stage.execution or {}).get("host_datafusion_boundary_count")
+    if boundaries != 0:
+        case.capture.note(f"stage {name} reported host_datafusion_boundary_count={boundaries}; "
+                          f"EXPLAIN summary {stage.explain}")
+        case.finish()
+        raise SystemExit(f"stage {name} has host_datafusion_boundary_count={boundaries}; "
+                         f"EXPLAIN summary {stage.explain}")
+    return stage
+
+
+def render(sql: str, **values: str) -> str:
+    for name, value in values.items():
+        sql = sql.replace("{" + name + "}", value)
+    return sql
+
+
+def item_id_table(item_ids) -> pa.Table:
+    return pa.table({"item_id": pa.array(sorted(set(item_ids)), pa.int64())})
+
+
+def counterfactual(case: Case, label: str, item_ids) -> list[dict]:
+    table_name = f"barbie_exclude_{label}"
+    case.algeon.register_parquet(table_name, DATA_DIR / f"{table_name}.parquet", item_id_table(item_ids))
+    stage = native_stage(case, f"counterfactual_{label}",
+                         render(case.sql("03_counterfactual.sql"), excluded_items=table_name))
+    return stage.table.to_pylist()
+
+
+def state_text(row: dict) -> str:
+    price = row["price"]
+    return "\n".join([
+        f"Brand: {row['brand_name']} (brand_id={row['brand_id']})",
+        f"Item Title: {row['item_name'] or ''}",
+        f"Category: {row['category_path'] or 'unknown'}",
+        f"Color: {row['color'] or 'not given'}",
+        f"Price: {'unknown' if price is None else f'${price:.2f}'}",
+        f"Likes in July and August 2023: {row['likes_after']} in total, {row['fan_likes_after']} from Barbie fans "
+        f"(users who liked a Barbie-brand item between May and August 2023)",
+    ])
+
+
+def keyword(row: dict) -> bool:
+    return "barbie" in (row["item_name"] or "").lower()
+
+
+def retained(base: float | None, cf: float | None) -> float | None:
+    if base is None or cf is None or base == 1:
+        return None
+    return 100 * (cf - 1) / (base - 1)
+
+
+def counterfactual_table(probe: list[dict], ids: list[int], runs: dict[str, list[dict]]) -> list[dict]:
+    by_label = {label: {row["brand_id"]: row for row in rows} for label, rows in runs.items()}
+    ranks = {label: {row["brand_id"]: rank for rank, row in enumerate(rows, 1)} for label, rows in runs.items()}
+    table = []
+    for rank, (row, brand_id) in enumerate(zip(probe, ids), 1):
+        base = row["lift_change"]
+        record = {"probe_rank": rank, "brand_id": brand_id, "brand_name": row["brand_name"],
+                  "base_lift_change": base}
+        for label in COUNTERFACTUALS:
+            cf_row = by_label[label].get(brand_id)
+            cf = cf_row["lift_change"] if cf_row else None
+            record[f"{label}_lift_change"] = cf
+            record[f"{label}_rank"] = ranks[label].get(brand_id)
+            record[f"{label}_fans_after"] = cf_row["fans_after"] if cf_row else None
+            record[f"{label}_excess_retained_pct"] = retained(base, cf)
+        table.append(record)
+    return table
+
+
+def item_record(row: dict, decision, band: str) -> dict:
+    return {
+        "brand_id": row["brand_id"], "brand_name": row["brand_name"], "item_id": row["item_id"],
+        "item_rank": row["item_rank"],
+        "title": row["item_name"], "color": row["color"], "price": row["price"],
+        "likes_after": row["likes_after"], "fan_likes_after": row["fan_likes_after"],
+        "keyword_barbie": keyword(row), "band": band,
+        "mechanism": decision.value("mechanism"), "mechanism_p": decision.probability("mechanism"),
+        "official_license": decision.value("official_license"), "pink_aesthetic": decision.value("pink_aesthetic"),
+    }
+
+
+def examples(items: list[dict]) -> dict:
+    ordered = sorted(items, key=lambda item: (-item["fan_likes_after"], item["item_rank"]))
+    return {"items": len(items), "fan_likes": sum(item["fan_likes_after"] for item in items),
+            "examples": ordered[:EXAMPLES]}
+
+
+def disagreements(records: list[dict], brands: list[dict]) -> list[dict]:
+    result = []
+    for brand in brands:
+        items = [item for item in records if item["brand_id"] == brand["brand_id"]]
+        result.append({
+            "brand_id": brand["brand_id"], "brand_name": brand["brand_name"],
+            "keyword_not_accepted": examples([item for item in items
+                                              if item["keyword_barbie"] and item["band"] != "accept"]),
+            "accepted_without_keyword": examples([item for item in items
+                                                  if item["band"] == "accept" and not item["keyword_barbie"]]),
+            "pink_without_keyword": examples([item for item in items
+                                              if item["pink_aesthetic"] >= PINK_MIN and not item["keyword_barbie"]]),
+        })
+    return result
+
+
+def fan_share(item: dict) -> float:
+    return item["fan_likes_after"] / item["likes_after"] if item["likes_after"] else 0.0
+
+
+def behavioral_rejects(records: list[dict]) -> dict:
+    accepted = [fan_share(item) for item in records if item["band"] == "accept"]
+    if not accepted:
+        return {"threshold_fan_share": None, "items": 0, "examples": []}
+    threshold = statistics.median(accepted)
+    rejects = [{**item, "fan_share": fan_share(item)} for item in records
+               if item["band"] == "reject" and fan_share(item) >= threshold]
+    rejects.sort(key=lambda item: (-item["fan_likes_after"], item["brand_name"], item["item_rank"]))
+    return {"threshold_fan_share": threshold, "items": len(rejects), "examples": rejects[:20]}
+
+
+def prior_comparison(table: list[dict]) -> list[dict]:
+    by_name = {row["brand_name"]: row for row in table}
+    rows = []
+    for name, prior in PRIOR.items():
+        row = by_name.get(name, {})
+        rows.append({"brand_name": name, "prior": prior, "observed": {
+            "base_lift_change": row.get("base_lift_change"),
+            "keyword_lift_change": row.get("keyword_lift_change"),
+            "keyword_retained_pct": row.get("keyword_excess_retained_pct"),
+            "model_lift_change": row.get("model_lift_change"),
+            "model_retained_pct": row.get("model_excess_retained_pct"),
+            "model_mechanism_lift_change": row.get("model_mechanism_lift_change"),
+            "model_mechanism_retained_pct": row.get("model_mechanism_excess_retained_pct"),
+        }})
+    return rows
+
+
+def official_license_by_band(records: list[dict]) -> list[dict]:
+    rows = []
+    for band in BANDS:
+        values = sorted(item["official_license"] for item in records
+                        if item["mechanism"] == OFFICIAL and item["band"] == band)
+        rows.append({"band": band, "items": len(values),
+                     "official_license_min": values[0] if values else None,
+                     "official_license_median": statistics.median(values) if values else None,
+                     "official_license_max": values[-1] if values else None})
+    return rows
+
+
+def main() -> None:
+    parser = build_parser(__doc__.splitlines()[0])
+    parser.set_defaults(max_entities=250)
+    args = parser.parse_args()
+    case = Case(CASE_DIR, args, license=merrec_license())
+    case.algeon.register_merrec()
+
+    probe_sql = case.sql("01_probe.sql")
+    if statement_body(probe_sql) != statement_body(PUBLISHED_PROBE.read_text(encoding="utf-8")):
+        raise SystemExit(f"01_probe.sql no longer matches {PUBLISHED_PROBE}")
+    probe = native_stage(case, "probe", probe_sql).table.to_pylist()
+    case.capture.result("probe", probe)
+
+    runs = {"baseline": counterfactual(case, "baseline", [])}
+    baseline_top = [{key: row[key] for key in PROBE_COLUMNS} for row in runs["baseline"][:len(probe)]]
+    if baseline_top != probe:
+        raise SystemExit("the baseline counterfactual with an empty exclusion table did not reproduce the probe rows")
+    ids = [row["brand_id"] for row in runs["baseline"][:len(probe)]]
+    audited = [{"probe_rank": rank, "brand_id": brand_id, "brand_name": row["brand_name"],
+                "lift_change": row["lift_change"]}
+               for rank, (row, brand_id) in enumerate(zip(probe[:AUDITED_BRANDS], ids), 1)]
+    case.capture.result("audited_brands", audited)
+
+    bridge_stage = native_stage(case, "bridge_items", render(
+        case.sql("02_bridge_items.sql"), brand_ids=", ".join(str(brand["brand_id"]) for brand in audited)))
+    brand_rank = {brand["brand_id"]: brand["probe_rank"] for brand in audited}
+    bridge = sorted(bridge_stage.table.to_pylist(),
+                    key=lambda row: (brand_rank[row["brand_id"]], row["item_rank"]))[:args.max_entities]
+    case.algeon.register_parquet(BRIDGE_TABLE, DATA_DIR / f"{BRIDGE_TABLE}.parquet",
+                                 pa.Table.from_pylist(bridge, schema=bridge_stage.table.schema))
+    case.capture.result("keyword_flag_mismatches", sum(keyword(row) != row["keyword_barbie"] for row in bridge))
+    case.capture.result("bridge_items", [
+        {"brand_id": brand["brand_id"], "brand_name": brand["brand_name"],
+         "items": sum(row["brand_id"] == brand["brand_id"] for row in bridge),
+         "keyword_items": sum(row["brand_id"] == brand["brand_id"] and keyword(row) for row in bridge),
+         "fan_likes": sum(row["fan_likes_after"] for row in bridge if row["brand_id"] == brand["brand_id"])}
+        for brand in audited])
+
+    registry = case.registry(REGISTRY)
+    batch = case.decide(registry, [Entity(str(row["item_id"]), state_text(row)) for row in bridge])
+    decisions = batch.by_key()
+    bands, counts = case.policy.apply(batch.decisions)
+    case.capture.result("band_counts", counts)
+    case.capture.result("mechanism_counts", dict(sorted(Counter(
+        decision.value("mechanism") for decision in batch.decisions).items())))
+
+    ordered = [decisions[str(row["item_id"])] for row in bridge]
+    engine = registry.engine_table(ordered, {
+        "item_id": pa.array([row["item_id"] for row in bridge], pa.int64()),
+        "brand_id": pa.array([row["brand_id"] for row in bridge], pa.int64()),
+    })
+    engine = engine.append_column("band", pa.array([bands[str(row["item_id"])] for row in bridge], pa.string()))
+    engine = engine.append_column("keyword_barbie", pa.array([keyword(row) for row in bridge], pa.bool_()))
+    case.decision_table(REGISTRY, engine)
+
+    keyword_ids = native_stage(case, "keyword_items", KEYWORD_ITEMS_SQL).table.column("item_id").to_pylist()
+    model_ids = [row["item_id"] for row in bridge if bands[str(row["item_id"])] == "accept"]
+    mechanism_ids = [row["item_id"] for row in bridge
+                     if decisions[str(row["item_id"])].value("mechanism") == OFFICIAL]
+    case.capture.result("exclusions", {"baseline": 0, "keyword": len(set(keyword_ids)), "model": len(set(model_ids)),
+                                       "model_mechanism": len(set(mechanism_ids))})
+    runs["keyword"] = counterfactual(case, "keyword", keyword_ids)
+    runs["model"] = counterfactual(case, "model", model_ids)
+    runs["model_mechanism"] = counterfactual(case, "model_mechanism", mechanism_ids)
+    table = counterfactual_table(probe, ids, runs)
+    case.capture.result("counterfactual", table)
+    case.capture.result("prior_comparison", prior_comparison(table))
+
+    decomposition = native_stage(case, "decomposition", render(
+        case.sql("04_decomposition.sql"), bridge_items=BRIDGE_TABLE, decisions=REGISTRY)).table.to_pylist()
+    decomposition.sort(key=lambda row: brand_rank[row["brand_id"]])
+    case.capture.result("decomposition", decomposition)
+
+    records = [item_record(row, decisions[str(row["item_id"])], bands[str(row["item_id"])]) for row in bridge]
+    case.capture.result("disagreements", disagreements(records, audited))
+    case.capture.result("official_license_by_band", official_license_by_band(records))
+    case.capture.result("review_queue", [item for item in records if item["band"] == "review"])
+    case.capture.result("behavioral_rejects", behavioral_rejects(records))
+    case.capture.result("band_counts_by_brand", [
+        {"brand_id": brand["brand_id"], "brand_name": brand["brand_name"],
+         **{band: sum(item["brand_id"] == brand["brand_id"] and item["band"] == band for item in records)
+            for band in BANDS}}
+        for brand in audited])
+    case.capture.result("decisions", [
+        {"item_id": row["item_id"], "content_hash": decisions[str(row["item_id"])].content_hash,
+         "model_id": decisions[str(row["item_id"])].model_id, "answers": decisions[str(row["item_id"])].answers}
+        for row in bridge])
+    case.finish()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/01_probe.sql b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/01_probe.sql
new file mode 100644
index 000000000..34ab1b142
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/01_probe.sql
@@ -0,0 +1,22 @@
+WITH pokemon_catalog AS (
+  SELECT item_id, name, category_path, item_condition_name, color, price
+  FROM merrec_items
+  WHERE brand_id = 17470
+), engagement AS (
+  SELECT e.item_id,
+         SUM(CASE WHEN e.event_type = 'item_view' THEN 1 ELSE 0 END) AS views,
+         SUM(CASE WHEN e.event_type = 'item_like' THEN 1 ELSE 0 END) AS likes,
+         SUM(CASE WHEN e.event_type = 'buy_comp' THEN 1 ELSE 0 END) AS buys,
+         COUNT(DISTINCT e.user_id) AS users
+  FROM merrec_events e
+  JOIN pokemon_catalog p ON p.item_id = e.item_id
+  WHERE e.event_time < TIMESTAMP '2023-09-01 00:00:00'
+  GROUP BY e.item_id
+)
+SELECT p.item_id, p.name, p.category_path, p.item_condition_name, p.color, p.price,
+       g.views, g.likes, g.buys, g.users
+FROM engagement g
+JOIN pokemon_catalog p ON p.item_id = g.item_id
+WHERE g.views >= 50
+ORDER BY g.views DESC, p.item_id
+LIMIT {max_entities}
diff --git a/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/02_forward_validation.sql b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/02_forward_validation.sql
new file mode 100644
index 000000000..2ed48a125
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/02_forward_validation.sql
@@ -0,0 +1,44 @@
+WITH labels AS (
+  SELECT d.item_id, {label} AS label
+  FROM {label_table} d
+), early AS (
+  SELECT l.label, e.user_id, e.event_type
+  FROM merrec_events e
+  JOIN labels l ON l.item_id = e.item_id
+  WHERE e.event_time < TIMESTAMP '2023-09-01 00:00:00'
+), catalog AS (
+  SELECT l.label, COUNT(*) AS items, ROUND(AVG(i.price), 2) AS mean_price
+  FROM labels l
+  JOIN merrec_items i ON i.item_id = l.item_id
+  GROUP BY l.label
+), engagement AS (
+  SELECT label,
+         SUM(CASE WHEN event_type = 'item_view' THEN 1 ELSE 0 END) AS views,
+         SUM(CASE WHEN event_type = 'item_like' THEN 1 ELSE 0 END) AS likes,
+         SUM(CASE WHEN event_type = 'buy_comp' THEN 1 ELSE 0 END) AS buys
+  FROM early
+  GROUP BY label
+), viewers AS (
+  SELECT DISTINCT label, user_id FROM early WHERE event_type = 'item_view'
+), pokemon_buyers AS (
+  SELECT e.user_id,
+         MAX(CASE WHEN e.event_time >= TIMESTAMP '2023-07-01 00:00:00'
+                   AND e.event_time < TIMESTAMP '2023-09-01 00:00:00' THEN 1 ELSE 0 END) AS prior_buyer,
+         MAX(CASE WHEN e.event_time >= TIMESTAMP '2023-09-01 00:00:00' THEN 1 ELSE 0 END) AS later_buyer
+  FROM merrec_events e
+  JOIN merrec_items i ON i.item_id = e.item_id
+  WHERE i.brand_id = 17470 AND e.event_type = 'buy_comp'
+  GROUP BY e.user_id
+), outcome AS (
+  SELECT v.label, COUNT(*) AS shoppers, SUM(COALESCE(b.later_buyer, 0)) AS buyers
+  FROM viewers v
+  LEFT JOIN pokemon_buyers b ON b.user_id = v.user_id
+  WHERE COALESCE(b.prior_buyer, 0) = 0
+  GROUP BY v.label
+)
+SELECT c.label, c.items, c.mean_price, g.views, g.likes, g.buys,
+       COALESCE(o.shoppers, 0) AS shoppers, COALESCE(o.buyers, 0) AS buyers
+FROM catalog c
+LEFT JOIN engagement g ON g.label = c.label
+LEFT JOIN outcome o ON o.label = c.label
+ORDER BY c.label
diff --git a/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/03_control_rules.sql b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/03_control_rules.sql
new file mode 100644
index 000000000..96ddb50de
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/03_control_rules.sql
@@ -0,0 +1,24 @@
+WITH titled AS (
+  SELECT d.item_id, i.category_path, ' ' || LOWER(i.name) || ' ' AS title
+  FROM pokemon_items d
+  JOIN merrec_items i ON i.item_id = d.item_id
+)
+SELECT item_id,
+       CASE
+         WHEN category_path LIKE '%Trading Cards%' AND (
+              title LIKE '% lot %' OR title LIKE '%bundle%' OR title LIKE '%binder%'
+              OR title LIKE '%bulk%' OR title LIKE '%collection%')
+           THEN 'tcg_bundle_lot_or_binder'
+         WHEN category_path LIKE '%Trading Cards%' THEN 'tcg_sealed_or_single_card'
+         WHEN category_path LIKE '%Video games%' OR title LIKE '%nintendo%' OR title LIKE '%switch%'
+              OR title LIKE '% ds %' OR title LIKE '% 3ds %' OR title LIKE '% gba %' OR title LIKE '%game boy%'
+              OR title LIKE '%gameboy%' OR title LIKE '%cartridge%' OR title LIKE '%go plus%'
+           THEN 'video_game_or_hardware'
+         WHEN category_path LIKE '%Stuffed Animals%' OR title LIKE '%plush%' OR title LIKE '%squishmallow%'
+              OR title LIKE '%figure%' OR title LIKE '%funko%' OR title LIKE '%shirt%' OR title LIKE '%hoodie%'
+              OR title LIKE '%backpack%'
+           THEN 'plush_toy_or_apparel'
+         ELSE 'unclassified'
+       END AS rule_label
+FROM titled
+ORDER BY item_id
diff --git a/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/compare_captures.py b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/compare_captures.py
new file mode 100644
index 000000000..6eab44fda
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/compare_captures.py
@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""Compare a live capture with its replay; exit 1 on the first difference.
+
+Ignored keys: timestamps, timings, query ids, the environment block, the mode
+and the replay sources. Keys ending in `elapsed_s` or `wall_s` and keys starting
+with `latency_` are timings. The decision batches and totals depend on how
+many answers came from the registry, so their counters (`registry_hits`,
+`hit_rate`, `backend_calls`, `api_calls`, `backend`, `output_tokens`,
+`cost_usd`) are not compared; every replay batch must report zero API calls.
+Each recorded response is compared on its entity key, model id, answers and
+input tokens, as in cases B and C: `source`, the raw `response`,
+`output_tokens` and `cost_usd` are null for a registry-served decision. The
+top-level `model` is skipped because the replay backend reports no model name.
+
+Usage: python3 cases/e_pokemon_submarkets/compare_captures.py LIVE.json REPLAY.json
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import sys
+
+IGNORED = {"decided_at", "started_at", "finished_at", "admission_wait_ms", "query_id", "environment", "mode",
+           "replay_sources"}
+TIMING_SUFFIXES = ("elapsed_s", "wall_s")
+COUNTERS = {"registry_hits", "hit_rate", "backend_calls", "api_calls", "backend", "input_tokens", "output_tokens",
+            "cost_usd"}
+RESPONSE_UNCOMPARED = {"source", "response", "output_tokens", "cost_usd"}
+
+
+def ignored(key: str, path: tuple) -> bool:
+    if key in IGNORED or key.startswith("latency_") or key.endswith(TIMING_SUFFIXES):
+        return True
+    if key == "model":
+        return path == ()
+    if path[:1] in (("decisions",), ("totals",)):
+        return key in COUNTERS
+    return len(path) == 2 and path[0] == "responses" and key in RESPONSE_UNCOMPARED
+
+
+def first_difference(live, replay, path: tuple = ()) -> str | None:
+    if isinstance(live, dict) and isinstance(replay, dict):
+        for key in sorted(set(live) | set(replay)):
+            if ignored(key, path):
+                continue
+            if key not in live or key not in replay:
+                return f"{'/'.join(map(str, path + (key,)))}: present only in {'live' if key in live else 'replay'}"
+            difference = first_difference(live[key], replay[key], path + (key,))
+            if difference:
+                return difference
+        return None
+    if isinstance(live, list) and isinstance(replay, list):
+        if len(live) != len(replay):
+            return f"{'/'.join(map(str, path))}: length {len(live)} != {len(replay)}"
+        for index, (left, right) in enumerate(zip(live, replay)):
+            difference = first_difference(left, right, path + (index,))
+            if difference:
+                return difference
+        return None
+    if live != replay:
+        return f"{'/'.join(map(str, path))}: {live!r} != {replay!r}"
+    return None
+
+
+def replay_problems(replay: dict) -> str | None:
+    for batch in replay.get("decisions", []):
+        if batch.get("api_calls") != 0:
+            return f"replay batch {batch.get('name')!r} reports api_calls={batch.get('api_calls')}"
+    if (replay.get("totals") or {}).get("api_calls") != 0:
+        return f"replay totals report api_calls={replay['totals'].get('api_calls')}"
+    return None
+
+
+def main() -> int:
+    if len(sys.argv) != 3:
+        print(__doc__.strip().splitlines()[-1], file=sys.stderr)
+        return 2
+    live, replay = (json.loads(Path(name).read_text(encoding="utf-8")) for name in sys.argv[1:])
+    if live.get("mode") != "live" or replay.get("mode") != "replay":
+        print(f"expected a live and a replay capture, got {live.get('mode')!r} and {replay.get('mode')!r}")
+        return 2
+    problem = replay_problems(replay) or first_difference(live, replay)
+    if problem:
+        print(f"captures differ: {problem}")
+        return 1
+    print(f"captures match: {len(live.get('responses', {}))} responses, {len(live.get('stages', []))} stages, "
+          f"{len(live.get('results', {}))} result entries")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/policy.json b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/policy.json
new file mode 100644
index 000000000..4fd70a963
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/policy.json
@@ -0,0 +1 @@
+{"action_question": "is_tcg_card", "accept_min": 0.70, "review_min": 0.30}
diff --git a/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/questions.json b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/questions.json
new file mode 100644
index 000000000..954947b10
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/questions.json
@@ -0,0 +1,38 @@
+{
+  "submarket": {
+    "type": "choice",
+    "instructions": "On a peer-to-peer marketplace (Mercari), this listing carries the Pokemon brand. The state gives only the listing's title, category, condition, color and price. Classify the listing into the Pokemon sub-market it sells into.",
+    "criteria": {
+      "tcg_sealed_or_single_card": "One Pokemon Trading Card Game card or one factory-sealed card product (e.g., single cards, alt arts, graded slabs from PSA, BGS or CGC, promo cards, booster packs, booster boxes, Elite Trainer Boxes (ETB), premium collection boxes)",
+      "tcg_bundle_lot_or_binder": "Many Pokemon cards or several card products sold together (e.g., bulk lots, mixed card lots, binders filled with cards, whole collections, tins with assorted cards, bundles of several packs or boxes)",
+      "video_game_or_hardware": "Pokemon video games and gaming hardware (e.g., game cartridges, discs and cases, Nintendo Switch, DS, 3DS, Game Boy and GBA games, consoles, Pokemon GO Plus+, strategy guides)",
+      "plush_toy_or_apparel": "Pokemon merchandise outside cards and games (e.g., plush, Squishmallows, figures, Funko, statues, apparel, hats, backpacks, keychains, stickers, home decor)"
+    }
+  },
+  "habitual_collector_score": {
+    "type": "score",
+    "instructions": "How habitual a Pokemon buyer is the typical shopper who opens this listing?",
+    "criteria": [
+      "0 - Casual gift shopper or novelty browser with a one-off interest",
+      "1 - Mainstream video game buyer who returns for new game releases",
+      "2 - Active hobbyist browsing card lots, bulk and binders",
+      "3 - Dedicated TCG collector chasing single cards, graded slabs and sealed boxes"
+    ]
+  },
+  "is_tcg_card": {
+    "type": "noul",
+    "instructions": "Is this listing a Pokemon Trading Card Game product, so that the shoppers who view it can be treated as a trading-card audience?",
+    "criteria": {
+      "true": "The listing sells Pokemon TCG cards or sealed card product: single or graded cards, booster packs, booster boxes, ETBs, tins, card lots or binders of cards",
+      "false": "The listing sells something else: a video game, console or accessory, plush, figure, apparel, decor, an empty box, a display case or other merchandise"
+    }
+  },
+  "is_hardware_or_game": {
+    "type": "noul",
+    "instructions": "Is this listing a video game, a game console or a gaming hardware accessory?",
+    "criteria": {
+      "true": "The listing sells a game cartridge, disc or case, a Nintendo Switch, DS, 3DS, Game Boy or GBA game or console, a Pokemon GO Plus+ or another gaming device or accessory",
+      "false": "The listing sells cards, sealed card product, plush, figures, apparel or other merchandise"
+    }
+  }
+}
diff --git a/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/run.py b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/run.py
new file mode 100644
index 000000000..0d5fccc43
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/e_pokemon_submarkets/run.py
@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""Case E (Project, forward validation): Pokemon sub-markets and the next months' purchase rate on MerRec.
+
+The probe (`01_probe.sql`) returns the `--max-entities` (default 200) Pokemon
+items (`brand_id = 17470`) with the most `item_view` events before 2023-09-01,
+at least 50 views each, with their views, likes, `buy_comp` purchases and
+distinct users (any event type) before September. The decision model sees only
+the title, category path, condition, color and price of each item; the state
+text never carries the engagement numbers, the item id or any later outcome, so
+two listings with the same text share one registry decision. The answers become
+`registry/pokemon_items.engine.parquet` (entity_key, item_id, answers, band),
+registered as `pokemon_items`.
+
+`02_forward_validation.sql` is a template over `{label_table}` and a label
+expression `{label}`. A shopper is eligible when they viewed a labelled item
+before 2023-09-01 and completed no Pokemon purchase (`buy_comp` on any
+`brand_id = 17470` item) from 2023-07-01 to 2023-09-01. The outcome is a Pokemon
+purchase of any Pokemon item on or after 2023-09-01, up to the end of the data.
+A shopper who viewed items of several labels counts once in each label, so the
+groups overlap and the two-proportion z treats them as independent samples; the
+z values are therefore approximate. The statement also reports the catalog side
+per label: items, mean price and the views, likes and purchases of the labelled
+items before September.
+
+Decisions the spec leaves open:
+
+- Every probe item is grouped by its `submarket` choice whatever its band. The
+  band follows the action noul `is_tcg_card` (policy: accept at 0.70, review at
+  0.30, no `require`) and selects the review queue.
+- The collector contrast splits items on the expected value of
+  `habitual_collector_score` (at least 2 against below 2).
+- The control is `03_control_rules.sql`: category path and title keywords in a
+  fixed priority order (Trading Cards category with a bundle keyword, other
+  Trading Cards, video game category or game keywords, plush or apparel
+  category and keywords, otherwise unclassified). Short tokens (`lot`, `ds`,
+  `3ds`, `gba`) match as space-delimited words so that `lot` skips `Lotad` and
+  `ds` skips `cards`. The labels go to `registry/pokemon_item_rules.engine.parquet`,
+  registered as `pokemon_item_rules`, and the same forward validation runs over
+  them.
+- `plan_prior` records the earlier pilot's sub-market figures beside the
+  measured ones. The pilot used its own eligibility query, so the run reports
+  both without a pass or fail check.
+- The audience re-ranking lift of the earlier pilot (+17.2% on a 5,000-shopper
+  target list) is out of scope and not implemented.
+
+Commands, from fixture/demo/decision_models/scripts, one GPU run at a time:
+
+    eval "$(grep -E '^export (JEV_API_URL|JEV_API_KEY)=' ~/.bashrc)"
+    flock /tmp/decision-demo-gpu.lock python3 cases/e_pokemon_submarkets/run.py --mode live
+    flock /tmp/decision-demo-gpu.lock python3 cases/e_pokemon_submarkets/run.py --mode replay
+    python3 cases/e_pokemon_submarkets/compare_captures.py \\
+        ../captures/e_pokemon_submarkets_live.json ../captures/e_pokemon_submarkets_replay.json
+
+Replay serves each decision from the registry, or from the live capture when
+the registry lacks it (pass `--registry-dir "$(mktemp -d)"` to force the
+capture path), with zero API calls. Pass the same `--max-entities` as the live
+run. A live run served entirely from the registry records no backend cost or
+raw responses; keep the capture of the run that called the backend and pass it
+to `--replay-from` for a replay from captures alone.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from itertools import combinations
+import math
+from pathlib import Path
+import sys
+
+import pyarrow as pa
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+from client.capture import merrec_license  # noqa: E402
+from client.case import Case, build_parser  # noqa: E402
+from client.decision_client import Entity  # noqa: E402
+from client.policy import BANDS  # noqa: E402
+
+CASE_DIR = Path(__file__).resolve().parent
+REGISTRY = "pokemon_items"
+DECISION_TABLE = "pokemon_items"
+RULES_TABLE = "pokemon_item_rules"
+DEFAULT_MAX_ENTITIES = 200
+UNCLASSIFIED = "unclassified"
+COLLECTOR_LABEL = ("CASE WHEN d.habitual_collector_score >= 2 THEN 'score_2_to_3' "
+                   "ELSE 'score_0_to_1' END")
+# Earlier pilot (buyers, eligible shoppers) per sub-market, reported beside the measured rates.
+PLAN_PRIOR = {
+    "tcg_bundle_lot_or_binder": (89, 7211),
+    "tcg_sealed_or_single_card": (189, 18220),
+    "video_game_or_hardware": (34, 4803),
+    "plush_toy_or_apparel": (20, 4701),
+}
+PLAN_PRIOR_CONTRAST = ("tcg_bundle_lot_or_binder", "plush_toy_or_apparel", 4.5)
+Z95 = 1.959963984540054
+
+
+def native_stage(case: Case, name: str, sql: str):
+    """Run one statement and stop the case when it crossed into DataFusion on the host."""
+    stage = case.run_stage(name, sql)
+    boundaries = (stage.execution or {}).get("host_datafusion_boundary_count")
+    if boundaries != 0:
+        case.capture.note(f"stage {name} reported host_datafusion_boundary_count={boundaries}; "
+                          f"EXPLAIN summary {stage.explain}")
+        case.finish()
+        raise SystemExit(f"stage {name} has host_datafusion_boundary_count={boundaries}; "
+                         f"EXPLAIN summary {stage.explain}")
+    return stage
+
+
+def render(sql: str, **values) -> str:
+    for name, value in values.items():
+        sql = sql.replace("{" + name + "}", str(value))
+    return sql
+
+
+def wilson(successes: int, total: int, z: float = Z95) -> list[float] | None:
+    if total == 0:
+        return None
+    p = successes / total
+    denominator = 1 + z * z / total
+    center = (p + z * z / (2 * total)) / denominator
+    half = z * math.sqrt(p * (1 - p) / total + z * z / (4 * total * total)) / denominator
+    return [center - half, center + half]
+
+
+def two_proportion_z(x1: int, n1: int, x2: int, n2: int) -> float | None:
+    """Pooled two-proportion z for rate 1 minus rate 2."""
+    if n1 == 0 or n2 == 0:
+        return None
+    pooled = (x1 + x2) / (n1 + n2)
+    se = math.sqrt(pooled * (1 - pooled) * (1 / n1 + 1 / n2))
+    return (x1 / n1 - x2 / n2) / se if se else None
+
+
+def state_text(row: dict) -> str:
+    price = row["price"]
+    return (
+        f"Listing Title: {row['name'] or ''}\n"
+        f"Category: {row['category_path'] or 'not specified'}\n"
+        f"Condition: {row['item_condition_name'] or 'not specified'}\n"
+        f"Color: {row['color'] or 'not specified'}\n"
+        f"Price: {'not specified' if price is None else f'${price:.2f}'}"
+    )
+
+
+def rate_rows(stage_rows: list[dict]) -> list[dict]:
+    rows = []
+    for row in stage_rows:
+        shoppers, buyers = row["shoppers"], row["buyers"]
+        rows.append({
+            "label": row["label"], "items": row["items"], "mean_price": row["mean_price"],
+            "views": row["views"], "likes": row["likes"], "buys": row["buys"],
+            "shoppers": shoppers, "buyers": buyers,
+            "rate": buyers / shoppers if shoppers else None,
+            "wilson95": wilson(buyers, shoppers),
+        })
+    return rows
+
+
+def pairwise(rows: list[dict], exclude: tuple[str, ...] = ()) -> list[dict]:
+    """z for every pair of labels, ordered by |z| descending; the higher rate comes first in each pair."""
+    usable = [row for row in rows if row["label"] not in exclude and row["shoppers"]]
+    pairs = []
+    for left, right in combinations(usable, 2):
+        high, low = (left, right) if left["rate"] >= right["rate"] else (right, left)
+        z = two_proportion_z(high["buyers"], high["shoppers"], low["buyers"], low["shoppers"])
+        pairs.append({
+            "higher": high["label"], "lower": low["label"],
+            "higher_rate": high["rate"], "lower_rate": low["rate"],
+            "rate_ratio": high["rate"] / low["rate"] if low["rate"] else None,
+            "difference_pp": 100 * (high["rate"] - low["rate"]),
+            "z": z,
+        })
+    pairs.sort(key=lambda pair: -abs(pair["z"] or 0.0))
+    return pairs
+
+
+def plan_prior(rows: list[dict], pairs: list[dict]) -> dict:
+    by_label = {row["label"]: row for row in rows}
+    prior_rows = []
+    for label, (buyers, shoppers) in PLAN_PRIOR.items():
+        measured = by_label.get(label, {})
+        prior_rows.append({
+            "label": label, "prior_buyers": buyers, "prior_shoppers": shoppers, "prior_rate": buyers / shoppers,
+            "measured_buyers": measured.get("buyers"), "measured_shoppers": measured.get("shoppers"),
+            "measured_rate": measured.get("rate"), "measured_wilson95": measured.get("wilson95"),
+            "prior_inside_measured_interval": (measured.get("wilson95") is not None
+                                               and measured["wilson95"][0] <= buyers / shoppers
+                                               <= measured["wilson95"][1]),
+        })
+    high, low, prior_z = PLAN_PRIOR_CONTRAST
+    measured = next((pair for pair in pairs if {pair["higher"], pair["lower"]} == {high, low}), None)
+    return {
+        "rows": prior_rows,
+        "contrast": {"higher": high, "lower": low, "prior_z": prior_z,
+                     "prior_z_recomputed": two_proportion_z(*PLAN_PRIOR[high], *PLAN_PRIOR[low]),
+                     "measured_higher": measured["higher"] if measured else None,
+                     "measured_z": measured["z"] if measured else None},
+        "rank_order_prior": sorted(PLAN_PRIOR, key=lambda label: -PLAN_PRIOR[label][0] / PLAN_PRIOR[label][1]),
+        "rank_order_measured": [row["label"] for row in sorted(rows, key=lambda row: -(row["rate"] or 0.0))],
+    }
+
+
+def control_summary(items: list[dict], rates: list[dict]) -> dict:
+    total = len(items)
+    unclassified = [item for item in items if item["rule_label"] == UNCLASSIFIED]
+    classified = [item for item in items if item["rule_label"] != UNCLASSIFIED]
+    agree = sum(item["rule_label"] == item["submarket"] for item in items)
+    classified_agree = sum(item["rule_label"] == item["submarket"] for item in classified)
+    confusion = Counter((item["rule_label"], item["submarket"]) for item in items)
+    return {
+        "items": total,
+        "agreement": agree / total if total else None,
+        "agreement_wilson95": wilson(agree, total),
+        "classified_items": len(classified),
+        "classified_agreement": classified_agree / len(classified) if classified else None,
+        "unclassified_items": len(unclassified),
+        "unclassified_share": len(unclassified) / total if total else None,
+        "unclassified_model_submarkets": dict(sorted(Counter(item["submarket"] for item in unclassified).items())),
+        "confusion_rule_vs_model": [{"rule_label": rule, "submarket": model, "items": count}
+                                    for (rule, model), count in sorted(confusion.items())],
+        "disagreements": [{key: item[key] for key in ("item_id", "name", "category_path", "rule_label", "submarket")}
+                          for item in classified if item["rule_label"] != item["submarket"]],
+        "forward_validation": rates,
+        "pairwise_z": pairwise(rates, exclude=(UNCLASSIFIED,)),
+        "pairwise_z_with_unclassified": pairwise(rates),
+    }
+
+
+def collector_contrast(rows: list[dict]) -> dict:
+    by_label = {row["label"]: row for row in rows}
+    high, low = by_label.get("score_2_to_3"), by_label.get("score_0_to_1")
+    contrast = {"threshold": 2.0, "groups": rows}
+    if high and low:
+        contrast.update({
+            "z_high_minus_low": two_proportion_z(high["buyers"], high["shoppers"], low["buyers"], low["shoppers"]),
+            "rate_ratio": high["rate"] / low["rate"] if low["rate"] else None,
+            "difference_pp": 100 * (high["rate"] - low["rate"]),
+        })
+    return contrast
+
+
+def stage_timings(case: Case) -> list[dict]:
+    return [{"name": stage["name"], "rows": stage["rows"], "elapsed_s": stage["elapsed_s"],
+             "gpu_path": (stage["explain"] or {}).get("gpu_path"),
+             "cpu_boundaries": (stage["explain"] or {}).get("cpu_boundaries"),
+             "host_datafusion_boundary_count": (stage["execution"] or {}).get("host_datafusion_boundary_count")}
+            for stage in case.capture.data["stages"]]
+
+
+def main() -> None:
+    args = build_parser(__doc__.splitlines()[0]).parse_args()
+    max_entities = args.max_entities or DEFAULT_MAX_ENTITIES
+    case = Case(CASE_DIR, args, license=merrec_license())
+    case.algeon.register_merrec()
+    case.capture.result("max_entities", max_entities)
+
+    probe = native_stage(case, "probe", render(case.sql("01_probe.sql"), max_entities=max_entities)).table.to_pylist()
+    entities = [Entity(str(row["item_id"]), state_text(row)) for row in probe]
+    case.capture.result("probe", {
+        "items": len(probe),
+        "distinct_states": len({entity.state for entity in entities}),
+        "views_min": min(row["views"] for row in probe),
+        "views_max": max(row["views"] for row in probe),
+        "views_total": sum(row["views"] for row in probe),
+        "likes_total": sum(row["likes"] for row in probe),
+        "buys_total": sum(row["buys"] for row in probe),
+        "users_total": sum(row["users"] for row in probe),
+        "mean_price": sum(row["price"] or 0.0 for row in probe) / len(probe),
+        "category_paths": dict(Counter(row["category_path"] for row in probe).most_common()),
+    })
+
+    registry = case.registry(REGISTRY)
+    batch = case.decide(registry, entities)
+    decisions = batch.by_key()
+    bands, counts = case.policy.apply(batch.decisions)
+    item_ids = [int(decision.entity_key) for decision in batch.decisions]
+    engine = registry.engine_table(batch.decisions, {"item_id": pa.array(item_ids, pa.int64())})
+    engine = engine.append_column("band", pa.array([bands[str(item_id)] for item_id in item_ids], pa.string()))
+    case.decision_table(DECISION_TABLE, engine)
+    case.capture.result("band_counts", counts)
+    case.capture.result("submarket_counts", dict(sorted(Counter(
+        decision.value("submarket") for decision in batch.decisions).items())))
+    case.capture.result("submarket_band_counts", [
+        {"submarket": submarket, **{band: sum(1 for decision in batch.decisions
+                                              if decision.value("submarket") == submarket
+                                              and bands[decision.entity_key] == band) for band in BANDS}}
+        for submarket in case.questions["submarket"]["criteria"]])
+
+    template = case.sql("02_forward_validation.sql")
+    forward = rate_rows(native_stage(case, "forward_validation", render(
+        template, label_table=DECISION_TABLE, label="d.submarket")).table.to_pylist())
+    pairs = pairwise(forward)
+    case.capture.result("forward_validation", forward)
+    case.capture.result("pairwise_z", pairs)
+    case.capture.result("largest_contrast", pairs[0] if pairs else None)
+    case.capture.result("plan_prior", plan_prior(forward, pairs))
+
+    collector = rate_rows(native_stage(case, "collector_contrast", render(
+        template, label_table=DECISION_TABLE, label=COLLECTOR_LABEL)).table.to_pylist())
+    case.capture.result("collector_contrast", collector_contrast(collector))
+
+    rules = {row["item_id"]: row["rule_label"]
+             for row in native_stage(case, "control_rules", case.sql("03_control_rules.sql")).table.to_pylist()}
+    missing = set(item_ids) - set(rules)
+    if missing:
+        raise SystemExit(f"control rules returned no label for {len(missing)} items")
+    case.decision_table(RULES_TABLE, pa.table({
+        "item_id": pa.array(item_ids, pa.int64()),
+        "rule_label": pa.array([rules[item_id] for item_id in item_ids], pa.string()),
+    }))
+    control_rates = rate_rows(native_stage(case, "control_forward_validation", render(
+        template, label_table=RULES_TABLE, label="d.rule_label")).table.to_pylist())
+
+    items = []
+    for row in probe:
+        decision = decisions[str(row["item_id"])]
+        items.append({
+            "item_id": row["item_id"], "name": row["name"], "category_path": row["category_path"],
+            "price": row["price"], "views": row["views"], "likes": row["likes"], "buys": row["buys"],
+            "users": row["users"], "submarket": decision.value("submarket"),
+            "submarket_p": decision.probability("submarket"),
+            "habitual_collector_score": decision.value("habitual_collector_score"),
+            "is_tcg_card": decision.value("is_tcg_card"),
+            "is_hardware_or_game": decision.value("is_hardware_or_game"),
+            "band": bands[str(row["item_id"])], "rule_label": rules[row["item_id"]],
+        })
+    case.capture.result("control", control_summary(items, control_rates))
+    case.capture.result("review_queue", [
+        {key: item[key] for key in ("item_id", "name", "category_path", "price", "views", "submarket", "submarket_p",
+                                    "is_tcg_card", "is_hardware_or_game", "habitual_collector_score", "rule_label")}
+        for item in items if item["band"] == "review"])
+    case.capture.result("items", items)
+    case.capture.result("stage_timings", stage_timings(case))
+    case.finish()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/fixture/demo/decision_models/scripts/cases/f_import_gate/01_probe.sql b/fixture/demo/decision_models/scripts/cases/f_import_gate/01_probe.sql
new file mode 100644
index 000000000..bd7feaf82
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/f_import_gate/01_probe.sql
@@ -0,0 +1,31 @@
+-- One row per DLL that has an import node in V1 (symbols imported by 3..100 Win32 challenge samples):
+-- its edges, distinct samples, distinct symbols and its 8 most widely imported symbols.
+WITH import_nodes AS (
+  SELECT node_id, name, dll_lower, doc_freq
+  FROM ember_f_nodes
+  WHERE kind = 'import' AND doc_freq >= 3 AND doc_freq <= 100
+), dll_stats AS (
+  SELECT n.dll_lower, COUNT(*) AS edges, COUNT(DISTINCT sn.id) AS samples, COUNT(DISTINCT sn.node_id) AS symbols
+  FROM ember_f_sample_nodes sn
+  JOIN import_nodes n ON n.node_id = sn.node_id
+  GROUP BY n.dll_lower
+  HAVING COUNT(DISTINCT sn.id) >= 3
+), ranked AS (
+  SELECT dll_lower, name, doc_freq,
+         ROW_NUMBER() OVER (PARTITION BY dll_lower ORDER BY doc_freq DESC, name) AS rk
+  FROM import_nodes
+)
+SELECT d.dll_lower, d.edges, d.samples, d.symbols,
+       MAX(CASE WHEN r.rk = 1 THEN r.name END) AS symbol_1,
+       MAX(CASE WHEN r.rk = 2 THEN r.name END) AS symbol_2,
+       MAX(CASE WHEN r.rk = 3 THEN r.name END) AS symbol_3,
+       MAX(CASE WHEN r.rk = 4 THEN r.name END) AS symbol_4,
+       MAX(CASE WHEN r.rk = 5 THEN r.name END) AS symbol_5,
+       MAX(CASE WHEN r.rk = 6 THEN r.name END) AS symbol_6,
+       MAX(CASE WHEN r.rk = 7 THEN r.name END) AS symbol_7,
+       MAX(CASE WHEN r.rk = 8 THEN r.name END) AS symbol_8
+FROM dll_stats d
+LEFT JOIN ranked r ON r.dll_lower = d.dll_lower AND r.rk <= 8
+GROUP BY d.dll_lower, d.edges, d.samples, d.symbols
+ORDER BY d.samples DESC, d.dll_lower
+LIMIT {max_entities}
diff --git a/fixture/demo/decision_models/scripts/cases/f_import_gate/02_coverage.sql b/fixture/demo/decision_models/scripts/cases/f_import_gate/02_coverage.sql
new file mode 100644
index 000000000..50a1db85b
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/f_import_gate/02_coverage.sql
@@ -0,0 +1,21 @@
+-- Retained nodes per Win32 sample in one variant, with its label and the labeled size of its family,
+-- plus the variant's distinct node count on every row.
+WITH {variant_edges}, per_sample AS (
+  SELECT src AS id, COUNT(*) AS retained_nodes
+  FROM variant_edges
+  GROUP BY src
+), family_sizes AS (
+  SELECT family, COUNT(*) AS family_members
+  FROM ember_f_samples
+  WHERE labeled AND file_type = 'Win32'
+  GROUP BY family
+), node_count AS (
+  SELECT COUNT(DISTINCT dst) AS variant_nodes FROM variant_edges
+)
+SELECT p.id, p.retained_nodes, s.labeled, s.family, COALESCE(f.family_members, 0) AS family_members,
+       c.variant_nodes
+FROM per_sample p
+JOIN ember_f_samples s ON s.id = p.id
+LEFT JOIN family_sizes f ON f.family = s.family
+CROSS JOIN node_count c
+ORDER BY p.id
diff --git a/fixture/demo/decision_models/scripts/cases/f_import_gate/03_precision_pairs.sql b/fixture/demo/decision_models/scripts/cases/f_import_gate/03_precision_pairs.sql
new file mode 100644
index 000000000..b6393c76b
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/f_import_gate/03_precision_pairs.sql
@@ -0,0 +1,28 @@
+-- The 300 most similar pairs among labeled Win32 samples with at least 5 retained nodes in the variant.
+-- Pairs tied on similarity are ordered by the number of retained nodes the two samples share, counted
+-- by joining the variant edges to themselves on dst as 07_challenge_import_review.sql counts shared imports.
+WITH {variant_edges}, labeled_active AS (
+  SELECT e.src AS id, s.family
+  FROM variant_edges e
+  JOIN ember_f_samples s ON s.id = e.src
+  WHERE s.labeled
+  GROUP BY e.src, s.family
+  HAVING COUNT(*) >= 5
+)
+SELECT j.first, j.second, j.similarity, COUNT(*) AS shared_nodes,
+       a.family AS family_first, b.family AS family_second
+FROM cugraph_jaccard(
+  edges => (SELECT {edge_columns} FROM variant_edges),
+  vertex_pairs => (
+    SELECT a.id AS first, b.id AS second
+    FROM labeled_active a JOIN labeled_active b ON a.id < b.id
+  ),
+  directed => false
+) j
+JOIN variant_edges first_edges ON first_edges.src = j.first
+JOIN variant_edges second_edges ON second_edges.src = j.second AND second_edges.dst = first_edges.dst
+JOIN labeled_active a ON a.id = j.first
+JOIN labeled_active b ON b.id = j.second
+GROUP BY j.first, j.second, j.similarity, a.family, b.family
+ORDER BY j.similarity DESC, shared_nodes DESC, j.first, j.second
+LIMIT 300
diff --git a/fixture/demo/decision_models/scripts/cases/f_import_gate/04_seed_neighbors.sql b/fixture/demo/decision_models/scripts/cases/f_import_gate/04_seed_neighbors.sql
new file mode 100644
index 000000000..e8c4957f3
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/f_import_gate/04_seed_neighbors.sql
@@ -0,0 +1,24 @@
+-- Similarity of each fixed seed to every labeled Win32 sample with at least 5 retained nodes in the variant.
+-- A seed with no retained node is absent from the graph and returns no rows.
+WITH {variant_edges}, labeled_active AS (
+  SELECT e.src AS id, s.family
+  FROM variant_edges e
+  JOIN ember_f_samples s ON s.id = e.src
+  WHERE s.labeled
+  GROUP BY e.src, s.family
+  HAVING COUNT(*) >= 5
+), seeds AS (
+  SELECT src AS id FROM variant_edges WHERE src IN ({seed_ids}) GROUP BY src
+)
+SELECT j.first AS seed_id, j.second AS neighbor_id, j.similarity, a.family AS neighbor_family
+FROM cugraph_jaccard(
+  edges => (SELECT {edge_columns} FROM variant_edges),
+  vertex_pairs => (
+    SELECT s.id AS first, a.id AS second
+    FROM seeds s CROSS JOIN labeled_active a
+    WHERE a.id <> s.id
+  ),
+  directed => false
+) j
+JOIN labeled_active a ON a.id = j.second
+ORDER BY j.first, j.similarity DESC, j.second
diff --git a/fixture/demo/decision_models/scripts/cases/f_import_gate/05_exact_pairs.sql b/fixture/demo/decision_models/scripts/cases/f_import_gate/05_exact_pairs.sql
new file mode 100644
index 000000000..13f2212a9
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/f_import_gate/05_exact_pairs.sql
@@ -0,0 +1,23 @@
+-- Labeled pairs with at least 5 retained nodes each whose Jaccard similarity is 1.0, and how many of them
+-- share a family. IDF-weighted sums of identical node sets can land one ulp below 1.0, so the bound
+-- allows 1e-9; with `= 1.0` V2 keeps 738 of the 793 identical-set pairs that V1 counts.
+WITH {variant_edges}, labeled_active AS (
+  SELECT e.src AS id, s.family
+  FROM variant_edges e
+  JOIN ember_f_samples s ON s.id = e.src
+  WHERE s.labeled
+  GROUP BY e.src, s.family
+  HAVING COUNT(*) >= 5
+)
+SELECT COUNT(*) AS pairs, COALESCE(SUM(CASE WHEN a.family = b.family THEN 1 ELSE 0 END), 0) AS same_family
+FROM cugraph_jaccard(
+  edges => (SELECT {edge_columns} FROM variant_edges),
+  vertex_pairs => (
+    SELECT a.id AS first, b.id AS second
+    FROM labeled_active a JOIN labeled_active b ON a.id < b.id
+  ),
+  directed => false
+) j
+JOIN labeled_active a ON a.id = j.first
+JOIN labeled_active b ON b.id = j.second
+WHERE j.similarity >= 0.999999999
diff --git a/fixture/demo/decision_models/scripts/cases/f_import_gate/compare_captures.py b/fixture/demo/decision_models/scripts/cases/f_import_gate/compare_captures.py
new file mode 100644
index 000000000..d6a108dfc
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/f_import_gate/compare_captures.py
@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""Compare a live capture of case F with its replay; exit 1 on the first difference.
+
+Ignored keys: timestamps, timings, query ids, the environment block, the mode
+and the replay sources. Keys ending in `elapsed_s` or `wall_s` and keys starting
+with `latency_` are timings. The decision batches and totals depend on how
+many answers came from the registry, so their counters (`registry_hits`,
+`hit_rate`, `backend_calls`, `api_calls`, `backend`, `output_tokens`,
+`cost_usd`) are not compared; every replay batch must report zero API calls.
+Each recorded response is compared on its entity key, model id, answers and
+input tokens, as in cases A, B and C: `source`, the raw `response`,
+`output_tokens` and `cost_usd` are null for a registry-served decision. The
+top-level `model` is skipped because the replay backend reports no model name.
+
+Usage: compare_captures.py LIVE.json REPLAY.json
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import sys
+
+IGNORED = {"decided_at", "started_at", "finished_at", "admission_wait_ms", "query_id", "environment", "mode",
+           "replay_sources"}
+TIMING_SUFFIXES = ("elapsed_s", "wall_s")
+COUNTERS = {"registry_hits", "hit_rate", "backend_calls", "api_calls", "backend", "input_tokens", "output_tokens",
+            "cost_usd"}
+RESPONSE_UNCOMPARED = {"source", "response", "output_tokens", "cost_usd"}
+
+
+def ignored(key: str, path: tuple) -> bool:
+    if key in IGNORED or key.startswith("latency_") or key.endswith(TIMING_SUFFIXES):
+        return True
+    if key == "model":
+        return path == ()
+    if path[:1] in (("decisions",), ("totals",)):
+        return key in COUNTERS
+    return len(path) == 2 and path[0] == "responses" and key in RESPONSE_UNCOMPARED
+
+
+def first_difference(live, replay, path: tuple = ()) -> str | None:
+    if isinstance(live, dict) and isinstance(replay, dict):
+        for key in sorted(set(live) | set(replay)):
+            if ignored(key, path):
+                continue
+            if key not in live or key not in replay:
+                return f"{'/'.join(map(str, path + (key,)))}: present only in {'live' if key in live else 'replay'}"
+            difference = first_difference(live[key], replay[key], path + (key,))
+            if difference:
+                return difference
+        return None
+    if isinstance(live, list) and isinstance(replay, list):
+        if len(live) != len(replay):
+            return f"{'/'.join(map(str, path))}: length {len(live)} != {len(replay)}"
+        for index, (left, right) in enumerate(zip(live, replay)):
+            difference = first_difference(left, right, path + (index,))
+            if difference:
+                return difference
+        return None
+    if live != replay:
+        return f"{'/'.join(map(str, path))}: {live!r} != {replay!r}"
+    return None
+
+
+def replay_problems(replay: dict) -> str | None:
+    for batch in replay.get("decisions", []):
+        if batch.get("api_calls") != 0:
+            return f"replay batch {batch.get('name')!r} reports api_calls={batch.get('api_calls')}"
+    if (replay.get("totals") or {}).get("api_calls") != 0:
+        return f"replay totals report api_calls={replay['totals'].get('api_calls')}"
+    return None
+
+
+def main() -> int:
+    if len(sys.argv) != 3:
+        print(__doc__.strip().splitlines()[-1], file=sys.stderr)
+        return 2
+    live, replay = (json.loads(Path(name).read_text(encoding="utf-8")) for name in sys.argv[1:])
+    if live.get("mode") != "live" or replay.get("mode") != "replay":
+        print(f"expected a live and a replay capture, got {live.get('mode')!r} and {replay.get('mode')!r}")
+        return 2
+    problem = replay_problems(replay) or first_difference(live, replay)
+    if problem:
+        print(f"captures differ: {problem}")
+        return 1
+    print(f"captures match: {len(live.get('responses', {}))} responses, {len(live.get('stages', []))} stages, "
+          f"{len(live.get('results', {}))} result entries")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/fixture/demo/decision_models/scripts/cases/f_import_gate/control_dll_list.json b/fixture/demo/decision_models/scripts/cases/f_import_gate/control_dll_list.json
new file mode 100644
index 000000000..194e98345
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/f_import_gate/control_dll_list.json
@@ -0,0 +1,15 @@
+{
+  "description": "Hand-written CRT, GUI and COM boilerplate DLLs for variant V3; every DLL whose name starts with a listed prefix is excluded as well.",
+  "dlls": [
+    "msvbvm60.dll", "msvbvm50.dll",
+    "msvcrt.dll", "msvcr70.dll", "msvcr71.dll", "msvcr80.dll", "msvcr90.dll", "msvcr100.dll", "msvcr110.dll",
+    "msvcr120.dll",
+    "msvcp60.dll", "msvcp71.dll", "msvcp80.dll", "msvcp90.dll", "msvcp100.dll", "msvcp110.dll", "msvcp120.dll",
+    "msvcp140.dll", "vcruntime140.dll", "vcruntime140_1.dll", "ucrtbase.dll",
+    "mfc42.dll", "mfc42u.dll", "mfc71.dll", "mfc80.dll", "mfc90.dll", "mfc100.dll", "mfc100u.dll", "mfc110u.dll",
+    "mfc120u.dll", "mfc140.dll", "mfc140u.dll",
+    "user32.dll", "gdi32.dll", "gdiplus.dll", "comctl32.dll", "comdlg32.dll", "imm32.dll", "uxtheme.dll",
+    "ole32.dll", "oleaut32.dll", "mscoree.dll"
+  ],
+  "prefixes": ["api-ms-win-crt-"]
+}
diff --git a/fixture/demo/decision_models/scripts/cases/f_import_gate/policy.json b/fixture/demo/decision_models/scripts/cases/f_import_gate/policy.json
new file mode 100644
index 000000000..dff900605
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/f_import_gate/policy.json
@@ -0,0 +1 @@
+{"action_question": "is_compiler_or_gui_noise", "accept_min": 0.70, "review_min": 0.30, "require": {"dll_role": ["language_crt_or_gui_boilerplate"]}}
diff --git a/fixture/demo/decision_models/scripts/cases/f_import_gate/prepare_tables.py b/fixture/demo/decision_models/scripts/cases/f_import_gate/prepare_tables.py
new file mode 100644
index 000000000..c72299f9d
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/f_import_gate/prepare_tables.py
@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""Materialize the EMBER2024 challenge node tables that case F reads.
+
+Writes three Parquet tables under `fixture/demo/decision_models/data/ember/`:
+
+- `ember_f_samples.parquet`: every challenge sample with its metadata id
+  (`id`, `sha256`, `file_type`, `family`, `labeled`). Ids come from
+  `input_metadata_challenge.parquet`; this script assigns no sample ids.
+- `ember_f_nodes.parquet`: one row per graph node seen in a Win32 sample.
+  Import symbols get `node_id` from 100000000 and behaviors from 200000000,
+  each in (kind, name) order. `doc_freq` counts distinct Win32 samples.
+- `ember_f_sample_nodes.parquet`: one row per Win32 sample and node it has.
+
+Behaviors come from the raw challenge JSONL: CAPA `caps[].Capability`, MITRE
+`ttps[].Technique` and MBC `mbc[].Behavior`, deduplicated by sha256. The script
+checks that imports with doc frequency 3..100 reproduce the published V0 graph
+(4,988 symbols, 80,673 edges) and prints the counts either way. Rerunning it
+rewrites the same files.
+
+Usage, from fixture/demo/decision_models/scripts:
+
+    python3 cases/f_import_gate/prepare_tables.py
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+import glob
+import json
+from pathlib import Path
+import sys
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+from client.algeon import DEMO_ROOT, ROOT  # noqa: E402
+from client.registry import write_parquet_atomic  # noqa: E402
+
+DATA_DIR = DEMO_ROOT / "decision_models/data/ember"
+RESEARCH_DIR = ROOT / "target/ember2024-research"
+RAW_GLOB = str(DEMO_ROOT / "ember2024/raw/*_challenge_malicious.jsonl")
+IMPORT_BASE = 100_000_000
+BEHAVIOR_BASE = 200_000_000
+# JSONL list field, item key and node kind for each behavior source.
+BEHAVIOR_SOURCES = (("caps", "Capability", "capa"), ("ttps", "Technique", "mitre"), ("mbc", "Behavior", "mbc"))
+PUBLISHED_V0 = {"symbols": 4988, "edges": 80673}
+
+SAMPLES_SCHEMA = pa.schema([
+    ("id", pa.int64()), ("sha256", pa.string()), ("file_type", pa.string()), ("family", pa.string()),
+    ("labeled", pa.bool_()),
+])
+NODES_SCHEMA = pa.schema([
+    ("node_id", pa.int64()), ("kind", pa.string()), ("name", pa.string()), ("dll_lower", pa.string()),
+    ("doc_freq", pa.int64()),
+])
+SAMPLE_NODES_SCHEMA = pa.schema([("id", pa.int64()), ("node_id", pa.int64())])
+
+
+def load_samples() -> list[dict]:
+    rows = pq.read_table(RESEARCH_DIR / "input_metadata_challenge.parquet",
+                         columns=["id", "sha256", "file_type", "family"]).to_pylist()
+    for row in rows:
+        row["labeled"] = bool(row["family"])
+    return sorted(rows, key=lambda row: row["id"])
+
+
+def load_imports(win32: set[int]) -> dict[tuple[str, str], set[int]]:
+    table = pq.read_table(RESEARCH_DIR / "input_imports_challenge.parquet", columns=["id", "symbol"])
+    members: dict[tuple[str, str], set[int]] = defaultdict(set)
+    for sample_id, symbol in zip(table.column("id").to_pylist(), table.column("symbol").to_pylist()):
+        if sample_id in win32:
+            members[("import", symbol)].add(sample_id)
+    return members
+
+
+def load_behaviors(id_of_sha: dict[str, int], win32: set[int]) -> tuple[dict[tuple[str, str], set[int]], dict]:
+    members: dict[tuple[str, str], set[int]] = defaultdict(set)
+    seen: set[str] = set()
+    stats = {"files": 0, "lines": 0, "duplicate_sha256": 0, "unknown_sha256": 0, "win32_with_behaviors": 0}
+    for path in sorted(glob.glob(RAW_GLOB)):
+        stats["files"] += 1
+        with open(path, encoding="utf-8") as handle:
+            for line in handle:
+                if not line.strip():
+                    continue
+                stats["lines"] += 1
+                record = json.loads(line)
+                sha = record["sha256"]
+                if sha in seen:
+                    stats["duplicate_sha256"] += 1
+                    continue
+                seen.add(sha)
+                sample_id = id_of_sha.get(sha)
+                if sample_id is None:
+                    stats["unknown_sha256"] += 1
+                    continue
+                if sample_id not in win32:
+                    continue
+                found = False
+                for field, key, kind in BEHAVIOR_SOURCES:
+                    for item in record.get(field) or []:
+                        name = item.get(key)
+                        if name:
+                            members[(kind, name)].add(sample_id)
+                            found = True
+                stats["win32_with_behaviors"] += found
+    return members, stats
+
+
+def main() -> None:
+    samples = load_samples()
+    id_of_sha = {row["sha256"]: row["id"] for row in samples}
+    win32 = {row["id"] for row in samples if row["file_type"] == "Win32"}
+    imports = load_imports(win32)
+    behaviors, behavior_stats = load_behaviors(id_of_sha, win32)
+
+    nodes, sample_nodes = [], []
+    for base, members in ((IMPORT_BASE, imports), (BEHAVIOR_BASE, behaviors)):
+        for offset, (kind, name) in enumerate(sorted(members)):
+            node_id = base + offset
+            nodes.append({"node_id": node_id, "kind": kind, "name": name,
+                          "dll_lower": name.split("!", 1)[0].lower() if kind == "import" else None,
+                          "doc_freq": len(members[(kind, name)])})
+            sample_nodes.extend({"id": sample_id, "node_id": node_id} for sample_id in sorted(members[(kind, name)]))
+    sample_nodes.sort(key=lambda row: (row["id"], row["node_id"]))
+
+    write_parquet_atomic(pa.Table.from_pylist(samples, schema=SAMPLES_SCHEMA), DATA_DIR / "ember_f_samples.parquet")
+    write_parquet_atomic(pa.Table.from_pylist(nodes, schema=NODES_SCHEMA), DATA_DIR / "ember_f_nodes.parquet")
+    write_parquet_atomic(pa.Table.from_pylist(sample_nodes, schema=SAMPLE_NODES_SCHEMA),
+                         DATA_DIR / "ember_f_sample_nodes.parquet")
+
+    v0 = [node for node in nodes if node["kind"] == "import" and 3 <= node["doc_freq"] <= 100]
+    v0_counts = {"symbols": len(v0), "edges": sum(node["doc_freq"] for node in v0)}
+    kinds = defaultdict(int)
+    for node in nodes:
+        kinds[node["kind"]] += 1
+    labeled = [row for row in samples if row["id"] in win32 and row["labeled"]]
+    report = {
+        "samples": len(samples), "win32": len(win32), "win32_labeled": len(labeled),
+        "nodes": len(nodes), "nodes_by_kind": dict(sorted(kinds.items())), "sample_nodes": len(sample_nodes),
+        "behaviors": behavior_stats, "v0": v0_counts, "published_v0": PUBLISHED_V0,
+        "v0_matches_published": v0_counts == PUBLISHED_V0,
+    }
+    print(json.dumps(report, indent=2))
+    if v0_counts != PUBLISHED_V0:
+        raise SystemExit(f"V0 construction gives {v0_counts}; the published graph has {PUBLISHED_V0}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/fixture/demo/decision_models/scripts/cases/f_import_gate/questions.json b/fixture/demo/decision_models/scripts/cases/f_import_gate/questions.json
new file mode 100644
index 000000000..bfb576347
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/f_import_gate/questions.json
@@ -0,0 +1,29 @@
+{
+  "dll_role": {
+    "type": "choice",
+    "instructions": "The state describes one Windows DLL as it appears in the import tables of Win32 malware samples from the EMBER2024 challenge set: how many samples import it, how many distinct functions they import from it, and its most widely imported functions. Classify the role of this DLL in an ordinary Windows program.",
+    "criteria": {
+      "language_crt_or_gui_boilerplate": "A language runtime, C or C++ runtime, .NET loader, or GUI, windowing, drawing or COM framework library that a compiler or UI toolkit links into ordinary programs regardless of what they do (e.g., MSVBVM60 and MSVBVM50 for Visual Basic 6; MSVCRT, MSVCR*, MSVCP*, VCRUNTIME140, UCRTBASE and api-ms-win-crt-* for the Microsoft C and C++ runtime; MSCOREE for .NET; MFC42 and MFC140U for MFC; USER32, GDI32, GDIPLUS, COMCTL32, COMDLG32, IMM32 and UXTHEME for windows and drawing; OLE32 and OLEAUT32 for COM)",
+      "bundled_third_party_app_lib": "A third-party or application-specific library shipped next to one program or framework and not part of Windows (e.g., Qt5Core or Qt5Gui for Qt, SDL2, libssl and libcrypto from OpenSSL, libcurl, sqlite3, zlib1, Python or Lua runtimes, game engine, VoIP or media SDK libraries)",
+      "os_system_network_crypto_or_security_api": "A Windows system library that exposes operating-system services: process, thread, memory, file, registry, service, network, cryptography, security, user session or diagnostics APIs (e.g., KERNEL32, ADVAPI32, NTDLL, WININET, WINHTTP, WS2_32, CRYPT32, SHELL32, PSAPI, DBGHELP, URLMON, NETAPI32, WTSAPI32)"
+    }
+  },
+  "is_compiler_or_gui_noise": {
+    "type": "noul",
+    "instructions": "A similarity graph links Windows malware samples through the imported functions they share and is used to find samples of the same malware family. Should the unweighted import edges to this DLL be dropped from that graph because two samples sharing these imports only indicates that both were built with the same compiler, language runtime or UI toolkit?",
+    "criteria": {
+      "true": "Shared imports from this DLL mostly reflect the build toolchain or UI framework (language runtime, C or C++ runtime, GUI, drawing or COM boilerplate); unrelated programs built the same way share them, so the edges add noise to family similarity.",
+      "false": "Shared imports from this DLL can reflect shared functionality, shared code or the same bundled component (system, network, crypto, security or process APIs, or one specific third-party library), so the edges carry evidence that two samples are related."
+    }
+  },
+  "forensic_signal_score": {
+    "type": "score",
+    "instructions": "How much does sharing imports from this DLL tell a malware analyst about two samples being related or having the same capabilities?",
+    "criteria": [
+      "0 - none: imported by almost any program built with the same compiler, runtime or UI toolkit",
+      "1 - weak: common Windows functionality used alike by benign and malicious programs",
+      "2 - moderate: capability-bearing APIs such as networking, cryptography, process or registry manipulation, or a specific bundled library",
+      "3 - strong: abuse-prone or rare APIs such as code injection, anti-debugging, credential access, service or driver control, or a library tied to one toolset"
+    ]
+  }
+}
diff --git a/fixture/demo/decision_models/scripts/cases/f_import_gate/run.py b/fixture/demo/decision_models/scripts/cases/f_import_gate/run.py
new file mode 100644
index 000000000..eaec5a076
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/f_import_gate/run.py
@@ -0,0 +1,430 @@
+#!/usr/bin/env python3
+"""Case F1 (Purify gate): five EMBER2024 import graph variants and the model-audited DLL exclusion.
+
+The cohort is the 3,225 Win32 files of the EMBER2024 challenge split (2,325
+with a family label, 152 families, 68 with at least 2 labeled members). The
+probe lists every DLL that has an import node in V1 with its footprint and its
+8 most widely imported functions; the decision model judges whether shared
+imports from that DLL are compiler or GUI boilerplate (`dll_noise`). Five graph
+variants are built in SQL from `variant_edges.sql`:
+
+    V0  imports only, doc frequency 3..100 (the published graph: 4,988 symbols, 80,673 edges)
+    V1  V0 plus CAPA, MITRE and MBC behavior nodes, doc frequency 3..300
+    V2  V1 with IDF edge weights LN(3225.0 / doc_freq) (non-model control)
+    V3  V1 minus the DLLs of control_dll_list.json (analyst control)
+    V4  V1 minus the DLLs in the accept band of `is_compiler_or_gui_noise`
+
+Each variant runs five native statements: coverage (02), the 300 most similar
+labeled pairs (03), the neighbors of 50 fixed seeds (04), the labeled pairs at
+Jaccard 1.0 (05) and the published review queue
+`07_challenge_import_review.sql` over the variant's tables. The gate passes
+when V4's precision@300 exceeds V2's and V3's and both bootstrap intervals of
+the paired differences exclude 0. The verdict is recorded either way, together
+with the same rule applied to `exact_match_precision`, which does not decide
+the gate; F2 is not part of this script.
+
+Commands, from fixture/demo/decision_models/scripts (prepare once, then one GPU
+run at a time under the shared lock):
+
+    python3 cases/f_import_gate/prepare_tables.py
+    eval "$(grep -E '^export (JEV_API_URL|JEV_API_KEY)=' ~/.bashrc)"
+    flock /tmp/decision-demo-gpu.lock python3 cases/f_import_gate/run.py --mode live
+    flock /tmp/decision-demo-gpu.lock python3 cases/f_import_gate/run.py --mode replay
+    python3 cases/f_import_gate/compare_captures.py \\
+        ../captures/f_import_gate_live.json ../captures/f_import_gate_replay.json
+
+Decisions taken while implementing the plan:
+
+- The probe returns the 112 DLLs that own at least one V1 import node. Counting
+  DLL-level frequency over every import gives 116; the 4 extra DLLs have no
+  symbol imported by 3..100 samples, so no variant can change through them.
+- Coverage is a fourth statement per variant: per-sample retained node counts
+  with labels and family sizes, plus the distinct node count. The 50 seeds are
+  drawn from V0's coverage rows, so every variant ranks the same seeds.
+- A seed with no retained node in a variant is absent from that graph; its 15
+  neighbor slots count as misses.
+- The review queue keeps the text of 07 and swaps five relation names: edges,
+  symbols, sample counts and metadata for the variant's CTEs and
+  `ember_f_samples`, and the seed table for a CTE that casts the Int32 seed id
+  to the Int64 vertex type of the variant edges. For V2 both edge subqueries
+  also pass the IDF `weight`, so the weighted variant changes the PageRank
+  candidates and the Jaccard order. In V1..V4 `retained_import_count` counts
+  behavior nodes too, and `example_shared_import` can name a behavior.
+- More than 300 labeled pairs reach Jaccard 1.0 in every variant (538 in V0,
+  about 800 in V1..V4), so 03 orders pairs tied on similarity by the number of
+  retained nodes the two samples share, then by id. `exact_match_precision`
+  covers the whole block at 1.0; its bound allows 1e-9 because IDF-weighted
+  sums of identical node sets can fall one ulp below 1.0 in V2.
+- The published 07 runs once unchanged as `review_published`; the capture
+  records whether V0's queue matches it.
+- Bootstrap intervals use 2,000 resamples, a fresh `random.Random(20261019)`
+  per interval and the percentile bounds `sorted[50]` and `sorted[1949]`. Paired
+  differences resample both variants' outcomes independently per iteration.
+  Besides V4 - V2 and V4 - V3, the capture records V1 - V0 (the behavior nodes'
+  contribution); it is not part of the gate.
+
+EMBER2024 is a research dataset; the capture records it as `dataset`.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import random
+import re
+import sys
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+from client.algeon import DEMO_ROOT, statement_body  # noqa: E402
+from client.case import Case, build_parser  # noqa: E402
+from client.decision_client import Entity  # noqa: E402
+
+CASE_DIR = Path(__file__).resolve().parent
+DATA_DIR = DEMO_ROOT / "decision_models/data/ember"
+REVIEW_SQL = DEMO_ROOT / "ember2024/scripts/scale/07_challenge_import_review.sql"
+CASE_TABLES = ("ember_f_samples", "ember_f_nodes", "ember_f_sample_nodes")
+REGISTRY = "dll_noise"
+DEFAULT_MAX_ENTITIES = 120
+WIN32_SAMPLES = 3225
+SEED = 20261019
+RESAMPLES = 2000
+SEED_COUNT = 50
+NEIGHBORS = 15
+PRECISION_PAIRS = 300
+MIN_ACTIVE_NODES = 5
+ALL_KINDS = ("import", "capa", "mitre", "mbc")
+EXCLUDE_NONE = "ember_f_exclude_none"
+EXCLUDE_CONTROL = "ember_f_exclude_control"
+EXCLUDE_MODEL = "ember_f_exclude_model"
+VARIANTS = {
+    "V0": {"graph": "imports, doc frequency 3..100", "kinds": ("import",), "exclusion": EXCLUDE_NONE,
+           "weighted": False},
+    "V1": {"graph": "V0 plus CAPA, MITRE and MBC behaviors, doc frequency 3..300", "kinds": ALL_KINDS,
+           "exclusion": EXCLUDE_NONE, "weighted": False},
+    "V2": {"graph": f"V1 with IDF edge weights LN({WIN32_SAMPLES}.0 / doc_freq)", "kinds": ALL_KINDS,
+           "exclusion": EXCLUDE_NONE, "weighted": True},
+    "V3": {"graph": "V1 minus the hand-written CRT, GUI and COM DLL list", "kinds": ALL_KINDS,
+           "exclusion": EXCLUDE_CONTROL, "weighted": False},
+    "V4": {"graph": "V1 minus DLLs in the accept band of is_compiler_or_gui_noise", "kinds": ALL_KINDS,
+           "exclusion": EXCLUDE_MODEL, "weighted": False},
+}
+DIFFERENCES = (("V4", "V2"), ("V4", "V3"), ("V1", "V0"))
+DIFFERENCE_METRICS = ("precision_at_300", "exact_match_precision", "seed_family_rate")
+GATE_DIFFERENCES = (("V4", "V2"), ("V4", "V3"))
+# 07 relation name -> variant relation; the seed CTE casts the Int32 id to the Int64 vertex type.
+REVIEW_RELATIONS = {
+    "ember_48_challenge_import_edges": "variant_import_edges",
+    "ember_48_challenge_import_symbols": "variant_import_symbols",
+    "ember_48_challenge_import_sample_counts": "variant_sample_counts",
+    "ember_metadata_challenge": "ember_f_samples",
+    "ember_49_challenge_graph_seed": "variant_seed",
+}
+REVIEW_EDGE_PROJECTION = "SELECT src_id AS src, dst_id AS dst\n"
+EXCLUSION_SCHEMA = pa.schema([("dll_lower", pa.string())])
+
+
+def native_stage(case: Case, name: str, sql: str):
+    """Run one statement and stop the case when it crossed into DataFusion on the host."""
+    stage = case.run_stage(name, sql)
+    boundaries = (stage.execution or {}).get("host_datafusion_boundary_count")
+    if boundaries != 0:
+        case.capture.note(f"stage {name} reported host_datafusion_boundary_count={boundaries}; "
+                          f"EXPLAIN summary {stage.explain}")
+        case.finish()
+        raise SystemExit(f"stage {name} has host_datafusion_boundary_count={boundaries}; "
+                         f"EXPLAIN summary {stage.explain}")
+    return stage
+
+
+def register_tables(case: Case) -> None:
+    case.algeon.register_ember()
+    for name in CASE_TABLES:
+        path = DATA_DIR / f"{name}.parquet"
+        if not path.exists():
+            raise SystemExit(f"{path} is missing; run cases/f_import_gate/prepare_tables.py first")
+        case.algeon.register_parquet(name, path)
+
+
+def variant_edges(case: Case, variant: str) -> str:
+    spec = VARIANTS[variant]
+    weight = f", LN({WIN32_SAMPLES}.0 / CAST(n.doc_freq AS DOUBLE)) AS weight" if spec["weighted"] else ""
+    return (statement_body(case.sql("variant_edges.sql"))
+            .replace("{kinds}", ", ".join(f"'{kind}'" for kind in spec["kinds"]))
+            .replace("{exclusion_table}", spec["exclusion"])
+            .replace("{weight_column}", weight))
+
+
+def variant_sql(case: Case, name: str, variant: str, **values) -> str:
+    sql = (case.sql(name)
+           .replace("{variant_edges}", variant_edges(case, variant))
+           .replace("{edge_columns}", "src, dst, weight" if VARIANTS[variant]["weighted"] else "src, dst"))
+    for key, value in values.items():
+        sql = sql.replace("{" + key + "}", value)
+    return sql
+
+
+def review_sql(case: Case, variant: str) -> str:
+    """07_challenge_import_review.sql over the variant's edges, symbols and sample counts."""
+    body = statement_body(REVIEW_SQL.read_text(encoding="utf-8")).rstrip().rstrip(";")
+    if not body.startswith("WITH candidates AS ("):
+        raise SystemExit(f"{REVIEW_SQL} no longer starts with the candidates CTE")
+    weighted = VARIANTS[variant]["weighted"]
+    if weighted:
+        if body.count(REVIEW_EDGE_PROJECTION) != 2:
+            raise SystemExit(f"{REVIEW_SQL} no longer has the two edge projections the weighted variant extends")
+        body = body.replace(REVIEW_EDGE_PROJECTION, "SELECT src_id AS src, dst_id AS dst, weight\n")
+    for published, local in REVIEW_RELATIONS.items():
+        body, count = re.subn(rf"\b{published}\b", local, body)
+        if count == 0:
+            raise SystemExit(f"{REVIEW_SQL} no longer reads {published}")
+    prefix = "\n".join([
+        f"WITH {variant_edges(case, variant)}, variant_import_edges AS (",
+        f"  SELECT src AS src_id, dst AS dst_id{', weight' if weighted else ''} FROM variant_edges",
+        "), variant_import_symbols AS (",
+        "  SELECT node_id AS symbol_id, name AS symbol FROM ember_f_nodes",
+        "), variant_sample_counts AS (",
+        "  SELECT src AS id, COUNT(*) AS retained_import_count FROM variant_edges GROUP BY src",
+        "), variant_seed AS (",
+        "  SELECT CAST(id AS BIGINT) AS id FROM ember_49_challenge_graph_seed",
+        "), ",
+    ])
+    return prefix + body[len("WITH "):]
+
+
+def state(row: dict) -> str:
+    functions = [row[f"symbol_{index}"].split("!", 1)[1] for index in range(1, 9) if row[f"symbol_{index}"]]
+    return "\n".join([
+        f"DLL: {row['dll_lower']}",
+        f"Footprint among the {WIN32_SAMPLES:,} Win32 malware samples of the EMBER2024 challenge set, counting only "
+        f"functions imported by 3 to 100 samples: {row['samples']:,} samples import {row['symbols']:,} distinct "
+        f"function{'' if row['symbols'] == 1 else 's'} from this DLL ({row['edges']:,} sample-function pairs).",
+        f"Most widely imported of those functions: {', '.join(functions)}",
+    ])
+
+
+def control_list(graph_dlls: set[str], all_dlls: set[str]) -> tuple[list[str], dict]:
+    spec = json.loads((CASE_DIR / "control_dll_list.json").read_text(encoding="utf-8"))
+    listed = list(spec["dlls"])
+    prefix_matches = sorted(dll for dll in all_dlls if dll.startswith(tuple(spec["prefixes"])))
+    entries = sorted(set(listed) | set(prefix_matches))
+    return entries, {
+        "listed": listed,
+        "prefixes": spec["prefixes"],
+        "prefix_matches": prefix_matches,
+        "excluded": len(entries),
+        "present": [dll for dll in entries if dll in graph_dlls],
+        "absent": [dll for dll in entries if dll not in graph_dlls],
+    }
+
+
+def register_exclusion(case: Case, name: str, dlls: list[str]) -> None:
+    table = pa.Table.from_pylist([{"dll_lower": dll} for dll in sorted(set(dlls))], schema=EXCLUSION_SCHEMA)
+    case.algeon.register_parquet(name, DATA_DIR / f"{name}.parquet", table)
+
+
+def percentile_interval(stats: list[float]) -> list[float]:
+    ordered = sorted(stats)
+    return [ordered[int(0.025 * len(ordered))], ordered[int(0.975 * len(ordered)) - 1]]
+
+
+def mean(values) -> float | None:
+    values = list(values)
+    return sum(values) / len(values) if values else None
+
+
+def bootstrap_mean(values: list[float]) -> list[float] | None:
+    if not values:
+        return None
+    rng = random.Random(SEED)
+    return percentile_interval([mean(rng.choices(values, k=len(values))) for _ in range(RESAMPLES)])
+
+
+def bootstrap_difference(left: list[float], right: list[float]) -> list[float] | None:
+    if not left or not right:
+        return None
+    rng = random.Random(SEED)
+    return percentile_interval([mean(rng.choices(left, k=len(left))) - mean(rng.choices(right, k=len(right)))
+                                for _ in range(RESAMPLES)])
+
+
+def difference_rows(samples: dict[str, list[float]]) -> list[dict]:
+    return [{"difference": f"{left} - {right}", "value": mean(samples[left]) - mean(samples[right]),
+             "ci95": bootstrap_difference(samples[left], samples[right])} for left, right in DIFFERENCES]
+
+
+def verdict(metric: str, rows: list[dict]) -> dict:
+    by_name = {row["difference"]: row for row in rows}
+    gate_rows = [by_name[f"{left} - {right}"] for left, right in GATE_DIFFERENCES]
+    wins = all(row["value"] > 0 for row in gate_rows)
+    excludes_zero = all(row["ci95"] is not None and (row["ci95"][0] > 0 or row["ci95"][1] < 0) for row in gate_rows)
+    return {"rule": f"V4 {metric} exceeds V2 and V3, and both difference intervals exclude 0",
+            "v4_exceeds_v2_and_v3": wins, "intervals_exclude_zero": excludes_zero, "passed": wins and excludes_zero}
+
+
+def coverage(rows: list[dict]) -> dict:
+    return {
+        "nodes": rows[0]["variant_nodes"] if rows else 0,
+        "edges": sum(row["retained_nodes"] for row in rows),
+        "samples_with_1_node": len(rows),
+        "samples_with_5_nodes": sum(row["retained_nodes"] >= MIN_ACTIVE_NODES for row in rows),
+        "labeled_active": sum(row["labeled"] and row["retained_nodes"] >= MIN_ACTIVE_NODES for row in rows),
+    }
+
+
+def draw_seeds(v0_rows: list[dict]) -> tuple[list[int], int]:
+    pool = sorted(row["id"] for row in v0_rows
+                  if row["labeled"] and row["family_members"] >= 2 and row["retained_nodes"] >= MIN_ACTIVE_NODES)
+    return sorted(random.Random(SEED).sample(pool, SEED_COUNT)), len(pool)
+
+
+def seed_hits(rows: list[dict], seeds: list[int], family_of: dict[int, str]) -> list[int]:
+    neighbors: dict[int, list[dict]] = {seed: [] for seed in seeds}
+    for row in rows:
+        neighbors[row["seed_id"]].append(row)
+    hits = []
+    for seed in seeds:
+        top = sorted(neighbors[seed], key=lambda row: (-row["similarity"], row["neighbor_id"]))[:NEIGHBORS]
+        hits.append(sum(row["neighbor_family"] == family_of[seed] for row in top))
+    return hits
+
+
+def main() -> None:
+    parser = build_parser(__doc__.splitlines()[0])
+    args = parser.parse_args()
+    case = Case(CASE_DIR, args)
+    case.capture.data["dataset"] = "EMBER2024 challenge split"
+    max_entities = args.max_entities or DEFAULT_MAX_ENTITIES
+
+    register_tables(case)
+    probe = native_stage(case, "probe", case.sql("01_probe.sql").replace("{max_entities}", str(max_entities)))
+    dll_rows = probe.table.to_pylist()
+    case.capture.result("probe", {"dlls": len(dll_rows), "max_entities": max_entities,
+                                  "rows": [{key: row[key] for key in ("dll_lower", "edges", "samples", "symbols")}
+                                           for row in dll_rows]})
+
+    registry = case.registry(REGISTRY)
+    entities = [Entity(row["dll_lower"], state(row)) for row in dll_rows]
+    batch = case.decide(registry, entities)
+    decisions = batch.decisions
+    bands, band_counts = case.policy.apply(decisions)
+    engine = registry.engine_table(decisions, {"dll_lower": [decision.entity_key for decision in decisions]})
+    engine = engine.append_column("band", pa.array([bands[decision.entity_key] for decision in decisions]))
+    case.decision_table(REGISTRY, engine)
+
+    nodes = pq.read_table(DATA_DIR / "ember_f_nodes.parquet", columns=["kind", "dll_lower", "doc_freq"]).to_pylist()
+    all_dlls = {node["dll_lower"] for node in nodes if node["kind"] == "import"}
+    graph_dlls = {node["dll_lower"] for node in nodes if node["kind"] == "import" and 3 <= node["doc_freq"] <= 100}
+    control_entries, control_record = control_list(graph_dlls, all_dlls)
+    accepted = sorted(key for key, band in bands.items() if band == "accept")
+    register_exclusion(case, EXCLUDE_NONE, [])
+    register_exclusion(case, EXCLUDE_CONTROL, control_entries)
+    register_exclusion(case, EXCLUDE_MODEL, accepted)
+    control_set = set(control_entries)
+    case.capture.result("bands", band_counts)
+    case.capture.result("decisions", [
+        {"dll_lower": decision.entity_key, "dll_role": decision.value("dll_role"),
+         "dll_role_p": decision.probability("dll_role"),
+         "is_compiler_or_gui_noise": decision.value("is_compiler_or_gui_noise"),
+         "forensic_signal_score": decision.value("forensic_signal_score"),
+         "band": bands[decision.entity_key], "in_control_list": decision.entity_key in control_set}
+        for decision in sorted(decisions, key=lambda decision: decision.entity_key)])
+    case.capture.result("review_queue", [
+        {"dll_lower": decision.entity_key, "dll_role": decision.value("dll_role"),
+         "is_compiler_or_gui_noise": decision.value("is_compiler_or_gui_noise"),
+         "forensic_signal_score": decision.value("forensic_signal_score")}
+        for decision in sorted(decisions, key=lambda decision: -decision.value("is_compiler_or_gui_noise"))
+        if bands[decision.entity_key] == "review"])
+    case.capture.result("dll_list_control", control_record)
+    case.capture.result("model_vs_control", {
+        "accepted": accepted,
+        "accepted_in_control_list": [dll for dll in accepted if dll in control_set],
+        "accepted_outside_control_list": [dll for dll in accepted if dll not in control_set],
+        "control_present_not_accepted": [dll for dll in control_record["present"] if dll not in set(accepted)],
+    })
+
+    published = native_stage(case, "review_published", REVIEW_SQL.read_text(encoding="utf-8"))
+    published_rows = published.table.to_pylist()
+
+    variants, queues = [], {}
+    samples: dict[str, dict[str, list[float]]] = {metric: {} for metric in DIFFERENCE_METRICS}
+    outcomes, exact_outcomes, seed_rates = (samples[metric] for metric in DIFFERENCE_METRICS)
+    seeds = family_of = None
+    precision_pairs, seed_hit_counts = {}, {}
+    for variant, spec in VARIANTS.items():
+        rows = native_stage(case, f"{variant}_coverage", variant_sql(case, "02_coverage.sql", variant)).table.to_pylist()
+        if seeds is None:
+            seeds, pool = draw_seeds(rows)
+            family_of = {row["id"]: row["family"] for row in rows}
+            case.capture.result("seeds", {"pool": pool, "ids": seeds})
+        pairs = native_stage(case, f"{variant}_precision_pairs",
+                             variant_sql(case, "03_precision_pairs.sql", variant)).table.to_pylist()
+        outcomes[variant] = [float(row["family_first"] == row["family_second"]) for row in pairs]
+        precision_pairs[variant] = [
+            {"first": row["first"], "second": row["second"], "similarity": row["similarity"],
+             "shared_nodes": row["shared_nodes"], "fam_a": row["family_first"], "fam_b": row["family_second"],
+             "same_family": row["family_first"] == row["family_second"]} for row in pairs]
+        exact = native_stage(case, f"{variant}_exact_pairs",
+                             variant_sql(case, "05_exact_pairs.sql", variant)).table.to_pylist()[0]
+        exact_outcomes[variant] = [1.0] * exact["same_family"] + [0.0] * (exact["pairs"] - exact["same_family"])
+        neighbors = native_stage(case, f"{variant}_seed_neighbors", variant_sql(
+            case, "04_seed_neighbors.sql", variant, seed_ids=", ".join(map(str, seeds)))).table.to_pylist()
+        hits = seed_hits(neighbors, seeds, family_of)
+        seed_hit_counts[variant] = hits
+        seed_rates[variant] = [hit / NEIGHBORS for hit in hits]
+        queue = native_stage(case, f"{variant}_review", review_sql(case, variant)).table.to_pylist()
+        queues[variant] = queue
+        variants.append({
+            "variant": variant,
+            "graph": spec["graph"],
+            "excluded_dlls": {EXCLUDE_NONE: 0, EXCLUDE_CONTROL: len(control_entries),
+                              EXCLUDE_MODEL: len(accepted)}[spec["exclusion"]],
+            **coverage(rows),
+            "precision_pairs": len(pairs),
+            "same_family_pairs": int(sum(outcomes[variant])),
+            "precision_at_300": mean(outcomes[variant]),
+            "precision_at_300_ci95": bootstrap_mean(outcomes[variant]),
+            "similarity_at_300": pairs[-1]["similarity"] if pairs else None,
+            "pairs_at_similarity_1": sum(row["similarity"] >= 0.999999999 for row in pairs),
+            "shared_nodes_range": [min(row["shared_nodes"] for row in pairs),
+                                   max(row["shared_nodes"] for row in pairs)] if pairs else None,
+            "exact_match_pairs": exact["pairs"],
+            "exact_match_same_family": exact["same_family"],
+            "exact_match_precision": mean(exact_outcomes[variant]),
+            "exact_match_precision_ci95": bootstrap_mean(exact_outcomes[variant]),
+            "seeds_in_graph": len({row["seed_id"] for row in neighbors}),
+            "seed_family_rate": mean(seed_rates[variant]),
+            "seed_family_rate_ci95": bootstrap_mean(seed_rates[variant]),
+            "review_rows": len(queue),
+            "review_labeled": sum(bool(row["family"]) for row in queue),
+        })
+
+    differences = {metric: difference_rows(samples[metric]) for metric in DIFFERENCE_METRICS}
+    case.capture.result("variants", variants)
+    case.capture.result("differences", differences)
+    case.capture.result("gate", {**verdict("precision_at_300", differences["precision_at_300"]),
+                                 "exact_match_precision": verdict("exact_match_precision",
+                                                                  differences["exact_match_precision"])})
+    v0_queue = [(row["candidate_id"], round(row["similarity"], 12)) for row in queues["V0"]]
+    case.capture.result("review_published", {
+        "rows": published_rows,
+        "v0_matches_published": v0_queue == [(row["candidate_id"], round(row["similarity"], 12))
+                                             for row in published_rows],
+    })
+    case.capture.result("variant_review_queues", queues)
+    case.capture.result("precision_pairs", precision_pairs)
+    case.capture.result("seed_hits", seed_hit_counts)
+    case.capture.result("bootstrap", {"seed": SEED, "resamples": RESAMPLES, "interval": "percentile sorted[50], sorted[1949]"})
+    print(json.dumps({"bands": band_counts, "gate": case.capture.data["results"]["gate"],
+                      "variants": [{key: row[key] for key in ("variant", "nodes", "edges", "labeled_active",
+                                                              "precision_at_300", "exact_match_precision",
+                                                              "seed_family_rate")}
+                                   for row in variants]}, default=str), file=sys.stderr)
+    case.finish()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/fixture/demo/decision_models/scripts/cases/f_import_gate/variant_edges.sql b/fixture/demo/decision_models/scripts/cases/f_import_gate/variant_edges.sql
new file mode 100644
index 000000000..a685f4686
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/cases/f_import_gate/variant_edges.sql
@@ -0,0 +1,14 @@
+-- Edge list of one graph variant: Win32 challenge sample to retained node.
+-- Imports keep doc frequency 3..100 and behaviors 3..300 among the 3,225 Win32 challenge samples.
+-- Nodes whose DLL is in the variant's exclusion table are dropped; behaviors carry no DLL and stay.
+-- Placeholders: {kinds} (quoted node kinds), {exclusion_table}, {weight_column} (empty, or the IDF weight).
+variant_edges AS (
+  SELECT sn.id AS src, sn.node_id AS dst{weight_column}
+  FROM ember_f_sample_nodes sn
+  JOIN ember_f_nodes n ON n.node_id = sn.node_id
+  LEFT JOIN {exclusion_table} x ON x.dll_lower = n.dll_lower
+  WHERE x.dll_lower IS NULL
+    AND n.kind IN ({kinds})
+    AND n.doc_freq >= 3
+    AND n.doc_freq <= CASE WHEN n.kind = 'import' THEN 100 ELSE 300 END
+)
diff --git a/fixture/demo/decision_models/scripts/client/__init__.py b/fixture/demo/decision_models/scripts/client/__init__.py
new file mode 100644
index 000000000..5f39ef014
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/client/__init__.py
@@ -0,0 +1,8 @@
+"""Decision-model loop client: probe, decide, recompute.
+
+The package is the orchestration layer of the decision-model demo. Algeon
+returns a bounded candidate set, a decision backend answers a fixed question
+set for each entity, the answers are cached in a Parquet registry with their
+provenance, and a typed decision table goes back into Algeon for the
+recompute query.
+"""
diff --git a/fixture/demo/decision_models/scripts/client/algeon.py b/fixture/demo/decision_models/scripts/client/algeon.py
new file mode 100644
index 000000000..a7a245121
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/client/algeon.py
@@ -0,0 +1,166 @@
+"""Flight SQL helper for the demo: timed queries, coverage checks, decision-table registration.
+
+Reuses `ResearchClient` from the Amazon Reviews research script for the Flight
+SQL protocol framing. Every executed stage records elapsed time, the query id,
+the plan-time coverage summary from `EXPLAIN GPU` and the runtime counters from
+the query stats, so a case can prove `host_datafusion_boundary_count = 0`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import importlib.util
+from pathlib import Path
+import time
+
+import pyarrow as pa
+
+from client.registry import write_parquet_atomic
+
+ROOT = Path(__file__).resolve().parents[5]
+DEMO_ROOT = ROOT / "fixture/demo"
+RESEARCH_CLIENT = DEMO_ROOT / "amazon_reviews_2023/scripts/amazon_reviews_research.py"
+DEFAULT_URI = "grpc://127.0.0.1:50064"
+EXECUTION_FIELDS = (
+    "native_plan_fragment_count", "host_datafusion_boundary_count", "allocator_high_water_bytes",
+    "admission_wait_ms", "query_grant_bytes", "output_rows", "retry_count", "post_native_execution_path",
+)
+
+MERREC_TABLES = {
+    "merrec_items": DEMO_ROOT / "merrec/parquet/items.parquet",
+    "merrec_events": DEMO_ROOT / "merrec/parquet/events.parquet",
+}
+AMAZON_TABLES = {
+    "products": DEMO_ROOT / "amazon_reviews_2023/parquet/products.parquet",
+    "reviews": DEMO_ROOT / "amazon_reviews_2023/parquet/reviews.parquet",
+    "semantic_reviews_text": ROOT / "target/amazon-reviews-bge-m3/reviews_text.parquet",
+    "semantic_reviews_vectors": ROOT / "target/amazon-reviews-bge-m3/reviews_vectors_compact.parquet",
+}
+EMBER_RESEARCH = ROOT / "target/ember2024-research"
+EMBER_TABLES = {
+    "ember_metadata_challenge": EMBER_RESEARCH / "input_metadata_challenge.parquet",
+    "ember_48_challenge_import_edges": EMBER_RESEARCH / "input_48_challenge_import_edges.parquet",
+    "ember_48_challenge_import_symbols": EMBER_RESEARCH / "input_48_challenge_import_symbols.parquet",
+    "ember_48_challenge_import_sample_counts": EMBER_RESEARCH / "input_48_challenge_import_sample_counts.parquet",
+    "ember_49_challenge_graph_seed": EMBER_RESEARCH / "input_49_challenge_graph_seed.parquet",
+}
+
+
+def _research_module():
+    spec = importlib.util.spec_from_file_location("amazon_reviews_research", RESEARCH_CLIENT)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+@dataclass
+class Stage:
+    name: str
+    table: pa.Table
+    elapsed_s: float
+    query_id: str | None
+    explain: dict | None
+    execution: dict | None
+
+    @property
+    def rows(self) -> int:
+        return self.table.num_rows
+
+    def record(self) -> dict:
+        return {
+            "name": self.name,
+            "rows": self.rows,
+            "elapsed_s": self.elapsed_s,
+            "query_id": self.query_id,
+            "explain": self.explain,
+            "execution": self.execution,
+        }
+
+
+def _parse_number(text: str):
+    if text in ("", "none", "null"):
+        return None
+    try:
+        return int(text)
+    except ValueError:
+        try:
+            return float(text)
+        except ValueError:
+            return text
+
+
+def statement_body(sql: str) -> str:
+    """The statement without leading `--` comment lines and blank lines."""
+    lines = sql.splitlines()
+    while lines and (not lines[0].strip() or lines[0].lstrip().startswith("--")):
+        lines.pop(0)
+    return "\n".join(lines).lstrip()
+
+
+def parse_execution_stats(stats: str) -> dict | None:
+    """Selected counters from the `[execution]` TSV section of GetQueryStats."""
+    if "[execution]" not in stats:
+        return None
+    section = stats.split("[execution]", 1)[1].lstrip("\n")
+    lines = [line for line in section.splitlines() if line and not line.startswith("[")]
+    if len(lines) < 2:
+        return None
+    header = lines[0].split("\t")
+    values = lines[1].split("\t")
+    record = dict(zip(header, values))
+    return {name: _parse_number(record[name]) for name in EXECUTION_FIELDS if name in record}
+
+
+class Algeon:
+    def __init__(self, uri: str = DEFAULT_URI, timeout: float = 1800.0):
+        module = _research_module()
+        self._client = module.ResearchClient(uri)
+        self._client.options = module.flight.FlightCallOptions(timeout=timeout)
+        self.uri = uri
+
+    def execute(self, sql: str) -> tuple[pa.Table, str | None]:
+        return self._client.execute(sql)
+
+    def stats(self, query_id: str) -> str:
+        return self._client.stats(query_id)
+
+    def explain_summary(self, sql: str) -> dict:
+        plan, _ = self.execute("EXPLAIN GPU FORMAT JSON " + sql)
+        for row in plan.to_pylist():
+            if row["row_kind"] == "summary":
+                return {key: row[key] for key in ("gpu_path", "gpu_fragments", "cpu_boundaries", "outcome")}
+        raise RuntimeError("EXPLAIN GPU returned no summary row")
+
+    def run(self, name: str, sql: str, *, explain: bool = True) -> Stage:
+        """Execute one query statement and collect its timing and coverage evidence."""
+        is_query = statement_body(sql).upper().startswith(("SELECT", "WITH"))
+        summary = self.explain_summary(sql) if explain and is_query else None
+        started = time.perf_counter()
+        table, query_id = self.execute(sql)
+        elapsed = time.perf_counter() - started
+        execution = parse_execution_stats(self.stats(query_id)) if query_id else None
+        return Stage(name, table, elapsed, query_id, summary, execution)
+
+    def register_parquet(self, table_name: str, path: Path, arrow_table: pa.Table | None = None) -> None:
+        """Write `arrow_table` (when given) and register `path` as an external Parquet table."""
+        path = Path(path).resolve()
+        if arrow_table is not None:
+            write_parquet_atomic(arrow_table, path)
+        self.execute(f"DROP TABLE IF EXISTS {table_name}")
+        self.execute(f"CREATE EXTERNAL TABLE {table_name} STORED AS PARQUET LOCATION '{path}'")
+
+    def register_sources(self, tables: dict[str, Path]) -> None:
+        for name, path in tables.items():
+            resolved = Path(path).resolve()
+            if not resolved.exists():
+                raise FileNotFoundError(f"source table {name} is missing at {resolved}")
+            self.execute(f"CREATE EXTERNAL TABLE IF NOT EXISTS {name} STORED AS PARQUET LOCATION '{resolved}'")
+
+    def register_merrec(self) -> None:
+        self.register_sources(MERREC_TABLES)
+
+    def register_amazon(self) -> None:
+        self.register_sources(AMAZON_TABLES)
+
+    def register_ember(self) -> None:
+        self.register_sources(EMBER_TABLES)
diff --git a/fixture/demo/decision_models/scripts/client/capture.py b/fixture/demo/decision_models/scripts/client/capture.py
new file mode 100644
index 000000000..b5684aa63
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/client/capture.py
@@ -0,0 +1,179 @@
+"""Run capture: timings, token counts, cost, hit rate, recorded responses and result tables.
+
+A capture is self-sufficient for replay: `responses` maps
+`content_hash:question_set_hash` to the normalized answers of every decision
+the run used, with the raw backend response for those fetched in that run. The writer refuses any content that looks like a token or names the
+decision endpoint host, so a capture can be shared.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import hashlib
+import importlib.util
+import json
+import os
+from pathlib import Path
+import platform
+import re
+import subprocess
+import sys
+import urllib.parse
+
+from client.decision_client import DecisionBatch, replay_key
+
+ROOT = Path(__file__).resolve().parents[5]
+MERREC_COMMON = ROOT / "scripts/dev/merrec_verify_common.py"
+JWT_SHAPE = re.compile(r"eyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}")
+
+
+def merrec_license() -> str:
+    spec = importlib.util.spec_from_file_location("merrec_verify_common", MERREC_COMMON)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module.MERREC_LICENSE
+
+
+def forbidden_fragments() -> list[str]:
+    """Endpoint hosts and keys from the environment; present only when the shell exports them."""
+    fragments = []
+    for name in ("JEV_API_URL", "OPENAI_COMPAT_BASE_URL"):
+        value = os.environ.get(name)
+        if value:
+            host = urllib.parse.urlsplit(value).netloc
+            fragments.extend(fragment for fragment in (value, host) if fragment)
+    for name in ("JEV_API_KEY", "OPENAI_COMPAT_API_KEY"):
+        value = os.environ.get(name)
+        if value:
+            fragments.append(value)
+    return fragments
+
+
+def scan_secrets(text: str) -> str | None:
+    if JWT_SHAPE.search(text):
+        return "JWT-shaped string"
+    if "Bearer " in text:
+        return "Bearer literal"
+    for fragment in forbidden_fragments():
+        if fragment in text:
+            return "decision endpoint host or key"
+    return None
+
+
+def file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with open(path, "rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def git_head() -> str | None:
+    try:
+        return subprocess.run(["git", "-C", str(ROOT), "rev-parse", "HEAD"], capture_output=True, text=True,
+                              check=True).stdout.strip()
+    except (OSError, subprocess.CalledProcessError):
+        return None
+
+
+def environment(server_binary: Path | None) -> dict:
+    record = {
+        "git_head": git_head(),
+        "python": platform.python_version(),
+        "pyarrow": __import__("pyarrow").__version__,
+    }
+    if server_binary is not None and Path(server_binary).exists():
+        record["server_binary"] = str(Path(server_binary).resolve().relative_to(ROOT)) \
+            if Path(server_binary).resolve().is_relative_to(ROOT) else str(server_binary)
+        record["server_binary_sha256"] = file_sha256(Path(server_binary))
+    return record
+
+
+class Capture:
+    def __init__(self, case: str, mode: str, backend: str, *, label: str | None = None,
+                 license: str | None = None, server_binary: Path | None = None):
+        self.data = {
+            "case": case,
+            "label": label,
+            "mode": mode,
+            "backend": backend,
+            "model_ids": [],
+            "started_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+            "environment": environment(server_binary),
+            "stages": [],
+            "decisions": [],
+            "responses": {},
+            "results": {},
+            "notes": [],
+        }
+        if license:
+            self.data["license"] = license
+
+    def stage(self, stage) -> None:
+        self.data["stages"].append(stage.record())
+
+    def decision_batch(self, name: str, batch: DecisionBatch) -> None:
+        self.data["decisions"].append({"name": name, **batch.summary})
+        models = set(self.data["model_ids"]) | set(batch.summary["model_ids"])
+        self.data["model_ids"] = sorted(models)
+        # Registry-served decisions are recorded too (without a raw response), so a capture alone can replay
+        # a run whose answers came from an earlier run's registry. A later registry hit on a state this
+        # run already fetched keeps the fetched record, which carries the raw response and the cost.
+        for decision in batch.decisions:
+            key = replay_key(decision.content_hash, decision.question_set_hash)
+            if decision.raw is None and key in self.data["responses"]:
+                continue
+            self.data["responses"][key] = {
+                "entity_key": decision.entity_key,
+                "source": decision.source,
+                "model_id": decision.model_id,
+                "answers": decision.answers,
+                "input_tokens": decision.input_tokens,
+                "output_tokens": decision.output_tokens,
+                "cost_usd": decision.cost_usd,
+                "latency_ms": decision.latency_ms,
+                "response": decision.raw,
+            }
+
+    def result(self, name: str, value) -> None:
+        self.data["results"][name] = value
+
+    def note(self, text: str) -> None:
+        self.data["notes"].append(text)
+
+    def totals(self) -> dict:
+        batches = self.data["decisions"]
+        stages = self.data["stages"]
+        costs = [batch["cost_usd"] for batch in batches]
+        return {
+            "gpu_elapsed_s": sum(stage["elapsed_s"] for stage in stages),
+            "decide_wall_s": sum(batch["wall_s"] for batch in batches),
+            "entities": sum(batch["entities"] for batch in batches),
+            "registry_hits": sum(batch["registry_hits"] for batch in batches),
+            "api_calls": sum(batch["api_calls"] for batch in batches),
+            "input_tokens": sum(batch["input_tokens"] for batch in batches),
+            "output_tokens": sum(batch["output_tokens"] for batch in batches),
+            "cost_usd": None if any(cost is None for cost in costs) else sum(costs),
+            "max_host_boundaries": max(
+                (((stage.get("execution") or {}).get("host_datafusion_boundary_count") or 0) for stage in stages),
+                default=0),
+        }
+
+    def write(self, path: Path) -> Path:
+        self.data["finished_at"] = datetime.now(timezone.utc).isoformat(timespec="seconds")
+        self.data["totals"] = self.totals()
+        text = json.dumps(self.data, indent=2, default=str, ensure_ascii=False) + "\n"
+        problem = scan_secrets(text)
+        if problem:
+            raise RuntimeError(f"refusing to write capture {path}: content contains a {problem}")
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        temporary = path.with_name(path.name + ".tmp")
+        temporary.write_text(text, encoding="utf-8")
+        os.replace(temporary, path)
+        return path
+
+
+def print_summary(capture: Capture, path: Path) -> None:
+    totals = capture.data["totals"]
+    print(json.dumps({"capture": str(path), **totals}, default=str), file=sys.stderr)
diff --git a/fixture/demo/decision_models/scripts/client/case.py b/fixture/demo/decision_models/scripts/client/case.py
new file mode 100644
index 000000000..ec1be23a8
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/client/case.py
@@ -0,0 +1,124 @@
+"""Shared case runner: argument parsing, backend selection, registries, capture output.
+
+A case directory holds its SQL files, `questions.json` and `policy.json`. The
+runner opens registries by name under `registry/`, builds the backend for the
+requested mode, times every Algeon stage into the capture and writes
+`captures/<case>[_<label>][.<backend>]_<mode>.json` at the end.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+from client.algeon import DEFAULT_URI, ROOT, Algeon, Stage
+from client.capture import Capture, print_summary
+from client.decision_client import (
+    DecisionBatch, DecisionClient, Entity, JevBackend, OpenAICompatibleBackend, ReplayBackend)
+from client.policy import Policy
+from client.registry import Registry
+
+DEMO_DIR = Path(__file__).resolve().parents[2]
+REGISTRY_DIR = DEMO_DIR / "registry"
+CAPTURES_DIR = DEMO_DIR / "captures"
+DEFAULT_SERVER_BINARY = ROOT / "target/release/algeon_server"
+BACKENDS = ("jev", "openai_compatible")
+
+
+def build_parser(description: str) -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument("--mode", choices=("live", "replay"), required=True,
+                        help="live: registry first, backend on a miss; replay: registry first, captures on a miss, no API")
+    parser.add_argument("--refresh", action="store_true", help="ignore registry hits and decide every entity again")
+    parser.add_argument("--backend", choices=BACKENDS, default="jev")
+    parser.add_argument("--model", default=None, help="backend model name (jev-1.13 or an OPENAI_COMPAT_MODEL)")
+    parser.add_argument("--uri", default=DEFAULT_URI)
+    parser.add_argument("--max-workers", type=int, default=16)
+    parser.add_argument("--max-entities", type=int, default=None, help="override the case's probe limit")
+    parser.add_argument("--label", default=None, help="capture suffix, for example a time window")
+    parser.add_argument("--replay-from", type=Path, action="append", default=[],
+                        help="additional capture files that serve replay responses")
+    parser.add_argument("--registry-dir", type=Path, default=REGISTRY_DIR)
+    parser.add_argument("--captures-dir", type=Path, default=CAPTURES_DIR)
+    parser.add_argument("--server-binary", type=Path, default=DEFAULT_SERVER_BINARY)
+    return parser
+
+
+class Case:
+    def __init__(self, case_dir: Path, args: argparse.Namespace, *, license: str | None = None):
+        self.dir = Path(case_dir)
+        self.name = self.dir.name
+        self.args = args
+        self.questions = self.load_json("questions.json")
+        policy_path = self.dir / "policy.json"
+        self.policy = Policy.load(policy_path) if policy_path.exists() else None
+        self.capture = Capture(self.name, args.mode, args.backend, label=args.label, license=license,
+                               server_binary=args.server_binary)
+        self.algeon = Algeon(args.uri)
+        self.backend = self._build_backend()
+        self.capture.data["model"] = getattr(self.backend, "model", None)
+
+    def load_json(self, name: str) -> dict:
+        with open(self.dir / name, encoding="utf-8") as handle:
+            return json.load(handle)
+
+    def sql(self, name: str) -> str:
+        return (self.dir / name).read_text(encoding="utf-8")
+
+    def _suffix(self) -> str:
+        parts = [self.name]
+        if self.args.label:
+            parts.append(self.args.label)
+        name = "_".join(parts)
+        if self.args.backend != "jev":
+            name += f".{self.args.backend}"
+        return name
+
+    def capture_path(self, mode: str | None = None) -> Path:
+        return self.args.captures_dir / f"{self._suffix()}_{mode or self.args.mode}.json"
+
+    def _build_backend(self):
+        if self.args.mode == "replay":
+            sources = [path for path in (self.capture_path("live"), *self.args.replay_from) if path.exists()]
+            if not sources:
+                raise SystemExit(f"replay needs {self.capture_path('live')} or --replay-from captures")
+            self.capture.data["replay_sources"] = [str(path) for path in sources]
+            return ReplayBackend.from_captures(sources)
+        if self.args.backend == "jev":
+            return JevBackend(self.args.model or "jev-1.13")
+        return OpenAICompatibleBackend(self.args.model)
+
+    def registry(self, name: str, questions: dict | None = None) -> Registry:
+        """Open the named registry; `name` is shared across cases (brand_ontology, brand_canonical)."""
+        file_name = name if self.args.backend == "jev" else f"{name}.{self.args.backend}"
+        return Registry(self.args.registry_dir / f"{file_name}.parquet", questions or self.questions)
+
+    def run_stage(self, name: str, sql: str, *, explain: bool = True) -> Stage:
+        stage = self.algeon.run(name, sql, explain=explain)
+        self.capture.stage(stage)
+        print(json.dumps({"stage": name, "rows": stage.rows, "elapsed_s": round(stage.elapsed_s, 3),
+                          "execution": stage.execution}), file=sys.stderr)
+        return stage
+
+    def decide(self, registry: Registry, entities: list[Entity], *, name: str = "decide",
+               questions: dict | None = None) -> DecisionBatch:
+        client = DecisionClient(self.backend, registry, max_workers=self.args.max_workers,
+                                refresh=self.args.refresh and self.args.mode == "live")
+        batch = client.decide(entities, questions or registry.questions)
+        self.capture.decision_batch(name, batch)
+        print(json.dumps({"decide": name, **{key: batch.summary[key] for key in (
+            "entities", "registry_hits", "api_calls", "cost_usd", "wall_s")}}, default=str), file=sys.stderr)
+        return batch
+
+    def decision_table(self, table_name: str, arrow_table, file_name: str | None = None) -> Path:
+        """Write a typed decision table under registry/ and register it in Algeon."""
+        path = self.args.registry_dir / (file_name or f"{table_name}.engine.parquet")
+        self.algeon.register_parquet(table_name, path, arrow_table)
+        return path
+
+    def finish(self) -> Path:
+        path = self.capture.write(self.capture_path())
+        print_summary(self.capture, path)
+        return path
diff --git a/fixture/demo/decision_models/scripts/client/decision_client.py b/fixture/demo/decision_models/scripts/client/decision_client.py
new file mode 100644
index 000000000..05a326cc7
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/client/decision_client.py
@@ -0,0 +1,553 @@
+"""Decision backends and the batched decide loop.
+
+A decision backend answers a fixed question set for one entity state. Three
+question types exist: `choice` (one option plus its probability), `noul`
+(probability that a statement holds) and `score` (expected value on a numbered
+rubric). Every backend returns the same normalized answer shape, so the
+registry, policy and recompute SQL never depend on which backend answered.
+
+Backends read their endpoint and credentials from environment variables only.
+Nothing in this module stores, logs or raises a URL, header or token.
+"""
+
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from datetime import datetime, timezone
+import hashlib
+import json
+import os
+import re
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+MAX_QUESTIONS = 12
+QUESTION_TYPES = ("choice", "noul", "score")
+RETRY_STATUS = (408, 429, 500, 502, 503, 504)
+
+
+class DecisionError(Exception):
+    """Base class for decision-loop failures."""
+
+
+class DecisionConfigError(DecisionError):
+    """A backend is missing configuration or a question set is malformed."""
+
+
+class ReplayMiss(DecisionError):
+    """A replay run needed a response that no capture provides."""
+
+
+def content_hash(state: str) -> str:
+    return hashlib.sha256(state.encode("utf-8")).hexdigest()
+
+
+def canonical_questions(questions: dict) -> str:
+    return json.dumps(questions, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+
+
+def question_set_hash(questions: dict) -> str:
+    return hashlib.sha256(canonical_questions(questions).encode("utf-8")).hexdigest()
+
+
+def validate_questions(questions: dict) -> None:
+    if not isinstance(questions, dict) or not questions:
+        raise DecisionConfigError("questions must be a non-empty object")
+    if len(questions) > MAX_QUESTIONS:
+        raise DecisionConfigError(f"question set has {len(questions)} questions; the limit is {MAX_QUESTIONS}")
+    for name, spec in questions.items():
+        if not re.fullmatch(r"[a-z][a-z0-9_]*", name):
+            raise DecisionConfigError(f"question name {name!r} must be a lowercase identifier")
+        kind = spec.get("type")
+        if kind not in QUESTION_TYPES:
+            raise DecisionConfigError(f"question {name!r} has type {kind!r}; expected one of {QUESTION_TYPES}")
+        if not spec.get("instructions"):
+            raise DecisionConfigError(f"question {name!r} has no instructions")
+        criteria = spec.get("criteria")
+        if kind == "choice" and (not isinstance(criteria, dict) or len(criteria) < 2):
+            raise DecisionConfigError(f"choice question {name!r} needs at least two criteria options")
+        if kind == "noul" and (not isinstance(criteria, dict) or set(criteria) != {"true", "false"}):
+            raise DecisionConfigError(f"noul question {name!r} needs criteria with keys 'true' and 'false'")
+        if kind == "score" and score_range(spec) is None:
+            raise DecisionConfigError(f"score question {name!r} needs criteria that start with their numeric level")
+
+
+def score_range(spec: dict) -> tuple[float, float] | None:
+    """Numeric bounds of a score rubric, read from the leading number of each criterion."""
+    criteria = spec.get("criteria")
+    labels = list(criteria.values()) if isinstance(criteria, dict) else criteria
+    if not isinstance(labels, list) or not labels:
+        return None
+    levels = []
+    for label in labels:
+        match = re.match(r"\s*(-?\d+(?:\.\d+)?)", str(label))
+        if match is None:
+            return None
+        levels.append(float(match.group(1)))
+    return min(levels), max(levels)
+
+
+@dataclass(frozen=True)
+class Entity:
+    key: str
+    state: str
+
+
+@dataclass
+class Decision:
+    entity_key: str
+    content_hash: str
+    question_set_hash: str
+    model_id: str
+    decided_at: datetime
+    answers: dict[str, dict]
+    input_tokens: int | None
+    output_tokens: int | None
+    cost_usd: float | None
+    latency_ms: int
+    source: str
+    raw: dict | None = None
+
+    def value(self, question: str):
+        answer = self.answers[question]
+        return answer["choice"] if answer["type"] == "choice" else answer["value"]
+
+    def probability(self, question: str) -> float | None:
+        answer = self.answers[question]
+        return answer.get("p") if answer["type"] == "choice" else answer.get("value")
+
+
+@dataclass
+class BackendResponse:
+    answers: dict[str, dict]
+    model_id: str
+    input_tokens: int | None
+    output_tokens: int | None
+    cost_usd: float | None
+    latency_ms: int
+    raw: dict
+
+
+@dataclass
+class DecisionBatch:
+    decisions: list[Decision]
+    summary: dict
+
+    def by_key(self) -> dict[str, Decision]:
+        return {decision.entity_key: decision for decision in self.decisions}
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc).replace(tzinfo=None)
+
+
+def _clamp(value: float, low: float, high: float) -> float:
+    return max(low, min(high, float(value)))
+
+
+def normalize_jev_answers(payload: dict, questions: dict) -> dict[str, dict]:
+    answers = payload.get("answers")
+    if not isinstance(answers, dict):
+        raise DecisionError("jev response has no answers object")
+    normalized = {}
+    for name, spec in questions.items():
+        answer = answers.get(name)
+        if not isinstance(answer, dict):
+            raise DecisionError(f"jev response has no answer for question {name!r}")
+        kind = spec["type"]
+        if kind == "choice":
+            choice = answer.get("choice")
+            if choice not in spec["criteria"]:
+                raise DecisionError(f"jev answered {choice!r} for {name!r}, which is not an option")
+            probabilities = answer.get("probabilities") or {}
+            normalized[name] = {"type": "choice", "choice": choice,
+                                "p": float(probabilities.get(choice, answer.get("confidence", 0.0)))}
+        elif kind == "noul":
+            normalized[name] = {"type": "noul", "value": _clamp(answer["noul"], 0.0, 1.0)}
+        else:
+            low, high = score_range(spec)
+            normalized[name] = {"type": "score", "value": _clamp(answer["score"], low, high)}
+    return normalized
+
+
+class Backend:
+    name = "backend"
+    model = ""
+
+    def decide(self, entity: Entity, questions: dict) -> BackendResponse:
+        raise NotImplementedError
+
+
+def _scrub(text: str, secrets: tuple[str, ...]) -> str:
+    for secret in secrets:
+        if secret:
+            text = text.replace(secret, "<redacted>")
+    return re.sub(r"eyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_.-]+", "<token>", text)
+
+
+def _post_json(url: str, key: str, payload: dict, *, timeout: float, retries: int, backend: str,
+               secrets: tuple[str, ...]) -> tuple[dict, int]:
+    body = json.dumps(payload).encode("utf-8")
+    headers = {"Authorization": f"Bearer {key}", "Content-Type": "application/json",
+               "User-Agent": "algeon-decision-demo/1.0"}
+    last_error = "no attempt"
+    for attempt in range(retries):
+        request = urllib.request.Request(url, data=body, headers=headers, method="POST")
+        started = time.perf_counter()
+        try:
+            with urllib.request.urlopen(request, timeout=timeout) as response:
+                data = json.loads(response.read().decode("utf-8"))
+                return data, int(round((time.perf_counter() - started) * 1000))
+        except urllib.error.HTTPError as error:
+            detail = _scrub(error.read().decode("utf-8", errors="replace")[:300], secrets)
+            last_error = f"decision backend {backend!r} returned HTTP {error.code}: {detail}"
+            if error.code not in RETRY_STATUS or attempt + 1 == retries:
+                raise DecisionError(last_error) from None
+        except (urllib.error.URLError, TimeoutError, ConnectionError, json.JSONDecodeError) as error:
+            last_error = f"decision backend {backend!r} request failed: {_scrub(str(error), secrets)}"
+            if attempt + 1 == retries:
+                raise DecisionError(last_error) from None
+        time.sleep(0.5 * (2 ** attempt))
+    raise DecisionError(last_error)
+
+
+def _require_env(*names: str) -> list[str]:
+    missing = [name for name in names if not os.environ.get(name)]
+    if missing:
+        raise DecisionConfigError(
+            f"missing environment variable(s): {', '.join(missing)}; export them in the shell, never in files under the repository")
+    return [os.environ[name] for name in names]
+
+
+class JevBackend(Backend):
+    """TypeSafe Jev `/systemone` request: one state, K independent questions."""
+
+    name = "jev"
+
+    def __init__(self, model: str = "jev-1.13", *, timeout: float = 60.0, retries: int = 3):
+        self._url, self._key = _require_env("JEV_API_URL", "JEV_API_KEY")
+        self.model = model
+        self.timeout = timeout
+        self.retries = retries
+        host = urllib.parse.urlsplit(self._url).netloc
+        self._secrets = (self._key, self._url, host)
+
+    def decide(self, entity: Entity, questions: dict) -> BackendResponse:
+        payload = {"model": self.model, "state": entity.state, "questions": questions}
+        data, latency_ms = _post_json(self._url, self._key, payload, timeout=self.timeout, retries=self.retries,
+                                      backend=self.name, secrets=self._secrets)
+        usage = data.get("usage") or {}
+        return BackendResponse(
+            answers=normalize_jev_answers(data, questions),
+            model_id=str(data.get("model") or self.model),
+            input_tokens=usage.get("input_tokens"),
+            output_tokens=usage.get("output_tokens"),
+            cost_usd=usage.get("cost"),
+            latency_ms=latency_ms,
+            raw=data,
+        )
+
+
+def openai_schema(questions: dict) -> dict:
+    """JSON schema that makes a chat model return the normalized answer shape."""
+    properties = {}
+    for name, spec in questions.items():
+        if spec["type"] == "choice":
+            properties[name] = {
+                "type": "object",
+                "properties": {
+                    "choice": {"type": "string", "enum": list(spec["criteria"])},
+                    "p": {"type": "number", "description": "probability that the chosen option is correct, 0 to 1"},
+                },
+                "required": ["choice", "p"],
+                "additionalProperties": False,
+            }
+        else:
+            properties[name] = {"type": "number"}
+    return {"type": "object", "properties": properties, "required": list(questions), "additionalProperties": False}
+
+
+def openai_prompt(questions: dict) -> str:
+    lines = ["Evaluate each question independently against the state. Answer every question.",
+             "Return JSON only, with one key per question name."]
+    for name, spec in questions.items():
+        kind = spec["type"]
+        lines.append("")
+        lines.append(f"Question `{name}` ({kind}): {spec['instructions']}")
+        if kind == "choice":
+            lines.append("Return {\"choice\": <option>, \"p\": <probability 0..1 that the option is correct>}. Options:")
+            for option, text in spec["criteria"].items():
+                lines.append(f"- {option}: {text}")
+        elif kind == "noul":
+            lines.append("Return the probability, 0 to 1, that the statement is true.")
+            lines.append(f"- true: {spec['criteria']['true']}")
+            lines.append(f"- false: {spec['criteria']['false']}")
+        else:
+            low, high = score_range(spec)
+            lines.append(f"Return the expected value on this rubric as a number from {low:g} to {high:g}:")
+            labels = spec["criteria"].values() if isinstance(spec["criteria"], dict) else spec["criteria"]
+            for label in labels:
+                lines.append(f"- {label}")
+    return "\n".join(lines)
+
+
+class OpenAICompatibleBackend(Backend):
+    """Any chat-completions endpoint that honors `response_format` JSON schemas."""
+
+    name = "openai_compatible"
+
+    def __init__(self, model: str | None = None, *, timeout: float = 120.0, retries: int = 3):
+        base_url, self._key = _require_env("OPENAI_COMPAT_BASE_URL", "OPENAI_COMPAT_API_KEY")
+        self.model = model or os.environ.get("OPENAI_COMPAT_MODEL") or ""
+        if not self.model:
+            raise DecisionConfigError("set OPENAI_COMPAT_MODEL or pass --model for the openai_compatible backend")
+        self._url = base_url.rstrip("/") + "/chat/completions"
+        self.timeout = timeout
+        self.retries = retries
+        host = urllib.parse.urlsplit(self._url).netloc
+        self._secrets = (self._key, self._url, base_url, host)
+
+    def decide(self, entity: Entity, questions: dict) -> BackendResponse:
+        payload = {
+            "model": self.model,
+            "temperature": 0,
+            "messages": [
+                {"role": "system", "content": openai_prompt(questions)},
+                {"role": "user", "content": entity.state},
+            ],
+            "response_format": {"type": "json_schema", "json_schema": {
+                "name": "decision", "strict": True, "schema": openai_schema(questions)}},
+        }
+        last_error = None
+        for attempt in range(self.retries):
+            if attempt:
+                # Resending an identical request at temperature 0 repeats the same malformed output.
+                payload["temperature"] = 0.2
+                payload["messages"][0]["content"] = openai_prompt(questions) + (
+                    "\n\nThe previous answer did not match the schema. Return exactly one JSON object whose "
+                    "top-level keys are the question names, with a plain number for every numeric question.")
+            data, latency_ms = _post_json(self._url, self._key, payload, timeout=self.timeout, retries=self.retries,
+                                          backend=self.name, secrets=self._secrets)
+            try:
+                content = data["choices"][0]["message"]["content"]
+                answers = coerce_openai_answers(json.loads(content), questions)
+            except (KeyError, IndexError, TypeError, json.JSONDecodeError) as error:
+                last_error = DecisionError(f"openai_compatible response had no JSON content: {type(error).__name__}")
+                continue
+            except DecisionError as error:
+                # Some endpoints ignore the strict schema on a few requests; a fresh request usually conforms.
+                last_error = error
+                continue
+            usage = data.get("usage") or {}
+            return BackendResponse(
+                answers=answers,
+                model_id=str(data.get("model") or self.model),
+                input_tokens=usage.get("prompt_tokens"),
+                output_tokens=usage.get("completion_tokens"),
+                cost_usd=None,
+                latency_ms=latency_ms,
+                raw={"model": data.get("model"), "usage": usage, "content": content, "schema_retries": attempt},
+            )
+        raise last_error
+
+
+def coerce_openai_answers(parsed, questions: dict) -> dict[str, dict]:
+    """Normalize a chat model's JSON into typed answers, unwrapping nested or stringified objects."""
+    if isinstance(parsed, str):
+        parsed = json.loads(parsed)
+    if not isinstance(parsed, dict):
+        raise DecisionError("openai_compatible response is not a JSON object")
+    if not all(name in parsed for name in questions):
+        for value in parsed.values():
+            candidate = value
+            if isinstance(candidate, str):
+                try:
+                    candidate = json.loads(candidate)
+                except json.JSONDecodeError:
+                    continue
+            if isinstance(candidate, dict) and all(name in candidate for name in questions):
+                parsed = candidate
+                break
+    answers = {}
+    for name, spec in questions.items():
+        value = parsed.get(name)
+        if isinstance(value, str) and spec["type"] == "choice":
+            try:
+                value = json.loads(value)
+            except json.JSONDecodeError:
+                value = {"choice": value, "p": 0.0}
+        if spec["type"] == "choice":
+            if not isinstance(value, dict) or value.get("choice") not in spec["criteria"]:
+                raise DecisionError(
+                    f"openai_compatible answered an unknown option for {name!r}: {repr(value)[:120]}")
+            answers[name] = {"type": "choice", "choice": value["choice"], "p": _clamp(value.get("p", 0.0), 0.0, 1.0)}
+        elif spec["type"] == "noul":
+            answers[name] = {"type": "noul", "value": _clamp(_number(value, name), 0.0, 1.0)}
+        else:
+            low, high = score_range(spec)
+            answers[name] = {"type": "score", "value": _clamp(_number(value, name), low, high)}
+    return answers
+
+
+def _number(value, name: str) -> float:
+    if isinstance(value, dict):
+        # A model that nests the number under a key such as "value" or "p" still answered the question.
+        numeric = [item for item in value.values() if isinstance(item, (int, float)) and not isinstance(item, bool)]
+        if len(numeric) == 1:
+            return float(numeric[0])
+    if isinstance(value, bool) or not isinstance(value, (int, float, str)):
+        raise DecisionError(
+            f"openai_compatible answered a non-numeric value for {name!r}: {type(value).__name__} {repr(value)[:80]}")
+    try:
+        return float(value)
+    except ValueError:
+        raise DecisionError(f"openai_compatible answered a non-numeric value for {name!r}: {repr(value)[:80]}") from None
+
+
+def replay_key(content: str, question_set: str) -> str:
+    return f"{content}:{question_set}"
+
+
+class ReplayBackend(Backend):
+    """Serves responses recorded by earlier live runs; never calls an API."""
+
+    name = "replay"
+
+    def __init__(self, responses: dict[str, dict]):
+        self.responses = responses
+        self.model = ""
+
+    @classmethod
+    def from_captures(cls, paths) -> "ReplayBackend":
+        responses: dict[str, dict] = {}
+        for path in paths:
+            with open(path, encoding="utf-8") as handle:
+                capture = json.load(handle)
+            responses.update(capture.get("responses") or {})
+        return cls(responses)
+
+    def decide(self, entity: Entity, questions: dict) -> BackendResponse:
+        key = replay_key(content_hash(entity.state), question_set_hash(questions))
+        record = self.responses.get(key)
+        if record is None:
+            raise ReplayMiss(f"no recorded response for entity {entity.key!r}; run with --mode live first")
+        return BackendResponse(
+            answers=record["answers"],
+            model_id=record["model_id"],
+            input_tokens=record.get("input_tokens"),
+            output_tokens=record.get("output_tokens"),
+            cost_usd=record.get("cost_usd"),
+            latency_ms=int(record.get("latency_ms") or 0),
+            raw=record.get("response"),
+        )
+
+
+def _percentile(values: list[int], fraction: float) -> int | None:
+    if not values:
+        return None
+    ordered = sorted(values)
+    return ordered[min(len(ordered) - 1, int(len(ordered) * fraction))]
+
+
+class DecisionClient:
+    """Registry-first decide loop with a bounded thread pool for backend calls."""
+
+    def __init__(self, backend: Backend, registry, *, max_workers: int = 16, refresh: bool = False):
+        """`refresh` ignores registry rows that existed before this process; rows it writes are reused."""
+        self.backend = backend
+        self.registry = registry
+        self.max_workers = max_workers
+        self.refresh = refresh
+
+    def decide(self, entities: list[Entity], questions: dict) -> DecisionBatch:
+        validate_questions(questions)
+        set_hash = question_set_hash(questions)
+        started = time.perf_counter()
+        hashes = [content_hash(entity.state) for entity in entities]
+        decisions: list[Decision | None] = [None] * len(entities)
+        pending: dict[str, list[int]] = {}
+        hits = 0
+        for index, (entity, digest) in enumerate(zip(entities, hashes)):
+            stale = self.refresh and (digest, set_hash) not in self.registry.fresh
+            cached = None if stale else self.registry.lookup(digest, set_hash)
+            if cached is not None:
+                hits += 1
+                decisions[index] = Decision(
+                    entity_key=entity.key, content_hash=digest, question_set_hash=set_hash,
+                    model_id=cached.model_id, decided_at=cached.decided_at, answers=cached.answers,
+                    input_tokens=cached.input_tokens, output_tokens=None, cost_usd=None,
+                    latency_ms=cached.latency_ms, source="registry")
+            else:
+                pending.setdefault(digest, []).append(index)
+
+        latencies: list[int] = []
+        totals = {"input_tokens": 0, "output_tokens": 0, "cost_usd": 0.0}
+        cost_known = True
+        model_ids: set[str] = set()
+
+        def call(digest: str) -> tuple[str, BackendResponse]:
+            return digest, self.backend.decide(entities[pending[digest][0]], questions)
+
+        new_decisions = []
+        failures: list[DecisionError] = []
+        if pending:
+            with ThreadPoolExecutor(max_workers=self.max_workers) as pool:
+                outcomes = []
+                for future in [pool.submit(call, digest) for digest in pending]:
+                    try:
+                        outcomes.append(future.result())
+                    except DecisionError as error:
+                        failures.append(error)
+                for digest, response in outcomes:
+                    decided_at = utc_now()
+                    latencies.append(response.latency_ms)
+                    model_ids.add(response.model_id)
+                    totals["input_tokens"] += response.input_tokens or 0
+                    totals["output_tokens"] += response.output_tokens or 0
+                    if response.cost_usd is None:
+                        cost_known = False
+                    else:
+                        totals["cost_usd"] += response.cost_usd
+                    source = "replay" if isinstance(self.backend, ReplayBackend) else "backend"
+                    for index in pending[digest]:
+                        decision = Decision(
+                            entity_key=entities[index].key, content_hash=digest, question_set_hash=set_hash,
+                            model_id=response.model_id, decided_at=decided_at, answers=response.answers,
+                            input_tokens=response.input_tokens, output_tokens=response.output_tokens,
+                            cost_usd=response.cost_usd, latency_ms=response.latency_ms, source=source,
+                            raw=response.raw)
+                        decisions[index] = decision
+                        new_decisions.append(decision)
+            # Decided entities reach the registry before any failure is raised, so a rerun only retries the rest.
+            self.registry.upsert(new_decisions)
+            self.registry.save()
+            if failures:
+                kind = ReplayMiss if all(isinstance(error, ReplayMiss) for error in failures) else DecisionError
+                raise kind(f"{len(failures)} of {len(pending)} backend calls failed; first failure: {failures[0]}")
+        for decision in decisions:
+            if decision is not None and decision.source == "registry":
+                model_ids.add(decision.model_id)
+        wall_s = time.perf_counter() - started
+        calls = len(pending)
+        summary = {
+            "backend": self.backend.name,
+            "model_ids": sorted(model_ids),
+            "entities": len(entities),
+            "distinct_states": len(set(hashes)),
+            "registry_hits": hits,
+            "hit_rate": (hits / len(entities)) if entities else None,
+            "backend_calls": calls,
+            "api_calls": 0 if isinstance(self.backend, ReplayBackend) else calls,
+            "max_workers": self.max_workers,
+            "wall_s": wall_s,
+            "input_tokens": totals["input_tokens"],
+            "output_tokens": totals["output_tokens"],
+            "cost_usd": totals["cost_usd"] if cost_known else None,
+            "latency_ms_p50": _percentile(latencies, 0.5),
+            "latency_ms_p95": _percentile(latencies, 0.95),
+            "latency_ms_max": max(latencies) if latencies else None,
+        }
+        return DecisionBatch([decision for decision in decisions if decision is not None], summary)
diff --git a/fixture/demo/decision_models/scripts/client/policy.py b/fixture/demo/decision_models/scripts/client/policy.py
new file mode 100644
index 000000000..9f770f6b5
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/client/policy.py
@@ -0,0 +1,48 @@
+"""Action thresholds: accept, review or reject each decision on its action noul.
+
+The action question is the `noul` head tied to what the recompute will do with
+the entity (merge, exclude, escalate). A choice head can be required to agree;
+when the heads disagree the entity goes to the review queue instead of being
+accepted or rejected on one head alone.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from client.decision_client import Decision
+
+BANDS = ("accept", "review", "reject")
+
+
+class Policy:
+    def __init__(self, spec: dict):
+        self.action_question = spec["action_question"]
+        self.accept_min = float(spec.get("accept_min", 0.70))
+        self.review_min = float(spec.get("review_min", 0.30))
+        self.require = {name: set(options) for name, options in (spec.get("require") or {}).items()}
+        self.spec = spec
+        if not 0.0 <= self.review_min <= self.accept_min <= 1.0:
+            raise ValueError("policy needs 0 <= review_min <= accept_min <= 1")
+
+    @classmethod
+    def load(cls, path: Path) -> "Policy":
+        with open(path, encoding="utf-8") as handle:
+            return cls(json.load(handle))
+
+    def band(self, decision: Decision) -> str:
+        value = float(decision.value(self.action_question))
+        if value < self.review_min:
+            return "reject"
+        agrees = all(decision.value(name) in options for name, options in self.require.items())
+        if value >= self.accept_min and agrees:
+            return "accept"
+        return "review"
+
+    def apply(self, decisions: list[Decision]) -> tuple[dict[str, str], dict[str, int]]:
+        bands = {decision.entity_key: self.band(decision) for decision in decisions}
+        counts = {band: 0 for band in BANDS}
+        for band in bands.values():
+            counts[band] += 1
+        return bands, counts
diff --git a/fixture/demo/decision_models/scripts/client/registry.py b/fixture/demo/decision_models/scripts/client/registry.py
new file mode 100644
index 000000000..d6a08fd00
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/client/registry.py
@@ -0,0 +1,150 @@
+"""Semantic registry: a Parquet table of decisions keyed by content and question-set hash.
+
+One registry file holds the decisions of one question set from one backend
+family. A lookup hit means the entity state and the questions are byte-identical
+to an earlier decision, so no backend call is needed. The engine-facing table
+carries only the typed answer columns next to the case's key columns.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+import os
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from client.decision_client import Decision, validate_questions
+
+BASE_FIELDS = (
+    ("entity_key", pa.string()),
+    ("content_hash", pa.string()),
+    ("question_set_hash", pa.string()),
+    ("model_id", pa.string()),
+    ("decided_at", pa.timestamp("us")),
+)
+TAIL_FIELDS = (
+    ("input_tokens", pa.int64()),
+    ("latency_ms", pa.int64()),
+)
+
+
+def answer_fields(questions: dict) -> list[tuple[str, pa.DataType]]:
+    fields = []
+    for name, spec in questions.items():
+        if spec["type"] == "choice":
+            fields.append((name, pa.string()))
+            fields.append((f"{name}_p", pa.float64()))
+        else:
+            fields.append((name, pa.float64()))
+    return fields
+
+
+def registry_schema(questions: dict) -> pa.Schema:
+    return pa.schema([pa.field(name, kind) for name, kind in (*BASE_FIELDS, *answer_fields(questions), *TAIL_FIELDS)])
+
+
+def answer_columns(decision: Decision, questions: dict) -> dict:
+    row = {}
+    for name, spec in questions.items():
+        answer = decision.answers[name]
+        if spec["type"] == "choice":
+            row[name] = answer["choice"]
+            row[f"{name}_p"] = float(answer["p"])
+        else:
+            row[name] = float(answer["value"])
+    return row
+
+
+def answers_from_row(row: dict, questions: dict) -> dict[str, dict]:
+    answers = {}
+    for name, spec in questions.items():
+        if spec["type"] == "choice":
+            answers[name] = {"type": "choice", "choice": row[name], "p": row[f"{name}_p"]}
+        else:
+            answers[name] = {"type": spec["type"], "value": row[name]}
+    return answers
+
+
+def write_parquet_atomic(table: pa.Table, path: Path) -> None:
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(path.name + ".tmp")
+    pq.write_table(table, temporary)
+    os.replace(temporary, path)
+
+
+class Registry:
+    def __init__(self, path: Path, questions: dict):
+        validate_questions(questions)
+        self.path = Path(path)
+        self.questions = questions
+        self.schema = registry_schema(questions)
+        self._rows: dict[tuple[str, str], dict] = {}
+        # Keys written by this process; a refresh run re-decides a state once and then reuses its own answer.
+        self.fresh: set[tuple[str, str]] = set()
+        self.loaded_rows = 0
+        if self.path.exists():
+            table = pq.read_table(self.path)
+            missing = set(self.schema.names) - set(table.schema.names)
+            if missing:
+                raise ValueError(
+                    f"registry {self.path} lacks columns {sorted(missing)}; it was written for another question set")
+            for row in table.select(self.schema.names).to_pylist():
+                self._rows[(row["content_hash"], row["question_set_hash"])] = row
+            self.loaded_rows = len(self._rows)
+
+    def __len__(self) -> int:
+        return len(self._rows)
+
+    def lookup(self, content_hash: str, question_set_hash: str) -> Decision | None:
+        row = self._rows.get((content_hash, question_set_hash))
+        if row is None:
+            return None
+        decided_at = row["decided_at"]
+        if not isinstance(decided_at, datetime):
+            decided_at = datetime.fromisoformat(str(decided_at))
+        return Decision(
+            entity_key=row["entity_key"], content_hash=content_hash, question_set_hash=question_set_hash,
+            model_id=row["model_id"], decided_at=decided_at, answers=answers_from_row(row, self.questions),
+            input_tokens=row["input_tokens"], output_tokens=None, cost_usd=None,
+            latency_ms=row["latency_ms"] or 0, source="registry")
+
+    def upsert(self, decisions: list[Decision]) -> None:
+        for decision in decisions:
+            row = {
+                "entity_key": decision.entity_key,
+                "content_hash": decision.content_hash,
+                "question_set_hash": decision.question_set_hash,
+                "model_id": decision.model_id,
+                "decided_at": decision.decided_at,
+                **answer_columns(decision, self.questions),
+                "input_tokens": decision.input_tokens,
+                "latency_ms": decision.latency_ms,
+            }
+            self._rows[(decision.content_hash, decision.question_set_hash)] = row
+            self.fresh.add((decision.content_hash, decision.question_set_hash))
+
+    def table(self) -> pa.Table:
+        rows = sorted(self._rows.values(), key=lambda row: (row["entity_key"], row["content_hash"]))
+        return pa.Table.from_pylist(rows, schema=self.schema)
+
+    def save(self) -> None:
+        write_parquet_atomic(self.table(), self.path)
+
+    def engine_table(self, decisions: list[Decision], keys: dict[str, pa.Array | list]) -> pa.Table:
+        """Typed decision table for `CREATE EXTERNAL TABLE`: key columns, then answer columns.
+
+        `keys` supplies one typed column per entry, each as long as `decisions`
+        and in the same order, so the recompute SQL joins on native types and
+        never parses `entity_key`.
+        """
+        columns: dict[str, pa.Array | list] = {"entity_key": [decision.entity_key for decision in decisions]}
+        for name, values in keys.items():
+            if len(values) != len(decisions):
+                raise ValueError(f"key column {name!r} has {len(values)} values for {len(decisions)} decisions")
+            columns[name] = values
+        for name, kind in answer_fields(self.questions):
+            columns[name] = pa.array([answer_columns(decision, self.questions)[name] for decision in decisions], kind)
+        return pa.table(columns)
diff --git a/fixture/demo/decision_models/scripts/export_website.py b/fixture/demo/decision_models/scripts/export_website.py
new file mode 100644
index 000000000..cfe62f0eb
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/export_website.py
@@ -0,0 +1,225 @@
+"""Export the website data files for cases A and B from their local captures.
+
+The website pages and the blog post read `merrec-decision-bridges.json` and
+`merrec-decision-twins.json` from `website/static/data`. Each file holds the
+question sets, the policy, the executed SQL, the GPU stage metrics, the
+decision batch counters, every judgment and every result row of the recorded
+runs, under the MerRec CC BY-NC terms like the other `merrec-*.json` files
+there.
+
+The public files name no decision backend or model: the capture's `backend`,
+`model_ids` and per-entity `model_id` fields are dropped, and so is the
+`content_hash` registry key. `check_no_backend_fields` enforces that.
+
+Usage, from fixture/demo/decision_models/scripts:
+
+    python3 export_website.py            # writes both files
+    python3 export_website.py --check    # verifies the files on disk match
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from client.algeon import ROOT  # noqa: E402
+
+DEMO_DIR = Path(__file__).resolve().parents[1]
+CASES_DIR = DEMO_DIR / "scripts" / "cases"
+CAPTURES_DIR = DEMO_DIR / "captures"
+DATA_DIR = ROOT / "website" / "static" / "data"
+LICENSE = ("CC-BY-NC-4.0; derived from the MerRec dataset, Copyright Mercari, Inc.; "
+           "see LICENSE-MERREC.md in this directory")
+BACKEND_FIELDS = frozenset({"backend", "model_ids", "model_id", "content_hash", "replay_sources"})
+BATCH_FIELDS = ("name", "entities", "distinct_states", "registry_hits", "hit_rate", "api_calls", "wall_s",
+                "input_tokens", "output_tokens", "cost_usd", "latency_ms_p50", "latency_ms_p95", "latency_ms_max")
+TOTAL_FIELDS = ("gpu_elapsed_s", "decide_wall_s", "entities", "registry_hits", "api_calls", "input_tokens",
+                "output_tokens", "cost_usd", "max_host_boundaries")
+B_WINDOWS = {"all": ("2023-05-01", "2023-11-01"), "sep_oct": ("2023-09-01", "2023-11-01")}
+
+
+def load_capture(name: str) -> dict:
+    return json.loads((CAPTURES_DIR / f"{name}.json").read_text(encoding="utf-8"))
+
+
+def load_json(case: str, name: str):
+    return json.loads((CASES_DIR / case / name).read_text(encoding="utf-8"))
+
+
+def load_sql(case: str, name: str, **values: str) -> str:
+    sql = (CASES_DIR / case / name).read_text(encoding="utf-8")
+    for key, value in values.items():
+        sql = sql.replace("{" + key + "}", value)
+    return sql
+
+
+def stage_record(stage: dict) -> dict:
+    execution = stage.get("execution") or {}
+    return {
+        "name": stage["name"],
+        "rows": stage["rows"],
+        "elapsed_s": stage["elapsed_s"],
+        "query_id": stage.get("query_id"),
+        "native_fragments": execution.get("native_plan_fragment_count"),
+        "host_boundaries": execution.get("host_datafusion_boundary_count"),
+        "allocator_peak_bytes": execution.get("allocator_high_water_bytes"),
+        "query_limit_bytes": execution.get("query_grant_bytes"),
+    }
+
+
+def batch_record(batch: dict) -> dict:
+    return {key: batch[key] for key in BATCH_FIELDS if key in batch}
+
+
+def totals_record(totals: dict) -> dict:
+    return {key: totals[key] for key in TOTAL_FIELDS if key in totals}
+
+
+def strip_backend_fields(value):
+    if isinstance(value, dict):
+        return {key: strip_backend_fields(item) for key, item in value.items() if key not in BACKEND_FIELDS}
+    if isinstance(value, list):
+        return [strip_backend_fields(item) for item in value]
+    return value
+
+
+def check_no_backend_fields(value, path: str = "") -> None:
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if key in BACKEND_FIELDS:
+                raise ValueError(f"backend field {key!r} at {path or '<root>'}")
+            check_no_backend_fields(item, f"{path}/{key}")
+    elif isinstance(value, list):
+        for index, item in enumerate(value):
+            check_no_backend_fields(item, f"{path}[{index}]")
+
+
+def bridges_window(capture: dict, *, canonical: dict | None = None) -> dict:
+    results = capture["results"]
+    record = {
+        "window": results["window"],
+        "stages": [stage_record(stage) for stage in capture["stages"]],
+        "decisions": [batch_record(batch) for batch in capture["decisions"]],
+        "totals": totals_record(capture["totals"]),
+        "passes": [{key: item[key] for key in ("pass", "new_entries", "new_band_counts", "registry_hits", "api_calls")}
+                   for item in results["passes"]],
+        "band_counts": results["band_counts"],
+        "kind_counts": results["kind_counts"],
+        "ranking": results["ranking"],
+        "review_queue": results["review_queue"],
+        "judgments": results["decisions"],
+        "denylist_vs_model": results["denylist_vs_model"],
+    }
+    if canonical is not None:
+        record["canonical_ranking"] = canonical["results"]["canonical_ranking"]
+        record["canonical_run"] = {
+            "stages": [stage_record(stage) for stage in canonical["stages"]],
+            "totals": totals_record(canonical["totals"]),
+        }
+    return record
+
+
+def export_bridges() -> dict:
+    case = "b_bridge_purification"
+    all_window = load_capture(f"{case}_all_live")
+    canonical = load_capture(f"{case}_all_canonical_live")
+    sep_oct = load_capture(f"{case}_sep_oct_live")
+    start, end = B_WINDOWS["all"]
+    return {
+        "license": LICENSE,
+        "name": case,
+        "description": "World bridges recomputed without the catalog entries a decision model rejects as "
+                       "standalone brands; the published betweenness ranking, the post-filtered ranking and "
+                       "the purified ranking over the same window, with a denylist control and a second window.",
+        "captures": [f"{case}_all_live.json", f"{case}_all_canonical_live.json", f"{case}_sep_oct_live.json"],
+        "server_binary_sha256": all_window["environment"]["server_binary_sha256"],
+        "questions": load_json(case, "questions.json"),
+        "policy": load_json(case, "policy.json"),
+        "control_denylist": load_json(case, "control_denylist.json"),
+        "sql": {
+            "probe": load_sql(case, "01_probe.sql", window_start=start, window_end=end),
+            "context": load_sql(case, "02_context.sql"),
+            "recompute": load_sql(case, "03_recompute.sql", ontology_table="brand_ontology",
+                                  window_start=start, window_end=end),
+            "recompute_canonical": load_sql(case, "04_recompute_canonical.sql", ontology_table="brand_ontology",
+                                            window_start=start, window_end=end),
+        },
+        "windows": {
+            "all": bridges_window(all_window, canonical=canonical),
+            "sep_oct": bridges_window(sep_oct),
+        },
+    }
+
+
+def export_twins() -> dict:
+    case = "a_brand_resolution"
+    capture = load_capture(f"{case}_live")
+    results = capture["results"]
+    return {
+        "license": LICENSE,
+        "name": case,
+        "description": "Brand twins resolved by a decision model: the 120 highest fan-Jaccard pairs among the "
+                       "2,000 most liked accepted brands, the pairs accepted as one brand, the exact fan counts "
+                       "of the merged brands and a trigram control over all 20,000 names.",
+        "captures": [f"{case}_live.json"],
+        "server_binary_sha256": capture["environment"]["server_binary_sha256"],
+        "questions": load_json(case, "questions.json"),
+        "policy": load_json(case, "policy.json"),
+        "ontology": results["ontology"],
+        "sql": {
+            "probe": load_sql(case, "01_probe.sql", max_entities="120"),
+            "context": load_sql(case, "02_context.sql"),
+            "canonical": load_sql(case, "03a_canonical.sql"),
+            "dedup": load_sql(case, "03_recompute.sql"),
+        },
+        "stages": [stage_record(stage) for stage in capture["stages"]],
+        "decisions": [batch_record(batch) for batch in capture["decisions"]],
+        "totals": totals_record(capture["totals"]),
+        "band_counts": results["band_counts"],
+        "relationship_counts": results["relationship_counts"],
+        "pairs": results["pairs"],
+        "review_queue": results["review_queue"],
+        "clusters": results["clusters"],
+        "trigram_control": results["trigram_control"],
+        "full_pairwise_cost_estimate": results["full_pairwise_cost_estimate"],
+    }
+
+
+EXPORTS = {
+    "merrec-decision-bridges.json": export_bridges,
+    "merrec-decision-twins.json": export_twins,
+}
+
+
+def render(name: str) -> str:
+    data = strip_backend_fields(EXPORTS[name]())
+    check_no_backend_fields(data)
+    return json.dumps(data, indent=1, ensure_ascii=False) + "\n"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--check", action="store_true", help="compare with the files on disk instead of writing")
+    parser.add_argument("--out-dir", type=Path, default=DATA_DIR)
+    args = parser.parse_args()
+    status = 0
+    for name in EXPORTS:
+        text = render(name)
+        path = args.out_dir / name
+        if args.check:
+            current = path.read_text(encoding="utf-8") if path.exists() else None
+            state = "matches" if current == text else "differs"
+            status |= state == "differs"
+            print(f"{path}: {state}")
+        else:
+            path.write_text(text, encoding="utf-8")
+            print(f"{path}: {len(text):,} bytes")
+    return status
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/fixture/demo/decision_models/scripts/tests/__init__.py b/fixture/demo/decision_models/scripts/tests/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/fixture/demo/decision_models/scripts/tests/test_client.py b/fixture/demo/decision_models/scripts/tests/test_client.py
new file mode 100644
index 000000000..051163f09
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/tests/test_client.py
@@ -0,0 +1,240 @@
+"""Unit tests for the decision client: hashing, registry hits, replay consistency, policy bands.
+
+Run from the repository root:
+
+    python3 -m unittest discover -s fixture/demo/decision_models/scripts/tests -t fixture/demo/decision_models/scripts
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+import json
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from client.capture import Capture, scan_secrets  # noqa: E402
+from client.decision_client import (  # noqa: E402
+    Backend, BackendResponse, Decision, DecisionClient, DecisionConfigError, Entity, ReplayBackend, ReplayMiss,
+    content_hash, normalize_jev_answers, openai_schema, question_set_hash, score_range, validate_questions)
+from client.policy import Policy  # noqa: E402
+from client.registry import Registry  # noqa: E402
+
+QUESTIONS = {
+    "relationship_type": {
+        "type": "choice",
+        "instructions": "Relationship between the two brand entries.",
+        "criteria": {"same_entity_alias": "same brand", "distinct_co_liked_peers": "different brands"},
+    },
+    "should_merge_brand_id": {
+        "type": "noul",
+        "instructions": "Should the two ids be merged?",
+        "criteria": {"true": "same entity", "false": "different entities"},
+    },
+    "alignment_score": {
+        "type": "score",
+        "instructions": "Rate the equivalence.",
+        "criteria": ["0 - separate", "1 - related", "2 - sub-brand", "3 - identical"],
+    },
+}
+
+
+class FakeBackend(Backend):
+    """Deterministic backend that counts calls; the answer depends on the state text."""
+
+    name = "fake"
+    model = "fake-1"
+
+    def __init__(self):
+        self.calls = 0
+
+    def decide(self, entity: Entity, questions: dict) -> BackendResponse:
+        self.calls += 1
+        alias = "TXT" in entity.state
+        answers = {
+            "relationship_type": {"type": "choice", "choice": "same_entity_alias" if alias else "distinct_co_liked_peers",
+                                  "p": 0.9 if alias else 0.8},
+            "should_merge_brand_id": {"type": "noul", "value": 0.85 if alias else 0.1},
+            "alignment_score": {"type": "score", "value": 2.7 if alias else 0.3},
+        }
+        return BackendResponse(answers=answers, model_id="fake/1", input_tokens=10, output_tokens=2,
+                               cost_usd=0.001, latency_ms=5, raw={"answers": answers, "usage": {"cost": 0.001}})
+
+
+def entities() -> list[Entity]:
+    return [Entity("1:2", "Brand A: TXT\nBrand B: Tomorrow X Together"),
+            Entity("3:4", "Brand A: Panini\nBrand B: Topps")]
+
+
+class HashTests(unittest.TestCase):
+    def test_content_hash_is_byte_sensitive(self):
+        self.assertNotEqual(content_hash("a"), content_hash("a "))
+
+    def test_question_hash_ignores_key_order(self):
+        reordered = {name: QUESTIONS[name] for name in reversed(list(QUESTIONS))}
+        self.assertEqual(question_set_hash(QUESTIONS), question_set_hash(reordered))
+        changed = json.loads(json.dumps(QUESTIONS))
+        changed["alignment_score"]["instructions"] += "!"
+        self.assertNotEqual(question_set_hash(QUESTIONS), question_set_hash(changed))
+
+    def test_validation_rejects_bad_sets(self):
+        with self.assertRaises(DecisionConfigError):
+            validate_questions({"Bad-Name": QUESTIONS["alignment_score"]})
+        with self.assertRaises(DecisionConfigError):
+            validate_questions({f"q{i}": QUESTIONS["should_merge_brand_id"] for i in range(13)})
+        self.assertEqual(score_range(QUESTIONS["alignment_score"]), (0.0, 3.0))
+
+
+class NormalizationTests(unittest.TestCase):
+    def test_jev_response_normalizes_to_typed_answers(self):
+        payload = {"answers": {
+            "relationship_type": {"type": "choice", "choice": "same_entity_alias",
+                                  "probabilities": {"same_entity_alias": 0.97, "distinct_co_liked_peers": 0.03}},
+            "should_merge_brand_id": {"type": "noul", "noul": 0.92},
+            "alignment_score": {"type": "score", "score": 3.4},
+        }}
+        answers = normalize_jev_answers(payload, QUESTIONS)
+        self.assertEqual(answers["relationship_type"], {"type": "choice", "choice": "same_entity_alias", "p": 0.97})
+        self.assertEqual(answers["alignment_score"]["value"], 3.0)
+
+    def test_openai_schema_mirrors_question_types(self):
+        schema = openai_schema(QUESTIONS)
+        self.assertEqual(schema["properties"]["relationship_type"]["properties"]["choice"]["enum"],
+                         ["same_entity_alias", "distinct_co_liked_peers"])
+        self.assertEqual(schema["properties"]["should_merge_brand_id"], {"type": "number"})
+        self.assertEqual(schema["required"], list(QUESTIONS))
+
+
+class LoopTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.registry_path = Path(self.temp.name) / "brand_canonical.parquet"
+
+    def tearDown(self):
+        self.temp.cleanup()
+
+    def test_second_run_hits_registry_and_replay_matches_live(self):
+        backend = FakeBackend()
+        live = DecisionClient(backend, Registry(self.registry_path, QUESTIONS)).decide(entities(), QUESTIONS)
+        self.assertEqual(backend.calls, 2)
+        self.assertEqual(live.summary["registry_hits"], 0)
+        self.assertEqual(live.summary["cost_usd"], 0.002)
+
+        again = DecisionClient(backend, Registry(self.registry_path, QUESTIONS)).decide(entities(), QUESTIONS)
+        self.assertEqual(backend.calls, 2)
+        self.assertEqual(again.summary["registry_hits"], 2)
+        self.assertEqual(again.summary["api_calls"], 0)
+        self.assertEqual([d.answers for d in again.decisions], [d.answers for d in live.decisions])
+        self.assertEqual([d.decided_at for d in again.decisions], [d.decided_at for d in live.decisions])
+
+        capture = Capture("unit", "live", "fake")
+        capture.decision_batch("decide", live)
+        capture_path = Path(self.temp.name) / "unit_live.json"
+        capture.write(capture_path)
+
+        empty_registry = Registry(Path(self.temp.name) / "fresh.parquet", QUESTIONS)
+        replay = DecisionClient(ReplayBackend.from_captures([capture_path]), empty_registry).decide(entities(), QUESTIONS)
+        self.assertEqual(backend.calls, 2)
+        self.assertEqual(replay.summary["api_calls"], 0)
+        self.assertEqual(replay.summary["backend_calls"], 2)
+        self.assertEqual([d.answers for d in replay.decisions], [d.answers for d in live.decisions])
+        self.assertEqual([d.model_id for d in replay.decisions], [d.model_id for d in live.decisions])
+        self.assertEqual(replay.summary["cost_usd"], live.summary["cost_usd"])
+        self.assertEqual(len(empty_registry), 2)
+
+        with self.assertRaises(ReplayMiss):
+            DecisionClient(ReplayBackend({}), Registry(Path(self.temp.name) / "none.parquet", QUESTIONS)).decide(
+                entities(), QUESTIONS)
+
+        # A run served entirely from the registry still yields a capture that can replay on its own.
+        hits_capture = Capture("unit", "live", "fake")
+        hits_capture.decision_batch("decide", again)
+        hits_path = Path(self.temp.name) / "unit_hits_live.json"
+        hits_capture.write(hits_path)
+        from_hits = DecisionClient(ReplayBackend.from_captures([hits_path]),
+                                   Registry(Path(self.temp.name) / "fresh2.parquet", QUESTIONS)).decide(entities(), QUESTIONS)
+        self.assertEqual([d.answers for d in from_hits.decisions], [d.answers for d in live.decisions])
+        self.assertIsNone(from_hits.summary["cost_usd"])
+
+    def test_registry_hit_after_fetch_keeps_fetched_record(self):
+        backend = FakeBackend()
+        registry = Registry(self.registry_path, QUESTIONS)
+        fetched = DecisionClient(backend, registry).decide(entities()[:1], QUESTIONS)
+        hit = DecisionClient(backend, registry).decide(entities(), QUESTIONS)
+        capture = Capture("unit", "live", "fake")
+        capture.decision_batch("first", fetched)
+        capture.decision_batch("second", hit)
+        records = list(capture.data["responses"].values())
+        self.assertEqual(len(records), 2)
+        kept = next(record for record in records if record["entity_key"] == "1:2")
+        self.assertEqual(kept["source"], "backend")
+        self.assertEqual(kept["cost_usd"], 0.001)
+        self.assertIsNotNone(kept["response"])
+
+    def test_refresh_bypasses_registry_and_content_change_misses(self):
+        backend = FakeBackend()
+        DecisionClient(backend, Registry(self.registry_path, QUESTIONS)).decide(entities(), QUESTIONS)
+        refreshed = Registry(self.registry_path, QUESTIONS)
+        DecisionClient(backend, refreshed, refresh=True).decide(entities(), QUESTIONS)
+        self.assertEqual(backend.calls, 4)
+        # Within one refresh run a state is decided once; a later batch reuses this run's answer.
+        again = DecisionClient(backend, refreshed, refresh=True).decide(entities(), QUESTIONS)
+        self.assertEqual(backend.calls, 4)
+        self.assertEqual(again.summary["registry_hits"], 2)
+        changed = [Entity("1:2", "Brand A: TXT\nBrand B: Tomorrow X Together (renamed)")]
+        batch = DecisionClient(backend, Registry(self.registry_path, QUESTIONS)).decide(changed, QUESTIONS)
+        self.assertEqual(batch.summary["registry_hits"], 0)
+        self.assertEqual(backend.calls, 5)
+
+    def test_engine_table_has_typed_answer_columns(self):
+        registry = Registry(self.registry_path, QUESTIONS)
+        batch = DecisionClient(FakeBackend(), registry).decide(entities(), QUESTIONS)
+        table = registry.engine_table(batch.decisions, {"brand_id_a": [1, 3], "brand_id_b": [2, 4]})
+        self.assertEqual(table.column_names, ["entity_key", "brand_id_a", "brand_id_b", "relationship_type",
+                                              "relationship_type_p", "should_merge_brand_id", "alignment_score"])
+        self.assertEqual(str(table.schema.field("should_merge_brand_id").type), "double")
+        self.assertEqual(table.column("relationship_type").to_pylist(), ["same_entity_alias", "distinct_co_liked_peers"])
+        with self.assertRaises(ValueError):
+            registry.engine_table(batch.decisions, {"brand_id_a": [1]})
+
+    def test_registry_rejects_other_question_set(self):
+        registry = Registry(self.registry_path, QUESTIONS)
+        DecisionClient(FakeBackend(), registry).decide(entities(), QUESTIONS)
+        other = {"entity_kind": QUESTIONS["relationship_type"]}
+        with self.assertRaises(ValueError):
+            Registry(self.registry_path, other)
+
+
+class PolicyTests(unittest.TestCase):
+    def decision(self, choice: str, noul: float, key: str = "k") -> Decision:
+        answers = {"relationship_type": {"type": "choice", "choice": choice, "p": 0.9},
+                   "should_merge_brand_id": {"type": "noul", "value": noul},
+                   "alignment_score": {"type": "score", "value": 1.0}}
+        return Decision(key, "c", "q", "m", datetime(2026, 10, 19), answers, 1, 1, 0.0, 1, "backend")
+
+    def test_bands_follow_action_noul_and_required_choice(self):
+        policy = Policy({"action_question": "should_merge_brand_id", "accept_min": 0.70, "review_min": 0.30,
+                         "require": {"relationship_type": ["same_entity_alias"]}})
+        self.assertEqual(policy.band(self.decision("same_entity_alias", 0.78)), "accept")
+        self.assertEqual(policy.band(self.decision("same_entity_alias", 0.44)), "review")
+        self.assertEqual(policy.band(self.decision("same_entity_alias", 0.28)), "reject")
+        self.assertEqual(policy.band(self.decision("distinct_co_liked_peers", 0.90)), "review")
+        bands, counts = policy.apply([self.decision("same_entity_alias", 0.78, "a"), self.decision("x", 0.1, "b")])
+        self.assertEqual(counts, {"accept": 1, "review": 0, "reject": 1})
+        self.assertEqual(bands, {"a": "accept", "b": "reject"})
+
+
+class CaptureTests(unittest.TestCase):
+    def test_secret_scan_refuses_tokens(self):
+        self.assertEqual(scan_secrets("Authorization: Bearer abc"), "Bearer literal")
+        # Assembled at runtime so that no JWT-shaped literal is stored in the repository.
+        jwt_shaped = "eyJ" + "a" * 12 + "." + "eyJ" + "b" * 12 + ".sig"
+        self.assertEqual(scan_secrets(jwt_shaped), "JWT-shaped string")
+        self.assertIsNone(scan_secrets('{"backend": "jev", "model_id": "typesafe/jev-1.13-20260917"}'))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/fixture/demo/decision_models/scripts/tests/test_export_website.py b/fixture/demo/decision_models/scripts/tests/test_export_website.py
new file mode 100644
index 000000000..697cca247
--- /dev/null
+++ b/fixture/demo/decision_models/scripts/tests/test_export_website.py
@@ -0,0 +1,31 @@
+"""The website export must carry no decision backend or model identity."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+import unittest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+import export_website  # noqa: E402
+
+
+class ExportWebsiteTests(unittest.TestCase):
+    def test_strip_removes_backend_fields_at_every_depth(self):
+        data = {
+            "backend": "x", "model_ids": ["m"], "totals": {"api_calls": 1},
+            "decisions": [{"model_id": "m", "content_hash": "h", "answers": {"q": {"value": 0.5}}}],
+        }
+        stripped = export_website.strip_backend_fields(data)
+        self.assertEqual(stripped, {"totals": {"api_calls": 1}, "decisions": [{"answers": {"q": {"value": 0.5}}}]})
+        export_website.check_no_backend_fields(stripped)
+
+    def test_check_names_the_offending_path(self):
+        with self.assertRaises(ValueError) as caught:
+            export_website.check_no_backend_fields({"windows": {"all": [{"model_id": "m"}]}})
+        self.assertIn("/windows/all[0]", str(caught.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/website/blog/decision-model-in-the-loop.md b/website/blog/decision-model-in-the-loop.md
new file mode 100644
index 000000000..68cac8326
--- /dev/null
+++ b/website/blog/decision-model-in-the-loop.md
@@ -0,0 +1,239 @@
+---
+title: "Decision Models in the Query Loop: Model Answers Go Back into the SQL, and the Controls Check What Changed"
+sidebar_label: "Decision Models in the Query Loop"
+description: "Two passes of model answers about catalog entries rebuild a 5,000-brand ranking on the GPU, a merge pass corrects 18 brand fan counts, and a hand-written list and a second window check what the answers changed."
+slug: decision-model-in-the-loop
+date: 2026-10-19
+tags: [jev, cugraph]
+authors: morris
+---
+
+import CodeBlock from '@theme/CodeBlock';
+import Link from '@docusaurus/Link';
+import Table from '@site/src/theme/MDXComponents/Table';
+import {DecisionLoopFigure, RankShiftFigure} from '@site/src/components/blog/DecisionFigures';
+import bridges from '@site/static/data/merrec-decision-bridges.json';
+import twins from '@site/static/data/merrec-decision-twins.json';
+
+export const n = value => value.toLocaleString('en-US');
+export const usd = value => `$${value.toFixed(4)}`;
+export const all = bridges.windows.all;
+export const sepOct = bridges.windows.sep_oct;
+export const stage = (window, name) => window.stages.find(item => item.name === name);
+export const purifiedTop = all.ranking.filter(row => row.purified_rank !== null && row.purified_rank <= 15)
+  .sort((a, b) => a.purified_rank - b.purified_rank);
+export const byName = name => all.ranking.find(row => row.name === name);
+export const claires = all.review_queue.find(row => row.name === "Claire's");
+export const dior = twins.clusters.find(row => row.canonical_name === 'Christian Dior');
+export const estimate = twins.full_pairwise_cost_estimate;
+export const unjudged = all.ranking.filter(row => row.purified_rank !== null && row.purified_rank <= 120 && row.band === null).length;
+
+The [MerRec case study](/guides/datasets/merrec#bridges) ranks 5,000 brands
+by betweenness centrality in a graph of shared fans, to find the brands that
+connect shopping worlds. Twelve of the first twenty entries in that
+ranking are retailers (Walmart, JCPenney, Macy's), house brands (Mainstays)
+and catch-all labels that sellers pick from the brand dropdown (As Seen on
+TV, Customized & Personalized, Eyeshadow). Shoppers from every world like
+each of them, which makes each one a short cut between worlds that no
+manufacturer provides. This post follows what it takes to get those entries
+out of the ranking, and what changes when they are gone.
+{/* truncate */}
+
+A decision model does part of the work. Telling a catch-all label from a
+brand is a judgment about catalog text, and a hosted decision model
+([Jev 1.13](https://docs.typesafe.ai/model-jaggedness/jev-1.13)) answers it
+for a fraction of a cent. The rest falls on the query engine: the graph has
+to be rebuilt without the rejected entries, and the rebuilt graph has to be
+checked against something other than the model. On Algeon a recompute over
+all 182.9 million like events takes nine seconds, which leaves room for a
+control run, a second window and a second pass.
+
+## Deleting from the output is not enough
+
+Betweenness counts how often a node lies on the shortest paths between
+other nodes. Walmart's score comes from paths that run through Walmart, and
+so does part of every other node's score, because those same paths decide
+which brands are on the way between two worlds. Removing Walmart from the
+result table leaves every other number as it was. Removing Walmart from the
+graph moves the paths, and with them the ranking.
+
+Because of that, the model's answers go into the query. The published query has one CTE that
+builds the fan graph. The rebuilt query joins that CTE to a table of
+decisions and drops the entries the policy rejected or held for review.
+
+<CodeBlock language="sql" className="no-collapse" folds={[
+  {from: '), top_brands AS (', label: 'the rest of the bridges query, unchanged'},
+]}>{bridges.sql.recompute}</CodeBlock>
+
+## The loop
+
+Two of the five steps in the figure are ordinary SQL queries.
+
+<DecisionLoopFigure
+  caption={<>A probe query bounds the set of entries worth asking about and
+  collects their context. A hosted model answers a fixed question set per
+  entry. The application's policy turns the answers into bands, the bands
+  become a Parquet table registered with the server, and the recompute is
+  the original query joined to that table.</>}
+/>
+
+The probe is the published bridges query itself, and its output is the top
+120 entries. A context query joins each of them to its catalog footprint:
+listings, distinct categories, the three largest category paths, mean price
+and four sample titles. The model sees that text and no graph numbers.
+
+For each entry the model answers three questions, each with a fixed shape.
+The first picks one of four kinds (standalone brand, multi-brand retailer,
+superstore house brand, generic catch-all) and returns a probability for
+the pick. The second returns a probability for a yes-or-no question, whether
+the entry is a standalone brand. The third returns a score from 0 to 3 for
+how much the entry conflates unrelated communities. The application's policy
+reads the second answer and checks it against the first:
+{bridges.policy.accept_min.toFixed(2)} or more with the kind `standalone_brand`
+is accepted, below {bridges.policy.review_min.toFixed(2)} is rejected, and
+everything else goes to a review queue, including a high probability paired
+with another kind. Review entries stay out of the graph until a person looks
+at them.
+
+Every answer is cached in a registry keyed by a hash of the entry's context
+text, and a later run over the same entry makes no call. The model's answers
+to the same entry vary slightly between calls; without the registry a rerun
+would be a new sample.
+
+## Two passes rebuild the ranking
+
+The first pass judged the published top 120 and the recompute dropped the
+rejected and review entries. The rebuilt top 120 contained {all.passes[1].new_entries}
+entries the first pass had never seen, so a second pass judged those and
+recomputed once more. That recompute brought {unjudged} further entries into
+the top 120 that no pass has judged; a third pass would take them.
+
+<Table>
+<thead><tr><th>Pass</th><th>Entries</th><th>New</th><th>Accept</th><th>Review</th><th>Reject</th><th>Model calls</th><th>Cost</th><th>Wall</th></tr></thead>
+<tbody>{all.passes.map((pass, index) => <tr key={pass.pass}><td>{pass.pass}</td><td>{all.decisions[index].entities}</td><td>{pass.new_entries}</td><td>{pass.new_band_counts.accept}</td><td>{pass.new_band_counts.review}</td><td>{pass.new_band_counts.reject}</td><td>{pass.api_calls}</td><td>{usd(all.decisions[index].cost_usd)}</td><td>{all.decisions[index].wall_s.toFixed(1)} s</td></tr>)}</tbody>
+</Table>
+
+<RankShiftFigure
+  rows={purifiedTop.map(row => ({name: row.name, original_rank: row.original_rank, postfilter_rank: row.postfilter_rank, purified_rank: row.purified_rank}))}
+  caption={<>The purified top 15 and where each brand stood in the published
+  ranking and in the published ranking with the rejected entries deleted
+  after the fact. Post-filtering keeps 11 of the 15 but in another order,
+  and it cannot place Bella, which was not in the original top 120.</>}
+/>
+
+Samsung moves from sixth to first with
+{(byName('Samsung').purified_betweenness / byName('Samsung').original_betweenness).toFixed(1)}
+times its betweenness. Conair rises from {byName('Conair').original_rank} to
+{byName('Conair').purified_rank} and Black & Decker from
+{byName('Black & Decker').original_rank} to {byName('Black & Decker').purified_rank}.
+Two hardware brands moved near the top of a ranking of the brands that
+connect shopping worlds, once the superstore labels left the graph.
+
+An entry lands in the review queue when the model's two answers disagree or
+the probability sits in the band. Claire's has a standalone probability of
+{claires.is_standalone_brand.toFixed(2)} and a kind of `multi_brand_retailer` at
+{claires.entity_kind_p.toFixed(2)}; the policy excludes it from the graph and lists
+it for a person. The {all.review_queue.length} entries
+in the queue from both passes, with their context, are in the data file.
+
+## A list and a second window
+
+One control is a hand-written list of forty-nine retailer and catch-all
+names for this window, run through the same recompute. The list
+and the model exclude {all.denylist_vs_model.overlap} of the same entries. The
+model also excludes {all.denylist_vs_model.only_model.length} the list missed
+(Bioworld, Custom Accessories, Pink Rose and nine more), and the list
+excludes {all.denylist_vs_model.only_denylist.length} the model accepted (Charming
+Charlie, Cherokee, Loot Crate, Rue21). The two purified rankings share 13 of
+their top 15. The structural effect, the hardware brands rising, is the same
+either way. The model produces the list more cheaply than a person and
+marks in the review queue where it is unsure.
+
+The other check is a second window. On September to October the probe
+returns a different top 120, {sepOct.totals.registry_hits} of the
+{sepOct.totals.entities} lookups across both passes hit the registry, and the
+remaining {sepOct.totals.api_calls} calls cost {usd(sepOct.totals.cost_usd)}. The
+hand list, written for the first window, has {sepOct.denylist_vs_model.denylist_unmatched.length}
+names that do not appear in this window's top 120 and misses
+{sepOct.denylist_vs_model.only_model.length} entries the model rejects, among them
+Amazon, Sephora and QVC. The list fits one ranking, while the model answers
+for whatever the probe returns next.
+
+## The same loop merges split brands
+
+The [brand twins query](/guides/datasets/merrec#brand-twins) pairs entries
+whose fans overlap. Many of the highest pairs are one brand entered twice,
+TXT and Tomorrow X Together, Bape and A Bathing Ape, Dior and Christian
+Dior, and every fan count for such a brand is computed on a fragment. A
+string comparison misses the acronyms and the rebrands. Asking a model about
+all {n(estimate.pairs)} pairs of 20,000 names is not an option either; at this
+run's cost per decision it would come to about
+${Math.round(estimate.estimated_cost_usd).toLocaleString('en-US')}.
+
+The probe keeps the question affordable. The pairing query, with
+the rejected entries of the bridges run removed from the fan graph, returns
+the 120 pairs with the highest fan Jaccard among the 2,000 most liked
+brands. The model judged those 120 with each pair's score and both entries'
+catalog context, for {usd(twins.decisions[0].cost_usd)} in
+{twins.decisions[0].wall_s.toFixed(1)} s. The policy merges {twins.band_counts.accept},
+holds {twins.band_counts.review} for review and leaves {twins.band_counts.reject}
+apart. The pairs left apart include the ones a fan-overlap rule alone would
+merge: Hello Kitty and Sanrio, Konami and Yu-Gi-Oh!, Panini and Topps.
+
+The accepted pairs are edges. `cugraph_weakly_connected_components` assigns
+each entry the smallest id of its component, and a scan of every like event
+counts, per merged brand, the exact number of distinct users who liked any
+member.
+
+<Table>
+<thead><tr><th>Brand</th><th>Most fans on one id</th><th>Both ids summed</th><th>Distinct fans</th><th>Gain</th></tr></thead>
+<tbody>{twins.clusters.slice(0, 6).map(row => <tr key={row.canonical_id}><td>{row.canonical_name}</td><td>{n(row.primary_fans)}</td><td>{n(row.naive_sum_fans)}</td><td>{n(row.exact_union_fans)}</td><td>+{row.gain_pct.toFixed(1)}%</td></tr>)}</tbody>
+</Table>
+
+Whichever id a report used for Dior, it was missing about a third of the
+brand's fans, and a report that added the two ids would have counted a
+quarter of its total twice. These are exact counts over every like event,
+and the whole table of {twins.clusters.length} merged brands is on the
+[case study page](/guides/datasets/merrec#brand-twins).
+
+The control here is trigram similarity over all 20,000 names. It finds
+{twins.trigram_control.accepted_found} of the {twins.trigram_control.accepted_aliases}
+pairs the policy merged and misses TXT, Bape, Dior, LOFT, HERMES and
+Thierry Mugler. The pairs it proposes that the policy did not merge are
+sub-brands and near names, Air Jordan and Jordan, Crystal and Crystal Rock.
+
+## What the model is for
+
+The model answers a bounded set of questions about catalog text, with a
+probability the application can act on, and the GPU does the rest: the probe
+that bounds the set, the recompute that turns the answers into a new graph,
+and the controls that show how much of the change depends on the model's
+particular answers.
+
+- The probe limits the cost. Judging the 120 pairs it returned cost under a
+  cent; judging every pair of 20,000 names would cost about ten thousand
+  dollars.
+- The recompute is cheap enough to run several times. A control list, a
+  second window and a second pass were each one more query, nine seconds on
+  the full window and four on the shorter one, and every recompute ran
+  natively on the GPU with zero host boundaries.
+- The answers are typed. A choice with a probability, a probability for a
+  question, a score. The policy is a few lines the application owns, and a
+  person handles the review band.
+
+The question set, the policy and the recompute belong to the application,
+and the list control shows the result with no model at all. The loop needs
+the recompute and the controls, at a cost below the question itself, and it
+works with any model that returns typed answers.
+
+## Reproduce
+
+Both follow-ups are on the [MerRec case study](/guides/datasets/merrec#bridges)
+page with their SQL, tables and provenance. The data files
+([bridges](/data/merrec-decision-bridges.json), [twins](/data/merrec-decision-twins.json))
+hold the question sets, the policy, the executed SQL, the stage metrics,
+every judgment and every ranking, under the dataset's CC BY-NC terms. The
+runner is in the repository under
+[`fixture/demo/decision_models`](https://github.com/algeon-dev/algeon/tree/main/fixture/demo/decision_models).
+A live run needs a model endpoint of your own; its replay mode reruns the
+queries from that run's capture with no model calls.
diff --git a/website/blog/introducing-algeon.md b/website/blog/introducing-algeon.md
index a2974350b..90271402a 100644
--- a/website/blog/introducing-algeon.md
+++ b/website/blog/introducing-algeon.md
@@ -1,5 +1,6 @@
 ---
 title: "Introducing Algeon: Interactive Graph, Vector, and ML Analytics for the Agent's Loop"
+sidebar_label: "Introducing Algeon"
 description: "Follow a marketplace investigation to see how Algeon combines SQL with GPU graph, vector, and ML algorithms, supports follow-up queries, and fits beside existing lakehouse engines."
 slug: introducing-algeon
 date: 2026-10-15
@@ -294,7 +295,9 @@ A graph ranking led to a product-title check and comparisons with other
 seed brands, all expressed through SQL. Some results gained supporting
 evidence; Taylor Swift remained a question for further investigation.
 The campaign example extended that interface to graph, vector, and model
-operations within one query.
+operations within one query. A [later post](/blog/decision-model-in-the-loop)
+puts a decision model's answers back into the bridges and brand twins
+queries and checks the rebuilt rankings against controls.
 
 Algeon is available to try when the required data can be staged as Parquet
 and the query fits on one GPU. Running it currently requires Linux, an
diff --git a/website/docs/cugraph/_examples/merrec_scale_bridges_decisions.mdx b/website/docs/cugraph/_examples/merrec_scale_bridges_decisions.mdx
new file mode 100644
index 000000000..7f30e81b5
--- /dev/null
+++ b/website/docs/cugraph/_examples/merrec_scale_bridges_decisions.mdx
@@ -0,0 +1,90 @@
+import CodeBlock from '@theme/CodeBlock';
+import Table from '@site/src/theme/MDXComponents/Table';
+import bridges from '@site/static/data/merrec-decision-bridges.json';
+
+export const n = value => value.toLocaleString('en-US');
+export const all = bridges.windows.all;
+export const sepOct = bridges.windows.sep_oct;
+export const stage = (window, name) => window.stages.find(item => item.name === name);
+export const purifiedTop = all.ranking.filter(row => row.purified_rank !== null && row.purified_rank <= 15)
+  .sort((a, b) => a.purified_rank - b.purified_rank);
+export const excludedInTop20 = all.ranking.filter(row => row.original_rank !== null && row.original_rank <= 20 && row.band === 'reject').length;
+export const unjudged = all.ranking.filter(row => row.purified_rank !== null && row.purified_rank <= 120 && row.band === null).length;
+export const pass1 = all.passes[0];
+export const pass2 = all.passes[1];
+export const decide1 = all.decisions[0];
+export const rankOrDash = value => value === null ? 'not in top 120' : value;
+export const multiplier = row => row.original_betweenness ? (row.purified_betweenness / row.original_betweenness).toFixed(2) : '';
+export const peak = window => (Math.max(...window.stages.map(item => item.allocator_peak_bytes)) / 2 ** 30).toFixed(2);
+
+The exclusion list came from a decision model. {excludedInTop20} of the
+first 20 entries in the published ranking are retailers, house brands or
+catch-all labels, and
+betweenness is a property of the paths through them, so deleting them from
+the output changes nothing for the other brands. The graph has to be rebuilt
+without them.
+
+A context query joined each of the 120 ranked entries to its catalog
+footprint: listings, distinct first and second level categories, the three
+largest category paths, mean price and four sample titles. A hosted decision
+model answered three questions per entry from that context alone, with no
+graph numbers in the prompt: the kind of entry (standalone brand,
+multi-brand retailer, superstore house brand, generic catch-all), the
+probability that the entry is a standalone brand, and a 0 to 3 pollution
+score. The application's policy accepts an entry when the probability is at
+least {bridges.policy.accept_min.toFixed(2)} and the kind is `standalone_brand`,
+rejects it below {bridges.policy.review_min.toFixed(2)}, and sends the rest to
+review. The answers for all 120 entries became a Parquet file, registered as
+`brand_ontology`, and the bridges query ran again with one change in its
+first CTE: entries the policy rejected or held for review leave the fan
+graph.
+
+<CodeBlock language="sql" className="no-collapse" folds={[
+  {from: '), top_brands AS (', label: 'unchanged from the bridges query above'},
+]}>{bridges.sql.recompute}</CodeBlock>
+
+Pass 1 judged the published top 120: {pass1.new_band_counts.accept} accepted,
+{pass1.new_band_counts.review} for review, {pass1.new_band_counts.reject} rejected
+({pass1.api_calls} calls, ${decide1.cost_usd.toFixed(4)}, {decide1.wall_s.toFixed(1)} s).
+Review entries stay out of the graph too. The purified ranking placed
+{pass2.new_entries} entries the first pass had not seen in its top 120, so a
+second pass judged those ({pass2.api_calls} calls) and recomputed once more,
+which brought {unjudged} further unjudged entries into the top 120. The table
+lists the purified top 15 with each brand's rank in the
+published ranking and in the published ranking with the excluded entries
+deleted after the fact, its purified betweenness and the ratio of that score
+to its original one.
+
+<Table>
+<thead><tr><th>Purified</th><th>Brand</th><th>Original</th><th>Post-filter</th><th>Betweenness</th><th>Ratio</th></tr></thead>
+<tbody>{purifiedTop.map(row => <tr key={row.brand_id}><td>{row.purified_rank}</td><td>{row.name}</td><td>{rankOrDash(row.original_rank)}</td><td>{rankOrDash(row.postfilter_rank)}</td><td>{row.purified_betweenness.toFixed(5)}</td><td>{multiplier(row)}</td></tr>)}</tbody>
+</Table>
+
+Samsung's betweenness doubles in the purified graph. Conair and Black & Decker move from the sixties
+into the top 10, and Bella enters a top 15 it was absent from. Post-filtering
+keeps 11 of these 15 brands but in a different order and cannot place Bella.
+The full 202-row table with every brand that appears in any of the three
+rankings is `windows.all.ranking` in the data file; the {all.review_queue.length}-entry
+review queue of both passes, with its context, is `windows.all.review_queue`. Claire's is there with
+a standalone probability of 0.89 and a kind of `multi_brand_retailer` at
+0.98, the kind of disagreement the review band holds.
+
+Two controls. A hand-written denylist of {all.denylist_vs_model.denylist_size} retailer
+and catch-all names, run through the same recompute, excludes
+{all.denylist_vs_model.overlap} of the same entries; the model also excludes
+{all.denylist_vs_model.only_model.length} the list missed and keeps
+{all.denylist_vs_model.only_denylist.length} the list names. The two purified rankings
+share 13 of their top 15. On the September to October window the model's
+answers are reused from the first run: {sepOct.totals.registry_hits} of
+{sepOct.totals.entities} lookups hit the registry, the remaining
+{sepOct.totals.api_calls} calls cost ${sepOct.totals.cost_usd.toFixed(4)}, and
+the model excludes {sepOct.denylist_vs_model.only_model.length} entries the denylist
+does not know, among them Amazon, Sephora and QVC, while
+{sepOct.denylist_vs_model.denylist_unmatched.length} of the list's names do not
+appear in that window's top 120 at all.
+
+<div className="fineprint">
+
+The probe and each recompute ran as one statement with {stage(all, 'probe').native_fragments} native fragments and zero host DataFusion boundaries; the probe took {stage(all, 'probe').elapsed_s.toFixed(2)} s and the purified recompute {stage(all, 'recompute').elapsed_s.toFixed(2)} s on the May to October window, {stage(sepOct, 'recompute').elapsed_s.toFixed(2)} s on September to October. The largest query allocator peak was {peak(all)} GiB of the {(stage(all, 'probe').query_limit_bytes / 2 ** 30).toFixed(0)} GiB query limit. Both passes together made {all.totals.api_calls} model calls for ${all.totals.cost_usd.toFixed(4)}. The [data file](/data/merrec-decision-bridges.json) holds the question set, the policy, the denylist, the executed SQL, the stage metrics, every judgment and every ranking and review row for both windows. The model's answers to the same entry vary slightly between calls, so a rerun that ignores the registry is a new sample.
+
+</div>
diff --git a/website/docs/cugraph/_examples/merrec_scale_twins_decisions.mdx b/website/docs/cugraph/_examples/merrec_scale_twins_decisions.mdx
new file mode 100644
index 000000000..d4dce04b3
--- /dev/null
+++ b/website/docs/cugraph/_examples/merrec_scale_twins_decisions.mdx
@@ -0,0 +1,74 @@
+import CodeBlock from '@theme/CodeBlock';
+import Table from '@site/src/theme/MDXComponents/Table';
+import twins from '@site/static/data/merrec-decision-twins.json';
+
+export const n = value => value.toLocaleString('en-US');
+export const stage = name => twins.stages.find(item => item.name === name);
+export const decide = twins.decisions[0];
+export const trigram = twins.trigram_control;
+export const estimate = twins.full_pairwise_cost_estimate;
+export const peak = (Math.max(...twins.stages.map(item => item.allocator_peak_bytes)) / 2 ** 30).toFixed(2);
+
+Which of those pairs are one brand? A decision model answered for the
+120 highest-scoring pairs. The pair list is the query above with the fan
+graph restricted to entries the [bridges follow-up](#bridges) accepted as
+standalone brands, so retailers and catch-all labels pair with nothing, and
+the limit raised from 30 to 120. For each pair the model saw the Jaccard
+score and both entries' listings, mean price, two largest category paths and
+three sample titles, and answered three questions: the relationship
+(`same_entity_alias`, `sub_brand_or_diffusion_line`,
+`ip_franchise_and_owner_maker`, `distinct_co_liked_peers`), the probability
+that the two ids should merge, and a 0 to 3 alignment score. The policy
+accepts a merge at a probability of {twins.policy.accept_min.toFixed(2)} or more
+when the relationship is `same_entity_alias`, rejects it below
+{twins.policy.review_min.toFixed(2)}, and sends the rest to review.
+
+{twins.band_counts.accept} pairs were accepted, {twins.band_counts.review} sent to
+review and {twins.band_counts.reject} rejected ({decide.api_calls} calls,
+${decide.cost_usd.toFixed(4)}, {decide.wall_s.toFixed(1)} s). The rejects include the
+pairs a fan-overlap rule alone would merge: Rilakkuma and San-X, Hello
+Kitty and Sanrio, Konami and Yu-Gi-Oh!, Panini and Topps. The review queue
+holds Hourglass Cosmetics and Hourglass at 0.69, Beats by Dr. Dre and Beats
+at 0.68, and the sub-brand pairs Air Jordan and Jordan, Polo Ralph Lauren
+and Ralph Lauren.
+
+Accepted pairs are edges. `cugraph_weakly_connected_components` gives each
+entry the smallest brand id of its component as a canonical id, and a scan
+of every like event counts, per canonical brand, the exact number of
+distinct users who liked any member. Every merged brand has two ids; the
+table compares the fans of the id with more of them against the distinct
+count over both, and the share of the summed count that is the same people
+twice.
+
+<CodeBlock language="sql" className="no-collapse">{twins.sql.canonical}</CodeBlock>
+
+<CodeBlock language="sql" className="no-collapse" folds={[
+  {from: ', brands AS (', label: 'brand names and the final aggregate'},
+]}>{twins.sql.dedup}</CodeBlock>
+
+<Table>
+<thead><tr><th>Brand</th><th>Most fans on one id</th><th>Distinct fans</th><th>Gain</th><th>Double counted</th></tr></thead>
+<tbody>{twins.clusters.map(row => <tr key={row.canonical_id}><td>{row.member_names.join(' / ')}</td><td>{n(row.primary_fans)}</td><td>{n(row.exact_union_fans)}</td><td>+{row.gain_pct.toFixed(1)}%</td><td>{row.double_count_pct.toFixed(1)}%</td></tr>)}</tbody>
+</Table>
+
+These are exact counts over all 182.9 million like events. Whichever id a
+report used for Dior, it was missing about a third of the brand's fans, and
+adding the two ids would have counted a quarter of the sum twice.
+
+A string control proposes pairs by word-trigram similarity over all
+{n(trigram.brand_names)} names, with a threshold of {trigram.threshold} (pg_trgm's
+default 0.3 pairs Dior with Christian Dior and a great deal else). It finds
+{trigram.accepted_found} of the {trigram.accepted_aliases} pairs the policy merged
+and misses the acronyms, rebrands and spellings: TXT, Bape, Dior, LOFT, HERMES,
+Thierry Mugler, L'Oreal, Thrive, e.l.f. Cosmetics. Its {n(trigram.pairs_proposed_all_brands)}
+proposals over the whole catalog are mostly case and punctuation variants,
+with pairs that share every trigram such as Boom Boom and Boom. Judging every one of the
+{n(estimate.pairs)} pairs instead of the probe's {estimate.probe_decisions} would cost
+about ${Math.round(estimate.estimated_cost_usd).toLocaleString('en-US')} at this
+run's mean cost per decision; the probe keeps the question affordable.
+
+<div className="fineprint">
+
+The probe ran with {stage('probe').native_fragments} native fragments and zero host DataFusion boundaries in {stage('probe').elapsed_s.toFixed(2)} s; the component labels took {stage('canonical').elapsed_s.toFixed(2)} s and the fan count over all likes {stage('dedup').elapsed_s.toFixed(2)} s. The largest query allocator peak was {peak} GiB of the {(stage('probe').query_limit_bytes / 2 ** 30).toFixed(0)} GiB query limit. The trigram control ran on the CPU in {trigram.elapsed_s.toFixed(1)} s. The [data file](/data/merrec-decision-twins.json) holds the question set, the policy, the executed SQL, the stage metrics, all 120 judged pairs, the review queue, the merged clusters and the control's found, missed and wrongly proposed pairs.
+
+</div>
diff --git a/website/docs/design/native-lowering.mdx b/website/docs/design/native-lowering.mdx
index f914b8915..3bc3cdda5 100644
--- a/website/docs/design/native-lowering.mdx
+++ b/website/docs/design/native-lowering.mdx
@@ -241,6 +241,14 @@ may still become GPU fragments. Explicit graph, vector and ML functions also
 form GPU fragments. Transfers at CPU/GPU boundaries are part of the cost of
 such a mixed plan.
 
+A join condition that reads both inputs stays on the join. Each part of it
+that reads one input and that the cuDF join AST cannot evaluate, such as
+`LIKE`, a string function or `IS DISTINCT FROM`, becomes a column of that
+input computed before the join, as an expression join key does. Only a part
+that cannot fail moves, because DataFusion evaluates the condition on
+key-matched pairs alone. [Native Evaluation Semantics](../reference/native-evaluation-semantics.mdx#where-checked-operations-are-not-evaluated)
+states where a part with a checked operation runs.
+
 Decimal division in a keyed inner join predicate uses the native GPU
 post-join filter. Equality keys first select candidate row pairs. The GPU
 column evaluator then checks decimal division and preserves `CASE` branch
diff --git a/website/docs/guides/datasets/merrec.mdx b/website/docs/guides/datasets/merrec.mdx
index 419cbdd98..bfdf49823 100644
--- a/website/docs/guides/datasets/merrec.mdx
+++ b/website/docs/guides/datasets/merrec.mdx
@@ -8,10 +8,12 @@ description: Eight questions over 1.27 billion Mercari US marketplace events, fr
 import Barbie from '../../cugraph/_examples/merrec_scale_barbie.mdx';
 import ShoppingWorlds from '../../cugraph/_examples/merrec_scale_worlds.mdx';
 import Bridges from '../../cugraph/_examples/merrec_scale_bridges.mdx';
+import BridgesDecisions from '../../cugraph/_examples/merrec_scale_bridges_decisions.mdx';
 import Funnel from '../../cuml/_examples/merrec_scale_funnel.mdx';
 import Pokemon from '../../cuvs/_examples/merrec_scale_lookalikes.mdx';
 import ExistingModel from '../../cuml/_examples/merrec_scale_xgboost.mdx';
 import Twins from '../../cugraph/_examples/merrec_scale_twins.mdx';
+import TwinsDecisions from '../../cugraph/_examples/merrec_scale_twins_decisions.mdx';
 import Sessions from '../../cugraph/_examples/merrec_scale_sessions.mdx';
 import CodeBlock from '@theme/CodeBlock';
 import BrandMap from '@site/src/components/merrec/BrandMap';
@@ -60,6 +62,8 @@ group. Select groups to see where they sit and which brands have the most fans.
 
 <Bridges />
 
+<BridgesDecisions />
+
 ## Does a Pokemon lookalike audience find new interest? {/* #pokemon */}
 
 <Pokemon />
@@ -72,6 +76,8 @@ group. Select groups to see where they sit and which brands have the most fans.
 
 <Twins />
 
+<TwinsDecisions />
+
 ## Is `session_id` a per-user session key? {/* #sessions */}
 
 <Sessions />
diff --git a/website/docs/reference/native-evaluation-semantics.mdx b/website/docs/reference/native-evaluation-semantics.mdx
index 1926853ba..acabd175a 100644
--- a/website/docs/reference/native-evaluation-semantics.mdx
+++ b/website/docs/reference/native-evaluation-semantics.mdx
@@ -65,10 +65,22 @@ WHERE n >= 0 AND total / n > 1          -- fails on a row with n = 0, as on Data
 ## Where checked operations are not evaluated
 
 Integer `/`, any `%`, and timestamp `+` or `-` are not evaluated inside reader
-predicates or join residual conditions. A reader predicate with one of them
-stays a filter after the scan, and a join residual with one of them keeps the
-join on DataFusion. A join residual with a decimal `/` keeps the join on
-DataFusion as well.
+predicates. A reader predicate with one of them stays a filter after the scan.
+
+DataFusion evaluates a join condition that reads both inputs only on the row
+pairs whose equality keys match. Native lowering moves each part of the
+condition that reads one input and contains no checked operation before the
+join, where it is computed on every row of that input. Such a part cannot
+fail, and the extra rows change no result. Integer `/` and `%` by a literal
+other than `0` and `-1`, and floating-point `%`, can move this way.
+
+A part that reads one input and contains a checked operation stays in the
+condition. When the condition belongs to an inner join with equality keys and
+contains a decimal `/`, it is evaluated after matching, on the matched pairs
+only, with the guards described above. Any other condition with a checked
+operation keeps the join on DataFusion. Integer `/` or `%` with a column
+divisor, `%` over both inputs, and timestamp `+` or `-` keep it there in every
+join.
 
 <div className="fineprint">
 
diff --git a/website/docs/reference/native-sql-support.mdx b/website/docs/reference/native-sql-support.mdx
index 89e3b6889..43b6e65bf 100644
--- a/website/docs/reference/native-sql-support.mdx
+++ b/website/docs/reference/native-sql-support.mdx
@@ -33,7 +33,7 @@ DataFusion, the DataFusion baseline remains in place.
 | Expression | Native forms |
 | --- | --- |
 | Values | Columns and literals. |
-| Arithmetic | `+`, `-`, `*`, `/`, `%` and unary minus. Decimal `%` is not native. Integer `/`, any `%` and timestamp `+`/`-` are not evaluated in reader predicates or join residuals. |
+| Arithmetic | `+`, `-`, `*`, `/`, `%` and unary minus. Decimal `%` is not native. Integer `/`, any `%` and timestamp `+`/`-` are not evaluated in reader predicates; [join conditions](./native-evaluation-semantics.mdx#where-checked-operations-are-not-evaluated) evaluate them only in parts that cannot fail. |
 | Timestamp arithmetic | Two timezone-free timestamps of one unit subtract to a `Duration` of that unit. Such a timestamp plus or minus a duration gives a timestamp. Duration plus duration, date plus or minus duration, and date minus date are not native. |
 | Comparison and logic | Comparisons, `AND`, `OR`, `NOT`, null tests. |
 | Conditionals | `CASE`. |
diff --git a/website/package-lock.json b/website/package-lock.json
index 5bf23f2e5..0d214588c 100644
--- a/website/package-lock.json
+++ b/website/package-lock.json
@@ -17,11 +17,11 @@
         "graphology": "^0.26.0",
         "graphology-types": "^0.24.8",
         "prism-react-renderer": "^2.3.0",
-        "react": "^19.3.0",
-        "react-dom": "^19.3.0",
+        "react": "^19.3.1",
+        "react-dom": "^19.3.1",
         "recharts": "^3.9.2",
         "roughjs": "^4.6.6",
-        "sigma": "^4.0.0"
+        "sigma": "^4.0.3"
       },
       "devDependencies": {
         "@docusaurus/module-type-aliases": "^3.10.2",
@@ -30,7 +30,7 @@
         "@types/react": "^19.3.0",
         "@types/react-dom": "^19.3.0",
         "typescript": "~7.0.2",
-        "wrangler": "^4.149.0"
+        "wrangler": "^4.151.0"
       },
       "engines": {
         "node": ">=22.0"
@@ -2029,9 +2029,9 @@
       }
     },
     "node_modules/@cloudflare/workerd-darwin-64": {
-      "version": "1.20261006.1",
-      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-darwin-64/-/workerd-darwin-64-1.20261006.1.tgz",
-      "integrity": "sha512-lCX6avJO2It9AyDEYitjmOtJRVp/xmaW0TziyoLAnfxlzozyyRbSFfIIMMCiDx/sTP1++E4VLbV+7BHSD33f0Q==",
+      "version": "1.20261012.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-darwin-64/-/workerd-darwin-64-1.20261012.1.tgz",
+      "integrity": "sha512-dkTL9aY3V4D40b+jBpGPCistWUPFQ/M61wlWi6i1o8MvHFFgEw7EQkcaYEv6Yd3bkPDD/3TFT4hRsMb2xVZSwQ==",
       "cpu": [
         "x64"
       ],
@@ -2046,9 +2046,9 @@
       }
     },
     "node_modules/@cloudflare/workerd-darwin-arm64": {
-      "version": "1.20261006.1",
-      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-darwin-arm64/-/workerd-darwin-arm64-1.20261006.1.tgz",
-      "integrity": "sha512-PyFGjOaldtppnLuKsdkoYWXfLVpDjuf8u+uoykX+1Xvxo2EPmCVViq0iDKm+U7c7PRno85ehS3/MPVXyk2HwHw==",
+      "version": "1.20261012.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-darwin-arm64/-/workerd-darwin-arm64-1.20261012.1.tgz",
+      "integrity": "sha512-2/nVGcKXjNNI+DhxKSepTKvFng9H7aN2WXv6Zu67iqgI6JrxypNt5kTPv4ZHosxrcfyKMci/2RfN7GIrN0BitQ==",
       "cpu": [
         "arm64"
       ],
@@ -2063,9 +2063,9 @@
       }
     },
     "node_modules/@cloudflare/workerd-linux-64": {
-      "version": "1.20261006.1",
-      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-linux-64/-/workerd-linux-64-1.20261006.1.tgz",
-      "integrity": "sha512-Ntf9S8eesmVufdjaT2kzWlz6Ng9XGYTc6cHQVRKAg59lFufwsIabGeMT6U4KkrpEeSIxgHq8aPtuLbZXE19tCA==",
+      "version": "1.20261012.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-linux-64/-/workerd-linux-64-1.20261012.1.tgz",
+      "integrity": "sha512-uMe7ONHnLxStD1Ye0YFHBO36uj4cStv5P53rW+5GVWXFT8BRjqVixlH0IqCAHe1Pmcwyd1+7fVoGde89MZSCJg==",
       "cpu": [
         "x64"
       ],
@@ -2080,9 +2080,9 @@
       }
     },
     "node_modules/@cloudflare/workerd-linux-arm64": {
-      "version": "1.20261006.1",
-      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-linux-arm64/-/workerd-linux-arm64-1.20261006.1.tgz",
-      "integrity": "sha512-JyeDBymVWw5tVRebSsVE8ojDYxd6UlZrAseHU8G+NpIyd5wF61tXlF/axLeCUqu0pOhBFHb8I5QKi0jwrCK41Q==",
+      "version": "1.20261012.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-linux-arm64/-/workerd-linux-arm64-1.20261012.1.tgz",
+      "integrity": "sha512-I0VMdcXk7ygG5vYDce0ePTBFdnBXC0i9WiBY5mWiv0iTinbfea6/rHqSQ7B1UMpjgrYVs9E0m4bZ9ufsk5GCFA==",
       "cpu": [
         "arm64"
       ],
@@ -2097,9 +2097,9 @@
       }
     },
     "node_modules/@cloudflare/workerd-windows-64": {
-      "version": "1.20261006.1",
-      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-windows-64/-/workerd-windows-64-1.20261006.1.tgz",
-      "integrity": "sha512-nWP0URNqOBN9fa/gZ7eh/w051DwjOXN8j4lDZDYVXyQPsux6sV3DfyYZT+CjR/rt9nKBSmJT9QE9/bWT18+84w==",
+      "version": "1.20261012.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-windows-64/-/workerd-windows-64-1.20261012.1.tgz",
+      "integrity": "sha512-c5hQvNx574UEoknaCFvMa/NdLrrYiALNbe6sx1okW8uOiRYWxrFuA8WpXFnBJ5XJypm0TEAHYaUTGv3rRLpY7Q==",
       "cpu": [
         "x64"
       ],
@@ -4977,6 +4977,9 @@
         "arm"
       ],
       "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -4994,6 +4997,9 @@
         "arm64"
       ],
       "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -5011,6 +5017,9 @@
         "ppc64"
       ],
       "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -5028,6 +5037,9 @@
         "riscv64"
       ],
       "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -5045,6 +5057,9 @@
         "s390x"
       ],
       "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -5062,6 +5077,9 @@
         "x64"
       ],
       "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -5079,6 +5097,9 @@
         "arm64"
       ],
       "dev": true,
+      "libc": [
+        "musl"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -5096,6 +5117,9 @@
         "x64"
       ],
       "dev": true,
+      "libc": [
+        "musl"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -5113,6 +5137,9 @@
         "arm"
       ],
       "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -5136,6 +5163,9 @@
         "arm64"
       ],
       "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -5159,6 +5189,9 @@
         "ppc64"
       ],
       "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -5182,6 +5215,9 @@
         "riscv64"
       ],
       "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -5205,6 +5241,9 @@
         "s390x"
       ],
       "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -5228,6 +5267,9 @@
         "x64"
       ],
       "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -5251,6 +5293,9 @@
         "arm64"
       ],
       "dev": true,
+      "libc": [
+        "musl"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -5274,6 +5319,9 @@
         "x64"
       ],
       "dev": true,
+      "libc": [
+        "musl"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8032,7 +8080,6 @@
       "cpu": [
         "ppc64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8049,7 +8096,6 @@
       "cpu": [
         "arm64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8066,7 +8112,6 @@
       "cpu": [
         "x64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8083,7 +8128,6 @@
       "cpu": [
         "arm64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8100,7 +8144,6 @@
       "cpu": [
         "x64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8117,7 +8160,6 @@
       "cpu": [
         "arm"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8134,7 +8176,6 @@
       "cpu": [
         "arm64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8151,7 +8192,6 @@
       "cpu": [
         "loong64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8168,7 +8208,6 @@
       "cpu": [
         "mips64el"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8185,7 +8224,6 @@
       "cpu": [
         "ppc64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8202,7 +8240,6 @@
       "cpu": [
         "riscv64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8219,7 +8256,6 @@
       "cpu": [
         "s390x"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8236,7 +8272,6 @@
       "cpu": [
         "x64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8253,7 +8288,6 @@
       "cpu": [
         "arm64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8270,7 +8304,6 @@
       "cpu": [
         "x64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8287,7 +8320,6 @@
       "cpu": [
         "arm64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8304,7 +8336,6 @@
       "cpu": [
         "x64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8321,7 +8352,6 @@
       "cpu": [
         "x64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8338,7 +8368,6 @@
       "cpu": [
         "arm64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -8355,7 +8384,6 @@
       "cpu": [
         "x64"
       ],
-      "dev": true,
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -16214,16 +16242,16 @@
       }
     },
     "node_modules/miniflare": {
-      "version": "5.20261006.1-alpha",
-      "resolved": "https://registry.npmjs.org/miniflare/-/miniflare-5.20261006.1-alpha.tgz",
-      "integrity": "sha512-6ylv8tamkrspDI2R/cAYfv+YWmfGNdXe76Pi9TauEUWsFVXn3LNF9Yk8oduzf1a+TYsSRYTqlOE7+nGGRsMHdw==",
+      "version": "5.20261012.0-beta",
+      "resolved": "https://registry.npmjs.org/miniflare/-/miniflare-5.20261012.0-beta.tgz",
+      "integrity": "sha512-Cjrs+vHHQ7krLO4HYELYpYBJBuMhcnNZD/Z5z/UcQSnFqWSQY3DhtTCFalXgI1/yO1iK+YrRKK8EYkumrEopxg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@cspotcode/source-map-support": "0.8.1",
         "sharp": "0.35.5",
         "undici": "7.29.1",
-        "workerd": "1.20261006.1",
+        "workerd": "1.20261012.1",
         "ws": "8.21.0",
         "youch": "4.1.0-beta.10"
       },
@@ -18623,24 +18651,24 @@
       }
     },
     "node_modules/react": {
-      "version": "19.3.0",
-      "resolved": "https://registry.npmjs.org/react/-/react-19.3.0.tgz",
-      "integrity": "sha512-E8LUcbtBWt20bbl2YoHfx4ZDBdxVTfOKtCZn9cDSJ4l6/nuoApcpIBcj47t2wZoVX8g2ZHuMHbiShgCR1T5Sog==",
+      "version": "19.3.1",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.3.1.tgz",
+      "integrity": "sha512-QNhWdt7nrgVWWQG58QuGsAR3jv3Hbe4mb4vz7w2csnHavciZJgda1CPNaldF6eVxv90ud3jUXpKlHL69gO38yw==",
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
       }
     },
     "node_modules/react-dom": {
-      "version": "19.3.0",
-      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.3.0.tgz",
-      "integrity": "sha512-JDk8dgif51OjFoDE70+OT9ICyYr+69HlmihNwp1+Nsfbna3t5sIiCa9ZJktDmQ4/1b/rn26hIAR2uYXDMr5r0Q==",
+      "version": "19.3.1",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.3.1.tgz",
+      "integrity": "sha512-Y0bARz53lhEC1NMCASs0/j+faB/zqt3R8hpvg1e8+61ZVJ4UL0UdC4cBbXfZMcIuhrfgeILTLe+ZeBCavQPtKQ==",
       "license": "MIT",
       "dependencies": {
         "scheduler": "^0.28.0"
       },
       "peerDependencies": {
-        "react": "^19.3.0"
+        "react": "^19.3.1"
       }
     },
     "node_modules/react-fast-compare": {
@@ -19981,9 +20009,9 @@
       }
     },
     "node_modules/sigma": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/sigma/-/sigma-4.0.0.tgz",
-      "integrity": "sha512-ZyLcCWCO4AxUrhIAF9I0H6vkS/A69wjVM7NduFK9EA0JLUYCQet8MeyDJTRf4zYldAydSu6Cq+BJwONhOAc61Q==",
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/sigma/-/sigma-4.0.3.tgz",
+      "integrity": "sha512-DwtnWVZMpHzgfyWwyH9bvNAV2DwSl9UZHmieLIAOdZboQAfjEGwcKNJzLQOca/vrKNiUYexVnPcNzhkNUQHdVA==",
       "license": "MIT",
       "dependencies": {
         "events": "^3.3.0",
@@ -21773,9 +21801,9 @@
       "license": "MIT"
     },
     "node_modules/workerd": {
-      "version": "1.20261006.1",
-      "resolved": "https://registry.npmjs.org/workerd/-/workerd-1.20261006.1.tgz",
-      "integrity": "sha512-8MadBuffZ5NdpLwZjUmsqT5QlaKXq4gjgT6wzcKeynZTICNXyePhc+5QVoKiK7+MMhFTLNrRO2KXLlpk8Q6BkA==",
+      "version": "1.20261012.1",
+      "resolved": "https://registry.npmjs.org/workerd/-/workerd-1.20261012.1.tgz",
+      "integrity": "sha512-tEHoMPsMga0seVjxfsR8Pd3f8IRqYwkq++dTUKI5Gdgj6zuSDluYwisydq+dn90SsIACwBquJUQ1nBpcOqaWTA==",
       "dev": true,
       "hasInstallScript": true,
       "license": "Apache-2.0",
@@ -21786,17 +21814,17 @@
         "node": ">=16"
       },
       "optionalDependencies": {
-        "@cloudflare/workerd-darwin-64": "1.20261006.1",
-        "@cloudflare/workerd-darwin-arm64": "1.20261006.1",
-        "@cloudflare/workerd-linux-64": "1.20261006.1",
-        "@cloudflare/workerd-linux-arm64": "1.20261006.1",
-        "@cloudflare/workerd-windows-64": "1.20261006.1"
+        "@cloudflare/workerd-darwin-64": "1.20261012.1",
+        "@cloudflare/workerd-darwin-arm64": "1.20261012.1",
+        "@cloudflare/workerd-linux-64": "1.20261012.1",
+        "@cloudflare/workerd-linux-arm64": "1.20261012.1",
+        "@cloudflare/workerd-windows-64": "1.20261012.1"
       }
     },
     "node_modules/wrangler": {
-      "version": "4.149.0",
-      "resolved": "https://registry.npmjs.org/wrangler/-/wrangler-4.149.0.tgz",
-      "integrity": "sha512-OzK7xmB5r5iLKb3cIT3783g13fe6T7xyeKu9LEdUyl+DKAM2KP/jkjnE0OUhyw+mB/XJM9ycjgF3MWm8PR9amg==",
+      "version": "4.151.0",
+      "resolved": "https://registry.npmjs.org/wrangler/-/wrangler-4.151.0.tgz",
+      "integrity": "sha512-ra8MpzSR+ClkbGofu9S+AmAKjytS60MqSuayXKpa1CAYIzP+NIc8q6EiF55Gz5PS3lxT4qcvMuPHihCNhTPpDg==",
       "dev": true,
       "license": "MIT OR Apache-2.0",
       "dependencies": {
@@ -21804,10 +21832,10 @@
         "@cloudflare/unenv-preset": "2.16.2",
         "blake3-wasm": "2.1.5",
         "esbuild": "0.28.2",
-        "miniflare": "5.20261006.1-alpha",
+        "miniflare": "5.20261012.0-beta",
         "path-to-regexp": "6.3.0",
         "unenv": "2.0.0-rc.24",
-        "workerd": "1.20261006.1"
+        "workerd": "1.20261012.1"
       },
       "bin": {
         "cf-wrangler": "bin/cf-wrangler.js",
diff --git a/website/package.json b/website/package.json
index 859cf61b0..891116fb2 100644
--- a/website/package.json
+++ b/website/package.json
@@ -25,11 +25,11 @@
     "graphology": "^0.26.0",
     "graphology-types": "^0.24.8",
     "prism-react-renderer": "^2.3.0",
-    "react": "^19.3.0",
-    "react-dom": "^19.3.0",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
     "recharts": "^3.9.2",
     "roughjs": "^4.6.6",
-    "sigma": "^4.0.0"
+    "sigma": "^4.0.3"
   },
   "devDependencies": {
     "@docusaurus/module-type-aliases": "^3.10.2",
@@ -38,7 +38,7 @@
     "@types/react": "^19.3.0",
     "@types/react-dom": "^19.3.0",
     "typescript": "~7.0.2",
-    "wrangler": "^4.149.0"
+    "wrangler": "^4.151.0"
   },
   "browserslist": {
     "production": [
diff --git a/website/src/components/blog/DecisionFigures.tsx b/website/src/components/blog/DecisionFigures.tsx
new file mode 100644
index 000000000..18812a3ca
--- /dev/null
+++ b/website/src/components/blog/DecisionFigures.tsx
@@ -0,0 +1,272 @@
+import React from 'react';
+import {
+  BackedLabel,
+  Box,
+  COLOR,
+  COMPACT_FONTS,
+  EDGE,
+  Figure,
+  LABEL,
+  measureNode,
+  textWidth,
+} from '@site/src/components/design/Diagram';
+import type {BoxFonts, DiagramNode, FontSpec} from '@site/src/components/design/Diagram';
+import {SANS, sketchHead, sketchLine, sketchPath} from '@site/src/components/design/sketch';
+
+/**
+ * The decision-model post's figures: the loop that puts a hosted model's
+ * typed answers back into a GPU query as a registered table, and the rank
+ * shift of the bridge brands before and after that table filters them.
+ * Built from the Design diagrams' box, figure, and sketch primitives so they
+ * match the introduction post's figures.
+ */
+
+const HEAD = {size: 11, track: 0.08};
+const INK = COLOR.fg;
+const EDGE_W = 1.4;
+
+/* ====================== DecisionLoopFigure ====================== */
+
+const DECISION_PROBE: DiagramNode = {
+  kind: 'GPU query', name: 'Probe',
+  note: ['graph UDTFs over all rows', 'bounded candidate set + context'], tone: 'gpu',
+};
+const DECISION_MODEL: DiagramNode = {
+  kind: 'hosted model', name: 'Decision model',
+  note: ['fixed question set per candidate', 'choice · probability · score'], tone: 'foreign',
+};
+const DECISION_POLICY: DiagramNode = {
+  kind: 'application rule', name: 'Policy',
+  note: ['accept ≥ 0.70 with the kind', 'reject < 0.30 · else review'], tone: 'plan',
+};
+const DECISION_TABLE: DiagramNode = {
+  kind: 'Parquet · CREATE EXTERNAL TABLE', name: 'Decision table',
+  note: ['one row per candidate', 'band · kind · probabilities'], tone: 'lake',
+};
+const DECISION_RECOMPUTE: DiagramNode = {
+  kind: 'GPU query', name: 'Recompute',
+  note: ['same query joined to the table', 'all rows, no host boundary'], tone: 'gpu',
+};
+const DECISION_REGISTRY = 'registry: one call per distinct state';
+const DECISION_RETURN = 'the recompute is the next probe';
+
+/**
+ * The decision model in the query loop. Probe, model and policy run left to
+ * right; the decision table sits under the policy and the recompute turns
+ * back toward the probe, so five boxes fit a 640 px figure in two rows.
+ */
+export function DecisionLoopFigure({caption}: {caption?: React.ReactNode}) {
+  const fonts: BoxFonts = COMPACT_FONTS;
+  const [probe, model, policy, table, recompute] =
+    [DECISION_PROBE, DECISION_MODEL, DECISION_POLICY, DECISION_TABLE, DECISION_RECOMPUTE]
+      .map((n) => measureNode(n, fonts));
+  const V_GAP = 64;
+  const RAIL_DROP = 34;
+  const R = 10;
+  const label12 = 'rows';
+  const label23 = 'typed answers';
+  const label34 = 'bands';
+  const label45 = 'registered relation';
+  const gapFor = (line: string) => Math.max(72, Math.ceil(textWidth(line, LABEL)) + 48);
+  const place = (x: number, rowTop: number, rowH: number, s: {w: number; h: number}) =>
+    ({x, y: rowTop + (rowH - s.h) / 2, w: s.w, h: s.h, cx: x + s.w / 2, cy: rowTop + rowH / 2});
+
+  // The registry note sits above the model box, so row 1 starts one label line down.
+  const row1Top = EDGE + LABEL.lh + 12;
+  const row1H = Math.max(probe.h, model.h, policy.h);
+  const P = place(EDGE + 8, row1Top, row1H, probe);
+  const M = place(P.x + P.w + gapFor(label12), row1Top, row1H, model);
+  const Q = place(M.x + M.w + gapFor(label23), row1Top, row1H, policy);
+
+  const row2Top = row1Top + row1H + V_GAP;
+  const row2H = Math.max(table.h, recompute.h);
+  const T = place(Q.cx - table.w / 2, row2Top, row2H, table);
+  const C = place(T.x - gapFor(label45) - recompute.w, row2Top, row2H, recompute);
+
+  const railY = row2Top + row2H + RAIL_DROP;
+  const svgH = railY + LABEL.lh + 8 + EDGE;
+  const svgW = Math.max(Q.x + Q.w, T.x + T.w, Q.cx + 12 + Math.ceil(textWidth(label34, LABEL))) + 8 + EDGE;
+  const edge = {stroke: INK, strokeWidth: EDGE_W};
+  const rail = [
+    `M ${C.cx} ${C.y + C.h}`,
+    `L ${C.cx} ${railY - R}`,
+    `Q ${C.cx} ${railY} ${C.cx - R} ${railY}`,
+    `L ${P.cx + R} ${railY}`,
+    `Q ${P.cx} ${railY} ${P.cx} ${railY - R}`,
+    `L ${P.cx} ${P.y + P.h + 1}`,
+  ].join(' ');
+
+  return (
+    <Figure caption={caption} svgW={svgW} svgH={svgH} minW={640} center
+      ariaLabel="A GPU probe query runs graph UDTFs over all rows and returns a bounded candidate set with context. A hosted decision model answers a fixed question set per candidate, with a registry making one call per distinct state. An application policy turns the answers into accept, review, or reject bands, which are written to Parquet and registered as an external table. The same GPU query joined to that table recomputes over all rows, and the recompute is the next probe.">
+      <text x={M.cx} y={row1Top - 10} fontSize={LABEL.size} fontFamily={SANS}
+        letterSpacing={`${LABEL.track ?? 0}em`} textAnchor="middle" fill={COLOR.muted}>
+        {DECISION_REGISTRY}
+      </text>
+      {sketchLine('decision:p-m', P.x + P.w + 2, P.cy, M.x - 2, P.cy, edge)}
+      {sketchHead('decision:p-m:head', M.x, P.cy, 'right', edge)}
+      <BackedLabel x={(P.x + P.w + M.x) / 2} y={P.cy - 14} text={label12} />
+      {sketchLine('decision:m-q', M.x + M.w + 2, M.cy, Q.x - 2, M.cy, edge)}
+      {sketchHead('decision:m-q:head', Q.x, M.cy, 'right', edge)}
+      <BackedLabel x={(M.x + M.w + Q.x) / 2} y={M.cy - 14} text={label23} />
+      {sketchLine('decision:q-t', Q.cx, Q.y + Q.h + 2, Q.cx, T.y - 2, edge)}
+      {sketchHead('decision:q-t:head', Q.cx, T.y, 'down', edge)}
+      <text x={Q.cx + 12} y={(Q.y + Q.h + T.y) / 2 + LABEL.size * 0.36} fontSize={LABEL.size}
+        fontFamily={SANS} fill={COLOR.muted}>
+        {label34}
+      </text>
+      {sketchLine('decision:t-c', T.x - 2, T.cy, C.x + C.w + 2, T.cy, edge)}
+      {sketchHead('decision:t-c:head', C.x + C.w, T.cy, 'left', edge)}
+      <BackedLabel x={(C.x + C.w + T.x) / 2} y={T.cy - 14} text={label45} />
+      {sketchPath('decision:rail', rail, {...edge, dashed: true})}
+      {sketchHead('decision:rail:head', P.cx, P.y + P.h, 'up', edge)}
+      <text x={(P.cx + C.cx) / 2} y={railY + LABEL.lh} fontSize={LABEL.size} fontFamily={SANS}
+        textAnchor="middle" fill={COLOR.muted}>
+        {DECISION_RETURN}
+      </text>
+      {/* boxes last so edge ends tuck under their borders */}
+      <Box node={DECISION_PROBE} x={P.x} y={P.y} w={P.w} h={P.h} fonts={fonts} />
+      <Box node={DECISION_MODEL} x={M.x} y={M.y} w={M.w} h={M.h} fonts={fonts} />
+      <Box node={DECISION_POLICY} x={Q.x} y={Q.y} w={Q.w} h={Q.h} fonts={fonts} />
+      <Box node={DECISION_TABLE} x={T.x} y={T.y} w={T.w} h={T.h} fonts={fonts} />
+      <Box node={DECISION_RECOMPUTE} x={C.x} y={C.y} w={C.w} h={C.h} fonts={fonts} />
+    </Figure>
+  );
+}
+
+/* ====================== RankShiftFigure ====================== */
+
+export interface RankShiftRow {
+  name: string;
+  original_rank: number | null;
+  postfilter_rank: number | null;
+  purified_rank: number;
+}
+
+const RANK_LABEL: FontSpec = {size: 13, lh: 18, face: 'sans'};
+const RANK_HEAD: FontSpec = {size: HEAD.size, lh: 16, face: 'sans', track: HEAD.track};
+const RANK_ROW_H = 30;
+const RANK_SLOPE_W = 130;
+const RANK_GAP = 6;
+const RANK_ABSENT = 'not in top 120';
+const RANK_HEADS = ['ORIGINAL', 'POST-FILTER', 'PURIFIED'] as const;
+
+/** Vertical slot of each row in a column ordered by `ranks`. Rows without a
+ * rank take the slots after the ranked ones, in input order. */
+function rankSlots(ranks: (number | null)[]): number[] {
+  const order = ranks
+    .map((rank, i) => ({rank, i}))
+    .sort((a, b) => (a.rank ?? Infinity) - (b.rank ?? Infinity) || a.i - b.i);
+  const slots = new Array<number>(ranks.length);
+  order.forEach(({i}, slot) => {
+    slots[i] = slot;
+  });
+  return slots;
+}
+
+/**
+ * Slope chart of the bridge ranking across the original, post-filter, and
+ * purified stages. Rows arrive sorted by purified rank. Each of the two
+ * earlier columns reorders the same brands by its own rank, and a line joins
+ * a brand's positions so the distance it moved reads as the line's slope.
+ */
+export function RankShiftFigure({rows, caption}: {rows: RankShiftRow[]; caption?: React.ReactNode}) {
+  const original = rows.map((r) => r.original_rank);
+  const postfilter = rows.map((r) => r.postfilter_rank);
+  const originalSlots = rankSlots(original);
+  const postfilterSlots = rankSlots(postfilter);
+
+  const allRanks = rows.flatMap((r) => [r.original_rank, r.postfilter_rank, r.purified_rank]);
+  const numW = Math.ceil(Math.max(...allRanks.map((rank) => (rank === null ? 0 : textWidth(String(rank), RANK_LABEL)))));
+  const absentW = Math.ceil(textWidth(RANK_ABSENT, RANK_LABEL));
+  const headW = RANK_HEADS.map((head) => Math.ceil(textWidth(head, RANK_HEAD)));
+  const nameW = Math.ceil(Math.max(...rows.map((r) => textWidth(r.name, RANK_LABEL))));
+
+  // Column 1 is right-aligned so lines leave from its numbers, column 2 is
+  // centered so lines meet its numbers from both sides, and column 3 starts
+  // with the rank so lines end where its rows begin.
+  const col1Right = EDGE + 8 + Math.max(numW, absentW, headW[0]);
+  const col2X = col1Right + RANK_SLOPE_W;
+  const col2W = Math.max(numW, absentW, headW[1]);
+  const col2Cx = col2X + col2W / 2;
+  const col3X = col2X + col2W + RANK_SLOPE_W;
+  const nameX = col3X + numW + 10;
+  const svgW = Math.max(nameX + nameW, col3X + headW[2]) + 8 + EDGE;
+
+  const top = EDGE + 14 + 10;
+  const svgH = top + rows.length * RANK_ROW_H + 8 + EDGE;
+  const slotY = (slot: number) => top + slot * RANK_ROW_H + RANK_ROW_H / 2;
+  const baseline = (y: number) => y + RANK_LABEL.size * 0.36;
+  const halfNum = (rank: number) => textWidth(String(rank), RANK_LABEL) / 2;
+  const line = {stroke: COLOR.muted, strokeWidth: 1.2, roughness: 0.4};
+  const headX = [col1Right, col2Cx, col3X];
+  const headAnchor = ['end', 'middle', 'start'] as const;
+
+  const absent = (key: string, x: number, y: number, anchor: 'end' | 'middle') => {
+    const left = anchor === 'end' ? x - absentW : x - absentW / 2;
+    // The surface backing hides any line that slopes through the bottom slots.
+    return (
+      <g key={key}>
+        <rect x={left - 4} y={y - 9} width={absentW + 8} height={18} rx={4} fill={COLOR.surface} opacity={0.92} />
+        <text x={x} y={baseline(y)} fontSize={RANK_LABEL.size} fontFamily={SANS} fontStyle="italic"
+          textAnchor={anchor} fill={COLOR.muted}>
+          {RANK_ABSENT}
+        </text>
+      </g>
+    );
+  };
+  const rankText = (key: string, x: number, y: number, rank: number, anchor: 'end' | 'middle') => (
+    <text key={key} x={x} y={baseline(y)} fontSize={RANK_LABEL.size} fontFamily={SANS}
+      textAnchor={anchor} fill={COLOR.fg}>
+      {rank}
+    </text>
+  );
+  const describe = (rank: number | null) => (rank === null ? RANK_ABSENT : `rank ${rank}`);
+
+  return (
+    <Figure caption={caption} svgW={svgW} svgH={svgH} minW={640} center
+      ariaLabel={`Slope chart of brand ranks in three columns: the original ranking, the post-filter ranking, and the purified ranking. ${
+        rows.map((r) => `${r.name}: original ${describe(r.original_rank)}, post-filter ${describe(r.postfilter_rank)}, purified rank ${r.purified_rank}`).join('; ')}.`}>
+      {RANK_HEADS.map((head, i) => (
+        <text key={head} x={headX[i]} y={EDGE + 14} fontSize={HEAD.size} fontFamily={SANS}
+          letterSpacing={`${HEAD.track}em`} textAnchor={headAnchor[i]} fill={COLOR.muted}>
+          {head}
+        </text>
+      ))}
+      {rows.map((r, i) => {
+        const y1 = slotY(originalSlots[i]);
+        const y2 = slotY(postfilterSlots[i]);
+        const y3 = slotY(i);
+        return (
+          <g key={`lines-${r.name}`}>
+            {r.original_rank !== null && r.postfilter_rank !== null &&
+              sketchLine(`rank:${r.name}:a`, col1Right + RANK_GAP, y1,
+                col2Cx - halfNum(r.postfilter_rank) - RANK_GAP, y2, line)}
+            {r.postfilter_rank !== null &&
+              sketchLine(`rank:${r.name}:b`, col2Cx + halfNum(r.postfilter_rank) + RANK_GAP, y2,
+                col3X - RANK_GAP, y3, line)}
+          </g>
+        );
+      })}
+      {rows.map((r, i) => {
+        const y1 = slotY(originalSlots[i]);
+        const y2 = slotY(postfilterSlots[i]);
+        const y3 = slotY(i);
+        return (
+          <g key={`text-${r.name}`}>
+            {r.original_rank === null
+              ? absent('original', col1Right, y1, 'end')
+              : rankText('original', col1Right, y1, r.original_rank, 'end')}
+            {r.postfilter_rank === null
+              ? absent('postfilter', col2Cx, y2, 'middle')
+              : rankText('postfilter', col2Cx, y2, r.postfilter_rank, 'middle')}
+            {rankText('purified', col3X + numW, y3, r.purified_rank, 'end')}
+            <text x={nameX} y={baseline(y3)} fontSize={RANK_LABEL.size} fontFamily={SANS} fill={COLOR.fg}>
+              {r.name}
+            </text>
+          </g>
+        );
+      })}
+    </Figure>
+  );
+}
diff --git a/website/static/data/LICENSE-MERREC.md b/website/static/data/LICENSE-MERREC.md
index 0d93a8f8f..288b4de75 100644
--- a/website/static/data/LICENSE-MERREC.md
+++ b/website/static/data/LICENSE-MERREC.md
@@ -25,6 +25,8 @@ Files covered:
 - `merrec-barbie-control-seeds.json`
 - `merrec-barbie-listing-check.json`
 - `merrec-brand-map.json`
+- `merrec-decision-bridges.json`
+- `merrec-decision-twins.json`
 - `merrec-pokemon-interest-check.json`
 - `merrec-scale-ann.json`
 - `merrec-scale-audience-funnel.json`
diff --git a/website/static/data/merrec-decision-bridges.json b/website/static/data/merrec-decision-bridges.json
new file mode 100644
index 000000000..08cc8d1c5
--- /dev/null
+++ b/website/static/data/merrec-decision-bridges.json
@@ -0,0 +1,16609 @@
+{
+ "license": "CC-BY-NC-4.0; derived from the MerRec dataset, Copyright Mercari, Inc.; see LICENSE-MERREC.md in this directory",
+ "name": "b_bridge_purification",
+ "description": "World bridges recomputed without the catalog entries a decision model rejects as standalone brands; the published betweenness ranking, the post-filtered ranking and the purified ranking over the same window, with a denylist control and a second window.",
+ "captures": [
+  "b_bridge_purification_all_live.json",
+  "b_bridge_purification_all_canonical_live.json",
+  "b_bridge_purification_sep_oct_live.json"
+ ],
+ "server_binary_sha256": "e2aaf1424e9dd8605835ddb3e09abef2cb5b3629796e3c4a11bb43dac3c9d697",
+ "questions": {
+  "entity_kind": {
+   "type": "choice",
+   "instructions": "In a peer-to-peer marketplace (Mercari), sellers select a `brand_name` from a dropdown. Some entries are real standalone brands, while others are generic catch-all tags, product categories, multi-brand department stores/retailers, or mass-retailer private labels. Classify this `brand_name` entry.",
+   "criteria": {
+    "standalone_brand": "A genuine standalone consumer brand, fashion label, cosmetics brand, electronics/toy manufacturer, or entertainment IP (e.g., H&M, ZARA, Anthropologie, Nike, Free People, Urban Outfitters, Morphe, Tarte, Disney)",
+    "multi_brand_retailer": "A department store, big-box superstore, specialty retail chain, or mall store that sells many third-party or licensed franchises under one roof (e.g., Walmart, Macy's, JCPenney, Target, Sephora, Claire's, Hot Topic, BoxLunch, Spencer's, Kohl's, Nordstrom, Costco)",
+    "superstore_house_brand": "A private-label / house brand owned by a mass big-box superstore (Walmart, Target, Costco, Amazon) spanning home/apparel/general merchandise (e.g., Mainstays, Better Homes & Gardens, THRESHOLD, Time and Tru, No Boundaries, Wild Fable, Universal Thread, Cat & Jack, Room Essentials, Kirkland Signature)",
+    "generic_catchall_or_category": "Not a brand at all, but a generic seller descriptor, vintage tag, infomercial label, or product type mistakenly listed as a brand (e.g., Customized & Personalized, US Vintage, American Vintage, As Seen on TV, Eyeshadow, Handmade, Boutique)"
+   }
+  },
+  "is_standalone_brand": {
+   "type": "noul",
+   "instructions": "Is this entry a genuine standalone consumer brand rather than a generic descriptor, category name, department store, or big-box private label?",
+   "criteria": {
+    "true": "Distinct standalone brand or creator label with its own brand identity",
+    "false": "Generic catch-all tag, product category, department store/superstore, or big-box house label"
+   }
+  },
+  "wormhole_pollution": {
+   "type": "score",
+   "instructions": "How severely does this entry act as an artificial cross-community 'wormhole' that conflates unrelated shopping communities in a brand co-liking graph?",
+   "criteria": [
+    "0 - Cohesive standalone brand representing a real, specific brand affinity",
+    "1 - Broad lifestyle/fashion retailer or specialty store with moderately diverse categories",
+    "2 - Mass-market superstore house label or department store spanning unrelated household and apparel verticals",
+    "3 - Severe graph pollutant: generic non-brand catch-all tag (e.g. 'Customized & Personalized', 'As Seen on TV', 'US Vintage', 'Eyeshadow') or universal big-box superstore ('Walmart')"
+   ]
+  }
+ },
+ "policy": {
+  "action_question": "is_standalone_brand",
+  "accept_min": 0.7,
+  "review_min": 0.3,
+  "require": {
+   "entity_kind": [
+    "standalone_brand"
+   ]
+  }
+ },
+ "control_denylist": {
+  "multi_brand_retailer": [
+   "Bed Bath & Beyond",
+   "Cabela's",
+   "Cato",
+   "Charming Charlie",
+   "Claire's",
+   "Hobby Lobby",
+   "Hot Topic",
+   "JCPenney",
+   "Kohl's",
+   "Loot Crate",
+   "Macy's",
+   "Nordstrom",
+   "Pier 1 Imports",
+   "Pier One",
+   "Rue21",
+   "Spencer's",
+   "Ulta",
+   "Walmart",
+   "World Market"
+  ],
+  "superstore_house_brand": [
+   "Better Homes & Gardens",
+   "Cherokee",
+   "Circo",
+   "Faded Glory",
+   "Hyper Tough",
+   "INC International Concepts",
+   "Mainstays",
+   "No Boundaries",
+   "Room Essentials",
+   "SO",
+   "Secret Treasures",
+   "Sonoma",
+   "Style & Co",
+   "Wonder Nation",
+   "Xhilaration",
+   "a.n.a"
+  ],
+  "generic_catchall_or_category": [
+   "American Vintage",
+   "ART",
+   "Army",
+   "As Seen on TV",
+   "Authentic Original Vintage Style",
+   "Customized & Personalized",
+   "Eyeshadow",
+   "Independent",
+   "Indie",
+   "Lot",
+   "Original Vintage Style",
+   "Rare",
+   "The Unbranded Brand",
+   "US Vintage"
+  ]
+ },
+ "sql": {
+  "probe": "WITH fans AS (\n  SELECT -(e.user_id + 1) AS src, CAST(i.brand_id AS BIGINT) AS dst\n  FROM merrec_events e JOIN merrec_items i ON i.item_id = e.item_id\n  WHERE e.event_type = 'item_like' AND i.brand_id <> 0\n    AND e.event_time >= TIMESTAMP '2023-05-01' AND e.event_time < TIMESTAMP '2023-11-01'\n  GROUP BY e.user_id, i.brand_id\n), top_brands AS (\n  SELECT dst AS brand_id, COUNT(*) AS fans FROM fans GROUP BY dst ORDER BY fans DESC, dst LIMIT 5000\n), similar AS (\n  SELECT first, second, similarity\n  FROM cugraph_jaccard(\n    edges => (SELECT src, dst FROM fans),\n    vertex_pairs => (SELECT a.brand_id AS first, b.brand_id AS second\n                     FROM top_brands a JOIN top_brands b ON a.brand_id < b.brand_id),\n    directed => false)\n  WHERE similarity >= 0.02\n), worlds AS (\n  SELECT vertex AS brand_id, community AS world\n  FROM cugraph_leiden(\n    edges => (SELECT first AS src, second AS dst, CAST(similarity AS DOUBLE) AS weight FROM similar),\n    directed => false, resolution => 3, seed => 42)\n), bridges AS (\n  SELECT vertex AS brand_id, value AS betweenness\n  FROM cugraph_betweenness_centrality(\n    edges => (SELECT first AS src, second AS dst FROM similar),\n    directed => false, normalized => true)\n), neighbors AS (\n  SELECT first AS brand_id, second AS neighbor FROM similar\n  UNION ALL SELECT second, first FROM similar\n), reach AS (\n  SELECT n.brand_id, COUNT(*) AS neighbors, COUNT(DISTINCT w.world) AS worlds_reached\n  FROM neighbors n JOIN worlds w ON w.brand_id = n.neighbor\n  GROUP BY n.brand_id\n), brands AS (\n  SELECT CAST(brand_id AS BIGINT) AS brand_id, MIN(brand_name) AS brand_name\n  FROM merrec_items WHERE brand_id <> 0 GROUP BY brand_id\n)\nSELECT br.brand_id, b.brand_name, t.fans, w.world, r.neighbors, r.worlds_reached, br.betweenness\nFROM bridges br\nJOIN worlds w ON w.brand_id = br.brand_id\nJOIN reach r ON r.brand_id = br.brand_id\nJOIN top_brands t ON t.brand_id = br.brand_id\nJOIN brands b ON b.brand_id = br.brand_id\nORDER BY br.betweenness DESC, b.brand_name\nLIMIT 120\n",
+  "context": "WITH target_items AS (\n  SELECT CAST(brand_id AS BIGINT) AS brand_id, c0_name, c1_name, category_path, name, price\n  FROM merrec_items\n  WHERE brand_id IN ({brand_ids})\n), brand_stats AS (\n  SELECT brand_id,\n         COUNT(*) AS total_listings,\n         COUNT(DISTINCT c0_name) AS distinct_c0,\n         COUNT(DISTINCT c1_name) AS distinct_c1,\n         ROUND(AVG(price), 2) AS avg_price\n  FROM target_items\n  GROUP BY brand_id\n), top_cats AS (\n  SELECT brand_id, category_path, COUNT(*) AS listings,\n         ROW_NUMBER() OVER (PARTITION BY brand_id ORDER BY COUNT(*) DESC, category_path) AS rk\n  FROM target_items\n  WHERE category_path IS NOT NULL\n  GROUP BY brand_id, category_path\n), sample_titles AS (\n  SELECT brand_id, name,\n         ROW_NUMBER() OVER (PARTITION BY brand_id ORDER BY name) AS trk\n  FROM target_items\n  WHERE name IS NOT NULL\n)\nSELECT bs.brand_id, bs.total_listings, bs.distinct_c0, bs.distinct_c1, bs.avg_price,\n       MAX(CASE WHEN tc.rk = 1 THEN tc.category_path END) AS cat1,\n       MAX(CASE WHEN tc.rk = 1 THEN tc.listings END) AS cat1_listings,\n       MAX(CASE WHEN tc.rk = 2 THEN tc.category_path END) AS cat2,\n       MAX(CASE WHEN tc.rk = 2 THEN tc.listings END) AS cat2_listings,\n       MAX(CASE WHEN tc.rk = 3 THEN tc.category_path END) AS cat3,\n       MAX(CASE WHEN tc.rk = 3 THEN tc.listings END) AS cat3_listings,\n       MAX(CASE WHEN st.trk = 10 THEN st.name END) AS title1,\n       MAX(CASE WHEN st.trk = 50 THEN st.name END) AS title2,\n       MAX(CASE WHEN st.trk = 100 THEN st.name END) AS title3,\n       MAX(CASE WHEN st.trk = 200 THEN st.name END) AS title4\nFROM brand_stats bs\nLEFT JOIN top_cats tc ON tc.brand_id = bs.brand_id AND tc.rk <= 3\nLEFT JOIN sample_titles st ON st.brand_id = bs.brand_id AND st.trk IN (10, 50, 100, 200)\nGROUP BY bs.brand_id, bs.total_listings, bs.distinct_c0, bs.distinct_c1, bs.avg_price\nORDER BY bs.brand_id\n",
+  "recompute": "WITH fans AS (\n  SELECT -(e.user_id + 1) AS src, CAST(i.brand_id AS BIGINT) AS dst\n  FROM merrec_events e JOIN merrec_items i ON i.item_id = e.item_id\n  LEFT JOIN brand_ontology o ON o.brand_id = CAST(i.brand_id AS BIGINT)\n  WHERE e.event_type = 'item_like' AND i.brand_id <> 0\n    AND (o.brand_id IS NULL OR o.band = 'accept')\n    AND e.event_time >= TIMESTAMP '2023-05-01' AND e.event_time < TIMESTAMP '2023-11-01'\n  GROUP BY e.user_id, i.brand_id\n), top_brands AS (\n  SELECT dst AS brand_id, COUNT(*) AS fans FROM fans GROUP BY dst ORDER BY fans DESC, dst LIMIT 5000\n), similar AS (\n  SELECT first, second, similarity\n  FROM cugraph_jaccard(\n    edges => (SELECT src, dst FROM fans),\n    vertex_pairs => (SELECT a.brand_id AS first, b.brand_id AS second\n                     FROM top_brands a JOIN top_brands b ON a.brand_id < b.brand_id),\n    directed => false)\n  WHERE similarity >= 0.02\n), worlds AS (\n  SELECT vertex AS brand_id, community AS world\n  FROM cugraph_leiden(\n    edges => (SELECT first AS src, second AS dst, CAST(similarity AS DOUBLE) AS weight FROM similar),\n    directed => false, resolution => 3, seed => 42)\n), bridges AS (\n  SELECT vertex AS brand_id, value AS betweenness\n  FROM cugraph_betweenness_centrality(\n    edges => (SELECT first AS src, second AS dst FROM similar),\n    directed => false, normalized => true)\n), neighbors AS (\n  SELECT first AS brand_id, second AS neighbor FROM similar\n  UNION ALL SELECT second, first FROM similar\n), reach AS (\n  SELECT n.brand_id, COUNT(*) AS neighbors, COUNT(DISTINCT w.world) AS worlds_reached\n  FROM neighbors n JOIN worlds w ON w.brand_id = n.neighbor\n  GROUP BY n.brand_id\n), brands AS (\n  SELECT CAST(brand_id AS BIGINT) AS brand_id, MIN(brand_name) AS brand_name\n  FROM merrec_items WHERE brand_id <> 0 GROUP BY brand_id\n)\nSELECT br.brand_id, b.brand_name, t.fans, w.world, r.neighbors, r.worlds_reached, br.betweenness\nFROM bridges br\nJOIN worlds w ON w.brand_id = br.brand_id\nJOIN reach r ON r.brand_id = br.brand_id\nJOIN top_brands t ON t.brand_id = br.brand_id\nJOIN brands b ON b.brand_id = br.brand_id\nORDER BY br.betweenness DESC, b.brand_name\nLIMIT 120\n",
+  "recompute_canonical": "WITH fans AS (\n  SELECT -(e.user_id + 1) AS src, COALESCE(c.canonical_id, CAST(i.brand_id AS BIGINT)) AS dst\n  FROM merrec_events e JOIN merrec_items i ON i.item_id = e.item_id\n  LEFT JOIN brand_ontology o ON o.brand_id = CAST(i.brand_id AS BIGINT)\n  LEFT JOIN brand_canonical c ON c.brand_id = CAST(i.brand_id AS BIGINT)\n  WHERE e.event_type = 'item_like' AND i.brand_id <> 0\n    AND (o.brand_id IS NULL OR o.band = 'accept')\n    AND e.event_time >= TIMESTAMP '2023-05-01' AND e.event_time < TIMESTAMP '2023-11-01'\n  GROUP BY 1, 2\n), top_brands AS (\n  SELECT dst AS brand_id, COUNT(*) AS fans FROM fans GROUP BY dst ORDER BY fans DESC, dst LIMIT 5000\n), similar AS (\n  SELECT first, second, similarity\n  FROM cugraph_jaccard(\n    edges => (SELECT src, dst FROM fans),\n    vertex_pairs => (SELECT a.brand_id AS first, b.brand_id AS second\n                     FROM top_brands a JOIN top_brands b ON a.brand_id < b.brand_id),\n    directed => false)\n  WHERE similarity >= 0.02\n), worlds AS (\n  SELECT vertex AS brand_id, community AS world\n  FROM cugraph_leiden(\n    edges => (SELECT first AS src, second AS dst, CAST(similarity AS DOUBLE) AS weight FROM similar),\n    directed => false, resolution => 3, seed => 42)\n), bridges AS (\n  SELECT vertex AS brand_id, value AS betweenness\n  FROM cugraph_betweenness_centrality(\n    edges => (SELECT first AS src, second AS dst FROM similar),\n    directed => false, normalized => true)\n), neighbors AS (\n  SELECT first AS brand_id, second AS neighbor FROM similar\n  UNION ALL SELECT second, first FROM similar\n), reach AS (\n  SELECT n.brand_id, COUNT(*) AS neighbors, COUNT(DISTINCT w.world) AS worlds_reached\n  FROM neighbors n JOIN worlds w ON w.brand_id = n.neighbor\n  GROUP BY n.brand_id\n), brands AS (\n  SELECT CAST(brand_id AS BIGINT) AS brand_id, MIN(brand_name) AS brand_name\n  FROM merrec_items WHERE brand_id <> 0 GROUP BY brand_id\n)\nSELECT br.brand_id, b.brand_name, t.fans, w.world, r.neighbors, r.worlds_reached, br.betweenness\nFROM bridges br\nJOIN worlds w ON w.brand_id = br.brand_id\nJOIN reach r ON r.brand_id = br.brand_id\nJOIN top_brands t ON t.brand_id = br.brand_id\nJOIN brands b ON b.brand_id = br.brand_id\nORDER BY br.betweenness DESC, b.brand_name\nLIMIT 120\n"
+ },
+ "windows": {
+  "all": {
+   "window": {
+    "start": "2023-05-01",
+    "end": "2023-11-01"
+   },
+   "stages": [
+    {
+     "name": "probe",
+     "rows": 120,
+     "elapsed_s": 8.761907765176147,
+     "query_id": "03fde0d5-d09c-4b79-986c-7481db065768",
+     "native_fragments": 15,
+     "host_boundaries": 0,
+     "allocator_peak_bytes": 58471525743,
+     "query_limit_bytes": 96636764160
+    },
+    {
+     "name": "context",
+     "rows": 120,
+     "elapsed_s": 0.625574650708586,
+     "query_id": "172341bc-3a23-4c2c-bd4d-91d091d64b50",
+     "native_fragments": 1,
+     "host_boundaries": 0,
+     "allocator_peak_bytes": 11622161774,
+     "query_limit_bytes": 96636764160
+    },
+    {
+     "name": "recompute",
+     "rows": 120,
+     "elapsed_s": 8.797936612274498,
+     "query_id": "e1b212ea-c331-47a9-8a69-21e5ac983bca",
+     "native_fragments": 15,
+     "host_boundaries": 0,
+     "allocator_peak_bytes": 56985725519,
+     "query_limit_bytes": 96636764160
+    },
+    {
+     "name": "recompute_denylist",
+     "rows": 120,
+     "elapsed_s": 8.79921491490677,
+     "query_id": "e3a88f94-0402-4497-b6ff-ef6efbeaa5bb",
+     "native_fragments": 15,
+     "host_boundaries": 0,
+     "allocator_peak_bytes": 57167449127,
+     "query_limit_bytes": 96636764160
+    },
+    {
+     "name": "context_pass2",
+     "rows": 120,
+     "elapsed_s": 0.6289979363791645,
+     "query_id": "b681ac24-5581-4c93-b0b6-5df52d9df528",
+     "native_fragments": 1,
+     "host_boundaries": 0,
+     "allocator_peak_bytes": 11622161582,
+     "query_limit_bytes": 96636764160
+    },
+    {
+     "name": "recompute_pass2",
+     "rows": 120,
+     "elapsed_s": 8.770125777926296,
+     "query_id": "c41bc852-d60d-4975-9777-1729edb3d702",
+     "native_fragments": 15,
+     "host_boundaries": 0,
+     "allocator_peak_bytes": 55491218111,
+     "query_limit_bytes": 96636764160
+    }
+   ],
+   "decisions": [
+    {
+     "name": "decide",
+     "entities": 120,
+     "distinct_states": 120,
+     "registry_hits": 0,
+     "hit_rate": 0.0,
+     "api_calls": 120,
+     "wall_s": 5.423525845166296,
+     "input_tokens": 127615,
+     "output_tokens": 11974,
+     "cost_usd": 0.00535983,
+     "latency_ms_p50": 577,
+     "latency_ms_p95": 1221,
+     "latency_ms_max": 2211
+    },
+    {
+     "name": "decide_pass2",
+     "entities": 120,
+     "distinct_states": 120,
+     "registry_hits": 61,
+     "hit_rate": 0.5083333333333333,
+     "api_calls": 59,
+     "wall_s": 6.267743187956512,
+     "input_tokens": 62460,
+     "output_tokens": 5871,
+     "cost_usd": 0.00262332,
+     "latency_ms_p50": 566,
+     "latency_ms_p95": 1251,
+     "latency_ms_max": 4637
+    }
+   ],
+   "totals": {
+    "gpu_elapsed_s": 36.38375765737146,
+    "decide_wall_s": 11.691269033122808,
+    "entities": 240,
+    "registry_hits": 61,
+    "api_calls": 179,
+    "input_tokens": 190075,
+    "output_tokens": 17845,
+    "cost_usd": 0.007983150000000001,
+    "max_host_boundaries": 0
+   },
+   "passes": [
+    {
+     "pass": 1,
+     "new_entries": 120,
+     "new_band_counts": {
+      "accept": 63,
+      "review": 30,
+      "reject": 27
+     },
+     "registry_hits": 120,
+     "api_calls": 0
+    },
+    {
+     "pass": 2,
+     "new_entries": 59,
+     "new_band_counts": {
+      "accept": 34,
+      "review": 13,
+      "reject": 12
+     },
+     "registry_hits": 120,
+     "api_calls": 0
+    }
+   ],
+   "band_counts": {
+    "accept": 97,
+    "review": 43,
+    "reject": 39
+   },
+   "kind_counts": {
+    "generic_catchall_or_category": 27,
+    "multi_brand_retailer": 21,
+    "standalone_brand": 117,
+    "superstore_house_brand": 14
+   },
+   "ranking": [
+    {
+     "brand_id": 20430,
+     "name": "Samsung",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.98,
+     "wormhole_pollution": 0.03,
+     "original_rank": 6,
+     "original_betweenness": 0.009053600952029228,
+     "postfilter_rank": 1,
+     "purified_rank": 1,
+     "purified_betweenness": 0.01773890294134617,
+     "betweenness_multiplier": 1.959320168332608,
+     "denylist_rank": 1
+    },
+    {
+     "brand_id": 505,
+     "name": "Avon",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.54,
+     "original_rank": 23,
+     "original_betweenness": 0.005223568063229322,
+     "postfilter_rank": 8,
+     "purified_rank": 2,
+     "purified_betweenness": 0.011489967815577984,
+     "betweenness_multiplier": 2.199639724513255,
+     "denylist_rank": 2
+    },
+    {
+     "brand_id": 16002,
+     "name": "Nicole Miller",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.85,
+     "wormhole_pollution": 1.62,
+     "original_rank": 18,
+     "original_betweenness": 0.005464966408908367,
+     "postfilter_rank": 5,
+     "purified_rank": 3,
+     "purified_betweenness": 0.010496553964912891,
+     "betweenness_multiplier": 1.9206987160621156,
+     "denylist_rank": 3
+    },
+    {
+     "brand_id": 4510,
+     "name": "Conair",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.08,
+     "original_rank": 65,
+     "original_betweenness": 0.003801466664299369,
+     "postfilter_rank": 30,
+     "purified_rank": 4,
+     "purified_betweenness": 0.008835939690470695,
+     "betweenness_multiplier": 2.324350170804196,
+     "denylist_rank": 7
+    },
+    {
+     "brand_id": 12843,
+     "name": "Laura Ashley",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.59,
+     "original_rank": 31,
+     "original_betweenness": 0.00449552433565259,
+     "postfilter_rank": 14,
+     "purified_rank": 5,
+     "purified_betweenness": 0.008678542450070381,
+     "betweenness_multiplier": 1.9304850340245274,
+     "denylist_rank": 10
+    },
+    {
+     "brand_id": 7265,
+     "name": "Ellen Tracy",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.34,
+     "original_rank": 15,
+     "original_betweenness": 0.005698487162590027,
+     "postfilter_rank": 4,
+     "purified_rank": 6,
+     "purified_betweenness": 0.008388789370656013,
+     "betweenness_multiplier": 1.4721081457772758,
+     "denylist_rank": 9
+    },
+    {
+     "brand_id": 10627,
+     "name": "IZOD",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.09,
+     "original_rank": 8,
+     "original_betweenness": 0.007952889427542686,
+     "postfilter_rank": 2,
+     "purified_rank": 7,
+     "purified_betweenness": 0.00820834282785654,
+     "betweenness_multiplier": 1.0321208288687078,
+     "denylist_rank": 5
+    },
+    {
+     "brand_id": 2854,
+     "name": "Bella",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.78,
+     "wormhole_pollution": 1.76,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 8,
+     "purified_betweenness": 0.008026077412068844,
+     "betweenness_multiplier": null,
+     "denylist_rank": 12
+    },
+    {
+     "brand_id": 2571,
+     "name": "Black & Decker",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 1.12,
+     "original_rank": 66,
+     "original_betweenness": 0.0037961988709867,
+     "postfilter_rank": 31,
+     "purified_rank": 9,
+     "purified_betweenness": 0.007740165572613478,
+     "betweenness_multiplier": 2.0389252079940876,
+     "denylist_rank": 6
+    },
+    {
+     "brand_id": 8910,
+     "name": "Gibson",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.75,
+     "wormhole_pollution": 1.16,
+     "original_rank": 10,
+     "original_betweenness": 0.007044518832117319,
+     "postfilter_rank": 3,
+     "purified_rank": 10,
+     "purified_betweenness": 0.0077077122405171394,
+     "betweenness_multiplier": 1.0941431805641848,
+     "denylist_rank": 8
+    },
+    {
+     "brand_id": 4184,
+     "name": "Charming Charlie",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.92,
+     "wormhole_pollution": 0.57,
+     "original_rank": 19,
+     "original_betweenness": 0.005450394004583359,
+     "postfilter_rank": 6,
+     "purified_rank": 11,
+     "purified_betweenness": 0.007215810474008322,
+     "betweenness_multiplier": 1.323906210806115,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4741,
+     "name": "Crayola",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.12,
+     "original_rank": 26,
+     "original_betweenness": 0.004831797908991575,
+     "postfilter_rank": 10,
+     "purified_rank": 12,
+     "purified_betweenness": 0.007092369720339775,
+     "betweenness_multiplier": 1.4678531374711394,
+     "denylist_rank": 13
+    },
+    {
+     "brand_id": 18651,
+     "name": "Rue21",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.8,
+     "wormhole_pollution": 0.41,
+     "original_rank": 41,
+     "original_betweenness": 0.0042989300563931465,
+     "postfilter_rank": 20,
+     "purified_rank": 13,
+     "purified_betweenness": 0.0070745437406003475,
+     "betweenness_multiplier": 1.645652208292957,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 24792,
+     "name": "Warner Bros.",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.77,
+     "original_rank": 27,
+     "original_betweenness": 0.004803807474672794,
+     "postfilter_rank": 11,
+     "purified_rank": 14,
+     "purified_betweenness": 0.006586064584553242,
+     "betweenness_multiplier": 1.3710092711410846,
+     "denylist_rank": 15
+    },
+    {
+     "brand_id": 12700,
+     "name": "L'Oreal",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.98,
+     "wormhole_pollution": 0.03,
+     "original_rank": 21,
+     "original_betweenness": 0.00537595059722662,
+     "postfilter_rank": 7,
+     "purified_rank": 15,
+     "purified_betweenness": 0.006371763069182634,
+     "betweenness_multiplier": 1.1852346769089992,
+     "denylist_rank": 14
+    },
+    {
+     "brand_id": 14099,
+     "name": "Martha Stewart",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.93,
+     "wormhole_pollution": 0.38,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 16,
+     "purified_betweenness": 0.00617002509534359,
+     "betweenness_multiplier": null,
+     "denylist_rank": 46
+    },
+    {
+     "brand_id": 2431,
+     "name": "Bobbie Brooks",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.92,
+     "wormhole_pollution": 0.13,
+     "original_rank": 81,
+     "original_betweenness": 0.0034558039624243975,
+     "postfilter_rank": 42,
+     "purified_rank": 17,
+     "purified_betweenness": 0.006122754421085119,
+     "betweenness_multiplier": 1.7717308295432763,
+     "denylist_rank": 27
+    },
+    {
+     "brand_id": 13610,
+     "name": "Loot Crate",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.93,
+     "wormhole_pollution": 0.65,
+     "original_rank": 24,
+     "original_betweenness": 0.0049698371440172195,
+     "postfilter_rank": 9,
+     "purified_rank": 18,
+     "purified_betweenness": 0.006121879443526268,
+     "betweenness_multiplier": 1.2318068512357387,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4348,
+     "name": "CoverGirl",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.02,
+     "original_rank": 37,
+     "original_betweenness": 0.004323725588619709,
+     "postfilter_rank": 17,
+     "purified_rank": 19,
+     "purified_betweenness": 0.0057258037850260735,
+     "betweenness_multiplier": 1.324275481334133,
+     "denylist_rank": 20
+    },
+    {
+     "brand_id": 21725,
+     "name": "Sigma",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.84,
+     "wormhole_pollution": 1.28,
+     "original_rank": 30,
+     "original_betweenness": 0.004514292348176241,
+     "postfilter_rank": 13,
+     "purified_rank": 20,
+     "purified_betweenness": 0.005709296558052301,
+     "betweenness_multiplier": 1.26471573343247,
+     "denylist_rank": 21
+    },
+    {
+     "brand_id": 15536,
+     "name": "Makeup Revolution",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.04,
+     "original_rank": 58,
+     "original_betweenness": 0.003876330330967903,
+     "postfilter_rank": 27,
+     "purified_rank": 21,
+     "purified_betweenness": 0.005611977074295282,
+     "betweenness_multiplier": 1.4477551176331238,
+     "denylist_rank": 26
+    },
+    {
+     "brand_id": 4308,
+     "name": "Coca-Cola",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.6,
+     "original_rank": 79,
+     "original_betweenness": 0.0035712618846446276,
+     "postfilter_rank": 41,
+     "purified_rank": 22,
+     "purified_betweenness": 0.005604110192507505,
+     "betweenness_multiplier": 1.5692240931989687,
+     "denylist_rank": 36
+    },
+    {
+     "brand_id": 9686,
+     "name": "Hanes",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.23,
+     "original_rank": 47,
+     "original_betweenness": 0.004221780225634575,
+     "postfilter_rank": 23,
+     "purified_rank": 23,
+     "purified_betweenness": 0.0055930218659341335,
+     "betweenness_multiplier": 1.324801758266194,
+     "denylist_rank": 17
+    },
+    {
+     "brand_id": 15997,
+     "name": "Nickelodeon",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.92,
+     "wormhole_pollution": 0.45,
+     "original_rank": 63,
+     "original_betweenness": 0.00383665319532156,
+     "postfilter_rank": 29,
+     "purified_rank": 24,
+     "purified_betweenness": 0.00558035122230649,
+     "betweenness_multiplier": 1.4544841397474253,
+     "denylist_rank": 19
+    },
+    {
+     "brand_id": 13581,
+     "name": "L.A. COLORS",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.92,
+     "wormhole_pollution": 0.04,
+     "original_rank": 67,
+     "original_betweenness": 0.0037848835345357656,
+     "postfilter_rank": 32,
+     "purified_rank": 25,
+     "purified_betweenness": 0.00545555679127574,
+     "betweenness_multiplier": 1.4414067808152227,
+     "denylist_rank": 24
+    },
+    {
+     "brand_id": 11129,
+     "name": "Justice",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.88,
+     "wormhole_pollution": 0.07,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 26,
+     "purified_betweenness": 0.005332311615347862,
+     "betweenness_multiplier": null,
+     "denylist_rank": 43
+    },
+    {
+     "brand_id": 18949,
+     "name": "Revlon",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.98,
+     "wormhole_pollution": 0.03,
+     "original_rank": 40,
+     "original_betweenness": 0.004299122374504805,
+     "postfilter_rank": 19,
+     "purified_rank": 27,
+     "purified_betweenness": 0.005280652549117804,
+     "betweenness_multiplier": 1.2283094290206282,
+     "denylist_rank": 25
+    },
+    {
+     "brand_id": 7962,
+     "name": "Farberware",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.08,
+     "original_rank": 95,
+     "original_betweenness": 0.003275750670582056,
+     "postfilter_rank": 52,
+     "purified_rank": 28,
+     "purified_betweenness": 0.005232510156929493,
+     "betweenness_multiplier": 1.597346893315219,
+     "denylist_rank": 30
+    },
+    {
+     "brand_id": 6812,
+     "name": "Dolls Kill",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.24,
+     "original_rank": 94,
+     "original_betweenness": 0.0032757834997028112,
+     "postfilter_rank": 51,
+     "purified_rank": 29,
+     "purified_betweenness": 0.005155077204108238,
+     "betweenness_multiplier": 1.5736928904416065,
+     "denylist_rank": 34
+    },
+    {
+     "brand_id": 17190,
+     "name": "Philosophy",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 1.12,
+     "original_rank": 39,
+     "original_betweenness": 0.0043009924702346325,
+     "postfilter_rank": 18,
+     "purified_rank": 30,
+     "purified_betweenness": 0.005085532553493977,
+     "betweenness_multiplier": 1.1824090808548997,
+     "denylist_rank": 33
+    },
+    {
+     "brand_id": 8923,
+     "name": "Gerber",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.15,
+     "original_rank": 33,
+     "original_betweenness": 0.004462003707885742,
+     "postfilter_rank": 16,
+     "purified_rank": 31,
+     "purified_betweenness": 0.0050772107206285,
+     "betweenness_multiplier": 1.1378768492853326,
+     "denylist_rank": 23
+    },
+    {
+     "brand_id": 13583,
+     "name": "Lefton",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.12,
+     "original_rank": 72,
+     "original_betweenness": 0.0036497670225799084,
+     "postfilter_rank": 35,
+     "purified_rank": 32,
+     "purified_betweenness": 0.005064120050519705,
+     "betweenness_multiplier": 1.3875187153562567,
+     "denylist_rank": 51
+    },
+    {
+     "brand_id": 24623,
+     "name": "Wondershop",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 33,
+     "purified_betweenness": 0.005046279635280371,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 7185,
+     "name": "Enesco",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.89,
+     "wormhole_pollution": 0.23,
+     "original_rank": 77,
+     "original_betweenness": 0.0035949840676039457,
+     "postfilter_rank": 39,
+     "purified_rank": 34,
+     "purified_betweenness": 0.005003511440008879,
+     "betweenness_multiplier": 1.3918035089773613,
+     "denylist_rank": 48
+    },
+    {
+     "brand_id": 4703,
+     "name": "Cynthia Rowley",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.86,
+     "wormhole_pollution": 1.37,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 35,
+     "purified_betweenness": 0.004958644509315491,
+     "betweenness_multiplier": null,
+     "denylist_rank": 59
+    },
+    {
+     "brand_id": 18762,
+     "name": "ROMWE",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.73,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 36,
+     "purified_betweenness": 0.004794684704393148,
+     "betweenness_multiplier": null,
+     "denylist_rank": 100
+    },
+    {
+     "brand_id": 19825,
+     "name": "Simply Southern",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.82,
+     "wormhole_pollution": 0.18,
+     "original_rank": 60,
+     "original_betweenness": 0.003848115913569927,
+     "postfilter_rank": 28,
+     "purified_rank": 37,
+     "purified_betweenness": 0.004794052802026272,
+     "betweenness_multiplier": 1.2458181899148644,
+     "denylist_rank": 37
+    },
+    {
+     "brand_id": 12711,
+     "name": "Liz Claiborne",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.16,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 38,
+     "purified_betweenness": 0.004777574446052313,
+     "betweenness_multiplier": null,
+     "denylist_rank": 57
+    },
+    {
+     "brand_id": 22652,
+     "name": "Tahari",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.86,
+     "wormhole_pollution": 1.46,
+     "original_rank": 98,
+     "original_betweenness": 0.0032571079209446907,
+     "postfilter_rank": 54,
+     "purified_rank": 39,
+     "purified_betweenness": 0.004569571930915117,
+     "betweenness_multiplier": 1.40295379883813,
+     "denylist_rank": 61
+    },
+    {
+     "brand_id": 11171,
+     "name": "Joie",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.19,
+     "original_rank": 69,
+     "original_betweenness": 0.003700133180245757,
+     "postfilter_rank": 33,
+     "purified_rank": 40,
+     "purified_betweenness": 0.004527280107140541,
+     "betweenness_multiplier": 1.2235451770522072,
+     "denylist_rank": 50
+    },
+    {
+     "brand_id": 20324,
+     "name": "Scholastic",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.11,
+     "original_rank": 74,
+     "original_betweenness": 0.0036281784996390343,
+     "postfilter_rank": 37,
+     "purified_rank": 41,
+     "purified_betweenness": 0.004508416634052992,
+     "betweenness_multiplier": 1.242611584435973,
+     "denylist_rank": 55
+    },
+    {
+     "brand_id": 11937,
+     "name": "Kirkland Signature",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 42,
+     "purified_betweenness": 0.0044813742861151695,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 24788,
+     "name": "Wilson",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.89,
+     "wormhole_pollution": 1.08,
+     "original_rank": 46,
+     "original_betweenness": 0.004234583582729101,
+     "postfilter_rank": 22,
+     "purified_rank": 43,
+     "purified_betweenness": 0.004481113515794277,
+     "betweenness_multiplier": 1.058218223409418,
+     "denylist_rank": 47
+    },
+    {
+     "brand_id": 6120,
+     "name": "Dana Buchman",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.13,
+     "original_rank": 71,
+     "original_betweenness": 0.0036722286604344845,
+     "postfilter_rank": 34,
+     "purified_rank": 44,
+     "purified_betweenness": 0.004461228847503662,
+     "betweenness_multiplier": 1.2148559526181102,
+     "denylist_rank": 31
+    },
+    {
+     "brand_id": 14116,
+     "name": "Motherhood Maternity",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.85,
+     "wormhole_pollution": 0.1,
+     "original_rank": 29,
+     "original_betweenness": 0.004610021598637104,
+     "postfilter_rank": 12,
+     "purified_rank": 45,
+     "purified_betweenness": 0.004455494228750467,
+     "betweenness_multiplier": 0.966480120194595,
+     "denylist_rank": 39
+    },
+    {
+     "brand_id": 14204,
+     "name": "Melissa & Doug",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.07,
+     "original_rank": 32,
+     "original_betweenness": 0.00448599411174655,
+     "postfilter_rank": 15,
+     "purified_rank": 46,
+     "purified_betweenness": 0.004420116078108549,
+     "betweenness_multiplier": 0.9853147302477506,
+     "denylist_rank": 42
+    },
+    {
+     "brand_id": 9912,
+     "name": "Hallmark",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.29,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 47,
+     "purified_betweenness": 0.004414132330566645,
+     "betweenness_multiplier": null,
+     "denylist_rank": 60
+    },
+    {
+     "brand_id": 832,
+     "name": "American Rag",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.85,
+     "wormhole_pollution": 0.24,
+     "original_rank": 91,
+     "original_betweenness": 0.003339627990499139,
+     "postfilter_rank": 49,
+     "purified_rank": 48,
+     "purified_betweenness": 0.004411266651004553,
+     "betweenness_multiplier": 1.3208856386262493,
+     "denylist_rank": 74
+    },
+    {
+     "brand_id": 11955,
+     "name": "Kensie",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.86,
+     "wormhole_pollution": 0.43,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 49,
+     "purified_betweenness": 0.004373530391603708,
+     "betweenness_multiplier": null,
+     "denylist_rank": 76
+    },
+    {
+     "brand_id": 17339,
+     "name": "prAna",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.08,
+     "original_rank": 51,
+     "original_betweenness": 0.004103062208741903,
+     "postfilter_rank": 25,
+     "purified_rank": 50,
+     "purified_betweenness": 0.0041785999201238155,
+     "betweenness_multiplier": 1.0184100819190538,
+     "denylist_rank": 58
+    },
+    {
+     "brand_id": 2816,
+     "name": "BCBGeneration",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.92,
+     "wormhole_pollution": 0.11,
+     "original_rank": 73,
+     "original_betweenness": 0.0036354318726807833,
+     "postfilter_rank": 36,
+     "purified_rank": 51,
+     "purified_betweenness": 0.004131675232201815,
+     "betweenness_multiplier": 1.1365019004344865,
+     "denylist_rank": 65
+    },
+    {
+     "brand_id": 6029,
+     "name": "DC Comics",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.04,
+     "original_rank": 86,
+     "original_betweenness": 0.0033653341233730316,
+     "postfilter_rank": 45,
+     "purified_rank": 52,
+     "purified_betweenness": 0.004110961686819792,
+     "betweenness_multiplier": 1.2215612287256123,
+     "denylist_rank": 63
+    },
+    {
+     "brand_id": 326,
+     "name": "Arizona Jean Company",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.72,
+     "wormhole_pollution": 0.29,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 53,
+     "purified_betweenness": 0.004066925961524248,
+     "betweenness_multiplier": null,
+     "denylist_rank": 83
+    },
+    {
+     "brand_id": 8452,
+     "name": "Franklin Mint",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.92,
+     "wormhole_pollution": 0.33,
+     "original_rank": 87,
+     "original_betweenness": 0.0033637131564319134,
+     "postfilter_rank": 46,
+     "purified_rank": 54,
+     "purified_betweenness": 0.00404765922576189,
+     "betweenness_multiplier": 1.2033306758105018,
+     "denylist_rank": 75
+    },
+    {
+     "brand_id": 24113,
+     "name": "Vera Wang",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.93,
+     "wormhole_pollution": 0.44,
+     "original_rank": 100,
+     "original_betweenness": 0.0032497860956937075,
+     "postfilter_rank": 55,
+     "purified_rank": 55,
+     "purified_betweenness": 0.004030552692711353,
+     "betweenness_multiplier": 1.2402516885810546,
+     "denylist_rank": 66
+    },
+    {
+     "brand_id": 22387,
+     "name": "The Honest Company",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.35,
+     "original_rank": 85,
+     "original_betweenness": 0.0033769598230719566,
+     "postfilter_rank": 44,
+     "purified_rank": 56,
+     "purified_betweenness": 0.004026262555271387,
+     "betweenness_multiplier": 1.1922743432608482,
+     "denylist_rank": 73
+    },
+    {
+     "brand_id": 22826,
+     "name": "The Children's Place",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.9,
+     "wormhole_pollution": 0.17,
+     "original_rank": 110,
+     "original_betweenness": 0.00312993535771966,
+     "postfilter_rank": 60,
+     "purified_rank": 57,
+     "purified_betweenness": 0.004023460671305656,
+     "betweenness_multiplier": 1.2854772420082765,
+     "denylist_rank": 72
+    },
+    {
+     "brand_id": 14265,
+     "name": "Maybelline",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.98,
+     "wormhole_pollution": 0.02,
+     "original_rank": 90,
+     "original_betweenness": 0.0033542874734848738,
+     "postfilter_rank": 48,
+     "purified_rank": 58,
+     "purified_betweenness": 0.004013882018625736,
+     "betweenness_multiplier": 1.196642222932547,
+     "denylist_rank": 67
+    },
+    {
+     "brand_id": 4198,
+     "name": "Catherine Malandrino",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.86,
+     "wormhole_pollution": 1.02,
+     "original_rank": 84,
+     "original_betweenness": 0.0033805458806455135,
+     "postfilter_rank": 43,
+     "purified_rank": 59,
+     "purified_betweenness": 0.00401352159678936,
+     "betweenness_multiplier": 1.1872406819761843,
+     "denylist_rank": 82
+    },
+    {
+     "brand_id": 13430,
+     "name": "Liz Lisa",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.86,
+     "wormhole_pollution": 0.07,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 60,
+     "purified_betweenness": 0.003979776985943317,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 2038,
+     "name": "Amuse",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.74,
+     "wormhole_pollution": 1.14,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 61,
+     "purified_betweenness": 0.003944956231862307,
+     "betweenness_multiplier": null,
+     "denylist_rank": 79
+    },
+    {
+     "brand_id": 12476,
+     "name": "Lush",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 1.08,
+     "original_rank": 89,
+     "original_betweenness": 0.0033545808400958776,
+     "postfilter_rank": 47,
+     "purified_rank": 62,
+     "purified_betweenness": 0.0039408509619534016,
+     "betweenness_multiplier": 1.174767027477796,
+     "denylist_rank": 69
+    },
+    {
+     "brand_id": 4010,
+     "name": "ColourPop Cosmetics",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.04,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 63,
+     "purified_betweenness": 0.003935107495635748,
+     "betweenness_multiplier": null,
+     "denylist_rank": 90
+    },
+    {
+     "brand_id": 4768,
+     "name": "Cherokee",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.86,
+     "original_rank": 75,
+     "original_betweenness": 0.0036072873044759035,
+     "postfilter_rank": 38,
+     "purified_rank": 64,
+     "purified_betweenness": 0.00392982317134738,
+     "betweenness_multiplier": 1.08941230338689,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 24653,
+     "name": "Wet n Wild",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.23,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 65,
+     "purified_betweenness": 0.003921573981642723,
+     "betweenness_multiplier": null,
+     "denylist_rank": 86
+    },
+    {
+     "brand_id": 4482,
+     "name": "Cotton On",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.93,
+     "wormhole_pollution": 0.7,
+     "original_rank": 107,
+     "original_betweenness": 0.0031825508922338486,
+     "postfilter_rank": 58,
+     "purified_rank": 66,
+     "purified_betweenness": 0.0038966552820056677,
+     "betweenness_multiplier": 1.2243811376322047,
+     "denylist_rank": 78
+    },
+    {
+     "brand_id": 23897,
+     "name": "Unique",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 67,
+     "purified_betweenness": 0.0038938606157898903,
+     "betweenness_multiplier": null,
+     "denylist_rank": 117
+    },
+    {
+     "brand_id": 11257,
+     "name": "Jessica Simpson",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.4,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 68,
+     "purified_betweenness": 0.0038593565113842487,
+     "betweenness_multiplier": null,
+     "denylist_rank": 92
+    },
+    {
+     "brand_id": 11239,
+     "name": "Jumping Beans",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.85,
+     "wormhole_pollution": 0.16,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 69,
+     "purified_betweenness": 0.003819285426288843,
+     "betweenness_multiplier": null,
+     "denylist_rank": 88
+    },
+    {
+     "brand_id": 8140,
+     "name": "Fox Racing",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.5,
+     "original_rank": 97,
+     "original_betweenness": 0.0032600879203528166,
+     "postfilter_rank": 53,
+     "purified_rank": 70,
+     "purified_betweenness": 0.0037987814284861088,
+     "betweenness_multiplier": 1.1652389510019696,
+     "denylist_rank": 105
+    },
+    {
+     "brand_id": 15377,
+     "name": "Modern Vintage",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 71,
+     "purified_betweenness": 0.003795450320467353,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 24722,
+     "name": "Warner Brothers",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.22,
+     "original_rank": 57,
+     "original_betweenness": 0.0039057480171322823,
+     "postfilter_rank": 26,
+     "purified_rank": 72,
+     "purified_betweenness": 0.003776057157665491,
+     "betweenness_multiplier": 0.9667948728648362,
+     "denylist_rank": 68
+    },
+    {
+     "brand_id": 4713,
+     "name": "Children's Place",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.85,
+     "wormhole_pollution": 0.11,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 73,
+     "purified_betweenness": 0.0037712808698415756,
+     "betweenness_multiplier": null,
+     "denylist_rank": 87
+    },
+    {
+     "brand_id": 10424,
+     "name": "IT Cosmetics",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.03,
+     "original_rank": 93,
+     "original_betweenness": 0.003281812882050872,
+     "postfilter_rank": 50,
+     "purified_rank": 74,
+     "purified_betweenness": 0.003747104899957776,
+     "betweenness_multiplier": 1.1417789601752473,
+     "denylist_rank": 91
+    },
+    {
+     "brand_id": 2815,
+     "name": "BCBGMAXAZRIA",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.04,
+     "original_rank": 106,
+     "original_betweenness": 0.0031846524216234684,
+     "postfilter_rank": 57,
+     "purified_rank": 75,
+     "purified_betweenness": 0.003706112038344145,
+     "betweenness_multiplier": 1.163741453597893,
+     "denylist_rank": 94
+    },
+    {
+     "brand_id": 2501,
+     "name": "Bebe",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.93,
+     "wormhole_pollution": 0.09,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 76,
+     "purified_betweenness": 0.0036426521837711334,
+     "betweenness_multiplier": null,
+     "denylist_rank": 77
+    },
+    {
+     "brand_id": 23840,
+     "name": "Universal Studios",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.89,
+     "wormhole_pollution": 0.09,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 77,
+     "purified_betweenness": 0.0036299845669418573,
+     "betweenness_multiplier": null,
+     "denylist_rank": 106
+    },
+    {
+     "brand_id": 18907,
+     "name": "Reebok",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.04,
+     "original_rank": 101,
+     "original_betweenness": 0.0032292704563587904,
+     "postfilter_rank": 56,
+     "purified_rank": 78,
+     "purified_betweenness": 0.0036156713031232357,
+     "betweenness_multiplier": 1.119655771167627,
+     "denylist_rank": 84
+    },
+    {
+     "brand_id": 16682,
+     "name": "Oscar de la Renta",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.57,
+     "original_rank": 78,
+     "original_betweenness": 0.003586449660360813,
+     "postfilter_rank": 40,
+     "purified_rank": 79,
+     "purified_betweenness": 0.0035714672412723303,
+     "betweenness_multiplier": 0.9958224928530084,
+     "denylist_rank": 64
+    },
+    {
+     "brand_id": 2475,
+     "name": "Burt's Bees",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.98,
+     "wormhole_pollution": 0.11,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 80,
+     "purified_betweenness": 0.00355152552947402,
+     "betweenness_multiplier": null,
+     "denylist_rank": 108
+    },
+    {
+     "brand_id": 23843,
+     "name": "Urban Outfitters",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 81,
+     "purified_betweenness": 0.003539892379194498,
+     "betweenness_multiplier": null,
+     "denylist_rank": 118
+    },
+    {
+     "brand_id": 19022,
+     "name": "RCA",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.89,
+     "wormhole_pollution": 0.32,
+     "original_rank": 49,
+     "original_betweenness": 0.004158234689384699,
+     "postfilter_rank": 24,
+     "purified_rank": 82,
+     "purified_betweenness": 0.003534614574164152,
+     "betweenness_multiplier": 0.8500276771745116,
+     "denylist_rank": 49
+    },
+    {
+     "brand_id": 11107,
+     "name": "Jada Toys",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 83,
+     "purified_betweenness": 0.0035290259402245283,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 25271,
+     "name": "Yankee Candle",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 84,
+     "purified_betweenness": 0.0035281197633594275,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4294,
+     "name": "Charlotte Russe",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.78,
+     "wormhole_pollution": 0.48,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 85,
+     "purified_betweenness": 0.0035098972730338573,
+     "betweenness_multiplier": null,
+     "denylist_rank": 96
+    },
+    {
+     "brand_id": 13731,
+     "name": "Mud Pie",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.93,
+     "wormhole_pollution": 0.21,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 86,
+     "purified_betweenness": 0.0035049146972596645,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 15981,
+     "name": "Nautica",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.19,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 87,
+     "purified_betweenness": 0.003489165101200342,
+     "betweenness_multiplier": null,
+     "denylist_rank": 112
+    },
+    {
+     "brand_id": 8099,
+     "name": "Fossil",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.96,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 88,
+     "purified_betweenness": 0.0034460010938346386,
+     "betweenness_multiplier": null,
+     "denylist_rank": 99
+    },
+    {
+     "brand_id": 7886,
+     "name": "Fruit of the Loom",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.26,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 89,
+     "purified_betweenness": 0.0034335723612457514,
+     "betweenness_multiplier": null,
+     "denylist_rank": 93
+    },
+    {
+     "brand_id": 11189,
+     "name": "Jones New York",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.88,
+     "wormhole_pollution": 0.08,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 90,
+     "purified_betweenness": 0.0034110385458916426,
+     "betweenness_multiplier": null,
+     "denylist_rank": 111
+    },
+    {
+     "brand_id": 11227,
+     "name": "Jennifer Lopez",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.78,
+     "wormhole_pollution": 0.37,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 91,
+     "purified_betweenness": 0.0034083083737641573,
+     "betweenness_multiplier": null,
+     "denylist_rank": 109
+    },
+    {
+     "brand_id": 7158,
+     "name": "Eddie Bauer",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.8,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 92,
+     "purified_betweenness": 0.003375931642949581,
+     "betweenness_multiplier": null,
+     "denylist_rank": 116
+    },
+    {
+     "brand_id": 13827,
+     "name": "Monet",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 93,
+     "purified_betweenness": 0.0033688799012452364,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4356,
+     "name": "Crystal",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 94,
+     "purified_betweenness": 0.003349634585902095,
+     "betweenness_multiplier": null,
+     "denylist_rank": 103
+    },
+    {
+     "brand_id": 14378,
+     "name": "Mudd",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.81,
+     "wormhole_pollution": 0.21,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 95,
+     "purified_betweenness": 0.0033387767616659403,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 19973,
+     "name": "Stampd",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 96,
+     "purified_betweenness": 0.0033348589204251766,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 18991,
+     "name": "Rachel Roy",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 97,
+     "purified_betweenness": 0.003321508876979351,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 745,
+     "name": "ASUS",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.18,
+     "original_rank": 42,
+     "original_betweenness": 0.004254375118762255,
+     "postfilter_rank": 21,
+     "purified_rank": 98,
+     "purified_betweenness": 0.0032781234476715326,
+     "betweenness_multiplier": 0.7705299500306528,
+     "denylist_rank": 107
+    },
+    {
+     "brand_id": 19884,
+     "name": "Sanrio",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.06,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 99,
+     "purified_betweenness": 0.003270916873589158,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4603,
+     "name": "Cuisinart",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 100,
+     "purified_betweenness": 0.003229856491088867,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 13854,
+     "name": "Maidenform",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.02,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 101,
+     "purified_betweenness": 0.0032290590461343527,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 765,
+     "name": "Anne Klein",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.17,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 102,
+     "purified_betweenness": 0.0032099680975079536,
+     "betweenness_multiplier": null,
+     "denylist_rank": 102
+    },
+    {
+     "brand_id": 12762,
+     "name": "Looney Tunes",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.86,
+     "wormhole_pollution": 0.23,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 103,
+     "purified_betweenness": 0.0032058353535830975,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 7296,
+     "name": "Elizabeth Arden",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.03,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 104,
+     "purified_betweenness": 0.0031893679406493902,
+     "betweenness_multiplier": null,
+     "denylist_rank": 110
+    },
+    {
+     "brand_id": 9020,
+     "name": "Gymboree",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 105,
+     "purified_betweenness": 0.00317977461963892,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 8824,
+     "name": "GUESS",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 106,
+     "purified_betweenness": 0.0031685009598731995,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 24759,
+     "name": "Wet Seal",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 107,
+     "purified_betweenness": 0.0031542154029011726,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 18415,
+     "name": "Pioneer Woman",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 108,
+     "purified_betweenness": 0.0031539176125079393,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 17512,
+     "name": "PartyLite",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 109,
+     "purified_betweenness": 0.003127177245914936,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 3850,
+     "name": "BELLA + CANVAS",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 110,
+     "purified_betweenness": 0.003115846076980233,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 17931,
+     "name": "Pacifica",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 111,
+     "purified_betweenness": 0.003105539595708251,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 19077,
+     "name": "Russell Athletic",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.24,
+     "original_rank": 109,
+     "original_betweenness": 0.003154805162921548,
+     "postfilter_rank": 59,
+     "purified_rank": 112,
+     "purified_betweenness": 0.003102901391685009,
+     "betweenness_multiplier": 0.9835477094285998,
+     "denylist_rank": 104
+    },
+    {
+     "brand_id": 4424,
+     "name": "Champion",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 113,
+     "purified_betweenness": 0.0030977108981460333,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 6054,
+     "name": "DKNY",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 114,
+     "purified_betweenness": 0.0030921415891498327,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 20330,
+     "name": "Sanctuary",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.86,
+     "wormhole_pollution": 0.17,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 115,
+     "purified_betweenness": 0.003079884685575962,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 8170,
+     "name": "FOREVER 21",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 116,
+     "purified_betweenness": 0.0030594170093536377,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 686,
+     "name": "Avia",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 117,
+     "purified_betweenness": 0.003035754431039095,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 19023,
+     "name": "Rene Rofe",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 118,
+     "purified_betweenness": 0.0030181489419192076,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 23811,
+     "name": "Uniqlo",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 119,
+     "purified_betweenness": 0.0030077705159783363,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 7307,
+     "name": "Estee Lauder",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 120,
+     "purified_betweenness": 0.002986000617966056,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 786,
+     "name": "As Seen on TV",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.2,
+     "wormhole_pollution": 2.84,
+     "original_rank": 1,
+     "original_betweenness": 0.016985926777124405,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4044,
+     "name": "Claire's",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.89,
+     "wormhole_pollution": 0.72,
+     "original_rank": 2,
+     "original_betweenness": 0.012742872349917889,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4680,
+     "name": "Customized & Personalized",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.08,
+     "wormhole_pollution": 2.88,
+     "original_rank": 3,
+     "original_betweenness": 0.012649746611714363,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 15548,
+     "name": "Mainstays",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.07,
+     "wormhole_pollution": 1.94,
+     "original_rank": 4,
+     "original_betweenness": 0.0118991294875741,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 3305,
+     "name": "Better Homes & Gardens",
+     "band": "review",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.65,
+     "wormhole_pollution": 0.9,
+     "original_rank": 5,
+     "original_betweenness": 0.010324093513190746,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 25120,
+     "name": "Walmart",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.04,
+     "wormhole_pollution": 2.87,
+     "original_rank": 7,
+     "original_betweenness": 0.008751538582146168,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 23778,
+     "name": "US Vintage",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.24,
+     "wormhole_pollution": 2.88,
+     "original_rank": 9,
+     "original_betweenness": 0.007170500699430704,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 7106,
+     "name": "Eyeshadow",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.07,
+     "wormhole_pollution": 2.93,
+     "original_rank": 11,
+     "original_betweenness": 0.006859411019831896,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 16807,
+     "name": "Original Vintage Style",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.17,
+     "wormhole_pollution": 2.36,
+     "original_rank": 12,
+     "original_betweenness": 0.006301338784396648,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 11163,
+     "name": "JCPenney",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.06,
+     "wormhole_pollution": 1.89,
+     "original_rank": 13,
+     "original_betweenness": 0.0061621819622814655,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 13763,
+     "name": "Macy's",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.04,
+     "wormhole_pollution": 1.78,
+     "original_rank": 14,
+     "original_betweenness": 0.006098608486354351,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 12259,
+     "name": "Kohl's",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.05,
+     "wormhole_pollution": 1.86,
+     "original_rank": 16,
+     "original_betweenness": 0.005688210483640432,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 12799,
+     "name": "Lot",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.08,
+     "wormhole_pollution": 2.73,
+     "original_rank": 17,
+     "original_betweenness": 0.00564983207732439,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 23372,
+     "name": "The Unbranded Brand",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.13,
+     "wormhole_pollution": 2.85,
+     "original_rank": 20,
+     "original_betweenness": 0.005441537592560053,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 15827,
+     "name": "New Directions",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.49,
+     "wormhole_pollution": 0.7,
+     "original_rank": 22,
+     "original_betweenness": 0.005256290081888437,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 11
+    },
+    {
+     "brand_id": 22109,
+     "name": "Secret Treasures",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 0.73,
+     "original_rank": 25,
+     "original_betweenness": 0.004856952000409365,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4814,
+     "name": "Cabela's",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 0.78,
+     "original_rank": 28,
+     "original_betweenness": 0.0046207839623093605,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 15946,
+     "name": "No Boundaries",
+     "band": "review",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.39,
+     "wormhole_pollution": 1.54,
+     "original_rank": 34,
+     "original_betweenness": 0.004385444335639477,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 23745,
+     "name": "Ulta",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.18,
+     "wormhole_pollution": 0.61,
+     "original_rank": 35,
+     "original_betweenness": 0.004373671021312475,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 469,
+     "name": "ART",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.27,
+     "wormhole_pollution": 0.95,
+     "original_rank": 36,
+     "original_betweenness": 0.004355890676379204,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 24936,
+     "name": "World Market",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.26,
+     "wormhole_pollution": 0.6,
+     "original_rank": 38,
+     "original_betweenness": 0.004320692736655474,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 10525,
+     "name": "Independent",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.3,
+     "wormhole_pollution": 2.25,
+     "original_rank": 43,
+     "original_betweenness": 0.0042512062937021255,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 17373,
+     "name": "Pier One",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.67,
+     "wormhole_pollution": 0.46,
+     "original_rank": 44,
+     "original_betweenness": 0.004249518737196922,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 751,
+     "name": "Army",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.15,
+     "wormhole_pollution": 2.18,
+     "original_rank": 45,
+     "original_betweenness": 0.004248266573995352,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 217,
+     "name": "American Vintage",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.24,
+     "wormhole_pollution": 2.56,
+     "original_rank": 48,
+     "original_betweenness": 0.0041641658172011375,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 20356,
+     "name": "Spencer's",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.58,
+     "wormhole_pollution": 1.06,
+     "original_rank": 50,
+     "original_betweenness": 0.0041237520053982735,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 10314,
+     "name": "Hobby Lobby",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.24,
+     "wormhole_pollution": 0.58,
+     "original_rank": 52,
+     "original_betweenness": 0.004070766270160675,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 17975,
+     "name": "Pier 1 Imports",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.78,
+     "wormhole_pollution": 0.82,
+     "original_rank": 53,
+     "original_betweenness": 0.003944051917642355,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 6149,
+     "name": "Derek Heart",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.63,
+     "wormhole_pollution": 1.1,
+     "original_rank": 54,
+     "original_betweenness": 0.003930298145860434,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 53
+    },
+    {
+     "brand_id": 19382,
+     "name": "Rare",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.29,
+     "wormhole_pollution": 1.74,
+     "original_rank": 55,
+     "original_betweenness": 0.003925210330635309,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 493,
+     "name": "Almost Famous",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.45,
+     "wormhole_pollution": 1.35,
+     "original_rank": 56,
+     "original_betweenness": 0.003924316260963678,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 54
+    },
+    {
+     "brand_id": 791,
+     "name": "Ambiance Apparel",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.54,
+     "wormhole_pollution": 0.67,
+     "original_rank": 59,
+     "original_betweenness": 0.0038713491521775723,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 56
+    },
+    {
+     "brand_id": 24197,
+     "name": "Venus",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 1.53,
+     "original_rank": 61,
+     "original_betweenness": 0.003842349862679839,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 40
+    },
+    {
+     "brand_id": 17140,
+     "name": "Pink Rose",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.47,
+     "wormhole_pollution": 0.95,
+     "original_rank": 62,
+     "original_betweenness": 0.003838449250906706,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 35
+    },
+    {
+     "brand_id": 15755,
+     "name": "Native",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.32,
+     "wormhole_pollution": 1.9,
+     "original_rank": 64,
+     "original_betweenness": 0.0038045805413275957,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 44
+    },
+    {
+     "brand_id": 4753,
+     "name": "Cato",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.63,
+     "wormhole_pollution": 0.41,
+     "original_rank": 68,
+     "original_betweenness": 0.0037579804193228483,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 15965,
+     "name": "Nobo",
+     "band": "review",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.52,
+     "wormhole_pollution": 1.48,
+     "original_rank": 70,
+     "original_betweenness": 0.0036913459189236164,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 38
+    },
+    {
+     "brand_id": 3311,
+     "name": "Bed Bath & Beyond",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.21,
+     "wormhole_pollution": 0.63,
+     "original_rank": 76,
+     "original_betweenness": 0.0036012919154018164,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 15901,
+     "name": "Nordstrom",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.07,
+     "wormhole_pollution": 1.23,
+     "original_rank": 80,
+     "original_betweenness": 0.0035007197875529528,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 7948,
+     "name": "Faded Glory",
+     "band": "review",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.5,
+     "wormhole_pollution": 0.34,
+     "original_rank": 82,
+     "original_betweenness": 0.0034527243115007877,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 2666,
+     "name": "Bioworld",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.66,
+     "wormhole_pollution": 1.1,
+     "original_rank": 83,
+     "original_betweenness": 0.0033876411616802216,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 28
+    },
+    {
+     "brand_id": 10548,
+     "name": "Indie",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.37,
+     "wormhole_pollution": 1.81,
+     "original_rank": 88,
+     "original_betweenness": 0.003362703835591674,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 20371,
+     "name": "Sonoma",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.51,
+     "wormhole_pollution": 0.66,
+     "original_rank": 92,
+     "original_betweenness": 0.0033218369353562593,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 19923,
+     "name": "Style & Co",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.43,
+     "wormhole_pollution": 0.33,
+     "original_rank": 96,
+     "original_betweenness": 0.0032613007351756096,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 10417,
+     "name": "Hyper Tough",
+     "band": "review",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.41,
+     "wormhole_pollution": 0.66,
+     "original_rank": 99,
+     "original_betweenness": 0.00325435190461576,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4055,
+     "name": "Circo",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.65,
+     "wormhole_pollution": 0.45,
+     "original_rank": 102,
+     "original_betweenness": 0.0032174603547900915,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 9739,
+     "name": "Hot Topic",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.59,
+     "wormhole_pollution": 0.58,
+     "original_rank": 103,
+     "original_betweenness": 0.0031902322079986334,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 25116,
+     "name": "Wonder Nation",
+     "band": "review",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 0.25,
+     "original_rank": 104,
+     "original_betweenness": 0.0031879728194326162,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 667,
+     "name": "a.n.a",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 0.63,
+     "original_rank": 105,
+     "original_betweenness": 0.0031861469615250826,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 20284,
+     "name": "SO",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.09,
+     "wormhole_pollution": 1.48,
+     "original_rank": 108,
+     "original_betweenness": 0.0031806009355932474,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 10617,
+     "name": "INC International Concepts",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 1.26,
+     "original_rank": 111,
+     "original_betweenness": 0.0031055761501193047,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 1997,
+     "name": "Applause",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.88,
+     "wormhole_pollution": 0.13,
+     "original_rank": 112,
+     "original_betweenness": 0.003101375186815858,
+     "postfilter_rank": 61,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 113
+    },
+    {
+     "brand_id": 337,
+     "name": "Authentic Original Vintage Style",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.15,
+     "wormhole_pollution": 2.58,
+     "original_rank": 113,
+     "original_betweenness": 0.0030937206465750933,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 15440,
+     "name": "Multiples",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.18,
+     "wormhole_pollution": 2.68,
+     "original_rank": 114,
+     "original_betweenness": 0.0030903813894838095,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 41
+    },
+    {
+     "brand_id": 9705,
+     "name": "HP",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.06,
+     "original_rank": 115,
+     "original_betweenness": 0.0030845049768686295,
+     "postfilter_rank": 62,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 24515,
+     "name": "Vivitar",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.92,
+     "wormhole_pollution": 0.12,
+     "original_rank": 116,
+     "original_betweenness": 0.003084166906774044,
+     "postfilter_rank": 63,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 18828,
+     "name": "Room Essentials",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.08,
+     "wormhole_pollution": 1.29,
+     "original_rank": 117,
+     "original_betweenness": 0.003077820176258683,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 25176,
+     "name": "Xhilaration",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.16,
+     "wormhole_pollution": 0.96,
+     "original_rank": 118,
+     "original_betweenness": 0.003074460430070758,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4775,
+     "name": "Custom Accessories",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.13,
+     "wormhole_pollution": 2.66,
+     "original_rank": 119,
+     "original_betweenness": 0.003067781450226903,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 18759,
+     "name": "Revolution",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.46,
+     "wormhole_pollution": 2.16,
+     "original_rank": 120,
+     "original_betweenness": 0.0030566330533474684,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 85
+    },
+    {
+     "brand_id": 749,
+     "name": "AmazonBasics",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.1,
+     "wormhole_pollution": 2.02,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 4
+    },
+    {
+     "brand_id": 5699,
+     "name": "Celebrate It",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.62,
+     "wormhole_pollution": 1.14,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 16
+    },
+    {
+     "brand_id": 23892,
+     "name": "Unique Boutique",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.24,
+     "wormhole_pollution": 2.02,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 18
+    },
+    {
+     "brand_id": 20464,
+     "name": "Sears",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.11,
+     "wormhole_pollution": 1.82,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 22
+    },
+    {
+     "brand_id": 14195,
+     "name": "Members Mark",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.06,
+     "wormhole_pollution": 2.09,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 29
+    },
+    {
+     "brand_id": 9821,
+     "name": "Home Interiors",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.18,
+     "wormhole_pollution": 1.7,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 32
+    },
+    {
+     "brand_id": 563,
+     "name": "Amazon",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.12,
+     "wormhole_pollution": 2.81,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 45
+    },
+    {
+     "brand_id": 8479,
+     "name": "Fabric",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.09,
+     "wormhole_pollution": 2.43,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 52
+    },
+    {
+     "brand_id": 19402,
+     "name": "Ross",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.15,
+     "wormhole_pollution": 1.58,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 62
+    },
+    {
+     "brand_id": 18643,
+     "name": "QVC",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.15,
+     "wormhole_pollution": 1.21,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 70
+    },
+    {
+     "brand_id": 640,
+     "name": "Athletic Works",
+     "band": "review",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.42,
+     "wormhole_pollution": 0.68,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 71
+    },
+    {
+     "brand_id": 10322,
+     "name": "Holiday Time",
+     "band": "review",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.36,
+     "wormhole_pollution": 1.81,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 80
+    },
+    {
+     "brand_id": 4491,
+     "name": "Columbia",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.54,
+     "wormhole_pollution": 2.28,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 81
+    },
+    {
+     "brand_id": 4577,
+     "name": "Candie's",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.65,
+     "wormhole_pollution": 0.55,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 89
+    },
+    {
+     "brand_id": 2703,
+     "name": "Boho Chic",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.19,
+     "wormhole_pollution": 1.24,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 95
+    },
+    {
+     "brand_id": 9589,
+     "name": "HeartSoul",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 97
+    },
+    {
+     "brand_id": 20561,
+     "name": "Sephora",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.27,
+     "wormhole_pollution": 0.41,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 98
+    },
+    {
+     "brand_id": 2712,
+     "name": "Bamboo",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.31,
+     "wormhole_pollution": 2.11,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 101
+    },
+    {
+     "brand_id": 14390,
+     "name": "Mossimo",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 0.58,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 114
+    },
+    {
+     "brand_id": 377,
+     "name": "Apt. 9",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.64,
+     "wormhole_pollution": 0.77,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 115
+    },
+    {
+     "brand_id": 18721,
+     "name": "Ring",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.1,
+     "wormhole_pollution": 2.64,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 119
+    },
+    {
+     "brand_id": 14263,
+     "name": "Max Studio",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 1.29,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 120
+    }
+   ],
+   "review_queue": [
+    {
+     "brand_id": 4044,
+     "name": "Claire's",
+     "pass": 1,
+     "probe_rank": 2,
+     "original_rank": 2,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 0.98,
+     "is_standalone_brand": 0.89,
+     "wormhole_pollution": 0.72,
+     "context": {
+      "total_listings": 16185,
+      "distinct_c0": 16,
+      "distinct_c1": 119,
+      "avg_price": 11.13,
+      "cat1": "Women > Jewelry > Earrings",
+      "cat1_listings": 3280
+     }
+    },
+    {
+     "brand_id": 3305,
+     "name": "Better Homes & Gardens",
+     "pass": 1,
+     "probe_rank": 5,
+     "original_rank": 5,
+     "entity_kind": "superstore_house_brand",
+     "entity_kind_p": 1.0,
+     "is_standalone_brand": 0.65,
+     "wormhole_pollution": 0.9,
+     "context": {
+      "total_listings": 10391,
+      "distinct_c0": 16,
+      "distinct_c1": 121,
+      "avg_price": 20.34,
+      "cat1": "Books > Reference Books > Cookbooks",
+      "cat1_listings": 1494
+     }
+    },
+    {
+     "brand_id": 15827,
+     "name": "New Directions",
+     "pass": 1,
+     "probe_rank": 22,
+     "original_rank": 22,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.51,
+     "is_standalone_brand": 0.49,
+     "wormhole_pollution": 0.7,
+     "context": {
+      "total_listings": 11186,
+      "distinct_c0": 13,
+      "distinct_c1": 51,
+      "avg_price": 13.93,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 3703
+     }
+    },
+    {
+     "brand_id": 22109,
+     "name": "Secret Treasures",
+     "pass": 1,
+     "probe_rank": 25,
+     "original_rank": 25,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.54,
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 0.73,
+     "context": {
+      "total_listings": 17417,
+      "distinct_c0": 12,
+      "distinct_c1": 68,
+      "avg_price": 11.63,
+      "cat1": "Women > Sleepwear & robes > Pajama sets",
+      "cat1_listings": 3025
+     }
+    },
+    {
+     "brand_id": 4814,
+     "name": "Cabela's",
+     "pass": 1,
+     "probe_rank": 28,
+     "original_rank": 28,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 0.78,
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 0.78,
+     "context": {
+      "total_listings": 11154,
+      "distinct_c0": 15,
+      "distinct_c1": 118,
+      "avg_price": 25.36,
+      "cat1": "Men > Tops > Button-front",
+      "cat1_listings": 1215
+     }
+    },
+    {
+     "brand_id": 15946,
+     "name": "No Boundaries",
+     "pass": 1,
+     "probe_rank": 34,
+     "original_rank": 34,
+     "entity_kind": "superstore_house_brand",
+     "entity_kind_p": 0.98,
+     "is_standalone_brand": 0.39,
+     "wormhole_pollution": 1.54,
+     "context": {
+      "total_listings": 72964,
+      "distinct_c0": 15,
+      "distinct_c1": 96,
+      "avg_price": 10.58,
+      "cat1": "Women > Tops & blouses > Tank Tops",
+      "cat1_listings": 5640
+     }
+    },
+    {
+     "brand_id": 10525,
+     "name": "Independent",
+     "pass": 1,
+     "probe_rank": 43,
+     "original_rank": 43,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.96,
+     "is_standalone_brand": 0.3,
+     "wormhole_pollution": 2.25,
+     "context": {
+      "total_listings": 292408,
+      "distinct_c0": 17,
+      "distinct_c1": 234,
+      "avg_price": 42.12,
+      "cat1": "Toys & Collectibles > Collectibles & Hobbies > Pins",
+      "cat1_listings": 103131
+     }
+    },
+    {
+     "brand_id": 17373,
+     "name": "Pier One",
+     "pass": 1,
+     "probe_rank": 44,
+     "original_rank": 44,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 0.67,
+     "is_standalone_brand": 0.67,
+     "wormhole_pollution": 0.46,
+     "context": {
+      "total_listings": 9896,
+      "distinct_c0": 16,
+      "distinct_c1": 118,
+      "avg_price": 24.46,
+      "cat1": "Home > Home decor > Home decor accents",
+      "cat1_listings": 1670
+     }
+    },
+    {
+     "brand_id": 20356,
+     "name": "Spencer's",
+     "pass": 1,
+     "probe_rank": 50,
+     "original_rank": 50,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 1.0,
+     "is_standalone_brand": 0.58,
+     "wormhole_pollution": 1.06,
+     "context": {
+      "total_listings": 12137,
+      "distinct_c0": 17,
+      "distinct_c1": 136,
+      "avg_price": 16.93,
+      "cat1": "Men > Tops > T-shirts",
+      "cat1_listings": 2988
+     }
+    },
+    {
+     "brand_id": 17975,
+     "name": "Pier 1 Imports",
+     "pass": 1,
+     "probe_rank": 53,
+     "original_rank": 53,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 0.75,
+     "is_standalone_brand": 0.78,
+     "wormhole_pollution": 0.82,
+     "context": {
+      "total_listings": 9662,
+      "distinct_c0": 17,
+      "distinct_c1": 116,
+      "avg_price": 24.63,
+      "cat1": "Home > Home decor > Home decor accents",
+      "cat1_listings": 1350
+     }
+    },
+    {
+     "brand_id": 6149,
+     "name": "Derek Heart",
+     "pass": 1,
+     "probe_rank": 54,
+     "original_rank": 54,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.62,
+     "is_standalone_brand": 0.63,
+     "wormhole_pollution": 1.1,
+     "context": {
+      "total_listings": 9455,
+      "distinct_c0": 11,
+      "distinct_c1": 39,
+      "avg_price": 11.87,
+      "cat1": "Women > Dresses > Above knee, mini",
+      "cat1_listings": 1546
+     }
+    },
+    {
+     "brand_id": 493,
+     "name": "Almost Famous",
+     "pass": 1,
+     "probe_rank": 56,
+     "original_rank": 56,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.45,
+     "is_standalone_brand": 0.45,
+     "wormhole_pollution": 1.35,
+     "context": {
+      "total_listings": 10583,
+      "distinct_c0": 12,
+      "distinct_c1": 48,
+      "avg_price": 14.71,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 1098
+     }
+    },
+    {
+     "brand_id": 791,
+     "name": "Ambiance Apparel",
+     "pass": 1,
+     "probe_rank": 59,
+     "original_rank": 59,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.48,
+     "is_standalone_brand": 0.54,
+     "wormhole_pollution": 0.67,
+     "context": {
+      "total_listings": 9425,
+      "distinct_c0": 10,
+      "distinct_c1": 49,
+      "avg_price": 11.29,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 1298
+     }
+    },
+    {
+     "brand_id": 24197,
+     "name": "Venus",
+     "pass": 1,
+     "probe_rank": 61,
+     "original_rank": 61,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.91,
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 1.53,
+     "context": {
+      "total_listings": 16979,
+      "distinct_c0": 15,
+      "distinct_c1": 81,
+      "avg_price": 19.69,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 2035
+     }
+    },
+    {
+     "brand_id": 17140,
+     "name": "Pink Rose",
+     "pass": 1,
+     "probe_rank": 62,
+     "original_rank": 62,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.55,
+     "is_standalone_brand": 0.47,
+     "wormhole_pollution": 0.95,
+     "context": {
+      "total_listings": 8603,
+      "distinct_c0": 12,
+      "distinct_c1": 46,
+      "avg_price": 11.88,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 1339
+     }
+    },
+    {
+     "brand_id": 15755,
+     "name": "Native",
+     "pass": 1,
+     "probe_rank": 64,
+     "original_rank": 64,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.76,
+     "is_standalone_brand": 0.32,
+     "wormhole_pollution": 1.9,
+     "context": {
+      "total_listings": 27458,
+      "distinct_c0": 15,
+      "distinct_c1": 105,
+      "avg_price": 49.87,
+      "cat1": "Kids > Girls shoes > Girls 2T-5T",
+      "cat1_listings": 5412
+     }
+    },
+    {
+     "brand_id": 4753,
+     "name": "Cato",
+     "pass": 1,
+     "probe_rank": 68,
+     "original_rank": 68,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.64,
+     "is_standalone_brand": 0.63,
+     "wormhole_pollution": 0.41,
+     "context": {
+      "total_listings": 25252,
+      "distinct_c0": 12,
+      "distinct_c1": 55,
+      "avg_price": 13.19,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 7049
+     }
+    },
+    {
+     "brand_id": 15965,
+     "name": "Nobo",
+     "pass": 1,
+     "probe_rank": 70,
+     "original_rank": 70,
+     "entity_kind": "superstore_house_brand",
+     "entity_kind_p": 0.56,
+     "is_standalone_brand": 0.52,
+     "wormhole_pollution": 1.48,
+     "context": {
+      "total_listings": 6047,
+      "distinct_c0": 11,
+      "distinct_c1": 56,
+      "avg_price": 10.59,
+      "cat1": "Women > Tops & blouses > T-shirts",
+      "cat1_listings": 376
+     }
+    },
+    {
+     "brand_id": 7948,
+     "name": "Faded Glory",
+     "pass": 1,
+     "probe_rank": 82,
+     "original_rank": 82,
+     "entity_kind": "superstore_house_brand",
+     "entity_kind_p": 0.67,
+     "is_standalone_brand": 0.5,
+     "wormhole_pollution": 0.34,
+     "context": {
+      "total_listings": 32001,
+      "distinct_c0": 13,
+      "distinct_c1": 65,
+      "avg_price": 10.77,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 2857
+     }
+    },
+    {
+     "brand_id": 2666,
+     "name": "Bioworld",
+     "pass": 1,
+     "probe_rank": 83,
+     "original_rank": 83,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 0.57,
+     "is_standalone_brand": 0.66,
+     "wormhole_pollution": 1.1,
+     "context": {
+      "total_listings": 17605,
+      "distinct_c0": 17,
+      "distinct_c1": 114,
+      "avg_price": 32.76,
+      "cat1": "Women > Women's handbags > Backpacks",
+      "cat1_listings": 3439
+     }
+    },
+    {
+     "brand_id": 10548,
+     "name": "Indie",
+     "pass": 1,
+     "probe_rank": 88,
+     "original_rank": 88,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.93,
+     "is_standalone_brand": 0.37,
+     "wormhole_pollution": 1.81,
+     "context": {
+      "total_listings": 39370,
+      "distinct_c0": 16,
+      "distinct_c1": 110,
+      "avg_price": 29.82,
+      "cat1": "Beauty > Makeup > Nails",
+      "cat1_listings": 15123
+     }
+    },
+    {
+     "brand_id": 20371,
+     "name": "Sonoma",
+     "pass": 1,
+     "probe_rank": 92,
+     "original_rank": 92,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.56,
+     "is_standalone_brand": 0.51,
+     "wormhole_pollution": 0.66,
+     "context": {
+      "total_listings": 38521,
+      "distinct_c0": 16,
+      "distinct_c1": 119,
+      "avg_price": 13.65,
+      "cat1": "Women > Tops & blouses > T-shirts",
+      "cat1_listings": 3245
+     }
+    },
+    {
+     "brand_id": 19923,
+     "name": "Style & Co",
+     "pass": 1,
+     "probe_rank": 96,
+     "original_rank": 96,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.52,
+     "is_standalone_brand": 0.43,
+     "wormhole_pollution": 0.33,
+     "context": {
+      "total_listings": 26496,
+      "distinct_c0": 12,
+      "distinct_c1": 56,
+      "avg_price": 17.33,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 5451
+     }
+    },
+    {
+     "brand_id": 10417,
+     "name": "Hyper Tough",
+     "pass": 1,
+     "probe_rank": 99,
+     "original_rank": 99,
+     "entity_kind": "superstore_house_brand",
+     "entity_kind_p": 0.8,
+     "is_standalone_brand": 0.41,
+     "wormhole_pollution": 0.66,
+     "context": {
+      "total_listings": 1445,
+      "distinct_c0": 15,
+      "distinct_c1": 72,
+      "avg_price": 28.62,
+      "cat1": "Other > Automotive > Tools & equipment",
+      "cat1_listings": 547
+     }
+    },
+    {
+     "brand_id": 4055,
+     "name": "Circo",
+     "pass": 1,
+     "probe_rank": 102,
+     "original_rank": 102,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.72,
+     "is_standalone_brand": 0.65,
+     "wormhole_pollution": 0.45,
+     "context": {
+      "total_listings": 8317,
+      "distinct_c0": 15,
+      "distinct_c1": 102,
+      "avg_price": 11.11,
+      "cat1": "Kids > Girls bottoms > Girls (4+)",
+      "cat1_listings": 526
+     }
+    },
+    {
+     "brand_id": 9739,
+     "name": "Hot Topic",
+     "pass": 1,
+     "probe_rank": 103,
+     "original_rank": 103,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 1.0,
+     "is_standalone_brand": 0.59,
+     "wormhole_pollution": 0.58,
+     "context": {
+      "total_listings": 85275,
+      "distinct_c0": 17,
+      "distinct_c1": 171,
+      "avg_price": 20.48,
+      "cat1": "Men > Tops > T-shirts",
+      "cat1_listings": 13488
+     }
+    },
+    {
+     "brand_id": 25116,
+     "name": "Wonder Nation",
+     "pass": 1,
+     "probe_rank": 104,
+     "original_rank": 104,
+     "entity_kind": "superstore_house_brand",
+     "entity_kind_p": 0.75,
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 0.25,
+     "context": {
+      "total_listings": 51342,
+      "distinct_c0": 15,
+      "distinct_c1": 96,
+      "avg_price": 9.52,
+      "cat1": "Kids > Girls shoes > Girls 2T-5T",
+      "cat1_listings": 4823
+     }
+    },
+    {
+     "brand_id": 667,
+     "name": "a.n.a",
+     "pass": 1,
+     "probe_rank": 105,
+     "original_rank": 105,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.74,
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 0.63,
+     "context": {
+      "total_listings": 19812,
+      "distinct_c0": 13,
+      "distinct_c1": 50,
+      "avg_price": 13.9,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 4170
+     }
+    },
+    {
+     "brand_id": 10617,
+     "name": "INC International Concepts",
+     "pass": 1,
+     "probe_rank": 111,
+     "original_rank": 111,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.59,
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 1.26,
+     "context": {
+      "total_listings": 42404,
+      "distinct_c0": 13,
+      "distinct_c1": 83,
+      "avg_price": 22.79,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 6846
+     }
+    },
+    {
+     "brand_id": 18759,
+     "name": "Revolution",
+     "pass": 1,
+     "probe_rank": 120,
+     "original_rank": 120,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.52,
+     "is_standalone_brand": 0.46,
+     "wormhole_pollution": 2.16,
+     "context": {
+      "total_listings": 6549,
+      "distinct_c0": 14,
+      "distinct_c1": 100,
+      "avg_price": 20.93,
+      "cat1": "Beauty > Makeup > Makeup palettes",
+      "cat1_listings": 1610
+     }
+    },
+    {
+     "brand_id": 5699,
+     "name": "Celebrate It",
+     "pass": 2,
+     "probe_rank": 18,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.56,
+     "is_standalone_brand": 0.62,
+     "wormhole_pollution": 1.14,
+     "context": {
+      "total_listings": 5698,
+      "distinct_c0": 16,
+      "distinct_c1": 113,
+      "avg_price": 13.7,
+      "cat1": "Home > Seasonal decor > Halloween",
+      "cat1_listings": 473
+     }
+    },
+    {
+     "brand_id": 4577,
+     "name": "Candie's",
+     "pass": 2,
+     "probe_rank": 60,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.72,
+     "is_standalone_brand": 0.65,
+     "wormhole_pollution": 0.55,
+     "context": {
+      "total_listings": 15419,
+      "distinct_c0": 12,
+      "distinct_c1": 66,
+      "avg_price": 14.45,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 2320
+     }
+    },
+    {
+     "brand_id": 640,
+     "name": "Athletic Works",
+     "pass": 2,
+     "probe_rank": 65,
+     "original_rank": null,
+     "entity_kind": "superstore_house_brand",
+     "entity_kind_p": 0.71,
+     "is_standalone_brand": 0.42,
+     "wormhole_pollution": 0.68,
+     "context": {
+      "total_listings": 16718,
+      "distinct_c0": 12,
+      "distinct_c1": 71,
+      "avg_price": 11.2,
+      "cat1": "Women > Athletic apparel > Shorts",
+      "cat1_listings": 1956
+     }
+    },
+    {
+     "brand_id": 4491,
+     "name": "Columbia",
+     "pass": 2,
+     "probe_rank": 82,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.96,
+     "is_standalone_brand": 0.54,
+     "wormhole_pollution": 2.28,
+     "context": {
+      "total_listings": 163500,
+      "distinct_c0": 16,
+      "distinct_c1": 151,
+      "avg_price": 23.94,
+      "cat1": "Women > Athletic apparel > Jackets",
+      "cat1_listings": 10981
+     }
+    },
+    {
+     "brand_id": 10322,
+     "name": "Holiday Time",
+     "pass": 2,
+     "probe_rank": 86,
+     "original_rank": null,
+     "entity_kind": "superstore_house_brand",
+     "entity_kind_p": 0.89,
+     "is_standalone_brand": 0.36,
+     "wormhole_pollution": 1.81,
+     "context": {
+      "total_listings": 13135,
+      "distinct_c0": 16,
+      "distinct_c1": 130,
+      "avg_price": 21.98,
+      "cat1": "Home > Seasonal decor > Christmas",
+      "cat1_listings": 6126
+     }
+    },
+    {
+     "brand_id": 2299,
+     "name": "Body Central",
+     "pass": 2,
+     "probe_rank": 93,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.83,
+     "is_standalone_brand": 0.64,
+     "wormhole_pollution": 0.24,
+     "context": {
+      "total_listings": 4049,
+      "distinct_c0": 9,
+      "distinct_c1": 37,
+      "avg_price": 12.42,
+      "cat1": "Women > Dresses > Above knee, mini",
+      "cat1_listings": 795
+     }
+    },
+    {
+     "brand_id": 15904,
+     "name": "NASCAR",
+     "pass": 2,
+     "probe_rank": 94,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.94,
+     "is_standalone_brand": 0.62,
+     "wormhole_pollution": 0.28,
+     "context": {
+      "total_listings": 42753,
+      "distinct_c0": 16,
+      "distinct_c1": 147,
+      "avg_price": 33.62,
+      "cat1": "Toys & Collectibles > Vintage & Antique Toys > Cars",
+      "cat1_listings": 12466
+     }
+    },
+    {
+     "brand_id": 2712,
+     "name": "Bamboo",
+     "pass": 2,
+     "probe_rank": 97,
+     "original_rank": null,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.85,
+     "is_standalone_brand": 0.31,
+     "wormhole_pollution": 2.11,
+     "context": {
+      "total_listings": 11030,
+      "distinct_c0": 16,
+      "distinct_c1": 126,
+      "avg_price": 22.37,
+      "cat1": "Women > Shoes > Sandals",
+      "cat1_listings": 2564
+     }
+    },
+    {
+     "brand_id": 14390,
+     "name": "Mossimo",
+     "pass": 2,
+     "probe_rank": 103,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.52,
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 0.58,
+     "context": {
+      "total_listings": 28158,
+      "distinct_c0": 12,
+      "distinct_c1": 60,
+      "avg_price": 12.22,
+      "cat1": "Women > Swimwear > Two-piece",
+      "cat1_listings": 1940
+     }
+    },
+    {
+     "brand_id": 14263,
+     "name": "Max Studio",
+     "pass": 2,
+     "probe_rank": 108,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.7,
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 1.29,
+     "context": {
+      "total_listings": 18522,
+      "distinct_c0": 15,
+      "distinct_c1": 81,
+      "avg_price": 21.11,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 3318
+     }
+    },
+    {
+     "brand_id": 377,
+     "name": "Apt. 9",
+     "pass": 2,
+     "probe_rank": 111,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.58,
+     "is_standalone_brand": 0.64,
+     "wormhole_pollution": 0.77,
+     "context": {
+      "total_listings": 37931,
+      "distinct_c0": 11,
+      "distinct_c1": 58,
+      "avg_price": 13.41,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 7451
+     }
+    },
+    {
+     "brand_id": 25185,
+     "name": "XOXO",
+     "pass": 2,
+     "probe_rank": 114,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.5599999999999999,
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 1.94,
+     "context": {
+      "total_listings": 8409,
+      "distinct_c0": 13,
+      "distinct_c1": 73,
+      "avg_price": 18.02,
+      "cat1": "Women > Dresses > Above knee, mini",
+      "cat1_listings": 650
+     }
+    },
+    {
+     "brand_id": 8378,
+     "name": "Fate",
+     "pass": 2,
+     "probe_rank": 118,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.72,
+     "is_standalone_brand": 0.51,
+     "wormhole_pollution": 1.22,
+     "context": {
+      "total_listings": 1436,
+      "distinct_c0": 11,
+      "distinct_c1": 40,
+      "avg_price": 27.14,
+      "cat1": "Women > Sweaters > Crewneck",
+      "cat1_listings": 202
+     }
+    }
+   ],
+   "judgments": [
+    {
+     "brand_id": 786,
+     "name": "As Seen on TV",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.2
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.84
+      }
+     }
+    },
+    {
+     "brand_id": 4044,
+     "name": "Claire's",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.89
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.72
+      }
+     }
+    },
+    {
+     "brand_id": 4680,
+     "name": "Customized & Personalized",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.08
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.88
+      }
+     }
+    },
+    {
+     "brand_id": 15548,
+     "name": "Mainstays",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.07
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.94
+      }
+     }
+    },
+    {
+     "brand_id": 3305,
+     "name": "Better Homes & Gardens",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.65
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.9
+      }
+     }
+    },
+    {
+     "brand_id": 20430,
+     "name": "Samsung",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.98
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.03
+      }
+     }
+    },
+    {
+     "brand_id": 25120,
+     "name": "Walmart",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.04
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.87
+      }
+     }
+    },
+    {
+     "brand_id": 10627,
+     "name": "IZOD",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.09
+      }
+     }
+    },
+    {
+     "brand_id": 23778,
+     "name": "US Vintage",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.24
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.88
+      }
+     }
+    },
+    {
+     "brand_id": 8910,
+     "name": "Gibson",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.85
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.75
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.16
+      }
+     }
+    },
+    {
+     "brand_id": 7106,
+     "name": "Eyeshadow",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.07
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.93
+      }
+     }
+    },
+    {
+     "brand_id": 16807,
+     "name": "Original Vintage Style",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.17
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.36
+      }
+     }
+    },
+    {
+     "brand_id": 11163,
+     "name": "JCPenney",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.06
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.89
+      }
+     }
+    },
+    {
+     "brand_id": 13763,
+     "name": "Macy's",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.04
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.78
+      }
+     }
+    },
+    {
+     "brand_id": 7265,
+     "name": "Ellen Tracy",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.34
+      }
+     }
+    },
+    {
+     "brand_id": 12259,
+     "name": "Kohl's",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.05
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.86
+      }
+     }
+    },
+    {
+     "brand_id": 12799,
+     "name": "Lot",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.08
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.73
+      }
+     }
+    },
+    {
+     "brand_id": 16002,
+     "name": "Nicole Miller",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.85
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.62
+      }
+     }
+    },
+    {
+     "brand_id": 4184,
+     "name": "Charming Charlie",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.86
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.92
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.57
+      }
+     }
+    },
+    {
+     "brand_id": 23372,
+     "name": "The Unbranded Brand",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.13
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.85
+      }
+     }
+    },
+    {
+     "brand_id": 12700,
+     "name": "L'Oreal",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.98
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.03
+      }
+     }
+    },
+    {
+     "brand_id": 15827,
+     "name": "New Directions",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.51
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.49
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.7
+      }
+     }
+    },
+    {
+     "brand_id": 505,
+     "name": "Avon",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.54
+      }
+     }
+    },
+    {
+     "brand_id": 13610,
+     "name": "Loot Crate",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.84
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.93
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.65
+      }
+     }
+    },
+    {
+     "brand_id": 22109,
+     "name": "Secret Treasures",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.54
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.55
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.73
+      }
+     }
+    },
+    {
+     "brand_id": 4741,
+     "name": "Crayola",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.12
+      }
+     }
+    },
+    {
+     "brand_id": 24792,
+     "name": "Warner Bros.",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.77
+      }
+     }
+    },
+    {
+     "brand_id": 4814,
+     "name": "Cabela's",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.78
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.53
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.78
+      }
+     }
+    },
+    {
+     "brand_id": 14116,
+     "name": "Motherhood Maternity",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.9
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.85
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.1
+      }
+     }
+    },
+    {
+     "brand_id": 21725,
+     "name": "Sigma",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.84
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.28
+      }
+     }
+    },
+    {
+     "brand_id": 12843,
+     "name": "Laura Ashley",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.59
+      }
+     }
+    },
+    {
+     "brand_id": 14204,
+     "name": "Melissa & Doug",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.07
+      }
+     }
+    },
+    {
+     "brand_id": 8923,
+     "name": "Gerber",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.15
+      }
+     }
+    },
+    {
+     "brand_id": 15946,
+     "name": "No Boundaries",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.39
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.54
+      }
+     }
+    },
+    {
+     "brand_id": 23745,
+     "name": "Ulta",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.18
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.61
+      }
+     }
+    },
+    {
+     "brand_id": 469,
+     "name": "ART",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.27
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.95
+      }
+     }
+    },
+    {
+     "brand_id": 4348,
+     "name": "CoverGirl",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.02
+      }
+     }
+    },
+    {
+     "brand_id": 24936,
+     "name": "World Market",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.92
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.26
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.6
+      }
+     }
+    },
+    {
+     "brand_id": 17190,
+     "name": "Philosophy",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.12
+      }
+     }
+    },
+    {
+     "brand_id": 18949,
+     "name": "Revlon",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.98
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.03
+      }
+     }
+    },
+    {
+     "brand_id": 18651,
+     "name": "Rue21",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.71
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.8
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.41
+      }
+     }
+    },
+    {
+     "brand_id": 745,
+     "name": "ASUS",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.18
+      }
+     }
+    },
+    {
+     "brand_id": 10525,
+     "name": "Independent",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.96
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.3
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.25
+      }
+     }
+    },
+    {
+     "brand_id": 17373,
+     "name": "Pier One",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.67
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.67
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.46
+      }
+     }
+    },
+    {
+     "brand_id": 751,
+     "name": "Army",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.92
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.15
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.18
+      }
+     }
+    },
+    {
+     "brand_id": 24788,
+     "name": "Wilson",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.89
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.08
+      }
+     }
+    },
+    {
+     "brand_id": 9686,
+     "name": "Hanes",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.23
+      }
+     }
+    },
+    {
+     "brand_id": 217,
+     "name": "American Vintage",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.24
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.56
+      }
+     }
+    },
+    {
+     "brand_id": 19022,
+     "name": "RCA",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.89
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.32
+      }
+     }
+    },
+    {
+     "brand_id": 20356,
+     "name": "Spencer's",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.58
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.06
+      }
+     }
+    },
+    {
+     "brand_id": 17339,
+     "name": "prAna",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.08
+      }
+     }
+    },
+    {
+     "brand_id": 10314,
+     "name": "Hobby Lobby",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.24
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.58
+      }
+     }
+    },
+    {
+     "brand_id": 17975,
+     "name": "Pier 1 Imports",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.75
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.78
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.82
+      }
+     }
+    },
+    {
+     "brand_id": 6149,
+     "name": "Derek Heart",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.62
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.63
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.1
+      }
+     }
+    },
+    {
+     "brand_id": 19382,
+     "name": "Rare",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.29
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.74
+      }
+     }
+    },
+    {
+     "brand_id": 493,
+     "name": "Almost Famous",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.45
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.45
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.35
+      }
+     }
+    },
+    {
+     "brand_id": 24722,
+     "name": "Warner Brothers",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.22
+      }
+     }
+    },
+    {
+     "brand_id": 15536,
+     "name": "Makeup Revolution",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 791,
+     "name": "Ambiance Apparel",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.48
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.54
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.67
+      }
+     }
+    },
+    {
+     "brand_id": 19825,
+     "name": "Simply Southern",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.82
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.18
+      }
+     }
+    },
+    {
+     "brand_id": 24197,
+     "name": "Venus",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.91
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.55
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.53
+      }
+     }
+    },
+    {
+     "brand_id": 17140,
+     "name": "Pink Rose",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.55
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.47
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.95
+      }
+     }
+    },
+    {
+     "brand_id": 15997,
+     "name": "Nickelodeon",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.92
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.45
+      }
+     }
+    },
+    {
+     "brand_id": 15755,
+     "name": "Native",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.76
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.32
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.9
+      }
+     }
+    },
+    {
+     "brand_id": 4510,
+     "name": "Conair",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.08
+      }
+     }
+    },
+    {
+     "brand_id": 2571,
+     "name": "Black & Decker",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.12
+      }
+     }
+    },
+    {
+     "brand_id": 13581,
+     "name": "L.A. COLORS",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.92
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 4753,
+     "name": "Cato",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.64
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.63
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.41
+      }
+     }
+    },
+    {
+     "brand_id": 11171,
+     "name": "Joie",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.19
+      }
+     }
+    },
+    {
+     "brand_id": 15965,
+     "name": "Nobo",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.56
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.52
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.48
+      }
+     }
+    },
+    {
+     "brand_id": 6120,
+     "name": "Dana Buchman",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.13
+      }
+     }
+    },
+    {
+     "brand_id": 13583,
+     "name": "Lefton",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.12
+      }
+     }
+    },
+    {
+     "brand_id": 2816,
+     "name": "BCBGeneration",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.92
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.11
+      }
+     }
+    },
+    {
+     "brand_id": 20324,
+     "name": "Scholastic",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.11
+      }
+     }
+    },
+    {
+     "brand_id": 4768,
+     "name": "Cherokee",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.86
+      }
+     }
+    },
+    {
+     "brand_id": 3311,
+     "name": "Bed Bath & Beyond",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.21
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.63
+      }
+     }
+    },
+    {
+     "brand_id": 7185,
+     "name": "Enesco",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.89
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.23
+      }
+     }
+    },
+    {
+     "brand_id": 16682,
+     "name": "Oscar de la Renta",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.57
+      }
+     }
+    },
+    {
+     "brand_id": 4308,
+     "name": "Coca-Cola",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.6
+      }
+     }
+    },
+    {
+     "brand_id": 15901,
+     "name": "Nordstrom",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.07
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.23
+      }
+     }
+    },
+    {
+     "brand_id": 2431,
+     "name": "Bobbie Brooks",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.92
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.13
+      }
+     }
+    },
+    {
+     "brand_id": 7948,
+     "name": "Faded Glory",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.67
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.5
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.34
+      }
+     }
+    },
+    {
+     "brand_id": 2666,
+     "name": "Bioworld",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.57
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.66
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.1
+      }
+     }
+    },
+    {
+     "brand_id": 4198,
+     "name": "Catherine Malandrino",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.86
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.02
+      }
+     }
+    },
+    {
+     "brand_id": 22387,
+     "name": "The Honest Company",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.35
+      }
+     }
+    },
+    {
+     "brand_id": 6029,
+     "name": "DC Comics",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 8452,
+     "name": "Franklin Mint",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.92
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.33
+      }
+     }
+    },
+    {
+     "brand_id": 10548,
+     "name": "Indie",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.93
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.37
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.81
+      }
+     }
+    },
+    {
+     "brand_id": 12476,
+     "name": "Lush",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.08
+      }
+     }
+    },
+    {
+     "brand_id": 14265,
+     "name": "Maybelline",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.98
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.02
+      }
+     }
+    },
+    {
+     "brand_id": 832,
+     "name": "American Rag",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.95
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.85
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.24
+      }
+     }
+    },
+    {
+     "brand_id": 20371,
+     "name": "Sonoma",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.56
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.51
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.66
+      }
+     }
+    },
+    {
+     "brand_id": 10424,
+     "name": "IT Cosmetics",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.03
+      }
+     }
+    },
+    {
+     "brand_id": 6812,
+     "name": "Dolls Kill",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.94
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.24
+      }
+     }
+    },
+    {
+     "brand_id": 7962,
+     "name": "Farberware",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.08
+      }
+     }
+    },
+    {
+     "brand_id": 19923,
+     "name": "Style & Co",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.52
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.43
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.33
+      }
+     }
+    },
+    {
+     "brand_id": 8140,
+     "name": "Fox Racing",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.5
+      }
+     }
+    },
+    {
+     "brand_id": 22652,
+     "name": "Tahari",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.96
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.86
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.46
+      }
+     }
+    },
+    {
+     "brand_id": 10417,
+     "name": "Hyper Tough",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.8
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.41
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.66
+      }
+     }
+    },
+    {
+     "brand_id": 24113,
+     "name": "Vera Wang",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.93
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.44
+      }
+     }
+    },
+    {
+     "brand_id": 18907,
+     "name": "Reebok",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 4055,
+     "name": "Circo",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.72
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.65
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.45
+      }
+     }
+    },
+    {
+     "brand_id": 9739,
+     "name": "Hot Topic",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.59
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.58
+      }
+     }
+    },
+    {
+     "brand_id": 25116,
+     "name": "Wonder Nation",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.75
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.55
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.25
+      }
+     }
+    },
+    {
+     "brand_id": 667,
+     "name": "a.n.a",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.74
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.53
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.63
+      }
+     }
+    },
+    {
+     "brand_id": 2815,
+     "name": "BCBGMAXAZRIA",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 4482,
+     "name": "Cotton On",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.97
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.93
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.7
+      }
+     }
+    },
+    {
+     "brand_id": 20284,
+     "name": "SO",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.78
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.09
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.48
+      }
+     }
+    },
+    {
+     "brand_id": 19077,
+     "name": "Russell Athletic",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.24
+      }
+     }
+    },
+    {
+     "brand_id": 22826,
+     "name": "The Children's Place",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.8
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.9
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.17
+      }
+     }
+    },
+    {
+     "brand_id": 10617,
+     "name": "INC International Concepts",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.59
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.53
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.26
+      }
+     }
+    },
+    {
+     "brand_id": 1997,
+     "name": "Applause",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.88
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.13
+      }
+     }
+    },
+    {
+     "brand_id": 337,
+     "name": "Authentic Original Vintage Style",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.15
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.58
+      }
+     }
+    },
+    {
+     "brand_id": 15440,
+     "name": "Multiples",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.18
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.68
+      }
+     }
+    },
+    {
+     "brand_id": 9705,
+     "name": "HP",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.06
+      }
+     }
+    },
+    {
+     "brand_id": 24515,
+     "name": "Vivitar",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.92
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.12
+      }
+     }
+    },
+    {
+     "brand_id": 18828,
+     "name": "Room Essentials",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.08
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.29
+      }
+     }
+    },
+    {
+     "brand_id": 25176,
+     "name": "Xhilaration",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.97
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.16
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.96
+      }
+     }
+    },
+    {
+     "brand_id": 4775,
+     "name": "Custom Accessories",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.13
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.66
+      }
+     }
+    },
+    {
+     "brand_id": 18759,
+     "name": "Revolution",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.52
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.46
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.16
+      }
+     }
+    },
+    {
+     "brand_id": 749,
+     "name": "AmazonBasics",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.1
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.02
+      }
+     }
+    },
+    {
+     "brand_id": 2854,
+     "name": "Bella",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.84
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.78
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.76
+      }
+     }
+    },
+    {
+     "brand_id": 5699,
+     "name": "Celebrate It",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.56
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.62
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.14
+      }
+     }
+    },
+    {
+     "brand_id": 23892,
+     "name": "Unique Boutique",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.24
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.02
+      }
+     }
+    },
+    {
+     "brand_id": 20464,
+     "name": "Sears",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.97
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.11
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.82
+      }
+     }
+    },
+    {
+     "brand_id": 14195,
+     "name": "Members Mark",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.06
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.09
+      }
+     }
+    },
+    {
+     "brand_id": 11129,
+     "name": "Justice",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.96
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.88
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.07
+      }
+     }
+    },
+    {
+     "brand_id": 9821,
+     "name": "Home Interiors",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.18
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.7
+      }
+     }
+    },
+    {
+     "brand_id": 14099,
+     "name": "Martha Stewart",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.93
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.38
+      }
+     }
+    },
+    {
+     "brand_id": 8479,
+     "name": "Fabric",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.09
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.43
+      }
+     }
+    },
+    {
+     "brand_id": 18762,
+     "name": "ROMWE",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.73
+      }
+     }
+    },
+    {
+     "brand_id": 563,
+     "name": "Amazon",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.87
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.12
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.81
+      }
+     }
+    },
+    {
+     "brand_id": 12711,
+     "name": "Liz Claiborne",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.16
+      }
+     }
+    },
+    {
+     "brand_id": 9912,
+     "name": "Hallmark",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.29
+      }
+     }
+    },
+    {
+     "brand_id": 4703,
+     "name": "Cynthia Rowley",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.86
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.37
+      }
+     }
+    },
+    {
+     "brand_id": 11955,
+     "name": "Kensie",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.95
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.86
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.43
+      }
+     }
+    },
+    {
+     "brand_id": 4577,
+     "name": "Candie's",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.72
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.65
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.55
+      }
+     }
+    },
+    {
+     "brand_id": 19402,
+     "name": "Ross",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.96
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.15
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.58
+      }
+     }
+    },
+    {
+     "brand_id": 640,
+     "name": "Athletic Works",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.71
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.42
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.68
+      }
+     }
+    },
+    {
+     "brand_id": 2038,
+     "name": "Amuse",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.92
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.74
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.14
+      }
+     }
+    },
+    {
+     "brand_id": 18643,
+     "name": "QVC",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.15
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.21
+      }
+     }
+    },
+    {
+     "brand_id": 24653,
+     "name": "Wet n Wild",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.23
+      }
+     }
+    },
+    {
+     "brand_id": 4010,
+     "name": "ColourPop Cosmetics",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 326,
+     "name": "Arizona Jean Company",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.91
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.72
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.29
+      }
+     }
+    },
+    {
+     "brand_id": 4491,
+     "name": "Columbia",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.96
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.54
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.28
+      }
+     }
+    },
+    {
+     "brand_id": 7886,
+     "name": "Fruit of the Loom",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.26
+      }
+     }
+    },
+    {
+     "brand_id": 11239,
+     "name": "Jumping Beans",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.83
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.85
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.16
+      }
+     }
+    },
+    {
+     "brand_id": 10322,
+     "name": "Holiday Time",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.89
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.36
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.81
+      }
+     }
+    },
+    {
+     "brand_id": 11257,
+     "name": "Jessica Simpson",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.4
+      }
+     }
+    },
+    {
+     "brand_id": 4713,
+     "name": "Children's Place",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.75
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.85
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.11
+      }
+     }
+    },
+    {
+     "brand_id": 2703,
+     "name": "Boho Chic",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.19
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.24
+      }
+     }
+    },
+    {
+     "brand_id": 2475,
+     "name": "Burt's Bees",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.98
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.11
+      }
+     }
+    },
+    {
+     "brand_id": 2501,
+     "name": "Bebe",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.93
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.09
+      }
+     }
+    },
+    {
+     "brand_id": 20561,
+     "name": "Sephora",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.27
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.41
+      }
+     }
+    },
+    {
+     "brand_id": 2299,
+     "name": "Body Central",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.83
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.64
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.24
+      }
+     }
+    },
+    {
+     "brand_id": 15904,
+     "name": "NASCAR",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.94
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.62
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.28
+      }
+     }
+    },
+    {
+     "brand_id": 4294,
+     "name": "Charlotte Russe",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.78
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.78
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.48
+      }
+     }
+    },
+    {
+     "brand_id": 8099,
+     "name": "Fossil",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.96
+      }
+     }
+    },
+    {
+     "brand_id": 2712,
+     "name": "Bamboo",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.85
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.31
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.11
+      }
+     }
+    },
+    {
+     "brand_id": 23840,
+     "name": "Universal Studios",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.89
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.09
+      }
+     }
+    },
+    {
+     "brand_id": 11189,
+     "name": "Jones New York",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.96
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.88
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.08
+      }
+     }
+    },
+    {
+     "brand_id": 11227,
+     "name": "Jennifer Lopez",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.95
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.78
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.37
+      }
+     }
+    },
+    {
+     "brand_id": 13854,
+     "name": "Maidenform",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.02
+      }
+     }
+    },
+    {
+     "brand_id": 14390,
+     "name": "Mossimo",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.52
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.55
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.58
+      }
+     }
+    },
+    {
+     "brand_id": 13430,
+     "name": "Liz Lisa",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.86
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.07
+      }
+     }
+    },
+    {
+     "brand_id": 19884,
+     "name": "Sanrio",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.06
+      }
+     }
+    },
+    {
+     "brand_id": 765,
+     "name": "Anne Klein",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.17
+      }
+     }
+    },
+    {
+     "brand_id": 14378,
+     "name": "Mudd",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.93
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.81
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.21
+      }
+     }
+    },
+    {
+     "brand_id": 14263,
+     "name": "Max Studio",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.7
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.53
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.29
+      }
+     }
+    },
+    {
+     "brand_id": 7296,
+     "name": "Elizabeth Arden",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.03
+      }
+     }
+    },
+    {
+     "brand_id": 377,
+     "name": "Apt. 9",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.58
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.64
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.77
+      }
+     }
+    },
+    {
+     "brand_id": 13731,
+     "name": "Mud Pie",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.93
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.21
+      }
+     }
+    },
+    {
+     "brand_id": 15981,
+     "name": "Nautica",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.19
+      }
+     }
+    },
+    {
+     "brand_id": 25185,
+     "name": "XOXO",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.5599999999999999
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.55
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.94
+      }
+     }
+    },
+    {
+     "brand_id": 20330,
+     "name": "Sanctuary",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.86
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.17
+      }
+     }
+    },
+    {
+     "brand_id": 7158,
+     "name": "Eddie Bauer",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.8
+      }
+     }
+    },
+    {
+     "brand_id": 8378,
+     "name": "Fate",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.72
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.51
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.22
+      }
+     }
+    },
+    {
+     "brand_id": 12762,
+     "name": "Looney Tunes",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.86
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.23
+      }
+     }
+    },
+    {
+     "brand_id": 18721,
+     "name": "Ring",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.1
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.64
+      }
+     }
+    }
+   ],
+   "denylist_vs_model": {
+    "denylist_size": 49,
+    "denylist_matched": 49,
+    "denylist_unmatched": [],
+    "model_excluded": 57,
+    "overlap": 45,
+    "only_denylist": [
+     "Charming Charlie",
+     "Cherokee",
+     "Loot Crate",
+     "Rue21"
+    ],
+    "only_model": [
+     "Almost Famous",
+     "Ambiance Apparel",
+     "Bioworld",
+     "Custom Accessories",
+     "Derek Heart",
+     "Multiples",
+     "Native",
+     "New Directions",
+     "Nobo",
+     "Pink Rose",
+     "Revolution",
+     "Venus"
+    ]
+   },
+   "canonical_ranking": [
+    {
+     "canonical_rank": 1,
+     "brand_id": 20430,
+     "name": "Samsung",
+     "betweenness": 0.017926303669810295,
+     "neighbors": 89,
+     "worlds_reached": 6
+    },
+    {
+     "canonical_rank": 2,
+     "brand_id": 505,
+     "name": "Avon",
+     "betweenness": 0.01116915326565504,
+     "neighbors": 523,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 3,
+     "brand_id": 16002,
+     "name": "Nicole Miller",
+     "betweenness": 0.0106908418238163,
+     "neighbors": 687,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 4,
+     "brand_id": 4510,
+     "name": "Conair",
+     "betweenness": 0.008863477036356926,
+     "neighbors": 273,
+     "worlds_reached": 27
+    },
+    {
+     "canonical_rank": 5,
+     "brand_id": 12843,
+     "name": "Laura Ashley",
+     "betweenness": 0.008810075931251049,
+     "neighbors": 513,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 6,
+     "brand_id": 7265,
+     "name": "Ellen Tracy",
+     "betweenness": 0.008450556546449661,
+     "neighbors": 762,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 7,
+     "brand_id": 10627,
+     "name": "IZOD",
+     "betweenness": 0.008266127668321133,
+     "neighbors": 314,
+     "worlds_reached": 29
+    },
+    {
+     "canonical_rank": 8,
+     "brand_id": 2854,
+     "name": "Bella",
+     "betweenness": 0.007874569855630398,
+     "neighbors": 345,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 9,
+     "brand_id": 2571,
+     "name": "Black & Decker",
+     "betweenness": 0.007791554089635611,
+     "neighbors": 44,
+     "worlds_reached": 3
+    },
+    {
+     "canonical_rank": 10,
+     "brand_id": 8910,
+     "name": "Gibson",
+     "betweenness": 0.007713505998253822,
+     "neighbors": 165,
+     "worlds_reached": 13
+    },
+    {
+     "canonical_rank": 11,
+     "brand_id": 4184,
+     "name": "Charming Charlie",
+     "betweenness": 0.007296960800886154,
+     "neighbors": 674,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 12,
+     "brand_id": 12590,
+     "name": "L'Oréal",
+     "betweenness": 0.007190956734120846,
+     "neighbors": 491,
+     "worlds_reached": 27
+    },
+    {
+     "canonical_rank": 13,
+     "brand_id": 18651,
+     "name": "Rue21",
+     "betweenness": 0.007019687443971634,
+     "neighbors": 725,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 14,
+     "brand_id": 4741,
+     "name": "Crayola",
+     "betweenness": 0.007017098367214203,
+     "neighbors": 128,
+     "worlds_reached": 9
+    },
+    {
+     "canonical_rank": 15,
+     "brand_id": 24792,
+     "name": "Warner Bros.",
+     "betweenness": 0.006622332148253918,
+     "neighbors": 271,
+     "worlds_reached": 16
+    },
+    {
+     "canonical_rank": 16,
+     "brand_id": 14099,
+     "name": "Martha Stewart",
+     "betweenness": 0.0061447834596037865,
+     "neighbors": 287,
+     "worlds_reached": 23
+    },
+    {
+     "canonical_rank": 17,
+     "brand_id": 2431,
+     "name": "Bobbie Brooks",
+     "betweenness": 0.006130807101726532,
+     "neighbors": 638,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 18,
+     "brand_id": 13610,
+     "name": "Loot Crate",
+     "betweenness": 0.0061231860890984535,
+     "neighbors": 213,
+     "worlds_reached": 8
+    },
+    {
+     "canonical_rank": 19,
+     "brand_id": 4348,
+     "name": "CoverGirl",
+     "betweenness": 0.006066648289561272,
+     "neighbors": 419,
+     "worlds_reached": 28
+    },
+    {
+     "canonical_rank": 20,
+     "brand_id": 21725,
+     "name": "Sigma",
+     "betweenness": 0.005731619894504547,
+     "neighbors": 89,
+     "worlds_reached": 4
+    },
+    {
+     "canonical_rank": 21,
+     "brand_id": 15997,
+     "name": "Nickelodeon",
+     "betweenness": 0.00564488535746932,
+     "neighbors": 327,
+     "worlds_reached": 21
+    },
+    {
+     "canonical_rank": 22,
+     "brand_id": 15536,
+     "name": "Makeup Revolution",
+     "betweenness": 0.005640476476401091,
+     "neighbors": 381,
+     "worlds_reached": 24
+    },
+    {
+     "canonical_rank": 23,
+     "brand_id": 4308,
+     "name": "Coca-Cola",
+     "betweenness": 0.0056069400161504745,
+     "neighbors": 231,
+     "worlds_reached": 23
+    },
+    {
+     "canonical_rank": 24,
+     "brand_id": 9686,
+     "name": "Hanes",
+     "betweenness": 0.0055777039378881454,
+     "neighbors": 407,
+     "worlds_reached": 27
+    },
+    {
+     "canonical_rank": 25,
+     "brand_id": 13581,
+     "name": "L.A. COLORS",
+     "betweenness": 0.005563793238252401,
+     "neighbors": 294,
+     "worlds_reached": 19
+    },
+    {
+     "canonical_rank": 26,
+     "brand_id": 11129,
+     "name": "Justice",
+     "betweenness": 0.0054918755777180195,
+     "neighbors": 495,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 27,
+     "brand_id": 8923,
+     "name": "Gerber",
+     "betweenness": 0.005422384478151798,
+     "neighbors": 244,
+     "worlds_reached": 16
+    },
+    {
+     "canonical_rank": 28,
+     "brand_id": 7962,
+     "name": "Farberware",
+     "betweenness": 0.005248229950666428,
+     "neighbors": 92,
+     "worlds_reached": 5
+    },
+    {
+     "canonical_rank": 29,
+     "brand_id": 6812,
+     "name": "Dolls Kill",
+     "betweenness": 0.005214401055127382,
+     "neighbors": 384,
+     "worlds_reached": 26
+    },
+    {
+     "canonical_rank": 30,
+     "brand_id": 18949,
+     "name": "Revlon",
+     "betweenness": 0.005155457649379969,
+     "neighbors": 459,
+     "worlds_reached": 27
+    },
+    {
+     "canonical_rank": 31,
+     "brand_id": 13583,
+     "name": "Lefton",
+     "betweenness": 0.005117680877447128,
+     "neighbors": 240,
+     "worlds_reached": 12
+    },
+    {
+     "canonical_rank": 32,
+     "brand_id": 24623,
+     "name": "Wondershop",
+     "betweenness": 0.0050203874707221985,
+     "neighbors": 207,
+     "worlds_reached": 23
+    },
+    {
+     "canonical_rank": 33,
+     "brand_id": 7185,
+     "name": "Enesco",
+     "betweenness": 0.005013594403862953,
+     "neighbors": 299,
+     "worlds_reached": 15
+    },
+    {
+     "canonical_rank": 34,
+     "brand_id": 4703,
+     "name": "Cynthia Rowley",
+     "betweenness": 0.005008791107684374,
+     "neighbors": 515,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 35,
+     "brand_id": 12667,
+     "name": "Lauren Conrad",
+     "betweenness": 0.004970616661012173,
+     "neighbors": 625,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 36,
+     "brand_id": 17190,
+     "name": "Philosophy",
+     "betweenness": 0.0049628023989498615,
+     "neighbors": 492,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 37,
+     "brand_id": 18762,
+     "name": "ROMWE",
+     "betweenness": 0.004799880553036928,
+     "neighbors": 481,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 38,
+     "brand_id": 19825,
+     "name": "Simply Southern",
+     "betweenness": 0.004790939390659332,
+     "neighbors": 396,
+     "worlds_reached": 31
+    },
+    {
+     "canonical_rank": 39,
+     "brand_id": 12711,
+     "name": "Liz Claiborne",
+     "betweenness": 0.004767265170812607,
+     "neighbors": 700,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 40,
+     "brand_id": 22652,
+     "name": "Tahari",
+     "betweenness": 0.0047632791101932526,
+     "neighbors": 652,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 41,
+     "brand_id": 20324,
+     "name": "Scholastic",
+     "betweenness": 0.004728560335934162,
+     "neighbors": 232,
+     "worlds_reached": 15
+    },
+    {
+     "canonical_rank": 42,
+     "brand_id": 24788,
+     "name": "Wilson",
+     "betweenness": 0.004576421808451414,
+     "neighbors": 44,
+     "worlds_reached": 4
+    },
+    {
+     "canonical_rank": 43,
+     "brand_id": 11171,
+     "name": "Joie",
+     "betweenness": 0.004506115801632404,
+     "neighbors": 555,
+     "worlds_reached": 29
+    },
+    {
+     "canonical_rank": 44,
+     "brand_id": 14204,
+     "name": "Melissa & Doug",
+     "betweenness": 0.004466860555112362,
+     "neighbors": 189,
+     "worlds_reached": 15
+    },
+    {
+     "canonical_rank": 45,
+     "brand_id": 9912,
+     "name": "Hallmark",
+     "betweenness": 0.004437887575477362,
+     "neighbors": 336,
+     "worlds_reached": 21
+    },
+    {
+     "canonical_rank": 46,
+     "brand_id": 832,
+     "name": "American Rag",
+     "betweenness": 0.004426386673003435,
+     "neighbors": 750,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 47,
+     "brand_id": 6120,
+     "name": "Dana Buchman",
+     "betweenness": 0.004418591503053904,
+     "neighbors": 643,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 48,
+     "brand_id": 11937,
+     "name": "Kirkland Signature",
+     "betweenness": 0.004407395608723164,
+     "neighbors": 296,
+     "worlds_reached": 28
+    },
+    {
+     "canonical_rank": 49,
+     "brand_id": 14116,
+     "name": "Motherhood Maternity",
+     "betweenness": 0.004376407712697983,
+     "neighbors": 187,
+     "worlds_reached": 21
+    },
+    {
+     "canonical_rank": 50,
+     "brand_id": 11955,
+     "name": "Kensie",
+     "betweenness": 0.004330622963607311,
+     "neighbors": 688,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 51,
+     "brand_id": 4713,
+     "name": "Children's Place",
+     "betweenness": 0.0042234500870108604,
+     "neighbors": 428,
+     "worlds_reached": 28
+    },
+    {
+     "canonical_rank": 52,
+     "brand_id": 17339,
+     "name": "prAna",
+     "betweenness": 0.004177915398031473,
+     "neighbors": 288,
+     "worlds_reached": 28
+    },
+    {
+     "canonical_rank": 53,
+     "brand_id": 4198,
+     "name": "Catherine Malandrino",
+     "betweenness": 0.004148845560848713,
+     "neighbors": 454,
+     "worlds_reached": 29
+    },
+    {
+     "canonical_rank": 54,
+     "brand_id": 4482,
+     "name": "Cotton On",
+     "betweenness": 0.00414684321731329,
+     "neighbors": 570,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 55,
+     "brand_id": 326,
+     "name": "Arizona Jean Company",
+     "betweenness": 0.004115242511034012,
+     "neighbors": 647,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 56,
+     "brand_id": 11239,
+     "name": "Jumping Beans",
+     "betweenness": 0.004106604959815741,
+     "neighbors": 329,
+     "worlds_reached": 27
+    },
+    {
+     "canonical_rank": 57,
+     "brand_id": 8452,
+     "name": "Franklin Mint",
+     "betweenness": 0.004053099080920219,
+     "neighbors": 157,
+     "worlds_reached": 9
+    },
+    {
+     "canonical_rank": 58,
+     "brand_id": 6029,
+     "name": "DC Comics",
+     "betweenness": 0.004019210580736399,
+     "neighbors": 201,
+     "worlds_reached": 14
+    },
+    {
+     "canonical_rank": 59,
+     "brand_id": 22387,
+     "name": "The Honest Company",
+     "betweenness": 0.004017870407551527,
+     "neighbors": 176,
+     "worlds_reached": 11
+    },
+    {
+     "canonical_rank": 60,
+     "brand_id": 14265,
+     "name": "Maybelline",
+     "betweenness": 0.004004945978522301,
+     "neighbors": 441,
+     "worlds_reached": 27
+    },
+    {
+     "canonical_rank": 61,
+     "brand_id": 13430,
+     "name": "Liz Lisa",
+     "betweenness": 0.004002392292022705,
+     "neighbors": 128,
+     "worlds_reached": 19
+    },
+    {
+     "canonical_rank": 62,
+     "brand_id": 24113,
+     "name": "Vera Wang",
+     "betweenness": 0.003989848308265209,
+     "neighbors": 532,
+     "worlds_reached": 29
+    },
+    {
+     "canonical_rank": 63,
+     "brand_id": 4768,
+     "name": "Cherokee",
+     "betweenness": 0.0039408570155501366,
+     "neighbors": 337,
+     "worlds_reached": 28
+    },
+    {
+     "canonical_rank": 64,
+     "brand_id": 2038,
+     "name": "Amuse",
+     "betweenness": 0.003934510983526707,
+     "neighbors": 124,
+     "worlds_reached": 7
+    },
+    {
+     "canonical_rank": 65,
+     "brand_id": 24653,
+     "name": "Wet n Wild",
+     "betweenness": 0.003931604791432619,
+     "neighbors": 332,
+     "worlds_reached": 23
+    },
+    {
+     "canonical_rank": 66,
+     "brand_id": 4010,
+     "name": "ColourPop Cosmetics",
+     "betweenness": 0.003927377983927727,
+     "neighbors": 404,
+     "worlds_reached": 22
+    },
+    {
+     "canonical_rank": 67,
+     "brand_id": 2816,
+     "name": "BCBGeneration",
+     "betweenness": 0.003917043097317219,
+     "neighbors": 738,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 68,
+     "brand_id": 11257,
+     "name": "Jessica Simpson",
+     "betweenness": 0.003916771151125431,
+     "neighbors": 622,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 69,
+     "brand_id": 23897,
+     "name": "Unique",
+     "betweenness": 0.0039026751182973385,
+     "neighbors": 257,
+     "worlds_reached": 21
+    },
+    {
+     "canonical_rank": 70,
+     "brand_id": 15377,
+     "name": "Modern Vintage",
+     "betweenness": 0.0038545734714716673,
+     "neighbors": 237,
+     "worlds_reached": 17
+    },
+    {
+     "canonical_rank": 71,
+     "brand_id": 12476,
+     "name": "Lush",
+     "betweenness": 0.0038323416374623775,
+     "neighbors": 466,
+     "worlds_reached": 29
+    },
+    {
+     "canonical_rank": 72,
+     "brand_id": 8140,
+     "name": "Fox Racing",
+     "betweenness": 0.00379868783056736,
+     "neighbors": 66,
+     "worlds_reached": 12
+    },
+    {
+     "canonical_rank": 73,
+     "brand_id": 24722,
+     "name": "Warner Brothers",
+     "betweenness": 0.0037963136564940214,
+     "neighbors": 193,
+     "worlds_reached": 10
+    },
+    {
+     "canonical_rank": 74,
+     "brand_id": 13731,
+     "name": "Mud Pie",
+     "betweenness": 0.00366424722597003,
+     "neighbors": 313,
+     "worlds_reached": 24
+    },
+    {
+     "canonical_rank": 75,
+     "brand_id": 23840,
+     "name": "Universal Studios",
+     "betweenness": 0.003620811505243182,
+     "neighbors": 257,
+     "worlds_reached": 15
+    },
+    {
+     "canonical_rank": 76,
+     "brand_id": 18907,
+     "name": "Reebok",
+     "betweenness": 0.0036161665339022875,
+     "neighbors": 291,
+     "worlds_reached": 25
+    },
+    {
+     "canonical_rank": 77,
+     "brand_id": 10424,
+     "name": "IT Cosmetics",
+     "betweenness": 0.0036144473124295473,
+     "neighbors": 444,
+     "worlds_reached": 24
+    },
+    {
+     "canonical_rank": 78,
+     "brand_id": 19022,
+     "name": "RCA",
+     "betweenness": 0.0035857195034623146,
+     "neighbors": 55,
+     "worlds_reached": 4
+    },
+    {
+     "canonical_rank": 79,
+     "brand_id": 16682,
+     "name": "Oscar de la Renta",
+     "betweenness": 0.0035653517115861177,
+     "neighbors": 289,
+     "worlds_reached": 25
+    },
+    {
+     "canonical_rank": 80,
+     "brand_id": 15981,
+     "name": "Nautica",
+     "betweenness": 0.0035572133492678404,
+     "neighbors": 507,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 81,
+     "brand_id": 2501,
+     "name": "Bebe",
+     "betweenness": 0.003547538770362735,
+     "neighbors": 643,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 82,
+     "brand_id": 7886,
+     "name": "Fruit of the Loom",
+     "betweenness": 0.0035456137266010046,
+     "neighbors": 329,
+     "worlds_reached": 26
+    },
+    {
+     "canonical_rank": 83,
+     "brand_id": 2815,
+     "name": "BCBGMAXAZRIA",
+     "betweenness": 0.0035393170546740294,
+     "neighbors": 657,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 84,
+     "brand_id": 11107,
+     "name": "Jada Toys",
+     "betweenness": 0.0035294396802783012,
+     "neighbors": 114,
+     "worlds_reached": 5
+    },
+    {
+     "canonical_rank": 85,
+     "brand_id": 9020,
+     "name": "Gymboree",
+     "betweenness": 0.003508244873955846,
+     "neighbors": 389,
+     "worlds_reached": 26
+    },
+    {
+     "canonical_rank": 86,
+     "brand_id": 25271,
+     "name": "Yankee Candle",
+     "betweenness": 0.00350396241992712,
+     "neighbors": 270,
+     "worlds_reached": 22
+    },
+    {
+     "canonical_rank": 87,
+     "brand_id": 2475,
+     "name": "Burt's Bees",
+     "betweenness": 0.003498140722513199,
+     "neighbors": 192,
+     "worlds_reached": 15
+    },
+    {
+     "canonical_rank": 88,
+     "brand_id": 23843,
+     "name": "Urban Outfitters",
+     "betweenness": 0.003478961531072855,
+     "neighbors": 387,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 89,
+     "brand_id": 8099,
+     "name": "Fossil",
+     "betweenness": 0.003466336289420724,
+     "neighbors": 346,
+     "worlds_reached": 28
+    },
+    {
+     "canonical_rank": 90,
+     "brand_id": 4294,
+     "name": "Charlotte Russe",
+     "betweenness": 0.0034528884571045637,
+     "neighbors": 694,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 91,
+     "brand_id": 11189,
+     "name": "Jones New York",
+     "betweenness": 0.0034512397833168507,
+     "neighbors": 724,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 92,
+     "brand_id": 13827,
+     "name": "Monet",
+     "betweenness": 0.003448875853791833,
+     "neighbors": 249,
+     "worlds_reached": 23
+    },
+    {
+     "canonical_rank": 93,
+     "brand_id": 7158,
+     "name": "Eddie Bauer",
+     "betweenness": 0.0034203261602669954,
+     "neighbors": 451,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 94,
+     "brand_id": 4356,
+     "name": "Crystal",
+     "betweenness": 0.003363103838637471,
+     "neighbors": 275,
+     "worlds_reached": 26
+    },
+    {
+     "canonical_rank": 95,
+     "brand_id": 14378,
+     "name": "Mudd",
+     "betweenness": 0.0033454231452196836,
+     "neighbors": 627,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 96,
+     "brand_id": 11227,
+     "name": "Jennifer Lopez",
+     "betweenness": 0.0033434403594583273,
+     "neighbors": 575,
+     "worlds_reached": 29
+    },
+    {
+     "canonical_rank": 97,
+     "brand_id": 18991,
+     "name": "Rachel Roy",
+     "betweenness": 0.003328827442601323,
+     "neighbors": 543,
+     "worlds_reached": 28
+    },
+    {
+     "canonical_rank": 98,
+     "brand_id": 19973,
+     "name": "Stampd",
+     "betweenness": 0.0033092217054218054,
+     "neighbors": 342,
+     "worlds_reached": 26
+    },
+    {
+     "canonical_rank": 99,
+     "brand_id": 745,
+     "name": "ASUS",
+     "betweenness": 0.0032871568109840155,
+     "neighbors": 45,
+     "worlds_reached": 3
+    },
+    {
+     "canonical_rank": 100,
+     "brand_id": 7296,
+     "name": "Elizabeth Arden",
+     "betweenness": 0.0032368884421885014,
+     "neighbors": 351,
+     "worlds_reached": 19
+    },
+    {
+     "canonical_rank": 101,
+     "brand_id": 4603,
+     "name": "Cuisinart",
+     "betweenness": 0.003236813470721245,
+     "neighbors": 64,
+     "worlds_reached": 5
+    },
+    {
+     "canonical_rank": 102,
+     "brand_id": 4424,
+     "name": "Champion",
+     "betweenness": 0.0032328686211258173,
+     "neighbors": 362,
+     "worlds_reached": 26
+    },
+    {
+     "canonical_rank": 103,
+     "brand_id": 12762,
+     "name": "Looney Tunes",
+     "betweenness": 0.0032200601417571306,
+     "neighbors": 164,
+     "worlds_reached": 18
+    },
+    {
+     "canonical_rank": 104,
+     "brand_id": 13854,
+     "name": "Maidenform",
+     "betweenness": 0.003200095845386386,
+     "neighbors": 549,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 105,
+     "brand_id": 765,
+     "name": "Anne Klein",
+     "betweenness": 0.0031967416871339083,
+     "neighbors": 592,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 106,
+     "brand_id": 3850,
+     "name": "BELLA + CANVAS",
+     "betweenness": 0.0031784113962203264,
+     "neighbors": 388,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 107,
+     "brand_id": 17931,
+     "name": "Pacifica",
+     "betweenness": 0.003169659525156021,
+     "neighbors": 379,
+     "worlds_reached": 20
+    },
+    {
+     "canonical_rank": 108,
+     "brand_id": 24759,
+     "name": "Wet Seal",
+     "betweenness": 0.003142333822324872,
+     "neighbors": 593,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 109,
+     "brand_id": 19023,
+     "name": "Rene Rofe",
+     "betweenness": 0.003130142344161868,
+     "neighbors": 247,
+     "worlds_reached": 21
+    },
+    {
+     "canonical_rank": 110,
+     "brand_id": 8824,
+     "name": "GUESS",
+     "betweenness": 0.003121702466160059,
+     "neighbors": 526,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 111,
+     "brand_id": 17512,
+     "name": "PartyLite",
+     "betweenness": 0.003083577612414956,
+     "neighbors": 239,
+     "worlds_reached": 16
+    },
+    {
+     "canonical_rank": 112,
+     "brand_id": 7307,
+     "name": "Estee Lauder",
+     "betweenness": 0.0030534095130860806,
+     "neighbors": 447,
+     "worlds_reached": 24
+    },
+    {
+     "canonical_rank": 113,
+     "brand_id": 19077,
+     "name": "Russell Athletic",
+     "betweenness": 0.0030388871673494577,
+     "neighbors": 139,
+     "worlds_reached": 16
+    },
+    {
+     "canonical_rank": 114,
+     "brand_id": 20330,
+     "name": "Sanctuary",
+     "betweenness": 0.003032094333320856,
+     "neighbors": 661,
+     "worlds_reached": 29
+    },
+    {
+     "canonical_rank": 115,
+     "brand_id": 8170,
+     "name": "FOREVER 21",
+     "betweenness": 0.0030278966296464205,
+     "neighbors": 490,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 116,
+     "brand_id": 686,
+     "name": "Avia",
+     "betweenness": 0.0030124271288514137,
+     "neighbors": 526,
+     "worlds_reached": 31
+    },
+    {
+     "canonical_rank": 117,
+     "brand_id": 4569,
+     "name": "Charter Club",
+     "betweenness": 0.0030032529029995203,
+     "neighbors": 616,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 118,
+     "brand_id": 5672,
+     "name": "Crown & Ivy",
+     "betweenness": 0.002959497971460223,
+     "neighbors": 539,
+     "worlds_reached": 30
+    },
+    {
+     "canonical_rank": 119,
+     "brand_id": 1997,
+     "name": "Applause",
+     "betweenness": 0.002959412056952715,
+     "neighbors": 205,
+     "worlds_reached": 8
+    },
+    {
+     "canonical_rank": 120,
+     "brand_id": 18415,
+     "name": "Pioneer Woman",
+     "betweenness": 0.0029539105016738176,
+     "neighbors": 318,
+     "worlds_reached": 28
+    }
+   ],
+   "canonical_run": {
+    "stages": [
+     {
+      "name": "probe",
+      "rows": 120,
+      "elapsed_s": 8.738067868631333,
+      "query_id": "82724a3d-655b-484c-9a0e-e2188bf79813",
+      "native_fragments": 15,
+      "host_boundaries": 0,
+      "allocator_peak_bytes": 58471525743,
+      "query_limit_bytes": 96636764160
+     },
+     {
+      "name": "context",
+      "rows": 120,
+      "elapsed_s": 0.6230580331757665,
+      "query_id": "488e06bb-9073-4692-b84f-2da80b7472ae",
+      "native_fragments": 1,
+      "host_boundaries": 0,
+      "allocator_peak_bytes": 11622161774,
+      "query_limit_bytes": 96636764160
+     },
+     {
+      "name": "recompute",
+      "rows": 120,
+      "elapsed_s": 8.806097234133631,
+      "query_id": "d0a38222-34af-4536-85ae-914d3686330a",
+      "native_fragments": 15,
+      "host_boundaries": 0,
+      "allocator_peak_bytes": 56985725519,
+      "query_limit_bytes": 96636764160
+     },
+     {
+      "name": "recompute_denylist",
+      "rows": 120,
+      "elapsed_s": 8.813148968853056,
+      "query_id": "3133b0c5-4757-41be-b192-c70cd8a621db",
+      "native_fragments": 15,
+      "host_boundaries": 0,
+      "allocator_peak_bytes": 57167449127,
+      "query_limit_bytes": 96636764160
+     },
+     {
+      "name": "context_pass2",
+      "rows": 120,
+      "elapsed_s": 0.6274258410558105,
+      "query_id": "59d5494d-ecc7-41e8-ae61-be524d57b42f",
+      "native_fragments": 1,
+      "host_boundaries": 0,
+      "allocator_peak_bytes": 11622161582,
+      "query_limit_bytes": 96636764160
+     },
+     {
+      "name": "recompute_pass2",
+      "rows": 120,
+      "elapsed_s": 8.801967766135931,
+      "query_id": "e6becc31-1771-4e0f-b581-c1d77ba49b0d",
+      "native_fragments": 15,
+      "host_boundaries": 0,
+      "allocator_peak_bytes": 55491218111,
+      "query_limit_bytes": 96636764160
+     },
+     {
+      "name": "recompute_canonical",
+      "rows": 120,
+      "elapsed_s": 8.884628142230213,
+      "query_id": "f259ced9-3f69-415f-8970-f31d6c880c40",
+      "native_fragments": 15,
+      "host_boundaries": 0,
+      "allocator_peak_bytes": 55366721767,
+      "query_limit_bytes": 96636764160
+     }
+    ],
+    "totals": {
+     "gpu_elapsed_s": 45.29439385421574,
+     "decide_wall_s": 0.001028573140501976,
+     "entities": 240,
+     "registry_hits": 240,
+     "api_calls": 0,
+     "input_tokens": 0,
+     "output_tokens": 0,
+     "cost_usd": 0.0,
+     "max_host_boundaries": 0
+    }
+   }
+  },
+  "sep_oct": {
+   "window": {
+    "start": "2023-09-01",
+    "end": "2023-11-01"
+   },
+   "stages": [
+    {
+     "name": "probe",
+     "rows": 120,
+     "elapsed_s": 4.115957702044398,
+     "query_id": "e6be659c-bbb5-4ab8-8b25-1e983cd3ffb4",
+     "native_fragments": 15,
+     "host_boundaries": 0,
+     "allocator_peak_bytes": 31725099196,
+     "query_limit_bytes": 96636764160
+    },
+    {
+     "name": "context",
+     "rows": 120,
+     "elapsed_s": 0.6457475828938186,
+     "query_id": "cab7692c-2865-4492-9098-bca0aa735ba8",
+     "native_fragments": 1,
+     "host_boundaries": 0,
+     "allocator_peak_bytes": 11622161830,
+     "query_limit_bytes": 96636764160
+    },
+    {
+     "name": "recompute",
+     "rows": 120,
+     "elapsed_s": 4.13087026309222,
+     "query_id": "fa3d1ec4-fe47-4223-96fe-f26df9b3e8e4",
+     "native_fragments": 15,
+     "host_boundaries": 0,
+     "allocator_peak_bytes": 31725102879,
+     "query_limit_bytes": 96636764160
+    },
+    {
+     "name": "recompute_denylist",
+     "rows": 120,
+     "elapsed_s": 4.144308797083795,
+     "query_id": "43e48042-a897-4ad9-85aa-b131cf455723",
+     "native_fragments": 15,
+     "host_boundaries": 0,
+     "allocator_peak_bytes": 31725103103,
+     "query_limit_bytes": 96636764160
+    },
+    {
+     "name": "context_pass2",
+     "rows": 120,
+     "elapsed_s": 0.6704731630161405,
+     "query_id": "bb4061ee-6894-432e-8ca8-f64dfa2f7e53",
+     "native_fragments": 1,
+     "host_boundaries": 0,
+     "allocator_peak_bytes": 11622161865,
+     "query_limit_bytes": 96636764160
+    },
+    {
+     "name": "recompute_pass2",
+     "rows": 120,
+     "elapsed_s": 4.127690306399018,
+     "query_id": "fb139411-f5d7-4851-a8e1-7d5b0dcac096",
+     "native_fragments": 15,
+     "host_boundaries": 0,
+     "allocator_peak_bytes": 31725105117,
+     "query_limit_bytes": 96636764160
+    },
+    {
+     "name": "recompute_canonical",
+     "rows": 120,
+     "elapsed_s": 4.221440759021789,
+     "query_id": "5ead553d-a7e9-4f1d-b752-083710711601",
+     "native_fragments": 15,
+     "host_boundaries": 0,
+     "allocator_peak_bytes": 31725106540,
+     "query_limit_bytes": 96636764160
+    }
+   ],
+   "decisions": [
+    {
+     "name": "decide",
+     "entities": 120,
+     "distinct_states": 120,
+     "registry_hits": 100,
+     "hit_rate": 0.8333333333333334,
+     "api_calls": 20,
+     "wall_s": 61.703797799069434,
+     "input_tokens": 21327,
+     "output_tokens": 1986,
+     "cost_usd": 0.0008957339999999999,
+     "latency_ms_p50": 896,
+     "latency_ms_p95": 927,
+     "latency_ms_max": 927
+    },
+    {
+     "name": "decide_pass2",
+     "entities": 120,
+     "distinct_states": 120,
+     "registry_hits": 86,
+     "hit_rate": 0.7166666666666667,
+     "api_calls": 34,
+     "wall_s": 61.91565170837566,
+     "input_tokens": 36107,
+     "output_tokens": 3374,
+     "cost_usd": 0.0015164939999999997,
+     "latency_ms_p50": 547,
+     "latency_ms_p95": 631,
+     "latency_ms_max": 652
+    }
+   ],
+   "totals": {
+    "gpu_elapsed_s": 22.056488573551178,
+    "decide_wall_s": 123.6194495074451,
+    "entities": 240,
+    "registry_hits": 186,
+    "api_calls": 54,
+    "input_tokens": 57434,
+    "output_tokens": 5360,
+    "cost_usd": 0.0024122279999999998,
+    "max_host_boundaries": 0
+   },
+   "passes": [
+    {
+     "pass": 1,
+     "new_entries": 120,
+     "new_band_counts": {
+      "accept": 63,
+      "review": 29,
+      "reject": 28
+     },
+     "registry_hits": 120,
+     "api_calls": 0
+    },
+    {
+     "pass": 2,
+     "new_entries": 59,
+     "new_band_counts": {
+      "accept": 41,
+      "review": 11,
+      "reject": 7
+     },
+     "registry_hits": 120,
+     "api_calls": 0
+    }
+   ],
+   "band_counts": {
+    "accept": 104,
+    "review": 40,
+    "reject": 35
+   },
+   "kind_counts": {
+    "generic_catchall_or_category": 19,
+    "multi_brand_retailer": 21,
+    "standalone_brand": 125,
+    "superstore_house_brand": 14
+   },
+   "ranking": [
+    {
+     "brand_id": 505,
+     "name": "Avon",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.54,
+     "original_rank": 3,
+     "original_betweenness": 0.0138278529047966,
+     "postfilter_rank": 1,
+     "purified_rank": 1,
+     "purified_betweenness": 0.03275798633694649,
+     "betweenness_multiplier": 2.3689857393249687,
+     "denylist_rank": 1
+    },
+    {
+     "brand_id": 18651,
+     "name": "Rue21",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.8,
+     "wormhole_pollution": 0.41,
+     "original_rank": 8,
+     "original_betweenness": 0.011296805925667286,
+     "postfilter_rank": 3,
+     "purified_rank": 2,
+     "purified_betweenness": 0.01793871447443962,
+     "betweenness_multiplier": 1.5879457071738627,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 8923,
+     "name": "Gerber",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.15,
+     "original_rank": 15,
+     "original_betweenness": 0.009809574112296104,
+     "postfilter_rank": 7,
+     "purified_rank": 3,
+     "purified_betweenness": 0.013874967582523823,
+     "betweenness_multiplier": 1.4144311897426647,
+     "denylist_rank": 3
+    },
+    {
+     "brand_id": 16002,
+     "name": "Nicole Miller",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.85,
+     "wormhole_pollution": 1.62,
+     "original_rank": 50,
+     "original_betweenness": 0.0059072584845125675,
+     "postfilter_rank": 18,
+     "purified_rank": 4,
+     "purified_betweenness": 0.01242967788130045,
+     "betweenness_multiplier": 2.104136447370319,
+     "denylist_rank": 9
+    },
+    {
+     "brand_id": 10627,
+     "name": "IZOD",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.09,
+     "original_rank": 6,
+     "original_betweenness": 0.011666354723274708,
+     "postfilter_rank": 2,
+     "purified_rank": 5,
+     "purified_betweenness": 0.011385406367480755,
+     "betweenness_multiplier": 0.9759180684577117,
+     "denylist_rank": 4
+    },
+    {
+     "brand_id": 18949,
+     "name": "Revlon",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.98,
+     "wormhole_pollution": 0.03,
+     "original_rank": 18,
+     "original_betweenness": 0.009191702120006084,
+     "postfilter_rank": 8,
+     "purified_rank": 6,
+     "purified_betweenness": 0.011279599741101265,
+     "betweenness_multiplier": 1.227150270302036,
+     "denylist_rank": 8
+    },
+    {
+     "brand_id": 12700,
+     "name": "L'Oreal",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.98,
+     "wormhole_pollution": 0.03,
+     "original_rank": 12,
+     "original_betweenness": 0.010098929516971111,
+     "postfilter_rank": 4,
+     "purified_rank": 7,
+     "purified_betweenness": 0.011203041300177574,
+     "betweenness_multiplier": 1.1093295860072119,
+     "denylist_rank": 5
+    },
+    {
+     "brand_id": 12711,
+     "name": "Liz Claiborne",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.16,
+     "original_rank": 60,
+     "original_betweenness": 0.005600044038146734,
+     "postfilter_rank": 27,
+     "purified_rank": 8,
+     "purified_betweenness": 0.01049390621483326,
+     "betweenness_multiplier": 1.873897087835418,
+     "denylist_rank": 17
+    },
+    {
+     "brand_id": 7265,
+     "name": "Ellen Tracy",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.34,
+     "original_rank": 29,
+     "original_betweenness": 0.0070944842882454395,
+     "postfilter_rank": 11,
+     "purified_rank": 9,
+     "purified_betweenness": 0.010138685815036297,
+     "betweenness_multiplier": 1.429094124830845,
+     "denylist_rank": 10
+    },
+    {
+     "brand_id": 802,
+     "name": "Apple",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.33,
+     "original_rank": 103,
+     "original_betweenness": 0.004314372316002846,
+     "postfilter_rank": 53,
+     "purified_rank": 10,
+     "purified_betweenness": 0.009761153720319271,
+     "betweenness_multiplier": 2.2624736590565573,
+     "denylist_rank": 74
+    },
+    {
+     "brand_id": 17190,
+     "name": "Philosophy",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 1.12,
+     "original_rank": 35,
+     "original_betweenness": 0.00634750397875905,
+     "postfilter_rank": 13,
+     "purified_rank": 11,
+     "purified_betweenness": 0.009113709442317486,
+     "betweenness_multiplier": 1.4357942071111918,
+     "denylist_rank": 15
+    },
+    {
+     "brand_id": 15997,
+     "name": "Nickelodeon",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.92,
+     "wormhole_pollution": 0.45,
+     "original_rank": 51,
+     "original_betweenness": 0.005895333364605904,
+     "postfilter_rank": 19,
+     "purified_rank": 12,
+     "purified_betweenness": 0.009045383892953396,
+     "betweenness_multiplier": 1.5343294998819919,
+     "denylist_rank": 25
+    },
+    {
+     "brand_id": 11257,
+     "name": "Jessica Simpson",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.4,
+     "original_rank": 38,
+     "original_betweenness": 0.006136373151093721,
+     "postfilter_rank": 14,
+     "purified_rank": 13,
+     "purified_betweenness": 0.0089852474629879,
+     "betweenness_multiplier": 1.4642602791172188,
+     "denylist_rank": 18
+    },
+    {
+     "brand_id": 14099,
+     "name": "Martha Stewart",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.93,
+     "wormhole_pollution": 0.38,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 14,
+     "purified_betweenness": 0.008859125897288322,
+     "betweenness_multiplier": null,
+     "denylist_rank": 30
+    },
+    {
+     "brand_id": 2501,
+     "name": "Bebe",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.93,
+     "wormhole_pollution": 0.09,
+     "original_rank": 54,
+     "original_betweenness": 0.0058161187916994095,
+     "postfilter_rank": 21,
+     "purified_rank": 15,
+     "purified_betweenness": 0.008846651762723923,
+     "betweenness_multiplier": 1.5210576123977384,
+     "denylist_rank": 22
+    },
+    {
+     "brand_id": 12843,
+     "name": "Laura Ashley",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.59,
+     "original_rank": 92,
+     "original_betweenness": 0.004509668331593275,
+     "postfilter_rank": 45,
+     "purified_rank": 16,
+     "purified_betweenness": 0.00876963883638382,
+     "betweenness_multiplier": 1.944630556297582,
+     "denylist_rank": 26
+    },
+    {
+     "brand_id": 6812,
+     "name": "Dolls Kill",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.24,
+     "original_rank": 77,
+     "original_betweenness": 0.005044217687100172,
+     "postfilter_rank": 32,
+     "purified_rank": 17,
+     "purified_betweenness": 0.008762601763010025,
+     "betweenness_multiplier": 1.7371577331840893,
+     "denylist_rank": 20
+    },
+    {
+     "brand_id": 4184,
+     "name": "Charming Charlie",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.92,
+     "wormhole_pollution": 0.57,
+     "original_rank": 31,
+     "original_betweenness": 0.00686437776312232,
+     "postfilter_rank": 12,
+     "purified_rank": 18,
+     "purified_betweenness": 0.00866455677896738,
+     "betweenness_multiplier": 1.2622494096283876,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 24792,
+     "name": "Warner Bros.",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.77,
+     "original_rank": 49,
+     "original_betweenness": 0.005910523235797882,
+     "postfilter_rank": 17,
+     "purified_rank": 19,
+     "purified_betweenness": 0.008508638478815556,
+     "betweenness_multiplier": 1.4395744910166053,
+     "denylist_rank": 23
+    },
+    {
+     "brand_id": 20430,
+     "name": "Samsung",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.98,
+     "wormhole_pollution": 0.03,
+     "original_rank": 22,
+     "original_betweenness": 0.008162290789186954,
+     "postfilter_rank": 9,
+     "purified_rank": 20,
+     "purified_betweenness": 0.008447283878922462,
+     "betweenness_multiplier": 1.0349158216848944,
+     "denylist_rank": 13
+    },
+    {
+     "brand_id": 14412,
+     "name": "Michael Kors",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.16,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 21,
+     "purified_betweenness": 0.007974091917276382,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 21725,
+     "name": "Sigma",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.84,
+     "wormhole_pollution": 1.28,
+     "original_rank": 57,
+     "original_betweenness": 0.005624058190733194,
+     "postfilter_rank": 24,
+     "purified_rank": 22,
+     "purified_betweenness": 0.007965398021042347,
+     "betweenness_multiplier": 1.4163078956343298,
+     "denylist_rank": 27
+    },
+    {
+     "brand_id": 11955,
+     "name": "Kensie",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.86,
+     "wormhole_pollution": 0.43,
+     "original_rank": 98,
+     "original_betweenness": 0.00437880540266633,
+     "postfilter_rank": 50,
+     "purified_rank": 23,
+     "purified_betweenness": 0.007769405376166105,
+     "betweenness_multiplier": 1.7743207705542658,
+     "denylist_rank": 40
+    },
+    {
+     "brand_id": 20324,
+     "name": "Scholastic",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.11,
+     "original_rank": 41,
+     "original_betweenness": 0.006046504247933626,
+     "postfilter_rank": 15,
+     "purified_rank": 24,
+     "purified_betweenness": 0.007631691172719002,
+     "betweenness_multiplier": 1.2621658498506982,
+     "denylist_rank": 24
+    },
+    {
+     "brand_id": 4294,
+     "name": "Charlotte Russe",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.78,
+     "wormhole_pollution": 0.48,
+     "original_rank": 87,
+     "original_betweenness": 0.004675493575632572,
+     "postfilter_rank": 40,
+     "purified_rank": 25,
+     "purified_betweenness": 0.007595646195113659,
+     "betweenness_multiplier": 1.6245656361715788,
+     "denylist_rank": 35
+    },
+    {
+     "brand_id": 13459,
+     "name": "Leatherman",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.88,
+     "wormhole_pollution": 1.48,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 26,
+     "purified_betweenness": 0.007536990102380514,
+     "betweenness_multiplier": null,
+     "denylist_rank": 45
+    },
+    {
+     "brand_id": 9912,
+     "name": "Hallmark",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.29,
+     "original_rank": 116,
+     "original_betweenness": 0.004076437093317509,
+     "postfilter_rank": 61,
+     "purified_rank": 27,
+     "purified_betweenness": 0.007489392999559641,
+     "betweenness_multiplier": 1.8372399298978466,
+     "denylist_rank": 46
+    },
+    {
+     "brand_id": 1997,
+     "name": "Applause",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.88,
+     "wormhole_pollution": 0.13,
+     "original_rank": 78,
+     "original_betweenness": 0.005014021880924702,
+     "postfilter_rank": 33,
+     "purified_rank": 28,
+     "purified_betweenness": 0.007262432482093573,
+     "betweenness_multiplier": 1.4484245690515838,
+     "denylist_rank": 37
+    },
+    {
+     "brand_id": 14309,
+     "name": "Marvel",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.17,
+     "original_rank": 94,
+     "original_betweenness": 0.004496631678193808,
+     "postfilter_rank": 47,
+     "purified_rank": 29,
+     "purified_betweenness": 0.007207892835140228,
+     "betweenness_multiplier": 1.602953799861916,
+     "denylist_rank": 38
+    },
+    {
+     "brand_id": 326,
+     "name": "Arizona Jean Company",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.72,
+     "wormhole_pollution": 0.29,
+     "original_rank": 118,
+     "original_betweenness": 0.004038454033434391,
+     "postfilter_rank": 62,
+     "purified_rank": 30,
+     "purified_betweenness": 0.007109828758984804,
+     "betweenness_multiplier": 1.7605322977858555,
+     "denylist_rank": 39
+    },
+    {
+     "brand_id": 9686,
+     "name": "Hanes",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.23,
+     "original_rank": 28,
+     "original_betweenness": 0.007107752840965986,
+     "postfilter_rank": 10,
+     "purified_rank": 31,
+     "purified_betweenness": 0.006896822713315487,
+     "betweenness_multiplier": 0.9703239360779696,
+     "denylist_rank": 14
+    },
+    {
+     "brand_id": 4603,
+     "name": "Cuisinart",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.04,
+     "original_rank": 84,
+     "original_betweenness": 0.0047713108360767365,
+     "postfilter_rank": 38,
+     "purified_rank": 32,
+     "purified_betweenness": 0.006814086344093084,
+     "betweenness_multiplier": 1.4281371677926653,
+     "denylist_rank": 54
+    },
+    {
+     "brand_id": 276,
+     "name": "Aéropostale",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.14,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 33,
+     "purified_betweenness": 0.006802919786423445,
+     "betweenness_multiplier": null,
+     "denylist_rank": 34
+    },
+    {
+     "brand_id": 2571,
+     "name": "Black & Decker",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 1.12,
+     "original_rank": 13,
+     "original_betweenness": 0.01009109802544117,
+     "postfilter_rank": 5,
+     "purified_rank": 34,
+     "purified_betweenness": 0.006641065701842308,
+     "betweenness_multiplier": 0.6581113061333055,
+     "denylist_rank": 21
+    },
+    {
+     "brand_id": 22826,
+     "name": "The Children's Place",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.9,
+     "wormhole_pollution": 0.17,
+     "original_rank": 79,
+     "original_betweenness": 0.004970733541995287,
+     "postfilter_rank": 34,
+     "purified_rank": 35,
+     "purified_betweenness": 0.006584429182112217,
+     "betweenness_multiplier": 1.324639336726382,
+     "denylist_rank": 42
+    },
+    {
+     "brand_id": 13610,
+     "name": "Loot Crate",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.93,
+     "wormhole_pollution": 0.65,
+     "original_rank": 55,
+     "original_betweenness": 0.005653765518218279,
+     "postfilter_rank": 22,
+     "purified_rank": 36,
+     "purified_betweenness": 0.00654225517064333,
+     "betweenness_multiplier": 1.157150070968109,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 18995,
+     "name": "Roxy",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.12,
+     "original_rank": 59,
+     "original_betweenness": 0.00560051528736949,
+     "postfilter_rank": 26,
+     "purified_rank": 37,
+     "purified_betweenness": 0.0064807129092514515,
+     "betweenness_multiplier": 1.157163685253573,
+     "denylist_rank": 41
+    },
+    {
+     "brand_id": 24759,
+     "name": "Wet Seal",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.88,
+     "wormhole_pollution": 0.35,
+     "original_rank": 70,
+     "original_betweenness": 0.005299730692058802,
+     "postfilter_rank": 30,
+     "purified_rank": 38,
+     "purified_betweenness": 0.006415109615772963,
+     "betweenness_multiplier": 1.2104595475738913,
+     "denylist_rank": 49
+    },
+    {
+     "brand_id": 4348,
+     "name": "CoverGirl",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.02,
+     "original_rank": 58,
+     "original_betweenness": 0.0056154741905629635,
+     "postfilter_rank": 25,
+     "purified_rank": 39,
+     "purified_betweenness": 0.0063925329595804214,
+     "betweenness_multiplier": 1.138378121356757,
+     "denylist_rank": 36
+    },
+    {
+     "brand_id": 7886,
+     "name": "Fruit of the Loom",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.26,
+     "original_rank": 52,
+     "original_betweenness": 0.005866439081728458,
+     "postfilter_rank": 20,
+     "purified_rank": 40,
+     "purified_betweenness": 0.006274478975683451,
+     "betweenness_multiplier": 1.0695549528888604,
+     "denylist_rank": 31
+    },
+    {
+     "brand_id": 2854,
+     "name": "Bella",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.78,
+     "wormhole_pollution": 1.76,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 41,
+     "purified_betweenness": 0.006261948496103287,
+     "betweenness_multiplier": null,
+     "denylist_rank": 70
+    },
+    {
+     "brand_id": 22652,
+     "name": "Tahari",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.86,
+     "wormhole_pollution": 1.46,
+     "original_rank": 56,
+     "original_betweenness": 0.005631535779684782,
+     "postfilter_rank": 23,
+     "purified_rank": 42,
+     "purified_betweenness": 0.006203548517078161,
+     "betweenness_multiplier": 1.101573133825565,
+     "denylist_rank": 33
+    },
+    {
+     "brand_id": 19884,
+     "name": "Sanrio",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.06,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 43,
+     "purified_betweenness": 0.0060984170995652676,
+     "betweenness_multiplier": null,
+     "denylist_rank": 50
+    },
+    {
+     "brand_id": 13581,
+     "name": "L.A. COLORS",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.92,
+     "wormhole_pollution": 0.04,
+     "original_rank": 109,
+     "original_betweenness": 0.004187622107565403,
+     "postfilter_rank": 58,
+     "purified_rank": 44,
+     "purified_betweenness": 0.006077515427023172,
+     "betweenness_multiplier": 1.451304647581134,
+     "denylist_rank": 59
+    },
+    {
+     "brand_id": 14019,
+     "name": "Maurices",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.8,
+     "wormhole_pollution": 0.3,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 45,
+     "purified_betweenness": 0.006045417860150337,
+     "betweenness_multiplier": null,
+     "denylist_rank": 58
+    },
+    {
+     "brand_id": 22105,
+     "name": "SHEIN",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.75,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 46,
+     "purified_betweenness": 0.006023026071488857,
+     "betweenness_multiplier": null,
+     "denylist_rank": 55
+    },
+    {
+     "brand_id": 11129,
+     "name": "Justice",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.88,
+     "wormhole_pollution": 0.07,
+     "original_rank": 106,
+     "original_betweenness": 0.004293596372008324,
+     "postfilter_rank": 55,
+     "purified_rank": 47,
+     "purified_betweenness": 0.005919107235968113,
+     "betweenness_multiplier": 1.3785895839108553,
+     "denylist_rank": 48
+    },
+    {
+     "brand_id": 4308,
+     "name": "Coca-Cola",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.6,
+     "original_rank": 64,
+     "original_betweenness": 0.005427930969744921,
+     "postfilter_rank": 28,
+     "purified_rank": 48,
+     "purified_betweenness": 0.005844173952937126,
+     "betweenness_multiplier": 1.0766853862940278,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 8099,
+     "name": "Fossil",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.96,
+     "original_rank": 46,
+     "original_betweenness": 0.00596085237339139,
+     "postfilter_rank": 16,
+     "purified_rank": 49,
+     "purified_betweenness": 0.005769551731646061,
+     "betweenness_multiplier": 0.9679071666664193,
+     "denylist_rank": 47
+    },
+    {
+     "brand_id": 21833,
+     "name": "Sterling",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 50,
+     "purified_betweenness": 0.005721018649637699,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 2011,
+     "name": "American Crafts",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.86,
+     "wormhole_pollution": 0.28,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 51,
+     "purified_betweenness": 0.0056314775720238686,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 13583,
+     "name": "Lefton",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.12,
+     "original_rank": 68,
+     "original_betweenness": 0.0053245434537529945,
+     "postfilter_rank": 29,
+     "purified_rank": 52,
+     "purified_betweenness": 0.005609051790088415,
+     "betweenness_multiplier": 1.0534333767404762,
+     "denylist_rank": 51
+    },
+    {
+     "brand_id": 9705,
+     "name": "HP",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.06,
+     "original_rank": 14,
+     "original_betweenness": 0.009949100203812122,
+     "postfilter_rank": 6,
+     "purified_rank": 53,
+     "purified_betweenness": 0.005602309014648199,
+     "betweenness_multiplier": 0.5630970539930439,
+     "denylist_rank": 7
+    },
+    {
+     "brand_id": 18415,
+     "name": "Pioneer Woman",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.25,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 54,
+     "purified_betweenness": 0.005548026878386736,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 6054,
+     "name": "DKNY",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.28,
+     "original_rank": 104,
+     "original_betweenness": 0.004307682625949383,
+     "postfilter_rank": 54,
+     "purified_rank": 55,
+     "purified_betweenness": 0.005532849580049515,
+     "betweenness_multiplier": 1.284414396436672,
+     "denylist_rank": 67
+    },
+    {
+     "brand_id": 2815,
+     "name": "BCBGMAXAZRIA",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.04,
+     "original_rank": 96,
+     "original_betweenness": 0.004482782445847988,
+     "postfilter_rank": 49,
+     "purified_rank": 56,
+     "purified_betweenness": 0.00550633342936635,
+     "betweenness_multiplier": 1.228329390480769,
+     "denylist_rank": 71
+    },
+    {
+     "brand_id": 4713,
+     "name": "Children's Place",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.85,
+     "wormhole_pollution": 0.11,
+     "original_rank": 119,
+     "original_betweenness": 0.004035549703985453,
+     "postfilter_rank": 63,
+     "purified_rank": 57,
+     "purified_betweenness": 0.0055062053725123405,
+     "betweenness_multiplier": 1.364425115883095,
+     "denylist_rank": 61
+    },
+    {
+     "brand_id": 20330,
+     "name": "Sanctuary",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.86,
+     "wormhole_pollution": 0.17,
+     "original_rank": 91,
+     "original_betweenness": 0.004543687682598829,
+     "postfilter_rank": 44,
+     "purified_rank": 58,
+     "purified_betweenness": 0.00545178446918726,
+     "betweenness_multiplier": 1.1998589801993238,
+     "denylist_rank": 79
+    },
+    {
+     "brand_id": 24775,
+     "name": "Wrangler",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.08,
+     "original_rank": 95,
+     "original_betweenness": 0.0044876146130263805,
+     "postfilter_rank": 48,
+     "purified_rank": 59,
+     "purified_betweenness": 0.005451195873320103,
+     "betweenness_multiplier": 1.2147201449733886,
+     "denylist_rank": 77
+    },
+    {
+     "brand_id": 17339,
+     "name": "prAna",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.08,
+     "original_rank": 73,
+     "original_betweenness": 0.005252694245427847,
+     "postfilter_rank": 31,
+     "purified_rank": 60,
+     "purified_betweenness": 0.005418690852820873,
+     "betweenness_multiplier": 1.0316021834961204,
+     "denylist_rank": 56
+    },
+    {
+     "brand_id": 7701,
+     "name": "Ertl",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.92,
+     "wormhole_pollution": 0.04,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 61,
+     "purified_betweenness": 0.005402407608926296,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 765,
+     "name": "Anne Klein",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.17,
+     "original_rank": 93,
+     "original_betweenness": 0.004502918105572462,
+     "postfilter_rank": 46,
+     "purified_rank": 62,
+     "purified_betweenness": 0.005335694644600153,
+     "betweenness_multiplier": 1.1849415244743429,
+     "denylist_rank": 65
+    },
+    {
+     "brand_id": 8094,
+     "name": "Fisher-Price",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.04,
+     "original_rank": 88,
+     "original_betweenness": 0.00463930144906044,
+     "postfilter_rank": 41,
+     "purified_rank": 63,
+     "purified_betweenness": 0.0052636852487921715,
+     "betweenness_multiplier": 1.1345857359319005,
+     "denylist_rank": 72
+    },
+    {
+     "brand_id": 178,
+     "name": "Anastasia Beverly Hills",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.03,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 64,
+     "purified_betweenness": 0.005137297324836254,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 11189,
+     "name": "Jones New York",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.88,
+     "wormhole_pollution": 0.08,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 65,
+     "purified_betweenness": 0.005113584455102682,
+     "betweenness_multiplier": null,
+     "denylist_rank": 116
+    },
+    {
+     "brand_id": 8170,
+     "name": "FOREVER 21",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.42,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 66,
+     "purified_betweenness": 0.005061187781393528,
+     "betweenness_multiplier": null,
+     "denylist_rank": 86
+    },
+    {
+     "brand_id": 14116,
+     "name": "Motherhood Maternity",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.85,
+     "wormhole_pollution": 0.1,
+     "original_rank": 85,
+     "original_betweenness": 0.004752139560878277,
+     "postfilter_rank": 39,
+     "purified_rank": 67,
+     "purified_betweenness": 0.005049698520451784,
+     "betweenness_multiplier": 1.0626157872178554,
+     "denylist_rank": 81
+    },
+    {
+     "brand_id": 24113,
+     "name": "Vera Wang",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.93,
+     "wormhole_pollution": 0.44,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 68,
+     "purified_betweenness": 0.005049378611147404,
+     "betweenness_multiplier": null,
+     "denylist_rank": 90
+    },
+    {
+     "brand_id": 5380,
+     "name": "Care Bears",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.14,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 69,
+     "purified_betweenness": 0.00501159206032753,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 7185,
+     "name": "Enesco",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.89,
+     "wormhole_pollution": 0.23,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 70,
+     "purified_betweenness": 0.004998777061700821,
+     "betweenness_multiplier": null,
+     "denylist_rank": 97
+    },
+    {
+     "brand_id": 11239,
+     "name": "Jumping Beans",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.85,
+     "wormhole_pollution": 0.16,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 71,
+     "purified_betweenness": 0.004987758584320545,
+     "betweenness_multiplier": null,
+     "denylist_rank": 92
+    },
+    {
+     "brand_id": 2677,
+     "name": "Bic",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.44,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 72,
+     "purified_betweenness": 0.004987198859453201,
+     "betweenness_multiplier": null,
+     "denylist_rank": 100
+    },
+    {
+     "brand_id": 7307,
+     "name": "Estee Lauder",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.25,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 73,
+     "purified_betweenness": 0.004924450069665909,
+     "betweenness_multiplier": null,
+     "denylist_rank": 89
+    },
+    {
+     "brand_id": 20701,
+     "name": "Speechless",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.76,
+     "wormhole_pollution": 0.45,
+     "original_rank": 101,
+     "original_betweenness": 0.004322684369981289,
+     "postfilter_rank": 51,
+     "purified_rank": 74,
+     "purified_betweenness": 0.004873282741755247,
+     "betweenness_multiplier": 1.1273741787851934,
+     "denylist_rank": 85
+    },
+    {
+     "brand_id": 4010,
+     "name": "ColourPop Cosmetics",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.04,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 75,
+     "purified_betweenness": 0.004857533611357212,
+     "betweenness_multiplier": null,
+     "denylist_rank": 115
+    },
+    {
+     "brand_id": 18991,
+     "name": "Rachel Roy",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.9,
+     "wormhole_pollution": 1.05,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 76,
+     "purified_betweenness": 0.004853953141719103,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 6029,
+     "name": "DC Comics",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.04,
+     "original_rank": 82,
+     "original_betweenness": 0.0049326480366289616,
+     "postfilter_rank": 36,
+     "purified_rank": 77,
+     "purified_betweenness": 0.004847247153520584,
+     "betweenness_multiplier": 0.9826866051511874,
+     "denylist_rank": 69
+    },
+    {
+     "brand_id": 14378,
+     "name": "Mudd",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.81,
+     "wormhole_pollution": 0.21,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 78,
+     "purified_betweenness": 0.00481080450117588,
+     "betweenness_multiplier": null,
+     "denylist_rank": 110
+    },
+    {
+     "brand_id": 15536,
+     "name": "Makeup Revolution",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.04,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 79,
+     "purified_betweenness": 0.00480069313198328,
+     "betweenness_multiplier": null,
+     "denylist_rank": 109
+    },
+    {
+     "brand_id": 24788,
+     "name": "Wilson",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.89,
+     "wormhole_pollution": 1.08,
+     "original_rank": 90,
+     "original_betweenness": 0.0045807319693267345,
+     "postfilter_rank": 43,
+     "purified_rank": 80,
+     "purified_betweenness": 0.004749592859297991,
+     "betweenness_multiplier": 1.0368632985081803,
+     "denylist_rank": 78
+    },
+    {
+     "brand_id": 22722,
+     "name": "The Limited",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.72,
+     "wormhole_pollution": 0.45,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 81,
+     "purified_betweenness": 0.004739970434457064,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 6120,
+     "name": "Dana Buchman",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.13,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 82,
+     "purified_betweenness": 0.004726709797978401,
+     "betweenness_multiplier": null,
+     "denylist_rank": 102
+    },
+    {
+     "brand_id": 2475,
+     "name": "Burt's Bees",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.98,
+     "wormhole_pollution": 0.11,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 83,
+     "purified_betweenness": 0.004691611509770155,
+     "betweenness_multiplier": null,
+     "denylist_rank": 95
+    },
+    {
+     "brand_id": 15835,
+     "name": "Nine West",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.94,
+     "wormhole_pollution": 0.1,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 84,
+     "purified_betweenness": 0.004689130932092667,
+     "betweenness_multiplier": null,
+     "denylist_rank": 118
+    },
+    {
+     "brand_id": 766,
+     "name": "Anchor Hocking",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.08,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 85,
+     "purified_betweenness": 0.0046719773672521114,
+     "betweenness_multiplier": null,
+     "denylist_rank": 113
+    },
+    {
+     "brand_id": 23840,
+     "name": "Universal Studios",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.89,
+     "wormhole_pollution": 0.09,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 86,
+     "purified_betweenness": 0.0046639335341751575,
+     "betweenness_multiplier": null,
+     "denylist_rank": 111
+    },
+    {
+     "brand_id": 18876,
+     "name": "Romeo & Juliet Couture",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.84,
+     "wormhole_pollution": 0.1,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 87,
+     "purified_betweenness": 0.004658468067646027,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 15965,
+     "name": "Nobo",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 88,
+     "purified_betweenness": 0.004654811695218086,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 18939,
+     "name": "Realtree",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.92,
+     "wormhole_pollution": 0.19,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 89,
+     "purified_betweenness": 0.004607371520251036,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4365,
+     "name": "Clinique",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.98,
+     "wormhole_pollution": 0.02,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 90,
+     "purified_betweenness": 0.00457417918369174,
+     "betweenness_multiplier": null,
+     "denylist_rank": 107
+    },
+    {
+     "brand_id": 8140,
+     "name": "Fox Racing",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.5,
+     "original_rank": 83,
+     "original_betweenness": 0.004914849065244198,
+     "postfilter_rank": 37,
+     "purified_rank": 91,
+     "purified_betweenness": 0.004554302431643009,
+     "betweenness_multiplier": 0.9266413619594491,
+     "denylist_rank": 64
+    },
+    {
+     "brand_id": 8452,
+     "name": "Franklin Mint",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.92,
+     "wormhole_pollution": 0.33,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 92,
+     "purified_betweenness": 0.004541479516774416,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 23843,
+     "name": "Urban Outfitters",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.71,
+     "wormhole_pollution": 0.56,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 93,
+     "purified_betweenness": 0.004522484727203846,
+     "betweenness_multiplier": null,
+     "denylist_rank": 108
+    },
+    {
+     "brand_id": 22614,
+     "name": "Tarte",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.03,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 94,
+     "purified_betweenness": 0.004458030220121145,
+     "betweenness_multiplier": null,
+     "denylist_rank": 114
+    },
+    {
+     "brand_id": 13731,
+     "name": "Mud Pie",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.93,
+     "wormhole_pollution": 0.21,
+     "original_rank": 107,
+     "original_betweenness": 0.00427060155197978,
+     "postfilter_rank": 56,
+     "purified_rank": 95,
+     "purified_betweenness": 0.00445273332297802,
+     "betweenness_multiplier": 1.0426478023719647,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 8378,
+     "name": "Fate",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 96,
+     "purified_betweenness": 0.0044439975172281265,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4531,
+     "name": "Coldwater Creek",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 97,
+     "purified_betweenness": 0.004426515195518732,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4577,
+     "name": "Candie's",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 98,
+     "purified_betweenness": 0.004426172003149986,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 24188,
+     "name": "Vince Camuto",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.29,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 99,
+     "purified_betweenness": 0.004393666982650757,
+     "betweenness_multiplier": null,
+     "denylist_rank": 117
+    },
+    {
+     "brand_id": 15260,
+     "name": "Marshalls",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 100,
+     "purified_betweenness": 0.004392880015075207,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 2840,
+     "name": "Betsey Johnson",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.95,
+     "wormhole_pollution": 0.32,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 101,
+     "purified_betweenness": 0.004380315542221069,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 12657,
+     "name": "Lancôme",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.98,
+     "wormhole_pollution": 0.04,
+     "original_rank": 111,
+     "original_betweenness": 0.0041642095893621445,
+     "postfilter_rank": 59,
+     "purified_rank": 102,
+     "purified_betweenness": 0.004328989423811436,
+     "betweenness_multiplier": 1.039570494931436,
+     "denylist_rank": 105
+    },
+    {
+     "brand_id": 841,
+     "name": "Anthropologie",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.86,
+     "wormhole_pollution": 0.43,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 103,
+     "purified_betweenness": 0.0043227700516581535,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 8910,
+     "name": "Gibson",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.75,
+     "wormhole_pollution": 1.16,
+     "original_rank": 80,
+     "original_betweenness": 0.004966886714100838,
+     "postfilter_rank": 35,
+     "purified_rank": 104,
+     "purified_betweenness": 0.004299841821193695,
+     "betweenness_multiplier": 0.8657016092166099,
+     "denylist_rank": 93
+    },
+    {
+     "brand_id": 20464,
+     "name": "Sears",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 105,
+     "purified_betweenness": 0.004288662225008011,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 7904,
+     "name": "Francesca's Collections",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 106,
+     "purified_betweenness": 0.00427758926525712,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 686,
+     "name": "Avia",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 107,
+     "purified_betweenness": 0.004270473029464483,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4703,
+     "name": "Cynthia Rowley",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 108,
+     "purified_betweenness": 0.004235957749187946,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 2742,
+     "name": "Billabong",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.93,
+     "wormhole_pollution": 0.32,
+     "original_rank": 108,
+     "original_betweenness": 0.004239210393279791,
+     "postfilter_rank": 57,
+     "purified_rank": 109,
+     "purified_betweenness": 0.004211400169879198,
+     "betweenness_multiplier": 0.9934397633472783,
+     "denylist_rank": 101
+    },
+    {
+     "brand_id": 16682,
+     "name": "Oscar de la Renta",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 110,
+     "purified_betweenness": 0.004177543334662914,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 2765,
+     "name": "Bulova",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.97,
+     "wormhole_pollution": 0.02,
+     "original_rank": 102,
+     "original_betweenness": 0.004319451749324799,
+     "postfilter_rank": 52,
+     "purified_rank": 111,
+     "purified_betweenness": 0.004165382590144873,
+     "betweenness_multiplier": 0.9643313160740806,
+     "denylist_rank": 82
+    },
+    {
+     "brand_id": 24715,
+     "name": "Wilsons Leather",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.89,
+     "wormhole_pollution": 1.27,
+     "original_rank": 113,
+     "original_betweenness": 0.004123270977288485,
+     "postfilter_rank": 60,
+     "purified_rank": 112,
+     "purified_betweenness": 0.004127552732825279,
+     "betweenness_multiplier": 1.0010384366102494,
+     "denylist_rank": 119
+    },
+    {
+     "brand_id": 14263,
+     "name": "Max Studio",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 113,
+     "purified_betweenness": 0.004110105335712433,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 745,
+     "name": "ASUS",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.96,
+     "wormhole_pollution": 0.18,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 114,
+     "purified_betweenness": 0.0040912386029958725,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4482,
+     "name": "Cotton On",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 115,
+     "purified_betweenness": 0.004082113038748503,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 24947,
+     "name": "Witchery",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 116,
+     "purified_betweenness": 0.0040526725351810455,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 9020,
+     "name": "Gymboree",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 117,
+     "purified_betweenness": 0.004051532130688429,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 8851,
+     "name": "Gap",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 118,
+     "purified_betweenness": 0.004023869056254625,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 5904,
+     "name": "Dress Barn",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 119,
+     "purified_betweenness": 0.0040190620347857475,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 862,
+     "name": "American Greetings",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.9,
+     "wormhole_pollution": 0.67,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": 120,
+     "purified_betweenness": 0.004016443155705929,
+     "betweenness_multiplier": null,
+     "denylist_rank": 106
+    },
+    {
+     "brand_id": 15548,
+     "name": "Mainstays",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.07,
+     "wormhole_pollution": 1.94,
+     "original_rank": 1,
+     "original_betweenness": 0.02021096646785736,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 15946,
+     "name": "No Boundaries",
+     "band": "review",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.39,
+     "wormhole_pollution": 1.54,
+     "original_rank": 2,
+     "original_betweenness": 0.013950924389064312,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 12799,
+     "name": "Lot",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.08,
+     "wormhole_pollution": 2.73,
+     "original_rank": 4,
+     "original_betweenness": 0.012170751579105854,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 23745,
+     "name": "Ulta",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.18,
+     "wormhole_pollution": 0.61,
+     "original_rank": 5,
+     "original_betweenness": 0.012066229246556759,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 786,
+     "name": "As Seen on TV",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.2,
+     "wormhole_pollution": 2.84,
+     "original_rank": 7,
+     "original_betweenness": 0.011413105763494968,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 13763,
+     "name": "Macy's",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.04,
+     "wormhole_pollution": 1.78,
+     "original_rank": 9,
+     "original_betweenness": 0.011281280778348446,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 7106,
+     "name": "Eyeshadow",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.07,
+     "wormhole_pollution": 2.93,
+     "original_rank": 10,
+     "original_betweenness": 0.011007234454154968,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4044,
+     "name": "Claire's",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.89,
+     "wormhole_pollution": 0.72,
+     "original_rank": 11,
+     "original_betweenness": 0.010544936172664165,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 10525,
+     "name": "Independent",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.3,
+     "wormhole_pollution": 2.25,
+     "original_rank": 16,
+     "original_betweenness": 0.009651679545640945,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 10314,
+     "name": "Hobby Lobby",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.24,
+     "wormhole_pollution": 0.58,
+     "original_rank": 17,
+     "original_betweenness": 0.009240037761628628,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4814,
+     "name": "Cabela's",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 0.78,
+     "original_rank": 19,
+     "original_betweenness": 0.009022349491715431,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 563,
+     "name": "Amazon",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.12,
+     "wormhole_pollution": 2.81,
+     "original_rank": 20,
+     "original_betweenness": 0.008742253296077251,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 2
+    },
+    {
+     "brand_id": 23372,
+     "name": "The Unbranded Brand",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.13,
+     "wormhole_pollution": 2.85,
+     "original_rank": 21,
+     "original_betweenness": 0.008408254943788052,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 15827,
+     "name": "New Directions",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.49,
+     "wormhole_pollution": 0.7,
+     "original_rank": 23,
+     "original_betweenness": 0.00784143153578043,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 11
+    },
+    {
+     "brand_id": 23778,
+     "name": "US Vintage",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.24,
+     "wormhole_pollution": 2.88,
+     "original_rank": 24,
+     "original_betweenness": 0.007715501356869936,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4680,
+     "name": "Customized & Personalized",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.08,
+     "wormhole_pollution": 2.88,
+     "original_rank": 25,
+     "original_betweenness": 0.007688445504754782,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 20371,
+     "name": "Sonoma",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.51,
+     "wormhole_pollution": 0.66,
+     "original_rank": 26,
+     "original_betweenness": 0.007349182851612568,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 4753,
+     "name": "Cato",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.63,
+     "wormhole_pollution": 0.41,
+     "original_rank": 27,
+     "original_betweenness": 0.007133087608963251,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 16807,
+     "name": "Original Vintage Style",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.17,
+     "wormhole_pollution": 2.36,
+     "original_rank": 30,
+     "original_betweenness": 0.006913555786013603,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 25120,
+     "name": "Walmart",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.04,
+     "wormhole_pollution": 2.87,
+     "original_rank": 32,
+     "original_betweenness": 0.006825816351920366,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 11163,
+     "name": "JCPenney",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.06,
+     "wormhole_pollution": 1.89,
+     "original_rank": 33,
+     "original_betweenness": 0.006692503113299608,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 5699,
+     "name": "Celebrate It",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.62,
+     "wormhole_pollution": 1.14,
+     "original_rank": 34,
+     "original_betweenness": 0.006495659239590168,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 6
+    },
+    {
+     "brand_id": 20561,
+     "name": "Sephora",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.27,
+     "wormhole_pollution": 0.41,
+     "original_rank": 36,
+     "original_betweenness": 0.006339358165860176,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 19
+    },
+    {
+     "brand_id": 25116,
+     "name": "Wonder Nation",
+     "band": "review",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 0.25,
+     "original_rank": 37,
+     "original_betweenness": 0.006142784841358662,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 25176,
+     "name": "Xhilaration",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.16,
+     "wormhole_pollution": 0.96,
+     "original_rank": 39,
+     "original_betweenness": 0.006079691927880049,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 217,
+     "name": "American Vintage",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.24,
+     "wormhole_pollution": 2.56,
+     "original_rank": 40,
+     "original_betweenness": 0.006058082450181246,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 20284,
+     "name": "SO",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.09,
+     "wormhole_pollution": 1.48,
+     "original_rank": 42,
+     "original_betweenness": 0.006039400584995747,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 337,
+     "name": "Authentic Original Vintage Style",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.15,
+     "wormhole_pollution": 2.58,
+     "original_rank": 43,
+     "original_betweenness": 0.006038578227162361,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 14390,
+     "name": "Mossimo",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 0.58,
+     "original_rank": 44,
+     "original_betweenness": 0.006005280185490847,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 29
+    },
+    {
+     "brand_id": 15901,
+     "name": "Nordstrom",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.07,
+     "wormhole_pollution": 1.23,
+     "original_rank": 45,
+     "original_betweenness": 0.005988423712551594,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 9739,
+     "name": "Hot Topic",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.59,
+     "wormhole_pollution": 0.58,
+     "original_rank": 47,
+     "original_betweenness": 0.005933693144470453,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 377,
+     "name": "Apt. 9",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.64,
+     "wormhole_pollution": 0.77,
+     "original_rank": 48,
+     "original_betweenness": 0.005920822732150555,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 12
+    },
+    {
+     "brand_id": 12259,
+     "name": "Kohl's",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.05,
+     "wormhole_pollution": 1.86,
+     "original_rank": 53,
+     "original_betweenness": 0.005841587670147419,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 17975,
+     "name": "Pier 1 Imports",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.78,
+     "wormhole_pollution": 0.82,
+     "original_rank": 61,
+     "original_betweenness": 0.005578614305704832,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 10617,
+     "name": "INC International Concepts",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 1.26,
+     "original_rank": 62,
+     "original_betweenness": 0.00557746784761548,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 469,
+     "name": "ART",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.27,
+     "wormhole_pollution": 0.95,
+     "original_rank": 63,
+     "original_betweenness": 0.005428515840321779,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 24936,
+     "name": "World Market",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.26,
+     "wormhole_pollution": 0.6,
+     "original_rank": 65,
+     "original_betweenness": 0.005410993937402964,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 3305,
+     "name": "Better Homes & Gardens",
+     "band": "review",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.65,
+     "wormhole_pollution": 0.9,
+     "original_rank": 66,
+     "original_betweenness": 0.005381855182349682,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 7948,
+     "name": "Faded Glory",
+     "band": "review",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.5,
+     "wormhole_pollution": 0.34,
+     "original_rank": 67,
+     "original_betweenness": 0.005344795528799295,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 22109,
+     "name": "Secret Treasures",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 0.73,
+     "original_rank": 69,
+     "original_betweenness": 0.005323375109583139,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 19923,
+     "name": "Style & Co",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.43,
+     "wormhole_pollution": 0.33,
+     "original_rank": 71,
+     "original_betweenness": 0.005289137363433838,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 6149,
+     "name": "Derek Heart",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.63,
+     "wormhole_pollution": 1.1,
+     "original_rank": 72,
+     "original_betweenness": 0.005265402141958475,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 43
+    },
+    {
+     "brand_id": 4089,
+     "name": "Custom Variety Pack",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.07,
+     "wormhole_pollution": 2.95,
+     "original_rank": 74,
+     "original_betweenness": 0.0052084471099078655,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 16
+    },
+    {
+     "brand_id": 10548,
+     "name": "Indie",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.37,
+     "wormhole_pollution": 1.81,
+     "original_rank": 75,
+     "original_betweenness": 0.005162771325558424,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 17373,
+     "name": "Pier One",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.67,
+     "wormhole_pollution": 0.46,
+     "original_rank": 76,
+     "original_betweenness": 0.005156893283128738,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 5622,
+     "name": "Cloud Island",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.68,
+     "wormhole_pollution": 0.16,
+     "original_rank": 81,
+     "original_betweenness": 0.0049507576040923595,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 75
+    },
+    {
+     "brand_id": 20356,
+     "name": "Spencer's",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.58,
+     "wormhole_pollution": 1.06,
+     "original_rank": 86,
+     "original_betweenness": 0.004684293642640114,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 9012,
+     "name": "GE",
+     "band": "accept",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.91,
+     "wormhole_pollution": 0.48,
+     "original_rank": 89,
+     "original_betweenness": 0.004634905606508255,
+     "postfilter_rank": 42,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 23619,
+     "name": "Time and Tru",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.13,
+     "wormhole_pollution": 1.0,
+     "original_rank": 97,
+     "original_betweenness": 0.004458552226424217,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 32
+    },
+    {
+     "brand_id": 18824,
+     "name": "Recollections",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.68,
+     "wormhole_pollution": 0.21,
+     "original_rank": 99,
+     "original_betweenness": 0.004359117709100246,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 66
+    },
+    {
+     "brand_id": 15904,
+     "name": "NASCAR",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.62,
+     "wormhole_pollution": 0.28,
+     "original_rank": 100,
+     "original_betweenness": 0.004326776135712862,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 83
+    },
+    {
+     "brand_id": 24623,
+     "name": "Wondershop",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.06,
+     "wormhole_pollution": 1.88,
+     "original_rank": 105,
+     "original_betweenness": 0.004299596883356571,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 84
+    },
+    {
+     "brand_id": 18643,
+     "name": "QVC",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.15,
+     "wormhole_pollution": 1.21,
+     "original_rank": 110,
+     "original_betweenness": 0.004181198310106993,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 53
+    },
+    {
+     "brand_id": 3311,
+     "name": "Bed Bath & Beyond",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.21,
+     "wormhole_pollution": 0.63,
+     "original_rank": 112,
+     "original_betweenness": 0.0041308095678687096,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": null
+    },
+    {
+     "brand_id": 15755,
+     "name": "Native",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.32,
+     "wormhole_pollution": 1.9,
+     "original_rank": 114,
+     "original_betweenness": 0.00411355821415782,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 52
+    },
+    {
+     "brand_id": 493,
+     "name": "Almost Famous",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.45,
+     "wormhole_pollution": 1.35,
+     "original_rank": 115,
+     "original_betweenness": 0.004089894704520702,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 94
+    },
+    {
+     "brand_id": 15574,
+     "name": "Magellan",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.56,
+     "wormhole_pollution": 0.94,
+     "original_rank": 117,
+     "original_betweenness": 0.004059504251927137,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 44
+    },
+    {
+     "brand_id": 791,
+     "name": "Ambiance Apparel",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.54,
+     "wormhole_pollution": 0.67,
+     "original_rank": 120,
+     "original_betweenness": 0.004007603973150253,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 68
+    },
+    {
+     "brand_id": 667,
+     "name": "a.n.a",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 0.63,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 28
+    },
+    {
+     "brand_id": 749,
+     "name": "AmazonBasics",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.1,
+     "wormhole_pollution": 2.02,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 57
+    },
+    {
+     "brand_id": 2666,
+     "name": "Bioworld",
+     "band": "review",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.66,
+     "wormhole_pollution": 1.1,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 60
+    },
+    {
+     "brand_id": 9821,
+     "name": "Home Interiors",
+     "band": "reject",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.18,
+     "wormhole_pollution": 1.7,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 62
+    },
+    {
+     "brand_id": 10322,
+     "name": "Holiday Time",
+     "band": "review",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.36,
+     "wormhole_pollution": 1.81,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 63
+    },
+    {
+     "brand_id": 3773,
+     "name": "BEAUTY CREATIONS COSMETICS",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.64,
+     "wormhole_pollution": 0.16,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 73
+    },
+    {
+     "brand_id": 14094,
+     "name": "Merona",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.16,
+     "wormhole_pollution": 0.89,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 76
+    },
+    {
+     "brand_id": 15979,
+     "name": "NYX",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 80
+    },
+    {
+     "brand_id": 11937,
+     "name": "Kirkland Signature",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.05,
+     "wormhole_pollution": 2.04,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 87
+    },
+    {
+     "brand_id": 24197,
+     "name": "Venus",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 1.53,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 88
+    },
+    {
+     "brand_id": 19973,
+     "name": "Stampd",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.56,
+     "wormhole_pollution": 0.59,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 91
+    },
+    {
+     "brand_id": 14034,
+     "name": "Microsoft",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 96
+    },
+    {
+     "brand_id": 23972,
+     "name": "Unique Vintage",
+     "band": "review",
+     "entity_kind": "generic_catchall_or_category",
+     "is_standalone_brand": 0.42,
+     "wormhole_pollution": 1.21,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 98
+    },
+    {
+     "brand_id": 25185,
+     "name": "XOXO",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 1.94,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 99
+    },
+    {
+     "brand_id": 15971,
+     "name": "New York & Company",
+     "band": "review",
+     "entity_kind": "standalone_brand",
+     "is_standalone_brand": 0.69,
+     "wormhole_pollution": 1.41,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 103
+    },
+    {
+     "brand_id": 14195,
+     "name": "Members Mark",
+     "band": "reject",
+     "entity_kind": "superstore_house_brand",
+     "is_standalone_brand": 0.06,
+     "wormhole_pollution": 2.09,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 104
+    },
+    {
+     "brand_id": 19402,
+     "name": "Ross",
+     "band": "reject",
+     "entity_kind": "multi_brand_retailer",
+     "is_standalone_brand": 0.15,
+     "wormhole_pollution": 1.58,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 112
+    },
+    {
+     "brand_id": 640,
+     "name": "Athletic Works",
+     "band": null,
+     "entity_kind": null,
+     "is_standalone_brand": null,
+     "wormhole_pollution": null,
+     "original_rank": null,
+     "original_betweenness": null,
+     "postfilter_rank": null,
+     "purified_rank": null,
+     "purified_betweenness": null,
+     "betweenness_multiplier": null,
+     "denylist_rank": 120
+    }
+   ],
+   "review_queue": [
+    {
+     "brand_id": 15946,
+     "name": "No Boundaries",
+     "pass": 1,
+     "probe_rank": 2,
+     "original_rank": 2,
+     "entity_kind": "superstore_house_brand",
+     "entity_kind_p": 0.98,
+     "is_standalone_brand": 0.39,
+     "wormhole_pollution": 1.54,
+     "context": {
+      "total_listings": 72964,
+      "distinct_c0": 15,
+      "distinct_c1": 96,
+      "avg_price": 10.58,
+      "cat1": "Women > Tops & blouses > Tank Tops",
+      "cat1_listings": 5640
+     }
+    },
+    {
+     "brand_id": 4044,
+     "name": "Claire's",
+     "pass": 1,
+     "probe_rank": 11,
+     "original_rank": 11,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 0.98,
+     "is_standalone_brand": 0.89,
+     "wormhole_pollution": 0.72,
+     "context": {
+      "total_listings": 16185,
+      "distinct_c0": 16,
+      "distinct_c1": 119,
+      "avg_price": 11.13,
+      "cat1": "Women > Jewelry > Earrings",
+      "cat1_listings": 3280
+     }
+    },
+    {
+     "brand_id": 10525,
+     "name": "Independent",
+     "pass": 1,
+     "probe_rank": 16,
+     "original_rank": 16,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.96,
+     "is_standalone_brand": 0.3,
+     "wormhole_pollution": 2.25,
+     "context": {
+      "total_listings": 292408,
+      "distinct_c0": 17,
+      "distinct_c1": 234,
+      "avg_price": 42.12,
+      "cat1": "Toys & Collectibles > Collectibles & Hobbies > Pins",
+      "cat1_listings": 103131
+     }
+    },
+    {
+     "brand_id": 4814,
+     "name": "Cabela's",
+     "pass": 1,
+     "probe_rank": 19,
+     "original_rank": 19,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 0.78,
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 0.78,
+     "context": {
+      "total_listings": 11154,
+      "distinct_c0": 15,
+      "distinct_c1": 118,
+      "avg_price": 25.36,
+      "cat1": "Men > Tops > Button-front",
+      "cat1_listings": 1215
+     }
+    },
+    {
+     "brand_id": 15827,
+     "name": "New Directions",
+     "pass": 1,
+     "probe_rank": 23,
+     "original_rank": 23,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.51,
+     "is_standalone_brand": 0.49,
+     "wormhole_pollution": 0.7,
+     "context": {
+      "total_listings": 11186,
+      "distinct_c0": 13,
+      "distinct_c1": 51,
+      "avg_price": 13.93,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 3703
+     }
+    },
+    {
+     "brand_id": 20371,
+     "name": "Sonoma",
+     "pass": 1,
+     "probe_rank": 26,
+     "original_rank": 26,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.56,
+     "is_standalone_brand": 0.51,
+     "wormhole_pollution": 0.66,
+     "context": {
+      "total_listings": 38521,
+      "distinct_c0": 16,
+      "distinct_c1": 119,
+      "avg_price": 13.65,
+      "cat1": "Women > Tops & blouses > T-shirts",
+      "cat1_listings": 3245
+     }
+    },
+    {
+     "brand_id": 4753,
+     "name": "Cato",
+     "pass": 1,
+     "probe_rank": 27,
+     "original_rank": 27,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.64,
+     "is_standalone_brand": 0.63,
+     "wormhole_pollution": 0.41,
+     "context": {
+      "total_listings": 25252,
+      "distinct_c0": 12,
+      "distinct_c1": 55,
+      "avg_price": 13.19,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 7049
+     }
+    },
+    {
+     "brand_id": 5699,
+     "name": "Celebrate It",
+     "pass": 1,
+     "probe_rank": 34,
+     "original_rank": 34,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.56,
+     "is_standalone_brand": 0.62,
+     "wormhole_pollution": 1.14,
+     "context": {
+      "total_listings": 5698,
+      "distinct_c0": 16,
+      "distinct_c1": 113,
+      "avg_price": 13.7,
+      "cat1": "Home > Seasonal decor > Halloween",
+      "cat1_listings": 473
+     }
+    },
+    {
+     "brand_id": 25116,
+     "name": "Wonder Nation",
+     "pass": 1,
+     "probe_rank": 37,
+     "original_rank": 37,
+     "entity_kind": "superstore_house_brand",
+     "entity_kind_p": 0.75,
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 0.25,
+     "context": {
+      "total_listings": 51342,
+      "distinct_c0": 15,
+      "distinct_c1": 96,
+      "avg_price": 9.52,
+      "cat1": "Kids > Girls shoes > Girls 2T-5T",
+      "cat1_listings": 4823
+     }
+    },
+    {
+     "brand_id": 14390,
+     "name": "Mossimo",
+     "pass": 1,
+     "probe_rank": 44,
+     "original_rank": 44,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.52,
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 0.58,
+     "context": {
+      "total_listings": 28158,
+      "distinct_c0": 12,
+      "distinct_c1": 60,
+      "avg_price": 12.22,
+      "cat1": "Women > Swimwear > Two-piece",
+      "cat1_listings": 1940
+     }
+    },
+    {
+     "brand_id": 9739,
+     "name": "Hot Topic",
+     "pass": 1,
+     "probe_rank": 47,
+     "original_rank": 47,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 1.0,
+     "is_standalone_brand": 0.59,
+     "wormhole_pollution": 0.58,
+     "context": {
+      "total_listings": 85275,
+      "distinct_c0": 17,
+      "distinct_c1": 171,
+      "avg_price": 20.48,
+      "cat1": "Men > Tops > T-shirts",
+      "cat1_listings": 13488
+     }
+    },
+    {
+     "brand_id": 377,
+     "name": "Apt. 9",
+     "pass": 1,
+     "probe_rank": 48,
+     "original_rank": 48,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.58,
+     "is_standalone_brand": 0.64,
+     "wormhole_pollution": 0.77,
+     "context": {
+      "total_listings": 37931,
+      "distinct_c0": 11,
+      "distinct_c1": 58,
+      "avg_price": 13.41,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 7451
+     }
+    },
+    {
+     "brand_id": 17975,
+     "name": "Pier 1 Imports",
+     "pass": 1,
+     "probe_rank": 61,
+     "original_rank": 61,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 0.75,
+     "is_standalone_brand": 0.78,
+     "wormhole_pollution": 0.82,
+     "context": {
+      "total_listings": 9662,
+      "distinct_c0": 17,
+      "distinct_c1": 116,
+      "avg_price": 24.63,
+      "cat1": "Home > Home decor > Home decor accents",
+      "cat1_listings": 1350
+     }
+    },
+    {
+     "brand_id": 10617,
+     "name": "INC International Concepts",
+     "pass": 1,
+     "probe_rank": 62,
+     "original_rank": 62,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.59,
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 1.26,
+     "context": {
+      "total_listings": 42404,
+      "distinct_c0": 13,
+      "distinct_c1": 83,
+      "avg_price": 22.79,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 6846
+     }
+    },
+    {
+     "brand_id": 3305,
+     "name": "Better Homes & Gardens",
+     "pass": 1,
+     "probe_rank": 66,
+     "original_rank": 66,
+     "entity_kind": "superstore_house_brand",
+     "entity_kind_p": 1.0,
+     "is_standalone_brand": 0.65,
+     "wormhole_pollution": 0.9,
+     "context": {
+      "total_listings": 10391,
+      "distinct_c0": 16,
+      "distinct_c1": 121,
+      "avg_price": 20.34,
+      "cat1": "Books > Reference Books > Cookbooks",
+      "cat1_listings": 1494
+     }
+    },
+    {
+     "brand_id": 7948,
+     "name": "Faded Glory",
+     "pass": 1,
+     "probe_rank": 67,
+     "original_rank": 67,
+     "entity_kind": "superstore_house_brand",
+     "entity_kind_p": 0.67,
+     "is_standalone_brand": 0.5,
+     "wormhole_pollution": 0.34,
+     "context": {
+      "total_listings": 32001,
+      "distinct_c0": 13,
+      "distinct_c1": 65,
+      "avg_price": 10.77,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 2857
+     }
+    },
+    {
+     "brand_id": 22109,
+     "name": "Secret Treasures",
+     "pass": 1,
+     "probe_rank": 69,
+     "original_rank": 69,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.54,
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 0.73,
+     "context": {
+      "total_listings": 17417,
+      "distinct_c0": 12,
+      "distinct_c1": 68,
+      "avg_price": 11.63,
+      "cat1": "Women > Sleepwear & robes > Pajama sets",
+      "cat1_listings": 3025
+     }
+    },
+    {
+     "brand_id": 19923,
+     "name": "Style & Co",
+     "pass": 1,
+     "probe_rank": 71,
+     "original_rank": 71,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.52,
+     "is_standalone_brand": 0.43,
+     "wormhole_pollution": 0.33,
+     "context": {
+      "total_listings": 26496,
+      "distinct_c0": 12,
+      "distinct_c1": 56,
+      "avg_price": 17.33,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 5451
+     }
+    },
+    {
+     "brand_id": 6149,
+     "name": "Derek Heart",
+     "pass": 1,
+     "probe_rank": 72,
+     "original_rank": 72,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.62,
+     "is_standalone_brand": 0.63,
+     "wormhole_pollution": 1.1,
+     "context": {
+      "total_listings": 9455,
+      "distinct_c0": 11,
+      "distinct_c1": 39,
+      "avg_price": 11.87,
+      "cat1": "Women > Dresses > Above knee, mini",
+      "cat1_listings": 1546
+     }
+    },
+    {
+     "brand_id": 10548,
+     "name": "Indie",
+     "pass": 1,
+     "probe_rank": 75,
+     "original_rank": 75,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.93,
+     "is_standalone_brand": 0.37,
+     "wormhole_pollution": 1.81,
+     "context": {
+      "total_listings": 39370,
+      "distinct_c0": 16,
+      "distinct_c1": 110,
+      "avg_price": 29.82,
+      "cat1": "Beauty > Makeup > Nails",
+      "cat1_listings": 15123
+     }
+    },
+    {
+     "brand_id": 17373,
+     "name": "Pier One",
+     "pass": 1,
+     "probe_rank": 76,
+     "original_rank": 76,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 0.67,
+     "is_standalone_brand": 0.67,
+     "wormhole_pollution": 0.46,
+     "context": {
+      "total_listings": 9896,
+      "distinct_c0": 16,
+      "distinct_c1": 118,
+      "avg_price": 24.46,
+      "cat1": "Home > Home decor > Home decor accents",
+      "cat1_listings": 1670
+     }
+    },
+    {
+     "brand_id": 5622,
+     "name": "Cloud Island",
+     "pass": 1,
+     "probe_rank": 81,
+     "original_rank": 81,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.49,
+     "is_standalone_brand": 0.68,
+     "wormhole_pollution": 0.16,
+     "context": {
+      "total_listings": 7976,
+      "distinct_c0": 11,
+      "distinct_c1": 69,
+      "avg_price": 12.0,
+      "cat1": "Kids > Boys one-pieces > Boys 0-24 mos",
+      "cat1_listings": 1971
+     }
+    },
+    {
+     "brand_id": 20356,
+     "name": "Spencer's",
+     "pass": 1,
+     "probe_rank": 86,
+     "original_rank": 86,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 1.0,
+     "is_standalone_brand": 0.58,
+     "wormhole_pollution": 1.06,
+     "context": {
+      "total_listings": 12137,
+      "distinct_c0": 17,
+      "distinct_c1": 136,
+      "avg_price": 16.93,
+      "cat1": "Men > Tops > T-shirts",
+      "cat1_listings": 2988
+     }
+    },
+    {
+     "brand_id": 18824,
+     "name": "Recollections",
+     "pass": 1,
+     "probe_rank": 99,
+     "original_rank": 99,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.84,
+     "is_standalone_brand": 0.68,
+     "wormhole_pollution": 0.21,
+     "context": {
+      "total_listings": 3040,
+      "distinct_c0": 14,
+      "distinct_c1": 79,
+      "avg_price": 13.08,
+      "cat1": "Handmade > Paper goods > Scrapbooking",
+      "cat1_listings": 460
+     }
+    },
+    {
+     "brand_id": 15904,
+     "name": "NASCAR",
+     "pass": 1,
+     "probe_rank": 100,
+     "original_rank": 100,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.94,
+     "is_standalone_brand": 0.62,
+     "wormhole_pollution": 0.28,
+     "context": {
+      "total_listings": 42753,
+      "distinct_c0": 16,
+      "distinct_c1": 147,
+      "avg_price": 33.62,
+      "cat1": "Toys & Collectibles > Vintage & Antique Toys > Cars",
+      "cat1_listings": 12466
+     }
+    },
+    {
+     "brand_id": 15755,
+     "name": "Native",
+     "pass": 1,
+     "probe_rank": 114,
+     "original_rank": 114,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.76,
+     "is_standalone_brand": 0.32,
+     "wormhole_pollution": 1.9,
+     "context": {
+      "total_listings": 27458,
+      "distinct_c0": 15,
+      "distinct_c1": 105,
+      "avg_price": 49.87,
+      "cat1": "Kids > Girls shoes > Girls 2T-5T",
+      "cat1_listings": 5412
+     }
+    },
+    {
+     "brand_id": 493,
+     "name": "Almost Famous",
+     "pass": 1,
+     "probe_rank": 115,
+     "original_rank": 115,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.45,
+     "is_standalone_brand": 0.45,
+     "wormhole_pollution": 1.35,
+     "context": {
+      "total_listings": 10583,
+      "distinct_c0": 12,
+      "distinct_c1": 48,
+      "avg_price": 14.71,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 1098
+     }
+    },
+    {
+     "brand_id": 15574,
+     "name": "Magellan",
+     "pass": 1,
+     "probe_rank": 117,
+     "original_rank": 117,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.63,
+     "is_standalone_brand": 0.56,
+     "wormhole_pollution": 0.94,
+     "context": {
+      "total_listings": 8693,
+      "distinct_c0": 12,
+      "distinct_c1": 86,
+      "avg_price": 16.17,
+      "cat1": "Men > Tops > Button-front",
+      "cat1_listings": 1613
+     }
+    },
+    {
+     "brand_id": 791,
+     "name": "Ambiance Apparel",
+     "pass": 1,
+     "probe_rank": 120,
+     "original_rank": 120,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.48,
+     "is_standalone_brand": 0.54,
+     "wormhole_pollution": 0.67,
+     "context": {
+      "total_listings": 9425,
+      "distinct_c0": 10,
+      "distinct_c1": 49,
+      "avg_price": 11.29,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 1298
+     }
+    },
+    {
+     "brand_id": 667,
+     "name": "a.n.a",
+     "pass": 2,
+     "probe_rank": 11,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.74,
+     "is_standalone_brand": 0.53,
+     "wormhole_pollution": 0.63,
+     "context": {
+      "total_listings": 19812,
+      "distinct_c0": 13,
+      "distinct_c1": 50,
+      "avg_price": 13.9,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 4170
+     }
+    },
+    {
+     "brand_id": 2666,
+     "name": "Bioworld",
+     "pass": 2,
+     "probe_rank": 36,
+     "original_rank": null,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 0.57,
+     "is_standalone_brand": 0.66,
+     "wormhole_pollution": 1.1,
+     "context": {
+      "total_listings": 17605,
+      "distinct_c0": 17,
+      "distinct_c1": 114,
+      "avg_price": 32.76,
+      "cat1": "Women > Women's handbags > Backpacks",
+      "cat1_listings": 3439
+     }
+    },
+    {
+     "brand_id": 10322,
+     "name": "Holiday Time",
+     "pass": 2,
+     "probe_rank": 46,
+     "original_rank": null,
+     "entity_kind": "superstore_house_brand",
+     "entity_kind_p": 0.89,
+     "is_standalone_brand": 0.36,
+     "wormhole_pollution": 1.81,
+     "context": {
+      "total_listings": 13135,
+      "distinct_c0": 16,
+      "distinct_c1": 130,
+      "avg_price": 21.98,
+      "cat1": "Home > Seasonal decor > Christmas",
+      "cat1_listings": 6126
+     }
+    },
+    {
+     "brand_id": 3773,
+     "name": "BEAUTY CREATIONS COSMETICS",
+     "pass": 2,
+     "probe_rank": 63,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.67,
+     "is_standalone_brand": 0.64,
+     "wormhole_pollution": 0.16,
+     "context": {
+      "total_listings": 5245,
+      "distinct_c0": 9,
+      "distinct_c1": 27,
+      "avg_price": 17.28,
+      "cat1": "Beauty > Makeup > Makeup palettes",
+      "cat1_listings": 1977
+     }
+    },
+    {
+     "brand_id": 24197,
+     "name": "Venus",
+     "pass": 2,
+     "probe_rank": 67,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.91,
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 1.53,
+     "context": {
+      "total_listings": 16979,
+      "distinct_c0": 15,
+      "distinct_c1": 81,
+      "avg_price": 19.69,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 2035
+     }
+    },
+    {
+     "brand_id": 19973,
+     "name": "Stampd",
+     "pass": 2,
+     "probe_rank": 69,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.54,
+     "is_standalone_brand": 0.56,
+     "wormhole_pollution": 0.59,
+     "context": {
+      "total_listings": 57048,
+      "distinct_c0": 15,
+      "distinct_c1": 84,
+      "avg_price": 130.6,
+      "cat1": "Women > Jewelry > Necklaces",
+      "cat1_listings": 17843
+     }
+    },
+    {
+     "brand_id": 15971,
+     "name": "New York & Company",
+     "pass": 2,
+     "probe_rank": 88,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.66,
+     "is_standalone_brand": 0.69,
+     "wormhole_pollution": 1.41,
+     "context": {
+      "total_listings": 53832,
+      "distinct_c0": 16,
+      "distinct_c1": 87,
+      "avg_price": 16.56,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 8894
+     }
+    },
+    {
+     "brand_id": 23972,
+     "name": "Unique Vintage",
+     "pass": 2,
+     "probe_rank": 89,
+     "original_rank": null,
+     "entity_kind": "generic_catchall_or_category",
+     "entity_kind_p": 0.59,
+     "is_standalone_brand": 0.42,
+     "wormhole_pollution": 1.21,
+     "context": {
+      "total_listings": 261282,
+      "distinct_c0": 17,
+      "distinct_c1": 242,
+      "avg_price": 36.4,
+      "cat1": "Vintage & collectibles > Antique > Collectibles",
+      "cat1_listings": 45764
+     }
+    },
+    {
+     "brand_id": 25185,
+     "name": "XOXO",
+     "pass": 2,
+     "probe_rank": 98,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.5599999999999999,
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 1.94,
+     "context": {
+      "total_listings": 8409,
+      "distinct_c0": 13,
+      "distinct_c1": 73,
+      "avg_price": 18.02,
+      "cat1": "Women > Dresses > Above knee, mini",
+      "cat1_listings": 650
+     }
+    },
+    {
+     "brand_id": 15722,
+     "name": "New Look",
+     "pass": 2,
+     "probe_rank": 115,
+     "original_rank": null,
+     "entity_kind": "standalone_brand",
+     "entity_kind_p": 0.91,
+     "is_standalone_brand": 0.6,
+     "wormhole_pollution": 1.54,
+     "context": {
+      "total_listings": 4972,
+      "distinct_c0": 14,
+      "distinct_c1": 62,
+      "avg_price": 16.61,
+      "cat1": "Vintage & collectibles > Supplies > Pattern",
+      "cat1_listings": 403
+     }
+    },
+    {
+     "brand_id": 6179,
+     "name": "dressbarn",
+     "pass": 2,
+     "probe_rank": 117,
+     "original_rank": null,
+     "entity_kind": "multi_brand_retailer",
+     "entity_kind_p": 0.54,
+     "is_standalone_brand": 0.55,
+     "wormhole_pollution": 0.35,
+     "context": {
+      "total_listings": 6148,
+      "distinct_c0": 9,
+      "distinct_c1": 38,
+      "avg_price": 17.4,
+      "cat1": "Women > Tops & blouses > Blouse",
+      "cat1_listings": 1481
+     }
+    }
+   ],
+   "judgments": [
+    {
+     "brand_id": 15548,
+     "name": "Mainstays",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.07
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.94
+      }
+     }
+    },
+    {
+     "brand_id": 15946,
+     "name": "No Boundaries",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.39
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.54
+      }
+     }
+    },
+    {
+     "brand_id": 505,
+     "name": "Avon",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.54
+      }
+     }
+    },
+    {
+     "brand_id": 12799,
+     "name": "Lot",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.08
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.73
+      }
+     }
+    },
+    {
+     "brand_id": 23745,
+     "name": "Ulta",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.18
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.61
+      }
+     }
+    },
+    {
+     "brand_id": 10627,
+     "name": "IZOD",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.09
+      }
+     }
+    },
+    {
+     "brand_id": 786,
+     "name": "As Seen on TV",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.2
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.84
+      }
+     }
+    },
+    {
+     "brand_id": 18651,
+     "name": "Rue21",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.71
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.8
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.41
+      }
+     }
+    },
+    {
+     "brand_id": 13763,
+     "name": "Macy's",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.04
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.78
+      }
+     }
+    },
+    {
+     "brand_id": 7106,
+     "name": "Eyeshadow",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.07
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.93
+      }
+     }
+    },
+    {
+     "brand_id": 4044,
+     "name": "Claire's",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.89
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.72
+      }
+     }
+    },
+    {
+     "brand_id": 12700,
+     "name": "L'Oreal",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.98
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.03
+      }
+     }
+    },
+    {
+     "brand_id": 2571,
+     "name": "Black & Decker",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.12
+      }
+     }
+    },
+    {
+     "brand_id": 9705,
+     "name": "HP",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.06
+      }
+     }
+    },
+    {
+     "brand_id": 8923,
+     "name": "Gerber",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.15
+      }
+     }
+    },
+    {
+     "brand_id": 10525,
+     "name": "Independent",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.96
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.3
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.25
+      }
+     }
+    },
+    {
+     "brand_id": 10314,
+     "name": "Hobby Lobby",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.24
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.58
+      }
+     }
+    },
+    {
+     "brand_id": 18949,
+     "name": "Revlon",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.98
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.03
+      }
+     }
+    },
+    {
+     "brand_id": 4814,
+     "name": "Cabela's",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.78
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.53
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.78
+      }
+     }
+    },
+    {
+     "brand_id": 563,
+     "name": "Amazon",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.87
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.12
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.81
+      }
+     }
+    },
+    {
+     "brand_id": 23372,
+     "name": "The Unbranded Brand",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.13
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.85
+      }
+     }
+    },
+    {
+     "brand_id": 20430,
+     "name": "Samsung",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.98
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.03
+      }
+     }
+    },
+    {
+     "brand_id": 15827,
+     "name": "New Directions",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.51
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.49
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.7
+      }
+     }
+    },
+    {
+     "brand_id": 23778,
+     "name": "US Vintage",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.24
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.88
+      }
+     }
+    },
+    {
+     "brand_id": 4680,
+     "name": "Customized & Personalized",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.08
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.88
+      }
+     }
+    },
+    {
+     "brand_id": 20371,
+     "name": "Sonoma",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.56
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.51
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.66
+      }
+     }
+    },
+    {
+     "brand_id": 4753,
+     "name": "Cato",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.64
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.63
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.41
+      }
+     }
+    },
+    {
+     "brand_id": 9686,
+     "name": "Hanes",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.23
+      }
+     }
+    },
+    {
+     "brand_id": 7265,
+     "name": "Ellen Tracy",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.34
+      }
+     }
+    },
+    {
+     "brand_id": 16807,
+     "name": "Original Vintage Style",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.17
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.36
+      }
+     }
+    },
+    {
+     "brand_id": 4184,
+     "name": "Charming Charlie",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.86
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.92
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.57
+      }
+     }
+    },
+    {
+     "brand_id": 25120,
+     "name": "Walmart",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.04
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.87
+      }
+     }
+    },
+    {
+     "brand_id": 11163,
+     "name": "JCPenney",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.06
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.89
+      }
+     }
+    },
+    {
+     "brand_id": 5699,
+     "name": "Celebrate It",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.56
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.62
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.14
+      }
+     }
+    },
+    {
+     "brand_id": 17190,
+     "name": "Philosophy",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.12
+      }
+     }
+    },
+    {
+     "brand_id": 20561,
+     "name": "Sephora",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.27
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.41
+      }
+     }
+    },
+    {
+     "brand_id": 25116,
+     "name": "Wonder Nation",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.75
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.55
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.25
+      }
+     }
+    },
+    {
+     "brand_id": 11257,
+     "name": "Jessica Simpson",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.4
+      }
+     }
+    },
+    {
+     "brand_id": 25176,
+     "name": "Xhilaration",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.97
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.16
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.96
+      }
+     }
+    },
+    {
+     "brand_id": 217,
+     "name": "American Vintage",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.24
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.56
+      }
+     }
+    },
+    {
+     "brand_id": 20324,
+     "name": "Scholastic",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.11
+      }
+     }
+    },
+    {
+     "brand_id": 20284,
+     "name": "SO",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.78
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.09
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.48
+      }
+     }
+    },
+    {
+     "brand_id": 337,
+     "name": "Authentic Original Vintage Style",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.15
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.58
+      }
+     }
+    },
+    {
+     "brand_id": 14390,
+     "name": "Mossimo",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.52
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.55
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.58
+      }
+     }
+    },
+    {
+     "brand_id": 15901,
+     "name": "Nordstrom",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.07
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.23
+      }
+     }
+    },
+    {
+     "brand_id": 8099,
+     "name": "Fossil",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.96
+      }
+     }
+    },
+    {
+     "brand_id": 9739,
+     "name": "Hot Topic",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.59
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.58
+      }
+     }
+    },
+    {
+     "brand_id": 377,
+     "name": "Apt. 9",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.58
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.64
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.77
+      }
+     }
+    },
+    {
+     "brand_id": 24792,
+     "name": "Warner Bros.",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.77
+      }
+     }
+    },
+    {
+     "brand_id": 16002,
+     "name": "Nicole Miller",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.85
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.62
+      }
+     }
+    },
+    {
+     "brand_id": 15997,
+     "name": "Nickelodeon",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.92
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.45
+      }
+     }
+    },
+    {
+     "brand_id": 7886,
+     "name": "Fruit of the Loom",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.26
+      }
+     }
+    },
+    {
+     "brand_id": 12259,
+     "name": "Kohl's",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.05
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.86
+      }
+     }
+    },
+    {
+     "brand_id": 2501,
+     "name": "Bebe",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.93
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.09
+      }
+     }
+    },
+    {
+     "brand_id": 13610,
+     "name": "Loot Crate",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.84
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.93
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.65
+      }
+     }
+    },
+    {
+     "brand_id": 22652,
+     "name": "Tahari",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.96
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.86
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.46
+      }
+     }
+    },
+    {
+     "brand_id": 21725,
+     "name": "Sigma",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.84
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.28
+      }
+     }
+    },
+    {
+     "brand_id": 4348,
+     "name": "CoverGirl",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.02
+      }
+     }
+    },
+    {
+     "brand_id": 18995,
+     "name": "Roxy",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.12
+      }
+     }
+    },
+    {
+     "brand_id": 12711,
+     "name": "Liz Claiborne",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.16
+      }
+     }
+    },
+    {
+     "brand_id": 17975,
+     "name": "Pier 1 Imports",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.75
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.78
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.82
+      }
+     }
+    },
+    {
+     "brand_id": 10617,
+     "name": "INC International Concepts",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.59
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.53
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.26
+      }
+     }
+    },
+    {
+     "brand_id": 469,
+     "name": "ART",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.27
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.95
+      }
+     }
+    },
+    {
+     "brand_id": 4308,
+     "name": "Coca-Cola",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.6
+      }
+     }
+    },
+    {
+     "brand_id": 24936,
+     "name": "World Market",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.92
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.26
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.6
+      }
+     }
+    },
+    {
+     "brand_id": 3305,
+     "name": "Better Homes & Gardens",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.65
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.9
+      }
+     }
+    },
+    {
+     "brand_id": 7948,
+     "name": "Faded Glory",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.67
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.5
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.34
+      }
+     }
+    },
+    {
+     "brand_id": 13583,
+     "name": "Lefton",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.12
+      }
+     }
+    },
+    {
+     "brand_id": 22109,
+     "name": "Secret Treasures",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.54
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.55
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.73
+      }
+     }
+    },
+    {
+     "brand_id": 24759,
+     "name": "Wet Seal",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.83
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.88
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.35
+      }
+     }
+    },
+    {
+     "brand_id": 19923,
+     "name": "Style & Co",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.52
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.43
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.33
+      }
+     }
+    },
+    {
+     "brand_id": 6149,
+     "name": "Derek Heart",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.62
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.63
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.1
+      }
+     }
+    },
+    {
+     "brand_id": 17339,
+     "name": "prAna",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.08
+      }
+     }
+    },
+    {
+     "brand_id": 4089,
+     "name": "Custom Variety Pack",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.07
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.95
+      }
+     }
+    },
+    {
+     "brand_id": 10548,
+     "name": "Indie",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.93
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.37
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.81
+      }
+     }
+    },
+    {
+     "brand_id": 17373,
+     "name": "Pier One",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.67
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.67
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.46
+      }
+     }
+    },
+    {
+     "brand_id": 6812,
+     "name": "Dolls Kill",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.94
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.24
+      }
+     }
+    },
+    {
+     "brand_id": 1997,
+     "name": "Applause",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.88
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.13
+      }
+     }
+    },
+    {
+     "brand_id": 22826,
+     "name": "The Children's Place",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.8
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.9
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.17
+      }
+     }
+    },
+    {
+     "brand_id": 8910,
+     "name": "Gibson",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.85
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.75
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.16
+      }
+     }
+    },
+    {
+     "brand_id": 5622,
+     "name": "Cloud Island",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.49
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.68
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.16
+      }
+     }
+    },
+    {
+     "brand_id": 6029,
+     "name": "DC Comics",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 8140,
+     "name": "Fox Racing",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.5
+      }
+     }
+    },
+    {
+     "brand_id": 4603,
+     "name": "Cuisinart",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 14116,
+     "name": "Motherhood Maternity",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.9
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.85
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.1
+      }
+     }
+    },
+    {
+     "brand_id": 20356,
+     "name": "Spencer's",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.58
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.06
+      }
+     }
+    },
+    {
+     "brand_id": 4294,
+     "name": "Charlotte Russe",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.78
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.78
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.48
+      }
+     }
+    },
+    {
+     "brand_id": 8094,
+     "name": "Fisher-Price",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 9012,
+     "name": "GE",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.48
+      }
+     }
+    },
+    {
+     "brand_id": 24788,
+     "name": "Wilson",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.89
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.08
+      }
+     }
+    },
+    {
+     "brand_id": 20330,
+     "name": "Sanctuary",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.86
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.17
+      }
+     }
+    },
+    {
+     "brand_id": 12843,
+     "name": "Laura Ashley",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.59
+      }
+     }
+    },
+    {
+     "brand_id": 765,
+     "name": "Anne Klein",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.17
+      }
+     }
+    },
+    {
+     "brand_id": 14309,
+     "name": "Marvel",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.17
+      }
+     }
+    },
+    {
+     "brand_id": 24775,
+     "name": "Wrangler",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.08
+      }
+     }
+    },
+    {
+     "brand_id": 2815,
+     "name": "BCBGMAXAZRIA",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 23619,
+     "name": "Time and Tru",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.13
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.0
+      }
+     }
+    },
+    {
+     "brand_id": 11955,
+     "name": "Kensie",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.95
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.86
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.43
+      }
+     }
+    },
+    {
+     "brand_id": 18824,
+     "name": "Recollections",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.84
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.68
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.21
+      }
+     }
+    },
+    {
+     "brand_id": 15904,
+     "name": "NASCAR",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.94
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.62
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.28
+      }
+     }
+    },
+    {
+     "brand_id": 20701,
+     "name": "Speechless",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.81
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.76
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.45
+      }
+     }
+    },
+    {
+     "brand_id": 2765,
+     "name": "Bulova",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.02
+      }
+     }
+    },
+    {
+     "brand_id": 802,
+     "name": "Apple",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.33
+      }
+     }
+    },
+    {
+     "brand_id": 6054,
+     "name": "DKNY",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.28
+      }
+     }
+    },
+    {
+     "brand_id": 24623,
+     "name": "Wondershop",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.06
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.88
+      }
+     }
+    },
+    {
+     "brand_id": 11129,
+     "name": "Justice",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.96
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.88
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.07
+      }
+     }
+    },
+    {
+     "brand_id": 13731,
+     "name": "Mud Pie",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.93
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.21
+      }
+     }
+    },
+    {
+     "brand_id": 2742,
+     "name": "Billabong",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.93
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.32
+      }
+     }
+    },
+    {
+     "brand_id": 13581,
+     "name": "L.A. COLORS",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.92
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 18643,
+     "name": "QVC",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.15
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.21
+      }
+     }
+    },
+    {
+     "brand_id": 12657,
+     "name": "Lancôme",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.98
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 3311,
+     "name": "Bed Bath & Beyond",
+     "pass": 1,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.21
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.63
+      }
+     }
+    },
+    {
+     "brand_id": 24715,
+     "name": "Wilsons Leather",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.97
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.89
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.27
+      }
+     }
+    },
+    {
+     "brand_id": 15755,
+     "name": "Native",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.76
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.32
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.9
+      }
+     }
+    },
+    {
+     "brand_id": 493,
+     "name": "Almost Famous",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.45
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.45
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.35
+      }
+     }
+    },
+    {
+     "brand_id": 9912,
+     "name": "Hallmark",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.29
+      }
+     }
+    },
+    {
+     "brand_id": 15574,
+     "name": "Magellan",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.63
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.56
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.94
+      }
+     }
+    },
+    {
+     "brand_id": 326,
+     "name": "Arizona Jean Company",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.91
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.72
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.29
+      }
+     }
+    },
+    {
+     "brand_id": 4713,
+     "name": "Children's Place",
+     "pass": 1,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.75
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.85
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.11
+      }
+     }
+    },
+    {
+     "brand_id": 791,
+     "name": "Ambiance Apparel",
+     "pass": 1,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.48
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.54
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.67
+      }
+     }
+    },
+    {
+     "brand_id": 667,
+     "name": "a.n.a",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.74
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.53
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.63
+      }
+     }
+    },
+    {
+     "brand_id": 14099,
+     "name": "Martha Stewart",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.93
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.38
+      }
+     }
+    },
+    {
+     "brand_id": 18721,
+     "name": "Ring",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.1
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.64
+      }
+     }
+    },
+    {
+     "brand_id": 2666,
+     "name": "Bioworld",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.57
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.66
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.1
+      }
+     }
+    },
+    {
+     "brand_id": 276,
+     "name": "Aéropostale",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.14
+      }
+     }
+    },
+    {
+     "brand_id": 13459,
+     "name": "Leatherman",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.97
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.88
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.48
+      }
+     }
+    },
+    {
+     "brand_id": 22105,
+     "name": "SHEIN",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.96
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.75
+      }
+     }
+    },
+    {
+     "brand_id": 14019,
+     "name": "Maurices",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.67
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.8
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.3
+      }
+     }
+    },
+    {
+     "brand_id": 14412,
+     "name": "Michael Kors",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.16
+      }
+     }
+    },
+    {
+     "brand_id": 10322,
+     "name": "Holiday Time",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.89
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.36
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.81
+      }
+     }
+    },
+    {
+     "brand_id": 9821,
+     "name": "Home Interiors",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.18
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.7
+      }
+     }
+    },
+    {
+     "brand_id": 2011,
+     "name": "American Crafts",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.86
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.28
+      }
+     }
+    },
+    {
+     "brand_id": 19884,
+     "name": "Sanrio",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.06
+      }
+     }
+    },
+    {
+     "brand_id": 7701,
+     "name": "Ertl",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.92
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 3773,
+     "name": "BEAUTY CREATIONS COSMETICS",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.67
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.64
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.16
+      }
+     }
+    },
+    {
+     "brand_id": 24197,
+     "name": "Venus",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.91
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.55
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.53
+      }
+     }
+    },
+    {
+     "brand_id": 8170,
+     "name": "FOREVER 21",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.42
+      }
+     }
+    },
+    {
+     "brand_id": 19973,
+     "name": "Stampd",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.54
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.56
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.59
+      }
+     }
+    },
+    {
+     "brand_id": 7307,
+     "name": "Estee Lauder",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.25
+      }
+     }
+    },
+    {
+     "brand_id": 2677,
+     "name": "Bic",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.44
+      }
+     }
+    },
+    {
+     "brand_id": 749,
+     "name": "AmazonBasics",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.1
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.02
+      }
+     }
+    },
+    {
+     "brand_id": 4010,
+     "name": "ColourPop Cosmetics",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 14094,
+     "name": "Merona",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.86
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.16
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.89
+      }
+     }
+    },
+    {
+     "brand_id": 2854,
+     "name": "Bella",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.84
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.78
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.76
+      }
+     }
+    },
+    {
+     "brand_id": 15536,
+     "name": "Makeup Revolution",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.04
+      }
+     }
+    },
+    {
+     "brand_id": 11239,
+     "name": "Jumping Beans",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.83
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.85
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.16
+      }
+     }
+    },
+    {
+     "brand_id": 24113,
+     "name": "Vera Wang",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.93
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.44
+      }
+     }
+    },
+    {
+     "brand_id": 11937,
+     "name": "Kirkland Signature",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.05
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.04
+      }
+     }
+    },
+    {
+     "brand_id": 11189,
+     "name": "Jones New York",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.96
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.88
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.08
+      }
+     }
+    },
+    {
+     "brand_id": 178,
+     "name": "Anastasia Beverly Hills",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.97
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.03
+      }
+     }
+    },
+    {
+     "brand_id": 4365,
+     "name": "Clinique",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.98
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.02
+      }
+     }
+    },
+    {
+     "brand_id": 7185,
+     "name": "Enesco",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.89
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.23
+      }
+     }
+    },
+    {
+     "brand_id": 15971,
+     "name": "New York & Company",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.66
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.69
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.41
+      }
+     }
+    },
+    {
+     "brand_id": 23972,
+     "name": "Unique Vintage",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "generic_catchall_or_category",
+       "p": 0.59
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.42
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.21
+      }
+     }
+    },
+    {
+     "brand_id": 5380,
+     "name": "Care Bears",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.14
+      }
+     }
+    },
+    {
+     "brand_id": 2475,
+     "name": "Burt's Bees",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.98
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.11
+      }
+     }
+    },
+    {
+     "brand_id": 18939,
+     "name": "Realtree",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.92
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.19
+      }
+     }
+    },
+    {
+     "brand_id": 18876,
+     "name": "Romeo & Juliet Couture",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.95
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.84
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.1
+      }
+     }
+    },
+    {
+     "brand_id": 25185,
+     "name": "XOXO",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.5599999999999999
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.55
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.94
+      }
+     }
+    },
+    {
+     "brand_id": 23843,
+     "name": "Urban Outfitters",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.95
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.71
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.56
+      }
+     }
+    },
+    {
+     "brand_id": 14195,
+     "name": "Members Mark",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "superstore_house_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.06
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 2.09
+      }
+     }
+    },
+    {
+     "brand_id": 15835,
+     "name": "Nine West",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.1
+      }
+     }
+    },
+    {
+     "brand_id": 22614,
+     "name": "Tarte",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.03
+      }
+     }
+    },
+    {
+     "brand_id": 18415,
+     "name": "Pioneer Woman",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.98
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.94
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.25
+      }
+     }
+    },
+    {
+     "brand_id": 14378,
+     "name": "Mudd",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.93
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.81
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.21
+      }
+     }
+    },
+    {
+     "brand_id": 23840,
+     "name": "Universal Studios",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.89
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.09
+      }
+     }
+    },
+    {
+     "brand_id": 8452,
+     "name": "Franklin Mint",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.92
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.33
+      }
+     }
+    },
+    {
+     "brand_id": 18991,
+     "name": "Rachel Roy",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.9
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.05
+      }
+     }
+    },
+    {
+     "brand_id": 745,
+     "name": "ASUS",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.96
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.18
+      }
+     }
+    },
+    {
+     "brand_id": 6120,
+     "name": "Dana Buchman",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.99
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.91
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.13
+      }
+     }
+    },
+    {
+     "brand_id": 766,
+     "name": "Anchor Hocking",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.08
+      }
+     }
+    },
+    {
+     "brand_id": 862,
+     "name": "American Greetings",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.96
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.9
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.67
+      }
+     }
+    },
+    {
+     "brand_id": 24188,
+     "name": "Vince Camuto",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.29
+      }
+     }
+    },
+    {
+     "brand_id": 15722,
+     "name": "New Look",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.91
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.6
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.54
+      }
+     }
+    },
+    {
+     "brand_id": 2840,
+     "name": "Betsey Johnson",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.95
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.32
+      }
+     }
+    },
+    {
+     "brand_id": 6179,
+     "name": "dressbarn",
+     "pass": 2,
+     "band": "review",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.54
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.55
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.35
+      }
+     }
+    },
+    {
+     "brand_id": 22722,
+     "name": "The Limited",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 0.72
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.72
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.45
+      }
+     }
+    },
+    {
+     "brand_id": 19402,
+     "name": "Ross",
+     "pass": 2,
+     "band": "reject",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "multi_brand_retailer",
+       "p": 0.96
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.15
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 1.58
+      }
+     }
+    },
+    {
+     "brand_id": 841,
+     "name": "Anthropologie",
+     "pass": 2,
+     "band": "accept",
+     "answers": {
+      "entity_kind": {
+       "type": "choice",
+       "choice": "standalone_brand",
+       "p": 1.0
+      },
+      "is_standalone_brand": {
+       "type": "noul",
+       "value": 0.86
+      },
+      "wormhole_pollution": {
+       "type": "score",
+       "value": 0.43
+      }
+     }
+    }
+   ],
+   "denylist_vs_model": {
+    "denylist_size": 49,
+    "denylist_matched": 42,
+    "denylist_unmatched": [
+     "Army",
+     "Cherokee",
+     "Circo",
+     "Hyper Tough",
+     "Rare",
+     "Room Essentials",
+     "a.n.a"
+    ],
+    "model_excluded": 57,
+    "overlap": 39,
+    "only_denylist": [
+     "Charming Charlie",
+     "Loot Crate",
+     "Rue21"
+    ],
+    "only_model": [
+     "Almost Famous",
+     "Amazon",
+     "Ambiance Apparel",
+     "Apt. 9",
+     "Celebrate It",
+     "Cloud Island",
+     "Custom Variety Pack",
+     "Derek Heart",
+     "Magellan",
+     "Mossimo",
+     "NASCAR",
+     "Native",
+     "New Directions",
+     "QVC",
+     "Recollections",
+     "Sephora",
+     "Time and Tru",
+     "Wondershop"
+    ]
+   }
+  }
+ }
+}
diff --git a/website/static/data/merrec-decision-twins.json b/website/static/data/merrec-decision-twins.json
new file mode 100644
index 000000000..a8caef69b
--- /dev/null
+++ b/website/static/data/merrec-decision-twins.json
@@ -0,0 +1,2920 @@
+{
+ "license": "CC-BY-NC-4.0; derived from the MerRec dataset, Copyright Mercari, Inc.; see LICENSE-MERREC.md in this directory",
+ "name": "a_brand_resolution",
+ "description": "Brand twins resolved by a decision model: the 120 highest fan-Jaccard pairs among the 2,000 most liked accepted brands, the pairs accepted as one brand, the exact fan counts of the merged brands and a trigram control over all 20,000 names.",
+ "captures": [
+  "a_brand_resolution_live.json"
+ ],
+ "server_binary_sha256": "e2aaf1424e9dd8605835ddb3e09abef2cb5b3629796e3c4a11bb43dac3c9d697",
+ "questions": {
+  "relationship_type": {
+   "type": "choice",
+   "instructions": "Determine the exact catalog relationship between Brand A and Brand B, which share high behavioral fan overlap in a peer-to-peer marketplace.",
+   "criteria": {
+    "same_entity_alias": "Exact same brand, artist group, or company entered under two different names, abbreviations, acronyms, or historical rebrands (e.g., 'Tomorrow X Together' = 'TXT', 'A Bathing Ape' = 'Bape', 'Mugler' = 'Thierry Mugler', 'Dior' = 'Christian Dior', 'Good Smile' = 'Good Smile Company', 'Jeffree Star Cosmetics' = 'JSC')",
+    "sub_brand_or_diffusion_line": "One is a direct sub-brand, diffusion line, or division of the other parent fashion/footwear brand (e.g., 'Victoria\\'s Secret' and 'PINK', 'Free People' and 'We The Free', 'Nike' and 'Air Jordan'/'Jordan', 'NCT' and sub-unit 'NCT 127' or 'NCT Dream')",
+    "ip_franchise_and_owner_maker": "One is a character IP / game / anime franchise and the other is its parent studio, publisher, or toy manufacturer (e.g., 'Hello Kitty'/'My Melody'/'Kuromi'/'Cinnamoroll' and 'Sanrio', 'Rilakkuma' and 'San-X', 'Yu-Gi-Oh!' and 'Konami', 'Pokemon' and 'Nintendo', 'Gundam' and 'Bandai')",
+    "distinct_co_liked_peers": "Two distinct competing brands, separate music artists/groups, or sister characters that merely appeal to the same fan demographic (e.g., 'Ateez' vs 'Stray Kids', 'Panini' vs 'Topps', 'My Melody' vs 'Kuromi')"
+   }
+  },
+  "should_merge_brand_id": {
+   "type": "noul",
+   "instructions": "In a master brand catalog deduplication pipeline, should Brand A and Brand B be merged into a single canonical `brand_id` because they denote the exact same brand entity (acronym, abbreviation, spelling variant, or rebrand)?",
+   "criteria": {
+    "true": "Yes: Brand A and Brand B are synonymous names/abbreviations/rebrands for the exact same entity and splitting them is a catalog duplication bug",
+    "false": "No: They are distinct brands, character vs parent company, parent vs sub-brand, or separate artists/characters"
+   }
+  },
+  "alignment_score": {
+   "type": "score",
+   "instructions": "Rate the ontological equivalence between Brand A and Brand B.",
+   "criteria": [
+    "0 - Separate competing brands, separate musical artists, or distinct sister characters",
+    "1 - Franchise/character IP paired with its manufacturer or publisher (e.g., Hello Kitty & Sanrio)",
+    "2 - Parent brand paired with an official sub-brand, division, or group sub-unit (e.g., Victoria's Secret & PINK)",
+    "3 - Identical brand entity split across two catalog strings (e.g., TXT & Tomorrow X Together, Bape & A Bathing Ape)"
+   ]
+  }
+ },
+ "policy": {
+  "action_question": "should_merge_brand_id",
+  "accept_min": 0.7,
+  "review_min": 0.3,
+  "require": {
+   "relationship_type": [
+    "same_entity_alias"
+   ]
+  }
+ },
+ "ontology": {
+  "rows": 179,
+  "excluded_brand_ids": 82
+ },
+ "sql": {
+  "probe": "WITH fans AS (\n  SELECT -(e.user_id + 1) AS src, CAST(i.brand_id AS BIGINT) AS dst\n  FROM merrec_events e JOIN merrec_items i ON i.item_id = e.item_id\n  LEFT JOIN brand_ontology o ON o.brand_id = CAST(i.brand_id AS BIGINT)\n  WHERE e.event_type = 'item_like' AND i.brand_id <> 0\n    AND (o.brand_id IS NULL OR o.band = 'accept')\n  GROUP BY e.user_id, i.brand_id\n), top_brands AS (\n  SELECT dst AS brand_id, COUNT(*) AS fans FROM fans GROUP BY dst ORDER BY fans DESC, dst LIMIT 2000\n), brands AS (\n  SELECT CAST(brand_id AS BIGINT) AS brand_id, MIN(brand_name) AS brand_name\n  FROM merrec_items WHERE brand_id <> 0 GROUP BY brand_id\n)\nSELECT r.first AS brand_id_a, ba.brand_name AS brand_a,\n       r.second AS brand_id_b, bb.brand_name AS brand_b,\n       a.fans AS fans_a, b.fans AS fans_b, r.similarity AS jaccard\nFROM cugraph_jaccard(\n  edges => (SELECT src, dst FROM fans),\n  vertex_pairs => (SELECT a.brand_id AS first, b.brand_id AS second\n                   FROM top_brands a JOIN top_brands b ON a.brand_id < b.brand_id),\n  directed => false\n) r\nJOIN top_brands a ON a.brand_id = r.first\nJOIN top_brands b ON b.brand_id = r.second\nJOIN brands ba ON ba.brand_id = r.first\nJOIN brands bb ON bb.brand_id = r.second\nORDER BY r.similarity DESC, r.first, r.second\nLIMIT 120\n",
+  "context": "WITH target_items AS (\n  SELECT CAST(brand_id AS BIGINT) AS brand_id, category_path, name, price\n  FROM merrec_items\n  WHERE brand_id IN ({brand_ids})\n), stats AS (\n  SELECT brand_id, COUNT(*) AS listings, ROUND(AVG(price), 2) AS avg_price\n  FROM target_items\n  GROUP BY brand_id\n), top_cat AS (\n  SELECT brand_id, category_path,\n         ROW_NUMBER() OVER (PARTITION BY brand_id ORDER BY COUNT(*) DESC, category_path) AS rk\n  FROM target_items\n  WHERE category_path IS NOT NULL\n  GROUP BY brand_id, category_path\n), sample_titles AS (\n  SELECT brand_id, name,\n         ROW_NUMBER() OVER (PARTITION BY brand_id ORDER BY name) AS trk\n  FROM target_items\n  WHERE name IS NOT NULL\n)\nSELECT s.brand_id, s.listings, s.avg_price,\n       MAX(CASE WHEN tc.rk = 1 THEN tc.category_path END) AS top_category,\n       MAX(CASE WHEN tc.rk = 2 THEN tc.category_path END) AS second_category,\n       MAX(CASE WHEN st.trk = 5 THEN st.name END) AS sample_1,\n       MAX(CASE WHEN st.trk = 25 THEN st.name END) AS sample_2,\n       MAX(CASE WHEN st.trk = 50 THEN st.name END) AS sample_3\nFROM stats s\nLEFT JOIN top_cat tc ON tc.brand_id = s.brand_id AND tc.rk <= 2\nLEFT JOIN sample_titles st ON st.brand_id = s.brand_id AND st.trk IN (5, 25, 50)\nGROUP BY s.brand_id, s.listings, s.avg_price\nORDER BY s.brand_id\n",
+  "canonical": "SELECT vertex AS brand_id, component AS canonical_id\nFROM cugraph_weakly_connected_components(\n  edges => (SELECT brand_id_a AS src, brand_id_b AS dst FROM brand_pairs WHERE band = 'accept'),\n  directed => false\n)\nORDER BY canonical_id, brand_id\n",
+  "dedup": "WITH likes AS (\n  SELECT c.canonical_id, c.brand_id, e.user_id\n  FROM merrec_events e\n  JOIN merrec_items i ON i.item_id = e.item_id\n  JOIN brand_canonical c ON c.brand_id = CAST(i.brand_id AS BIGINT)\n  WHERE e.event_type = 'item_like'\n), member_fans AS (\n  SELECT canonical_id, brand_id, COUNT(DISTINCT user_id) AS fans\n  FROM likes GROUP BY canonical_id, brand_id\n), union_fans AS (\n  SELECT canonical_id, COUNT(DISTINCT user_id) AS exact_union_fans\n  FROM likes GROUP BY canonical_id\n), brands AS (\n  SELECT CAST(brand_id AS BIGINT) AS brand_id, MIN(brand_name) AS brand_name\n  FROM merrec_items WHERE brand_id <> 0 GROUP BY brand_id\n)\nSELECT m.canonical_id,\n       MIN(cb.brand_name) AS canonical_name,\n       COUNT(*) AS members,\n       MAX(m.fans) AS primary_fans,\n       SUM(m.fans) AS naive_sum_fans,\n       MAX(u.exact_union_fans) AS exact_union_fans,\n       ROUND(100.0 * (MAX(u.exact_union_fans) - MAX(m.fans)) / MAX(m.fans), 1) AS gain_pct,\n       ROUND(100.0 * (SUM(m.fans) - MAX(u.exact_union_fans)) / SUM(m.fans), 1) AS double_count_pct\nFROM member_fans m\nJOIN union_fans u ON u.canonical_id = m.canonical_id\nJOIN brands cb ON cb.brand_id = m.canonical_id\nGROUP BY m.canonical_id\nORDER BY exact_union_fans DESC, m.canonical_id\n"
+ },
+ "stages": [
+  {
+   "name": "probe",
+   "rows": 120,
+   "elapsed_s": 3.287839761003852,
+   "query_id": "aecb6cc4-181b-4f99-9461-a21d737ca8f5",
+   "native_fragments": 6,
+   "host_boundaries": 0,
+   "allocator_peak_bytes": 75028853123,
+   "query_limit_bytes": 96636764160
+  },
+  {
+   "name": "context",
+   "rows": 157,
+   "elapsed_s": 0.5209308722987771,
+   "query_id": "f55b0d08-2558-41b0-aceb-95ed73ae555c",
+   "native_fragments": 1,
+   "host_boundaries": 0,
+   "allocator_peak_bytes": 11622153154,
+   "query_limit_bytes": 96636764160
+  },
+  {
+   "name": "canonical",
+   "rows": 36,
+   "elapsed_s": 0.022468896117061377,
+   "query_id": "320d6edb-96f2-45f5-8e72-f09441fbae4f",
+   "native_fragments": 2,
+   "host_boundaries": 0,
+   "allocator_peak_bytes": 13862,
+   "query_limit_bytes": 96636764160
+  },
+  {
+   "name": "dedup",
+   "rows": 18,
+   "elapsed_s": 2.8503389838151634,
+   "query_id": "93fd28b1-3e07-4bcc-aab9-7e2acf6cb569",
+   "native_fragments": 1,
+   "host_boundaries": 0,
+   "allocator_peak_bytes": 31264881599,
+   "query_limit_bytes": 96636764160
+  },
+  {
+   "name": "brand_names",
+   "rows": 20000,
+   "elapsed_s": 0.09620286244899035,
+   "query_id": "767f3a94-3cbd-489b-8ba5-494a56578036",
+   "native_fragments": 1,
+   "host_boundaries": 0,
+   "allocator_peak_bytes": 4382405297,
+   "query_limit_bytes": 96636764160
+  }
+ ],
+ "decisions": [
+  {
+   "name": "decide",
+   "entities": 120,
+   "distinct_states": 120,
+   "registry_hits": 0,
+   "hit_rate": 0.0,
+   "api_calls": 120,
+   "wall_s": 5.640766701195389,
+   "input_tokens": 146828,
+   "output_tokens": 12686,
+   "cost_usd": 0.006166776000000003,
+   "latency_ms_p50": 577,
+   "latency_ms_p95": 1064,
+   "latency_ms_max": 2125
+  }
+ ],
+ "totals": {
+  "gpu_elapsed_s": 6.777781375683844,
+  "decide_wall_s": 5.640766701195389,
+  "entities": 120,
+  "registry_hits": 0,
+  "api_calls": 120,
+  "input_tokens": 146828,
+  "output_tokens": 12686,
+  "cost_usd": 0.006166776000000003,
+  "max_host_boundaries": 0
+ },
+ "band_counts": {
+  "accept": 18,
+  "review": 7,
+  "reject": 95
+ },
+ "relationship_counts": {
+  "distinct_co_liked_peers": 82,
+  "ip_franchise_and_owner_maker": 6,
+  "same_entity_alias": 22,
+  "sub_brand_or_diffusion_line": 10
+ },
+ "pairs": [
+  {
+   "rank": 1,
+   "brand_id_a": 22527,
+   "brand_a": "Tomorrow X Together",
+   "brand_id_b": 23732,
+   "brand_b": "TXT",
+   "fans_a": 13880,
+   "fans_b": 8267,
+   "jaccard": 0.43578606843948364,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.73,
+   "alignment_score": 2.83,
+   "band": "accept",
+   "trigram_similarity": 0.0476
+  },
+  {
+   "rank": 2,
+   "brand_id_a": 19332,
+   "brand_a": "Rilakkuma",
+   "brand_id_b": 22167,
+   "brand_b": "San-X",
+   "fans_a": 10232,
+   "fans_b": 14392,
+   "jaccard": 0.36739227175712585,
+   "relationship_type": "ip_franchise_and_owner_maker",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.1,
+   "alignment_score": 1.03,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 3,
+   "brand_id_a": 3698,
+   "brand_a": "Baby Tula",
+   "brand_id_b": 23174,
+   "brand_b": "Tula",
+   "fans_a": 3398,
+   "fans_b": 3806,
+   "jaccard": 0.35515424609184265,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.76,
+   "should_merge_brand_id": 0.44,
+   "alignment_score": 2.24,
+   "band": "review",
+   "trigram_similarity": 0.5
+  },
+  {
+   "rank": 4,
+   "brand_id_a": 436,
+   "brand_a": "Air Jordan",
+   "brand_id_b": 11073,
+   "brand_b": "Jordan",
+   "fans_a": 123149,
+   "fans_b": 72496,
+   "jaccard": 0.3533264994621277,
+   "relationship_type": "sub_brand_or_diffusion_line",
+   "relationship_type_p": 0.78,
+   "should_merge_brand_id": 0.54,
+   "alignment_score": 2.32,
+   "band": "review",
+   "trigram_similarity": 0.6364
+  },
+  {
+   "rank": 5,
+   "brand_id_a": 13832,
+   "brand_a": "Mugler",
+   "brand_id_b": 22763,
+   "brand_b": "Thierry Mugler",
+   "fans_a": 6232,
+   "fans_b": 5925,
+   "jaccard": 0.34823110699653625,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.9,
+   "alignment_score": 2.92,
+   "band": "accept",
+   "trigram_similarity": 0.4667
+  },
+  {
+   "rank": 6,
+   "brand_id_a": 8486,
+   "brand_a": "Freebird",
+   "brand_id_b": 8593,
+   "brand_b": "Freebird By Steven",
+   "fans_a": 2949,
+   "fans_b": 4173,
+   "jaccard": 0.34377357363700867,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.6900000000000001,
+   "should_merge_brand_id": 0.61,
+   "alignment_score": 2.31,
+   "band": "review",
+   "trigram_similarity": 0.4737
+  },
+  {
+   "rank": 7,
+   "brand_id_a": 9755,
+   "brand_a": "Hello Kitty",
+   "brand_id_b": 19884,
+   "brand_b": "Sanrio",
+   "fans_a": 72010,
+   "fans_b": 109359,
+   "jaccard": 0.3370266258716583,
+   "relationship_type": "ip_franchise_and_owner_maker",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.09,
+   "alignment_score": 1.03,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 8,
+   "brand_id_a": 3481,
+   "brand_a": "Bandai Tamashii Nations",
+   "brand_id_b": 20151,
+   "brand_b": "SH Figuarts",
+   "fans_a": 19742,
+   "fans_b": 9907,
+   "jaccard": 0.33409827947616577,
+   "relationship_type": "sub_brand_or_diffusion_line",
+   "relationship_type_p": 0.95,
+   "should_merge_brand_id": 0.21,
+   "alignment_score": 1.99,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 9,
+   "brand_id_a": 11904,
+   "brand_a": "Konami",
+   "brand_id_b": 25248,
+   "brand_b": "Yu-Gi-Oh!",
+   "fans_a": 12915,
+   "fans_b": 8340,
+   "jaccard": 0.3244641125202179,
+   "relationship_type": "ip_franchise_and_owner_maker",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.11,
+   "alignment_score": 1.02,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 10,
+   "brand_id_a": 25269,
+   "brand_a": "Yves Saint Laurent",
+   "brand_id_b": 25277,
+   "brand_b": "YSL Yves Saint Laurent",
+   "fans_a": 22460,
+   "fans_b": 23895,
+   "jaccard": 0.3239746391773224,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.87,
+   "alignment_score": 2.93,
+   "band": "accept",
+   "trigram_similarity": 0.8571
+  },
+  {
+   "rank": 11,
+   "brand_id_a": 4513,
+   "brand_a": "Christian Dior",
+   "brand_id_b": 5856,
+   "brand_b": "Dior",
+   "fans_a": 38883,
+   "fans_b": 37626,
+   "jaccard": 0.32126203179359436,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.78,
+   "alignment_score": 2.86,
+   "band": "accept",
+   "trigram_similarity": 0.3333
+  },
+  {
+   "rank": 12,
+   "brand_id_a": 303,
+   "brand_a": "A Bathing Ape",
+   "brand_id_b": 2493,
+   "brand_b": "Bape",
+   "fans_a": 12620,
+   "fans_b": 13245,
+   "jaccard": 0.320249080657959,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.87,
+   "alignment_score": 2.89,
+   "band": "accept",
+   "trigram_similarity": 0.2857
+  },
+  {
+   "rank": 13,
+   "brand_id_a": 2830,
+   "brand_a": "BabyBjorn",
+   "brand_id_b": 3422,
+   "brand_b": "BABYBJÖRN",
+   "fans_a": 2969,
+   "fans_b": 3434,
+   "jaccard": 0.3202061951160431,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.92,
+   "alignment_score": 2.95,
+   "band": "accept",
+   "trigram_similarity": 0.5385
+  },
+  {
+   "rank": 14,
+   "brand_id_a": 9624,
+   "brand_a": "Hermès",
+   "brand_id_b": 9895,
+   "brand_b": "HERMES",
+   "fans_a": 8923,
+   "fans_b": 7051,
+   "jaccard": 0.3201652765274048,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.86,
+   "alignment_score": 2.92,
+   "band": "accept",
+   "trigram_similarity": 0.4
+  },
+  {
+   "rank": 15,
+   "brand_id_a": 7262,
+   "brand_a": "Essentials",
+   "brand_id_b": 8602,
+   "brand_b": "Fear of God",
+   "fans_a": 10099,
+   "fans_b": 11729,
+   "jaccard": 0.31517744064331055,
+   "relationship_type": "sub_brand_or_diffusion_line",
+   "relationship_type_p": 0.91,
+   "should_merge_brand_id": 0.15,
+   "alignment_score": 1.04,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 16,
+   "brand_id_a": 18406,
+   "brand_a": "Panini",
+   "brand_id_b": 22635,
+   "brand_b": "Topps",
+   "fans_a": 36503,
+   "fans_b": 36718,
+   "jaccard": 0.3148670196533203,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.04,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 17,
+   "brand_id_a": 23265,
+   "brand_a": "Toy Biz",
+   "brand_id_b": 23415,
+   "brand_b": "Toybiz",
+   "fans_a": 7008,
+   "fans_b": 6707,
+   "jaccard": 0.3043271601200104,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.81,
+   "alignment_score": 2.88,
+   "band": "accept",
+   "trigram_similarity": 0.5
+  },
+  {
+   "rank": 18,
+   "brand_id_a": 4411,
+   "brand_a": "Collector's Gallery",
+   "brand_id_b": 22301,
+   "brand_b": "Stray Kids",
+   "fans_a": 10098,
+   "fans_b": 7822,
+   "jaccard": 0.3013797998428345,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.92,
+   "should_merge_brand_id": 0.08,
+   "alignment_score": 0.42,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 19,
+   "brand_id_a": 15822,
+   "brand_a": "NCT",
+   "brand_id_b": 22302,
+   "brand_b": "SM Entertainment",
+   "fans_a": 14569,
+   "fans_b": 16116,
+   "jaccard": 0.2992209196090698,
+   "relationship_type": "sub_brand_or_diffusion_line",
+   "relationship_type_p": 0.61,
+   "should_merge_brand_id": 0.09,
+   "alignment_score": 1.61,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 20,
+   "brand_id_a": 3611,
+   "brand_a": "Banpresto",
+   "brand_id_b": 9384,
+   "brand_b": "Good Smile Company",
+   "fans_a": 43473,
+   "fans_b": 40636,
+   "jaccard": 0.29709765315055847,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 21,
+   "brand_id_a": 2599,
+   "brand_a": "Bandai",
+   "brand_id_b": 3611,
+   "brand_b": "Banpresto",
+   "fans_a": 70021,
+   "fans_b": 43473,
+   "jaccard": 0.2914656400680542,
+   "relationship_type": "sub_brand_or_diffusion_line",
+   "relationship_type_p": 0.55,
+   "should_merge_brand_id": 0.07,
+   "alignment_score": 0.61,
+   "band": "reject",
+   "trigram_similarity": 0.2143
+  },
+  {
+   "rank": 22,
+   "brand_id_a": 17626,
+   "brand_a": "PINK",
+   "brand_id_b": 24159,
+   "brand_b": "Victoria's Secret",
+   "fans_a": 91079,
+   "fans_b": 140039,
+   "jaccard": 0.2841387093067169,
+   "relationship_type": "sub_brand_or_diffusion_line",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.09,
+   "alignment_score": 1.8,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 23,
+   "brand_id_a": 4815,
+   "brand_a": "Carter's",
+   "brand_id_b": 5617,
+   "brand_b": "Cat & Jack",
+   "fans_a": 70873,
+   "fans_b": 61575,
+   "jaccard": 0.2800000011920929,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.68,
+   "should_merge_brand_id": 0.07,
+   "alignment_score": 0.82,
+   "band": "reject",
+   "trigram_similarity": 0.1333
+  },
+  {
+   "rank": 24,
+   "brand_id_a": 22302,
+   "brand_a": "SM Entertainment",
+   "brand_id_b": 22531,
+   "brand_b": "Twice",
+   "fans_a": 16116,
+   "fans_b": 20576,
+   "jaccard": 0.2788233757019043,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.07,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 25,
+   "brand_id_a": 22529,
+   "brand_a": "Thrive Causemetics",
+   "brand_id_b": 22545,
+   "brand_b": "Thrive",
+   "fans_a": 2485,
+   "fans_b": 2745,
+   "jaccard": 0.2787286043167114,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.97,
+   "should_merge_brand_id": 0.74,
+   "alignment_score": 2.87,
+   "band": "accept",
+   "trigram_similarity": 0.3684
+  },
+  {
+   "rank": 26,
+   "brand_id_a": 3855,
+   "brand_a": "Bowman",
+   "brand_id_b": 6843,
+   "brand_b": "Donruss",
+   "fans_a": 8053,
+   "fans_b": 7271,
+   "jaccard": 0.27159571647644043,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.97,
+   "should_merge_brand_id": 0.07,
+   "alignment_score": 0.03,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 27,
+   "brand_id_a": 2595,
+   "brand_a": "Barbie",
+   "brand_id_b": 15568,
+   "brand_b": "Mattel",
+   "fans_a": 79520,
+   "fans_b": 118872,
+   "jaccard": 0.26959505677223206,
+   "relationship_type": "ip_franchise_and_owner_maker",
+   "relationship_type_p": 0.64,
+   "should_merge_brand_id": 0.09,
+   "alignment_score": 1.03,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 28,
+   "brand_id_a": 3838,
+   "brand_a": "BTS",
+   "brand_id_b": 22531,
+   "brand_b": "Twice",
+   "fans_a": 61458,
+   "fans_b": 20576,
+   "jaccard": 0.26466870307922363,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 29,
+   "brand_id_a": 7927,
+   "brand_a": "Fleer",
+   "brand_id_b": 23927,
+   "brand_b": "Upper Deck",
+   "fans_a": 7641,
+   "fans_b": 12982,
+   "jaccard": 0.2627357244491577,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0625
+  },
+  {
+   "rank": 30,
+   "brand_id_a": 14034,
+   "brand_a": "Microsoft",
+   "brand_id_b": 25168,
+   "brand_b": "Xbox",
+   "fans_a": 68969,
+   "fans_b": 37371,
+   "jaccard": 0.2621958553791046,
+   "relationship_type": "sub_brand_or_diffusion_line",
+   "relationship_type_p": 0.84,
+   "should_merge_brand_id": 0.12,
+   "alignment_score": 1.79,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 31,
+   "brand_id_a": 2152,
+   "brand_a": "Beats by Dr. Dre",
+   "brand_id_b": 3915,
+   "brand_b": "Beats",
+   "fans_a": 18814,
+   "fans_b": 7676,
+   "jaccard": 0.25867149233818054,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.82,
+   "should_merge_brand_id": 0.68,
+   "alignment_score": 2.34,
+   "band": "review",
+   "trigram_similarity": 0.4615
+  },
+  {
+   "rank": 32,
+   "brand_id_a": 13788,
+   "brand_a": "Manga",
+   "brand_id_b": 24126,
+   "brand_b": "Viz Media",
+   "fans_a": 48494,
+   "fans_b": 23050,
+   "jaccard": 0.25328895449638367,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.8,
+   "should_merge_brand_id": 0.1,
+   "alignment_score": 0.26,
+   "band": "reject",
+   "trigram_similarity": 0.0667
+  },
+  {
+   "rank": 33,
+   "brand_id_a": 10925,
+   "brand_a": "Isabel Maternity",
+   "brand_id_b": 14116,
+   "brand_b": "Motherhood Maternity",
+   "fans_a": 5181,
+   "fans_b": 8238,
+   "jaccard": 0.2522396445274353,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.07,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.3704
+  },
+  {
+   "rank": 34,
+   "brand_id_a": 17474,
+   "brand_a": "Polo Ralph Lauren",
+   "brand_id_b": 18895,
+   "brand_b": "Ralph Lauren",
+   "fans_a": 62987,
+   "fans_b": 48355,
+   "jaccard": 0.251539945602417,
+   "relationship_type": "sub_brand_or_diffusion_line",
+   "relationship_type_p": 0.76,
+   "should_merge_brand_id": 0.49,
+   "alignment_score": 2.23,
+   "band": "review",
+   "trigram_similarity": 0.7222
+  },
+  {
+   "rank": 35,
+   "brand_id_a": 3541,
+   "brand_a": "Bratz",
+   "brand_id_b": 14071,
+   "brand_b": "MGA Entertainment",
+   "fans_a": 20231,
+   "fans_b": 31221,
+   "jaccard": 0.2501700818538666,
+   "relationship_type": "ip_franchise_and_owner_maker",
+   "relationship_type_p": 0.8099999999999999,
+   "should_merge_brand_id": 0.09,
+   "alignment_score": 1.03,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 36,
+   "brand_id_a": 8851,
+   "brand_a": "Gap",
+   "brand_id_b": 16658,
+   "brand_b": "Old Navy",
+   "fans_a": 86674,
+   "fans_b": 127634,
+   "jaccard": 0.24442121386528015,
+   "relationship_type": "sub_brand_or_diffusion_line",
+   "relationship_type_p": 0.72,
+   "should_merge_brand_id": 0.06,
+   "alignment_score": 1.24,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 37,
+   "brand_id_a": 9549,
+   "brand_a": "Hourglass Cosmetics",
+   "brand_id_b": 9730,
+   "brand_b": "Hourglass",
+   "fans_a": 6397,
+   "fans_b": 2383,
+   "jaccard": 0.24362605810165405,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.94,
+   "should_merge_brand_id": 0.69,
+   "alignment_score": 2.68,
+   "band": "review",
+   "trigram_similarity": 0.5
+  },
+  {
+   "rank": 38,
+   "brand_id_a": 6843,
+   "brand_a": "Donruss",
+   "brand_id_b": 7927,
+   "brand_b": "Fleer",
+   "fans_a": 7271,
+   "fans_b": 7641,
+   "jaccard": 0.24297741055488586,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.04,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 39,
+   "brand_id_a": 4713,
+   "brand_a": "Children's Place",
+   "brand_id_b": 22826,
+   "brand_b": "The Children's Place",
+   "fans_a": 22072,
+   "fans_b": 17548,
+   "jaccard": 0.239907369017601,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.85,
+   "alignment_score": 2.94,
+   "band": "accept",
+   "trigram_similarity": 0.8
+  },
+  {
+   "rank": 40,
+   "brand_id_a": 3438,
+   "brand_a": "By Kilian",
+   "brand_id_b": 12327,
+   "brand_b": "KILIAN",
+   "fans_a": 2273,
+   "fans_b": 7040,
+   "jaccard": 0.2397497296333313,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.88,
+   "alignment_score": 2.94,
+   "band": "accept",
+   "trigram_similarity": 0.7
+  },
+  {
+   "rank": 41,
+   "brand_id_a": 10596,
+   "brand_a": "Ingrid & Isabel",
+   "brand_id_b": 10925,
+   "brand_b": "Isabel Maternity",
+   "fans_a": 2713,
+   "fans_b": 5181,
+   "jaccard": 0.2371101677417755,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.93,
+   "should_merge_brand_id": 0.18,
+   "alignment_score": 0.19,
+   "band": "reject",
+   "trigram_similarity": 0.3043
+  },
+  {
+   "rank": 42,
+   "brand_id_a": 21482,
+   "brand_a": "Sizzix",
+   "brand_id_b": 23384,
+   "brand_b": "Tim Holtz",
+   "fans_a": 2162,
+   "fans_b": 2474,
+   "jaccard": 0.23659642040729523,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.86,
+   "should_merge_brand_id": 0.05,
+   "alignment_score": 0.2,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 43,
+   "brand_id_a": 2033,
+   "brand_a": "ATEEZ",
+   "brand_id_b": 22307,
+   "brand_b": "SEVENTEEN",
+   "fans_a": 16297,
+   "fans_b": 13786,
+   "jaccard": 0.23539073765277863,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0667
+  },
+  {
+   "rank": 44,
+   "brand_id_a": 3373,
+   "brand_a": "Boutique",
+   "brand_id_b": 10235,
+   "brand_b": "Handmade",
+   "fans_a": 224817,
+   "fans_b": 397593,
+   "jaccard": 0.23518554866313934,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.05,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 45,
+   "brand_id_a": 11658,
+   "brand_a": "Jamie kay",
+   "brand_id_b": 18806,
+   "brand_b": "Rylee + Cru",
+   "fans_a": 5427,
+   "fans_b": 6163,
+   "jaccard": 0.23481781780719757,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 46,
+   "brand_id_a": 8170,
+   "brand_a": "FOREVER 21",
+   "brand_id_b": 22105,
+   "brand_b": "SHEIN",
+   "fans_a": 75763,
+   "fans_b": 99093,
+   "jaccard": 0.2340482622385025,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 47,
+   "brand_id_a": 6959,
+   "brand_a": "EVGA",
+   "brand_id_b": 8726,
+   "brand_b": "Gigabyte",
+   "fans_a": 4387,
+   "fans_b": 4136,
+   "jaccard": 0.23342980444431305,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 48,
+   "brand_id_a": 6959,
+   "brand_a": "EVGA",
+   "brand_id_b": 15716,
+   "brand_b": "NVIDIA",
+   "fans_a": 4387,
+   "fans_b": 5202,
+   "jaccard": 0.23125320672988892,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.87,
+   "should_merge_brand_id": 0.05,
+   "alignment_score": 0.07,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 49,
+   "brand_id_a": 9272,
+   "brand_a": "Garden Collection",
+   "brand_id_b": 9296,
+   "brand_b": "Garden at Home",
+   "fans_a": 2665,
+   "fans_b": 5014,
+   "jaccard": 0.22883661091327667,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.1,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.2692
+  },
+  {
+   "rank": 50,
+   "brand_id_a": 7927,
+   "brand_a": "Fleer",
+   "brand_id_b": 20184,
+   "brand_b": "SkyBox",
+   "fans_a": 7641,
+   "fans_b": 3725,
+   "jaccard": 0.2279602438211441,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.06,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 51,
+   "brand_id_a": 3611,
+   "brand_a": "Banpresto",
+   "brand_id_b": 20222,
+   "brand_b": "Sega",
+   "fans_a": 43473,
+   "fans_b": 43434,
+   "jaccard": 0.22776012122631073,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.95,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 52,
+   "brand_id_a": 208,
+   "brand_a": "All Saints",
+   "brand_id_b": 514,
+   "brand_b": "AllSaints",
+   "fans_a": 2433,
+   "fans_b": 3201,
+   "jaccard": 0.22718362510204315,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.98,
+   "should_merge_brand_id": 0.9,
+   "alignment_score": 2.94,
+   "band": "accept",
+   "trigram_similarity": 0.6154
+  },
+  {
+   "rank": 53,
+   "brand_id_a": 18593,
+   "brand_a": "Quincy Mae",
+   "brand_id_b": 18806,
+   "brand_b": "Rylee + Cru",
+   "fans_a": 4501,
+   "fans_b": 6163,
+   "jaccard": 0.22701644897460938,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.04,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 54,
+   "brand_id_a": 9384,
+   "brand_a": "Good Smile Company",
+   "brand_id_b": 23485,
+   "brand_b": "Taito",
+   "fans_a": 40636,
+   "fans_b": 19799,
+   "jaccard": 0.22623516619205475,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 55,
+   "brand_id_a": 400,
+   "brand_a": "Armani Exchange",
+   "brand_id_b": 715,
+   "brand_b": "A|X Armani Exchange",
+   "fans_a": 3097,
+   "fans_b": 2155,
+   "jaccard": 0.22538498044013977,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.91,
+   "alignment_score": 2.93,
+   "band": "accept",
+   "trigram_similarity": 0.8889
+  },
+  {
+   "rank": 56,
+   "brand_id_a": 2916,
+   "brand_a": "BB",
+   "brand_id_b": 25740,
+   "brand_b": "illumicrate",
+   "fans_a": 6739,
+   "fans_b": 12207,
+   "jaccard": 0.22532661259174347,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.07,
+   "alignment_score": 0.03,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 57,
+   "brand_id_a": 14353,
+   "brand_a": "Mega Bloks",
+   "brand_id_b": 15213,
+   "brand_b": "Mega Construx",
+   "fans_a": 5295,
+   "fans_b": 5325,
+   "jaccard": 0.22519612312316895,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.51,
+   "should_merge_brand_id": 0.3,
+   "alignment_score": 0.52,
+   "band": "review",
+   "trigram_similarity": 0.25
+  },
+  {
+   "rank": 58,
+   "brand_id_a": 9384,
+   "brand_a": "Good Smile Company",
+   "brand_id_b": 20222,
+   "brand_b": "Sega",
+   "fans_a": 40636,
+   "fans_b": 43434,
+   "jaccard": 0.22495664656162262,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.93,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0435
+  },
+  {
+   "rank": 59,
+   "brand_id_a": 472,
+   "brand_a": "Adidas",
+   "brand_id_b": 15987,
+   "brand_b": "Nike",
+   "fans_a": 203424,
+   "fans_b": 507979,
+   "jaccard": 0.22330038249492645,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 60,
+   "brand_id_a": 3611,
+   "brand_a": "Banpresto",
+   "brand_id_b": 23485,
+   "brand_b": "Taito",
+   "fans_a": 43473,
+   "fans_b": 19799,
+   "jaccard": 0.2225055992603302,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0667
+  },
+  {
+   "rank": 61,
+   "brand_id_a": 9647,
+   "brand_a": "Hanna Andersson",
+   "brand_id_b": 13808,
+   "brand_b": "Mini Boden",
+   "fans_a": 23138,
+   "fans_b": 14622,
+   "jaccard": 0.22208556532859802,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.08,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 62,
+   "brand_id_a": 22625,
+   "brand_a": "Titleist",
+   "brand_id_b": 22713,
+   "brand_b": "TaylorMade",
+   "fans_a": 7499,
+   "fans_b": 8476,
+   "jaccard": 0.22189077734947205,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0526
+  },
+  {
+   "rank": 63,
+   "brand_id_a": 15822,
+   "brand_a": "NCT",
+   "brand_id_b": 22307,
+   "brand_b": "SEVENTEEN",
+   "fans_a": 14569,
+   "fans_b": 13786,
+   "jaccard": 0.22109296917915344,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 64,
+   "brand_id_a": 4356,
+   "brand_a": "Crystal",
+   "brand_id_b": 4479,
+   "brand_b": "Crystal Rock",
+   "fans_a": 9481,
+   "fans_b": 24256,
+   "jaccard": 0.22063027322292328,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.98,
+   "should_merge_brand_id": 0.17,
+   "alignment_score": 0.14,
+   "band": "reject",
+   "trigram_similarity": 0.6154
+  },
+  {
+   "rank": 65,
+   "brand_id_a": 15818,
+   "brand_a": "Nishane",
+   "brand_id_b": 25163,
+   "brand_b": "Xerjoff",
+   "fans_a": 2370,
+   "fans_b": 3848,
+   "jaccard": 0.22041216492652893,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 66,
+   "brand_id_a": 17360,
+   "brand_a": "PlayStation",
+   "brand_id_b": 20652,
+   "brand_b": "Sony",
+   "fans_a": 50216,
+   "fans_b": 160635,
+   "jaccard": 0.21950387954711914,
+   "relationship_type": "sub_brand_or_diffusion_line",
+   "relationship_type_p": 0.93,
+   "should_merge_brand_id": 0.1,
+   "alignment_score": 1.64,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 67,
+   "brand_id_a": 2033,
+   "brand_a": "ATEEZ",
+   "brand_id_b": 15822,
+   "brand_b": "NCT",
+   "fans_a": 16297,
+   "fans_b": 14569,
+   "jaccard": 0.21802611649036407,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.04,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 68,
+   "brand_id_a": 6843,
+   "brand_a": "Donruss",
+   "brand_id_b": 23927,
+   "brand_b": "Upper Deck",
+   "fans_a": 7271,
+   "fans_b": 12982,
+   "jaccard": 0.21800577640533447,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0556
+  },
+  {
+   "rank": 69,
+   "brand_id_a": 2033,
+   "brand_a": "ATEEZ",
+   "brand_id_b": 4411,
+   "brand_b": "Collector's Gallery",
+   "fans_a": 16297,
+   "fans_b": 10098,
+   "jaccard": 0.21753771603107452,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.05,
+   "alignment_score": 0.05,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 70,
+   "brand_id_a": 2599,
+   "brand_a": "Bandai",
+   "brand_id_b": 9384,
+   "brand_b": "Good Smile Company",
+   "fans_a": 70021,
+   "fans_b": 40636,
+   "jaccard": 0.21696048974990845,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.98,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 71,
+   "brand_id_a": 9384,
+   "brand_a": "Good Smile Company",
+   "brand_id_b": 13788,
+   "brand_b": "Manga",
+   "fans_a": 40636,
+   "fans_b": 48494,
+   "jaccard": 0.21654269099235535,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.96,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 72,
+   "brand_id_a": 9004,
+   "brand_a": "Gucci",
+   "brand_id_b": 12906,
+   "brand_b": "Louis Vuitton",
+   "fans_a": 81287,
+   "fans_b": 81888,
+   "jaccard": 0.21648924052715302,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 73,
+   "brand_id_a": 1243,
+   "brand_a": "Amouage",
+   "brand_id_b": 25163,
+   "brand_b": "Xerjoff",
+   "fans_a": 2499,
+   "fans_b": 3848,
+   "jaccard": 0.21636642515659332,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 74,
+   "brand_id_a": 2033,
+   "brand_a": "ATEEZ",
+   "brand_id_b": 3838,
+   "brand_b": "BTS",
+   "fans_a": 16297,
+   "fans_b": 61458,
+   "jaccard": 0.21617606282234192,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 75,
+   "brand_id_a": 4495,
+   "brand_a": "Callaway",
+   "brand_id_b": 22713,
+   "brand_b": "TaylorMade",
+   "fans_a": 10082,
+   "fans_b": 8476,
+   "jaccard": 0.21612057089805603,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 76,
+   "brand_id_a": 1842,
+   "brand_a": "Alter",
+   "brand_id_b": 8543,
+   "brand_b": "Freeing",
+   "fans_a": 3319,
+   "fans_b": 4970,
+   "jaccard": 0.21575242280960083,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.04,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 77,
+   "brand_id_a": 2033,
+   "brand_a": "ATEEZ",
+   "brand_id_b": 22527,
+   "brand_b": "Tomorrow X Together",
+   "fans_a": 16297,
+   "fans_b": 13880,
+   "jaccard": 0.2154422402381897,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.4,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 78,
+   "brand_id_a": 11726,
+   "brand_a": "Kay Jewelers",
+   "brand_id_b": 25439,
+   "brand_b": "Zales",
+   "fans_a": 6401,
+   "fans_b": 4807,
+   "jaccard": 0.214696004986763,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.96,
+   "should_merge_brand_id": 0.07,
+   "alignment_score": 0.08,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 79,
+   "brand_id_a": 17571,
+   "brand_a": "Pampered Chef",
+   "brand_id_b": 23414,
+   "brand_b": "The Pampered Chef",
+   "fans_a": 7075,
+   "fans_b": 2818,
+   "jaccard": 0.2138650268316269,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.98,
+   "should_merge_brand_id": 0.84,
+   "alignment_score": 2.94,
+   "band": "accept",
+   "trigram_similarity": 0.7778
+  },
+  {
+   "rank": 80,
+   "brand_id_a": 423,
+   "brand_a": "Ani Mate",
+   "brand_id_b": 7672,
+   "brand_b": "Ensky",
+   "fans_a": 7716,
+   "fans_b": 5044,
+   "jaccard": 0.21258196234703064,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.05,
+   "alignment_score": 0.04,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 81,
+   "brand_id_a": 3838,
+   "brand_a": "BTS",
+   "brand_id_b": 22302,
+   "brand_b": "SM Entertainment",
+   "fans_a": 61458,
+   "fans_b": 16116,
+   "jaccard": 0.2116393893957138,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 82,
+   "brand_id_a": 15777,
+   "brand_a": "Natasha Denona",
+   "brand_id_b": 17094,
+   "brand_b": "PAT McGRATH LABS",
+   "fans_a": 7258,
+   "fans_b": 7295,
+   "jaccard": 0.21153846383094788,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 83,
+   "brand_id_a": 3611,
+   "brand_a": "Banpresto",
+   "brand_id_b": 13788,
+   "brand_b": "Manga",
+   "fans_a": 43473,
+   "fans_b": 48494,
+   "jaccard": 0.21108008921146393,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.98,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 84,
+   "brand_id_a": 19973,
+   "brand_a": "Stampd",
+   "brand_id_b": 21833,
+   "brand_b": "Sterling",
+   "fans_a": 26522,
+   "fans_b": 51637,
+   "jaccard": 0.208600714802742,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.1,
+   "alignment_score": 0.03,
+   "band": "reject",
+   "trigram_similarity": 0.1429
+  },
+  {
+   "rank": 85,
+   "brand_id_a": 11658,
+   "brand_a": "Jamie kay",
+   "brand_id_b": 18593,
+   "brand_b": "Quincy Mae",
+   "fans_a": 5427,
+   "fans_b": 4501,
+   "jaccard": 0.20763897895812988,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.05,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 86,
+   "brand_id_a": 4411,
+   "brand_a": "Collector's Gallery",
+   "brand_id_b": 22531,
+   "brand_b": "Twice",
+   "fans_a": 10098,
+   "fans_b": 20576,
+   "jaccard": 0.20754271745681763,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.05,
+   "alignment_score": 0.05,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 87,
+   "brand_id_a": 8726,
+   "brand_a": "Gigabyte",
+   "brand_id_b": 13899,
+   "brand_b": "MSI",
+   "fans_a": 4136,
+   "fans_b": 7601,
+   "jaccard": 0.20688946545124054,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 88,
+   "brand_id_a": 9849,
+   "brand_a": "H&M",
+   "brand_id_b": 25466,
+   "brand_b": "ZARA",
+   "fans_a": 78073,
+   "fans_b": 103555,
+   "jaccard": 0.206718310713768,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 89,
+   "brand_id_a": 5617,
+   "brand_a": "Cat & Jack",
+   "brand_id_b": 8851,
+   "brand_b": "Gap",
+   "fans_a": 61575,
+   "fans_b": 86674,
+   "jaccard": 0.20528621971607208,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.61,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.13,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 90,
+   "brand_id_a": 12590,
+   "brand_a": "L'Oréal",
+   "brand_id_b": 12700,
+   "brand_b": "L'Oreal",
+   "fans_a": 3264,
+   "fans_b": 7554,
+   "jaccard": 0.2032032012939453,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.96,
+   "should_merge_brand_id": 0.8,
+   "alignment_score": 2.89,
+   "band": "accept",
+   "trigram_similarity": 0.4
+  },
+  {
+   "rank": 91,
+   "brand_id_a": 12667,
+   "brand_a": "Lauren Conrad",
+   "brand_id_b": 12938,
+   "brand_b": "LC Lauren Conrad",
+   "fans_a": 8504,
+   "fans_b": 8086,
+   "jaccard": 0.20278401672840118,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.96,
+   "should_merge_brand_id": 0.83,
+   "alignment_score": 2.78,
+   "band": "accept",
+   "trigram_similarity": 0.875
+  },
+  {
+   "rank": 92,
+   "brand_id_a": 1243,
+   "brand_a": "Amouage",
+   "brand_id_b": 15818,
+   "brand_b": "Nishane",
+   "fans_a": 2499,
+   "fans_b": 2370,
+   "jaccard": 0.20251913368701935,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 93,
+   "brand_id_a": 22307,
+   "brand_a": "SEVENTEEN",
+   "brand_id_b": 22527,
+   "brand_b": "Tomorrow X Together",
+   "fans_a": 13786,
+   "fans_b": 13880,
+   "jaccard": 0.20245131850242615,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.28,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 94,
+   "brand_id_a": 4815,
+   "brand_a": "Carter's",
+   "brand_id_b": 8851,
+   "brand_b": "Gap",
+   "fans_a": 70873,
+   "fans_b": 86674,
+   "jaccard": 0.20200656354427338,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 95,
+   "brand_id_a": 12668,
+   "brand_a": "little sleepies",
+   "brand_id_b": 18461,
+   "brand_b": "Posh peanut",
+   "fans_a": 33246,
+   "fans_b": 18420,
+   "jaccard": 0.20125551521778107,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.94,
+   "should_merge_brand_id": 0.13,
+   "alignment_score": 0.11,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 96,
+   "brand_id_a": 20234,
+   "brand_a": "Silver",
+   "brand_id_b": 23775,
+   "brand_b": "US Mint",
+   "fans_a": 16971,
+   "fans_b": 10506,
+   "jaccard": 0.2002883106470108,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.9299999999999999,
+   "should_merge_brand_id": 0.15,
+   "alignment_score": 0.25,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 97,
+   "brand_id_a": 8726,
+   "brand_a": "Gigabyte",
+   "brand_id_b": 15716,
+   "brand_b": "NVIDIA",
+   "fans_a": 4136,
+   "fans_b": 5202,
+   "jaccard": 0.2002570629119873,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.86,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.1,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 98,
+   "brand_id_a": 6959,
+   "brand_a": "EVGA",
+   "brand_id_b": 13899,
+   "brand_b": "MSI",
+   "fans_a": 4387,
+   "fans_b": 7601,
+   "jaccard": 0.20000000298023224,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 99,
+   "brand_id_a": 9384,
+   "brand_a": "Good Smile Company",
+   "brand_id_b": 12291,
+   "brand_b": "Kotobukiya",
+   "fans_a": 40636,
+   "fans_b": 15473,
+   "jaccard": 0.1997818946838379,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 100,
+   "brand_id_a": 15921,
+   "brand_a": "New Age",
+   "brand_id_b": 24947,
+   "brand_b": "Witchery",
+   "fans_a": 3997,
+   "fans_b": 5048,
+   "jaccard": 0.19976124167442322,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.08,
+   "alignment_score": 0.03,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 101,
+   "brand_id_a": 748,
+   "brand_a": "Ann Taylor LOFT",
+   "brand_id_b": 12529,
+   "brand_b": "LOFT",
+   "fans_a": 10812,
+   "fans_b": 25211,
+   "jaccard": 0.19960704445838928,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.92,
+   "should_merge_brand_id": 0.85,
+   "alignment_score": 2.86,
+   "band": "accept",
+   "trigram_similarity": 0.3125
+  },
+  {
+   "rank": 102,
+   "brand_id_a": 6146,
+   "brand_a": "Disney",
+   "brand_id_b": 10235,
+   "brand_b": "Handmade",
+   "fans_a": 364888,
+   "fans_b": 397593,
+   "jaccard": 0.19925981760025024,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 103,
+   "brand_id_a": 13964,
+   "brand_a": "Mancera",
+   "brand_id_b": 25163,
+   "brand_b": "Xerjoff",
+   "fans_a": 3581,
+   "fans_b": 3848,
+   "jaccard": 0.19880586862564087,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 104,
+   "brand_id_a": 15822,
+   "brand_a": "NCT",
+   "brand_id_b": 22527,
+   "brand_b": "Tomorrow X Together",
+   "fans_a": 14569,
+   "fans_b": 13880,
+   "jaccard": 0.1979535073041916,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.29,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 105,
+   "brand_id_a": 5617,
+   "brand_a": "Cat & Jack",
+   "brand_id_b": 16658,
+   "brand_b": "Old Navy",
+   "fans_a": 61575,
+   "fans_b": 127634,
+   "jaccard": 0.1976011097431183,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.68,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.4,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 106,
+   "brand_id_a": 18307,
+   "brand_a": "Parfums de Marly",
+   "brand_id_b": 25163,
+   "brand_b": "Xerjoff",
+   "fans_a": 7322,
+   "fans_b": 3848,
+   "jaccard": 0.19759836792945862,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 107,
+   "brand_id_a": 3855,
+   "brand_a": "Bowman",
+   "brand_id_b": 7927,
+   "brand_b": "Fleer",
+   "fans_a": 8053,
+   "fans_b": 7641,
+   "jaccard": 0.19746680557727814,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.05,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 108,
+   "brand_id_a": 6992,
+   "brand_a": "ELF",
+   "brand_id_b": 7254,
+   "brand_b": "e.l.f. Cosmetics",
+   "fans_a": 3767,
+   "fans_b": 6791,
+   "jaccard": 0.19732365012168884,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.97,
+   "should_merge_brand_id": 0.76,
+   "alignment_score": 2.83,
+   "band": "accept",
+   "trigram_similarity": 0.2857
+  },
+  {
+   "rank": 109,
+   "brand_id_a": 4495,
+   "brand_a": "Callaway",
+   "brand_id_b": 22625,
+   "brand_b": "Titleist",
+   "fans_a": 10082,
+   "fans_b": 7499,
+   "jaccard": 0.1972895711660385,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 110,
+   "brand_id_a": 8851,
+   "brand_a": "Gap",
+   "brand_id_b": 9849,
+   "brand_b": "H&M",
+   "fans_a": 86674,
+   "fans_b": 78073,
+   "jaccard": 0.19705435633659363,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 111,
+   "brand_id_a": 13964,
+   "brand_a": "Mancera",
+   "brand_id_b": 14860,
+   "brand_b": "Montale",
+   "fans_a": 3581,
+   "fans_b": 2341,
+   "jaccard": 0.19684721529483795,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.99,
+   "should_merge_brand_id": 0.04,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.0667
+  },
+  {
+   "rank": 112,
+   "brand_id_a": 22527,
+   "brand_a": "Tomorrow X Together",
+   "brand_id_b": 22531,
+   "brand_b": "Twice",
+   "fans_a": 13880,
+   "fans_b": 20576,
+   "jaccard": 0.19672131538391113,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.02,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.0435
+  },
+  {
+   "rank": 113,
+   "brand_id_a": 17606,
+   "brand_a": "Playmates",
+   "brand_id_b": 22890,
+   "brand_b": "Teenage Mutant Ninja Turtles",
+   "fans_a": 16181,
+   "fans_b": 12119,
+   "jaccard": 0.19611157476902008,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.78,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.03,
+   "band": "reject",
+   "trigram_similarity": 0.027
+  },
+  {
+   "rank": 114,
+   "brand_id_a": 22635,
+   "brand_a": "Topps",
+   "brand_id_b": 23927,
+   "brand_b": "Upper Deck",
+   "fans_a": 36718,
+   "fans_b": 12982,
+   "jaccard": 0.1960916370153427,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 115,
+   "brand_id_a": 18406,
+   "brand_a": "Panini",
+   "brand_id_b": 23927,
+   "brand_b": "Upper Deck",
+   "fans_a": 36503,
+   "fans_b": 12982,
+   "jaccard": 0.1954919844865799,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.04,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 116,
+   "brand_id_a": 6841,
+   "brand_a": "Kyte BABY",
+   "brand_id_b": 12668,
+   "brand_b": "little sleepies",
+   "fans_a": 17900,
+   "fans_b": 33246,
+   "jaccard": 0.19525133073329926,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.06,
+   "alignment_score": 0.02,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 117,
+   "brand_id_a": 20222,
+   "brand_a": "Sega",
+   "brand_id_b": 23485,
+   "brand_b": "Taito",
+   "fans_a": 43434,
+   "fans_b": 19799,
+   "jaccard": 0.1946081817150116,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.9,
+   "should_merge_brand_id": 0.04,
+   "alignment_score": 0.1,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 118,
+   "brand_id_a": 3838,
+   "brand_a": "BTS",
+   "brand_id_b": 22527,
+   "brand_b": "Tomorrow X Together",
+   "fans_a": 61458,
+   "fans_b": 13880,
+   "jaccard": 0.1944950968027115,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.97,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.64,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  },
+  {
+   "rank": 119,
+   "brand_id_a": 13797,
+   "brand_a": "monster high",
+   "brand_id_b": 14071,
+   "brand_b": "MGA Entertainment",
+   "fans_a": 32503,
+   "fans_b": 31221,
+   "jaccard": 0.19438457489013672,
+   "relationship_type": "ip_franchise_and_owner_maker",
+   "relationship_type_p": 0.87,
+   "should_merge_brand_id": 0.07,
+   "alignment_score": 1.03,
+   "band": "reject",
+   "trigram_similarity": 0.0714
+  },
+  {
+   "rank": 120,
+   "brand_id_a": 3855,
+   "brand_a": "Bowman",
+   "brand_id_b": 23927,
+   "brand_b": "Upper Deck",
+   "fans_a": 8053,
+   "fans_b": 12982,
+   "jaccard": 0.19401714205741882,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 1.0,
+   "should_merge_brand_id": 0.03,
+   "alignment_score": 0.01,
+   "band": "reject",
+   "trigram_similarity": 0.0
+  }
+ ],
+ "review_queue": [
+  {
+   "rank": 37,
+   "brand_id_a": 9549,
+   "brand_a": "Hourglass Cosmetics",
+   "brand_id_b": 9730,
+   "brand_b": "Hourglass",
+   "fans_a": 6397,
+   "fans_b": 2383,
+   "jaccard": 0.24362605810165405,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.94,
+   "should_merge_brand_id": 0.69,
+   "alignment_score": 2.68,
+   "band": "review",
+   "trigram_similarity": 0.5
+  },
+  {
+   "rank": 31,
+   "brand_id_a": 2152,
+   "brand_a": "Beats by Dr. Dre",
+   "brand_id_b": 3915,
+   "brand_b": "Beats",
+   "fans_a": 18814,
+   "fans_b": 7676,
+   "jaccard": 0.25867149233818054,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.82,
+   "should_merge_brand_id": 0.68,
+   "alignment_score": 2.34,
+   "band": "review",
+   "trigram_similarity": 0.4615
+  },
+  {
+   "rank": 6,
+   "brand_id_a": 8486,
+   "brand_a": "Freebird",
+   "brand_id_b": 8593,
+   "brand_b": "Freebird By Steven",
+   "fans_a": 2949,
+   "fans_b": 4173,
+   "jaccard": 0.34377357363700867,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.6900000000000001,
+   "should_merge_brand_id": 0.61,
+   "alignment_score": 2.31,
+   "band": "review",
+   "trigram_similarity": 0.4737
+  },
+  {
+   "rank": 4,
+   "brand_id_a": 436,
+   "brand_a": "Air Jordan",
+   "brand_id_b": 11073,
+   "brand_b": "Jordan",
+   "fans_a": 123149,
+   "fans_b": 72496,
+   "jaccard": 0.3533264994621277,
+   "relationship_type": "sub_brand_or_diffusion_line",
+   "relationship_type_p": 0.78,
+   "should_merge_brand_id": 0.54,
+   "alignment_score": 2.32,
+   "band": "review",
+   "trigram_similarity": 0.6364
+  },
+  {
+   "rank": 34,
+   "brand_id_a": 17474,
+   "brand_a": "Polo Ralph Lauren",
+   "brand_id_b": 18895,
+   "brand_b": "Ralph Lauren",
+   "fans_a": 62987,
+   "fans_b": 48355,
+   "jaccard": 0.251539945602417,
+   "relationship_type": "sub_brand_or_diffusion_line",
+   "relationship_type_p": 0.76,
+   "should_merge_brand_id": 0.49,
+   "alignment_score": 2.23,
+   "band": "review",
+   "trigram_similarity": 0.7222
+  },
+  {
+   "rank": 3,
+   "brand_id_a": 3698,
+   "brand_a": "Baby Tula",
+   "brand_id_b": 23174,
+   "brand_b": "Tula",
+   "fans_a": 3398,
+   "fans_b": 3806,
+   "jaccard": 0.35515424609184265,
+   "relationship_type": "same_entity_alias",
+   "relationship_type_p": 0.76,
+   "should_merge_brand_id": 0.44,
+   "alignment_score": 2.24,
+   "band": "review",
+   "trigram_similarity": 0.5
+  },
+  {
+   "rank": 57,
+   "brand_id_a": 14353,
+   "brand_a": "Mega Bloks",
+   "brand_id_b": 15213,
+   "brand_b": "Mega Construx",
+   "fans_a": 5295,
+   "fans_b": 5325,
+   "jaccard": 0.22519612312316895,
+   "relationship_type": "distinct_co_liked_peers",
+   "relationship_type_p": 0.51,
+   "should_merge_brand_id": 0.3,
+   "alignment_score": 0.52,
+   "band": "review",
+   "trigram_similarity": 0.25
+  }
+ ],
+ "clusters": [
+  {
+   "canonical_id": 4513,
+   "canonical_name": "Christian Dior",
+   "members": 2,
+   "primary_fans": 38883,
+   "naive_sum_fans": 76509,
+   "exact_union_fans": 57906,
+   "gain_pct": 48.9,
+   "double_count_pct": 24.3,
+   "member_ids": [
+    4513,
+    5856
+   ],
+   "member_names": [
+    "Christian Dior",
+    "Dior"
+   ]
+  },
+  {
+   "canonical_id": 25269,
+   "canonical_name": "Yves Saint Laurent",
+   "members": 2,
+   "primary_fans": 23895,
+   "naive_sum_fans": 46355,
+   "exact_union_fans": 35012,
+   "gain_pct": 46.5,
+   "double_count_pct": 24.5,
+   "member_ids": [
+    25277,
+    25269
+   ],
+   "member_names": [
+    "YSL Yves Saint Laurent",
+    "Yves Saint Laurent"
+   ]
+  },
+  {
+   "canonical_id": 4713,
+   "canonical_name": "Children's Place",
+   "members": 2,
+   "primary_fans": 22072,
+   "naive_sum_fans": 39620,
+   "exact_union_fans": 31954,
+   "gain_pct": 44.8,
+   "double_count_pct": 19.3,
+   "member_ids": [
+    4713,
+    22826
+   ],
+   "member_names": [
+    "Children's Place",
+    "The Children's Place"
+   ]
+  },
+  {
+   "canonical_id": 748,
+   "canonical_name": "Ann Taylor LOFT",
+   "members": 2,
+   "primary_fans": 25211,
+   "naive_sum_fans": 36023,
+   "exact_union_fans": 30029,
+   "gain_pct": 19.1,
+   "double_count_pct": 16.6,
+   "member_ids": [
+    12529,
+    748
+   ],
+   "member_names": [
+    "LOFT",
+    "Ann Taylor LOFT"
+   ]
+  },
+  {
+   "canonical_id": 303,
+   "canonical_name": "A Bathing Ape",
+   "members": 2,
+   "primary_fans": 13245,
+   "naive_sum_fans": 25865,
+   "exact_union_fans": 19591,
+   "gain_pct": 47.9,
+   "double_count_pct": 24.3,
+   "member_ids": [
+    2493,
+    303
+   ],
+   "member_names": [
+    "Bape",
+    "A Bathing Ape"
+   ]
+  },
+  {
+   "canonical_id": 22527,
+   "canonical_name": "Tomorrow X Together",
+   "members": 2,
+   "primary_fans": 13880,
+   "naive_sum_fans": 22147,
+   "exact_union_fans": 15425,
+   "gain_pct": 11.1,
+   "double_count_pct": 30.4,
+   "member_ids": [
+    22527,
+    23732
+   ],
+   "member_names": [
+    "Tomorrow X Together",
+    "TXT"
+   ]
+  },
+  {
+   "canonical_id": 12667,
+   "canonical_name": "Lauren Conrad",
+   "members": 2,
+   "primary_fans": 8504,
+   "naive_sum_fans": 16590,
+   "exact_union_fans": 13793,
+   "gain_pct": 62.2,
+   "double_count_pct": 16.9,
+   "member_ids": [
+    12667,
+    12938
+   ],
+   "member_names": [
+    "Lauren Conrad",
+    "LC Lauren Conrad"
+   ]
+  },
+  {
+   "canonical_id": 9624,
+   "canonical_name": "Hermès",
+   "members": 2,
+   "primary_fans": 8923,
+   "naive_sum_fans": 15974,
+   "exact_union_fans": 12100,
+   "gain_pct": 35.6,
+   "double_count_pct": 24.3,
+   "member_ids": [
+    9624,
+    9895
+   ],
+   "member_names": [
+    "Hermès",
+    "HERMES"
+   ]
+  },
+  {
+   "canonical_id": 23265,
+   "canonical_name": "Toy Biz",
+   "members": 2,
+   "primary_fans": 7008,
+   "naive_sum_fans": 13715,
+   "exact_union_fans": 10515,
+   "gain_pct": 50.0,
+   "double_count_pct": 23.3,
+   "member_ids": [
+    23265,
+    23415
+   ],
+   "member_names": [
+    "Toy Biz",
+    "Toybiz"
+   ]
+  },
+  {
+   "canonical_id": 13832,
+   "canonical_name": "Mugler",
+   "members": 2,
+   "primary_fans": 6232,
+   "naive_sum_fans": 12157,
+   "exact_union_fans": 9017,
+   "gain_pct": 44.7,
+   "double_count_pct": 25.8,
+   "member_ids": [
+    13832,
+    22763
+   ],
+   "member_names": [
+    "Mugler",
+    "Thierry Mugler"
+   ]
+  },
+  {
+   "canonical_id": 12590,
+   "canonical_name": "L'Oréal",
+   "members": 2,
+   "primary_fans": 7554,
+   "naive_sum_fans": 10818,
+   "exact_union_fans": 8991,
+   "gain_pct": 19.0,
+   "double_count_pct": 16.9,
+   "member_ids": [
+    12700,
+    12590
+   ],
+   "member_names": [
+    "L'Oreal",
+    "L'Oréal"
+   ]
+  },
+  {
+   "canonical_id": 6992,
+   "canonical_name": "ELF",
+   "members": 2,
+   "primary_fans": 6791,
+   "naive_sum_fans": 10558,
+   "exact_union_fans": 8818,
+   "gain_pct": 29.8,
+   "double_count_pct": 16.5,
+   "member_ids": [
+    7254,
+    6992
+   ],
+   "member_names": [
+    "e.l.f. Cosmetics",
+    "ELF"
+   ]
+  },
+  {
+   "canonical_id": 17571,
+   "canonical_name": "Pampered Chef",
+   "members": 2,
+   "primary_fans": 7075,
+   "naive_sum_fans": 9893,
+   "exact_union_fans": 8150,
+   "gain_pct": 15.2,
+   "double_count_pct": 17.6,
+   "member_ids": [
+    17571,
+    23414
+   ],
+   "member_names": [
+    "Pampered Chef",
+    "The Pampered Chef"
+   ]
+  },
+  {
+   "canonical_id": 3438,
+   "canonical_name": "By Kilian",
+   "members": 2,
+   "primary_fans": 7040,
+   "naive_sum_fans": 9313,
+   "exact_union_fans": 7512,
+   "gain_pct": 6.7,
+   "double_count_pct": 19.3,
+   "member_ids": [
+    12327,
+    3438
+   ],
+   "member_names": [
+    "KILIAN",
+    "By Kilian"
+   ]
+  },
+  {
+   "canonical_id": 2830,
+   "canonical_name": "BabyBjorn",
+   "members": 2,
+   "primary_fans": 3434,
+   "naive_sum_fans": 6403,
+   "exact_union_fans": 4850,
+   "gain_pct": 41.2,
+   "double_count_pct": 24.3,
+   "member_ids": [
+    3422,
+    2830
+   ],
+   "member_names": [
+    "BABYBJÖRN",
+    "BabyBjorn"
+   ]
+  },
+  {
+   "canonical_id": 208,
+   "canonical_name": "All Saints",
+   "members": 2,
+   "primary_fans": 3201,
+   "naive_sum_fans": 5634,
+   "exact_union_fans": 4591,
+   "gain_pct": 43.4,
+   "double_count_pct": 18.5,
+   "member_ids": [
+    514,
+    208
+   ],
+   "member_names": [
+    "AllSaints",
+    "All Saints"
+   ]
+  },
+  {
+   "canonical_id": 400,
+   "canonical_name": "Armani Exchange",
+   "members": 2,
+   "primary_fans": 3097,
+   "naive_sum_fans": 5252,
+   "exact_union_fans": 4286,
+   "gain_pct": 38.4,
+   "double_count_pct": 18.4,
+   "member_ids": [
+    400,
+    715
+   ],
+   "member_names": [
+    "Armani Exchange",
+    "A|X Armani Exchange"
+   ]
+  },
+  {
+   "canonical_id": 22529,
+   "canonical_name": "Thrive Causemetics",
+   "members": 2,
+   "primary_fans": 2745,
+   "naive_sum_fans": 5230,
+   "exact_union_fans": 4090,
+   "gain_pct": 49.0,
+   "double_count_pct": 21.8,
+   "member_ids": [
+    22545,
+    22529
+   ],
+   "member_names": [
+    "Thrive",
+    "Thrive Causemetics"
+   ]
+  }
+ ],
+ "trigram_control": {
+  "threshold": 0.5,
+  "normalization": "NFKC, lowercase, punctuation deleted, pg_trgm word trigrams",
+  "brand_names": 20000,
+  "names_without_trigrams": 0,
+  "pairs_proposed_all_brands": 7310,
+  "examples_all_brands": [
+   {
+    "brand_id_a": 9,
+    "brand_a": "10 Crosby Derek Lam",
+    "brand_id_b": 5947,
+    "brand_b": "DEREK LAM 10 CROSBY",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 298,
+    "brand_a": "a'gaci",
+    "brand_id_b": 1963,
+    "brand_b": "Agaci",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 1435,
+    "brand_a": "APL: Athletic Propulsion Labs",
+    "brand_id_b": 1919,
+    "brand_b": "Athletic Propulsion Labs (APL)",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 1477,
+    "brand_a": "Ai",
+    "brand_id_b": 1982,
+    "brand_b": "A&I",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 1997,
+    "brand_a": "Applause",
+    "brand_id_b": 2149,
+    "brand_b": "Applause",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 2330,
+    "brand_a": "b. makowsky",
+    "brand_id_b": 4009,
+    "brand_b": "B. Makowsky",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 2379,
+    "brand_a": "BLACKHAWK!",
+    "brand_id_b": 2842,
+    "brand_b": "Blackhawk",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 2477,
+    "brand_a": "Boom Boom",
+    "brand_id_b": 3733,
+    "brand_b": "Boom",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 2527,
+    "brand_a": "Blue Coral",
+    "brand_id_b": 5304,
+    "brand_b": "Coral Blue",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 2541,
+    "brand_a": "BOSS HUGO BOSS",
+    "brand_id_b": 9630,
+    "brand_b": "Hugo Boss",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 2652,
+    "brand_a": "Beechnut",
+    "brand_id_b": 3645,
+    "brand_b": "Beech-Nut",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 2777,
+    "brand_a": "B. Darlin",
+    "brand_id_b": 4008,
+    "brand_b": "B. Darlin",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 4196,
+    "brand_a": "Charles David",
+    "brand_id_b": 6779,
+    "brand_b": "David Charles",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 4198,
+    "brand_a": "Catherine Malandrino",
+    "brand_id_b": 4707,
+    "brand_b": "Catherine Catherine Malandrino",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 4308,
+    "brand_a": "Coca-Cola",
+    "brand_id_b": 5839,
+    "brand_b": "Coca-Cola",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 4795,
+    "brand_a": "Christian Louboutin",
+    "brand_id_b": 13402,
+    "brand_b": "LOUBOUTIN, CHRISTIAN",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 5380,
+    "brand_a": "Care Bears",
+    "brand_id_b": 5843,
+    "brand_b": "Care Bears",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 5600,
+    "brand_a": "Case-Mate",
+    "brand_id_b": 5842,
+    "brand_b": "Case-Mate",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 6045,
+    "brand_a": "Demdaco",
+    "brand_id_b": 6940,
+    "brand_b": "DEMDACO",
+    "trigram_similarity": 1.0
+   },
+   {
+    "brand_id_a": 7285,
+    "brand_a": "Eureka!",
+    "brand_id_b": 7631,
+    "brand_b": "Eureka",
+    "trigram_similarity": 1.0
+   }
+  ],
+  "probe_pairs": 120,
+  "probe_pairs_proposed": 14,
+  "accepted_aliases": 18,
+  "accepted_found": 9,
+  "accepted_missed": 9,
+  "wrongly_proposed": 5,
+  "wrongly_proposed_by_relationship": {
+   "distinct_co_liked_peers": 1,
+   "same_entity_alias": 2,
+   "sub_brand_or_diffusion_line": 2
+  },
+  "found": [
+   {
+    "brand_id_a": 25269,
+    "brand_a": "Yves Saint Laurent",
+    "brand_id_b": 25277,
+    "brand_b": "YSL Yves Saint Laurent",
+    "trigram_similarity": 0.8571,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.87,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 2830,
+    "brand_a": "BabyBjorn",
+    "brand_id_b": 3422,
+    "brand_b": "BABYBJÖRN",
+    "trigram_similarity": 0.5385,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.92,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 23265,
+    "brand_a": "Toy Biz",
+    "brand_id_b": 23415,
+    "brand_b": "Toybiz",
+    "trigram_similarity": 0.5,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.81,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 4713,
+    "brand_a": "Children's Place",
+    "brand_id_b": 22826,
+    "brand_b": "The Children's Place",
+    "trigram_similarity": 0.8,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.85,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 3438,
+    "brand_a": "By Kilian",
+    "brand_id_b": 12327,
+    "brand_b": "KILIAN",
+    "trigram_similarity": 0.7,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.88,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 208,
+    "brand_a": "All Saints",
+    "brand_id_b": 514,
+    "brand_b": "AllSaints",
+    "trigram_similarity": 0.6154,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.9,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 400,
+    "brand_a": "Armani Exchange",
+    "brand_id_b": 715,
+    "brand_b": "A|X Armani Exchange",
+    "trigram_similarity": 0.8889,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.91,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 17571,
+    "brand_a": "Pampered Chef",
+    "brand_id_b": 23414,
+    "brand_b": "The Pampered Chef",
+    "trigram_similarity": 0.7778,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.84,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 12667,
+    "brand_a": "Lauren Conrad",
+    "brand_id_b": 12938,
+    "brand_b": "LC Lauren Conrad",
+    "trigram_similarity": 0.875,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.83,
+    "band": "accept"
+   }
+  ],
+  "missed": [
+   {
+    "brand_id_a": 22527,
+    "brand_a": "Tomorrow X Together",
+    "brand_id_b": 23732,
+    "brand_b": "TXT",
+    "trigram_similarity": 0.0476,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.73,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 13832,
+    "brand_a": "Mugler",
+    "brand_id_b": 22763,
+    "brand_b": "Thierry Mugler",
+    "trigram_similarity": 0.4667,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.9,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 4513,
+    "brand_a": "Christian Dior",
+    "brand_id_b": 5856,
+    "brand_b": "Dior",
+    "trigram_similarity": 0.3333,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.78,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 303,
+    "brand_a": "A Bathing Ape",
+    "brand_id_b": 2493,
+    "brand_b": "Bape",
+    "trigram_similarity": 0.2857,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.87,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 9624,
+    "brand_a": "Hermès",
+    "brand_id_b": 9895,
+    "brand_b": "HERMES",
+    "trigram_similarity": 0.4,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.86,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 22529,
+    "brand_a": "Thrive Causemetics",
+    "brand_id_b": 22545,
+    "brand_b": "Thrive",
+    "trigram_similarity": 0.3684,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.74,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 12590,
+    "brand_a": "L'Oréal",
+    "brand_id_b": 12700,
+    "brand_b": "L'Oreal",
+    "trigram_similarity": 0.4,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.8,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 748,
+    "brand_a": "Ann Taylor LOFT",
+    "brand_id_b": 12529,
+    "brand_b": "LOFT",
+    "trigram_similarity": 0.3125,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.85,
+    "band": "accept"
+   },
+   {
+    "brand_id_a": 6992,
+    "brand_a": "ELF",
+    "brand_id_b": 7254,
+    "brand_b": "e.l.f. Cosmetics",
+    "trigram_similarity": 0.2857,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.76,
+    "band": "accept"
+   }
+  ],
+  "wrongly_proposed_pairs": [
+   {
+    "brand_id_a": 3698,
+    "brand_a": "Baby Tula",
+    "brand_id_b": 23174,
+    "brand_b": "Tula",
+    "trigram_similarity": 0.5,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.44,
+    "band": "review"
+   },
+   {
+    "brand_id_a": 436,
+    "brand_a": "Air Jordan",
+    "brand_id_b": 11073,
+    "brand_b": "Jordan",
+    "trigram_similarity": 0.6364,
+    "relationship_type": "sub_brand_or_diffusion_line",
+    "should_merge_brand_id": 0.54,
+    "band": "review"
+   },
+   {
+    "brand_id_a": 17474,
+    "brand_a": "Polo Ralph Lauren",
+    "brand_id_b": 18895,
+    "brand_b": "Ralph Lauren",
+    "trigram_similarity": 0.7222,
+    "relationship_type": "sub_brand_or_diffusion_line",
+    "should_merge_brand_id": 0.49,
+    "band": "review"
+   },
+   {
+    "brand_id_a": 9549,
+    "brand_a": "Hourglass Cosmetics",
+    "brand_id_b": 9730,
+    "brand_b": "Hourglass",
+    "trigram_similarity": 0.5,
+    "relationship_type": "same_entity_alias",
+    "should_merge_brand_id": 0.69,
+    "band": "review"
+   },
+   {
+    "brand_id_a": 4356,
+    "brand_a": "Crystal",
+    "brand_id_b": 4479,
+    "brand_b": "Crystal Rock",
+    "trigram_similarity": 0.6154,
+    "relationship_type": "distinct_co_liked_peers",
+    "should_merge_brand_id": 0.17,
+    "band": "reject"
+   }
+  ],
+  "elapsed_s": 2.0779002448543906
+ },
+ "full_pairwise_cost_estimate": {
+  "brands": 20000,
+  "pairs": 199990000,
+  "probe_decisions": 120,
+  "pairs_per_probe_decision": 1666583.3333333333,
+  "mean_cost_usd_per_decision": 5.138980000000003e-05,
+  "mean_input_tokens_per_decision": 1223.5666666666666,
+  "estimated_cost_usd": 10277.446102000005,
+  "estimated_input_tokens": 244701097666.66666,
+  "basis": "this run's backend calls; not executed"
+ }
+}