@elaraai/east-py-datascience 1.0.19 → 1.0.20

package/dist/src/causal/causal.d.ts

@@ -59,6 +59,20 @@ export declare const CausalTargetUnitsType: VariantType<{
     /** Average treatment effect on the controls */
     readonly atc: NullType;
 }>;
+/**
+ * A directional prior on the effect — the sign a domain expert expects. Used by
+ * {@link causal_experiment}'s `expected_sign` guard: a material, CI-clear effect
+ * pointing the *other* way is flagged (a reverse-causation / reactive-assignment
+ * signal a backdoor adjustment cannot catch).
+ *
+ * twin: e3-ui/src/experiment/types.ts `SignType`
+ */
+export declare const CausalSignType: VariantType<{
+    /** The effect is expected to increase the outcome. */
+    readonly positive: NullType;
+    /** The effect is expected to decrease the outcome. */
+    readonly negative: NullType;
+}>;
 /**
  * Bootstrap confidence interval configuration.
  *
@@ -160,6 +174,23 @@ export declare const CausalExperimentConfigType: StructType<{
     }>>;
     /** Random seed. */
     readonly random_state: OptionType<IntegerType>;
+    /** Graded-overlap threshold — common support below this keeps `causal` from the
+     *  top tier (verdict `modest`, `overlap.support_strength = thin`); default 0.55. */
+    readonly strong_overlap: OptionType<FloatType>;
+    /** Robustness floor — when set, a `causal` verdict whose E-value
+     *  (`refutation.robustness_value`, risk-ratio scale) is below this is downgraded to
+     *  `modest`. Off by default. The E-value is a monotone transform of the standardized
+     *  effect, so this acts as a stricter materiality bar, not an independent check. */
+    readonly evalue_floor: OptionType<FloatType>;
+    /** Directional prior — when set, a material, CI-clear effect of the opposite sign is
+     *  flagged (`refutation.expected_sign_ok = some(false)`, verdict `adjustment_insufficient`).
+     *  Off by default. Catches reverse causation / reactive assignment the refuters can't. */
+    readonly expected_sign: OptionType<VariantType<{
+        /** The effect is expected to increase the outcome. */
+        readonly positive: NullType;
+        /** The effect is expected to decrease the outcome. */
+        readonly negative: NullType;
+    }>>;
 }>;
 /** One confounder's before-adjustment imbalance (categoricals → one row per level). */
 export declare const BalanceRowType: StructType<{
@@ -172,6 +203,24 @@ export declare const BalanceRowType: StructType<{
     /** Standardized mean difference, (mt-mc)/sqrt((vt+vc)/2). */
     readonly std_diff: FloatType;
 }>;
+/**
+ * Graded common-support tier — the honest three-state reading of overlap a
+ * consumer can switch on without re-deriving thresholds:
+ * `refused` (below `min_overlap`, the engine refuses), `thin` (clears the refuse
+ * gate but below `strong_overlap` — fragile), `strong` (≥ `strong_overlap`). With
+ * no confounders (or a degenerate arm) there is nothing to separate on, so the tier
+ * is vacuously `strong`.
+ *
+ * twin: e3-ui/src/experiment/types.ts `SupportStrengthType`
+ */
+export declare const SupportStrengthType: VariantType<{
+    /** Below `min_overlap` — no like-for-like comparison (engine refuses). */
+    readonly refused: NullType;
+    /** Clears the refuse gate but below `strong_overlap` — fragile support. */
+    readonly thin: NullType;
+    /** Common support ≥ `strong_overlap` — solid. */
+    readonly strong: NullType;
+}>;
 /** Positivity / common-support diagnostic (binary treatment). */
 export declare const OverlapDiagnosticType: StructType<{
     /** Propensity histogram (20 bins over [0,1]) for the treated arm. */
@@ -180,8 +229,21 @@ export declare const OverlapDiagnosticType: StructType<{
     readonly control_propensity: VectorType<FloatType>;
     /** Fraction of rows inside the treated/control common support. */
     readonly common_support_frac: FloatType;
-    /** Whether common support clears `min_overlap`. */
+    /** Whether common support clears the **refuse** gate `min_overlap` — i.e. an
+     *  adjusted estimate is attempted at all. NOT a quality signal: `true` at the
+     *  default gate (0.10) still means barely-overlapping. Read `support_strength`
+     *  for the graded tier. */
     readonly positivity_ok: BooleanType;
+    /** Graded common-support tier (`refused` / `thin` / `strong` vs `strong_overlap`).
+     *  twin: e3-ui OverlapDiagnosticType.support_strength */
+    readonly support_strength: VariantType<{
+        /** Below `min_overlap` — no like-for-like comparison (engine refuses). */
+        readonly refused: NullType;
+        /** Clears the refuse gate but below `strong_overlap` — fragile support. */
+        readonly thin: NullType;
+        /** Common support ≥ `strong_overlap` — solid. */
+        readonly strong: NullType;
+    }>;
 }>;
 /** The robustness summary the verdict + Trust tab consume. */
 export declare const RefutationType: StructType<{
@@ -195,13 +257,22 @@ export declare const RefutationType: StructType<{
     readonly data_subset_effect: OptionType<FloatType>;
     /** Std of the effect across data subsamples. */
     readonly data_subset_std: OptionType<FloatType>;
-    /** Closed-form E-value — confounder strength needed to explain the effect away. */
+    /** Closed-form E-value (risk-ratio scale) — the confounder strength needed to
+     *  explain the effect away. A monotone transform of the standardized effect, so
+     *  it is NOT independent of the effect size; read it as "how easily overturned",
+     *  not as a separate confounding measure. */
     readonly robustness_value: OptionType<FloatType>;
     /** Unobserved-confounder sensitivity (tipping) curve: effect at each simulated strength. */
     readonly sensitivity: OptionType<StructType<{
         readonly strengths: VectorType<FloatType>;
         readonly effects: VectorType<FloatType>;
     }>>;
+    /** Sign-prior check (when `config.expected_sign` is set): `some(true)` if a
+     *  material effect matches the expected direction, `some(false)` if it points the
+     *  other way (→ verdict `adjustment_insufficient`). `none` when no prior is given
+     *  or the effect is near-zero (its sign is undefined).
+     *  twin: e3-ui RefutationType.expected_sign_ok */
+    readonly expected_sign_ok: OptionType<BooleanType>;
 }>;
 /** A dose-response (ALE) curve of a continuous feature on the outcome. */
 export declare const DoseResponseType: StructType<{
@@ -218,7 +289,10 @@ export declare const DoseResponseType: StructType<{
  * Only `not_estimable` carries a (human-readable) reason.
  */
 export declare const ExperimentVerdictType: VariantType<{
-    /** A real, robust, material effect. */
+    /** A real, robust, material effect — robust to the **observed** backdoor set + the
+     *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+     *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+     *  (E-value) and `refutation.expected_sign_ok` alongside it. */
     readonly causal: NullType;
     /** A small but real effect, or no clear effect after adjustment. */
     readonly modest: NullType;
@@ -271,8 +345,21 @@ export declare const CausalExperimentResultType: StructType<{
         readonly control_propensity: VectorType<FloatType>;
         /** Fraction of rows inside the treated/control common support. */
         readonly common_support_frac: FloatType;
-        /** Whether common support clears `min_overlap`. */
+        /** Whether common support clears the **refuse** gate `min_overlap` — i.e. an
+         *  adjusted estimate is attempted at all. NOT a quality signal: `true` at the
+         *  default gate (0.10) still means barely-overlapping. Read `support_strength`
+         *  for the graded tier. */
         readonly positivity_ok: BooleanType;
+        /** Graded common-support tier (`refused` / `thin` / `strong` vs `strong_overlap`).
+         *  twin: e3-ui OverlapDiagnosticType.support_strength */
+        readonly support_strength: VariantType<{
+            /** Below `min_overlap` — no like-for-like comparison (engine refuses). */
+            readonly refused: NullType;
+            /** Clears the refuse gate but below `strong_overlap` — fragile support. */
+            readonly thin: NullType;
+            /** Common support ≥ `strong_overlap` — solid. */
+            readonly strong: NullType;
+        }>;
     }>;
     readonly refutation: OptionType<StructType<{
         /** Effect under a permuted (placebo) treatment — should be ≈ 0. */
@@ -285,13 +372,22 @@ export declare const CausalExperimentResultType: StructType<{
         readonly data_subset_effect: OptionType<FloatType>;
         /** Std of the effect across data subsamples. */
         readonly data_subset_std: OptionType<FloatType>;
-        /** Closed-form E-value — confounder strength needed to explain the effect away. */
+        /** Closed-form E-value (risk-ratio scale) — the confounder strength needed to
+         *  explain the effect away. A monotone transform of the standardized effect, so
+         *  it is NOT independent of the effect size; read it as "how easily overturned",
+         *  not as a separate confounding measure. */
         readonly robustness_value: OptionType<FloatType>;
         /** Unobserved-confounder sensitivity (tipping) curve: effect at each simulated strength. */
         readonly sensitivity: OptionType<StructType<{
             readonly strengths: VectorType<FloatType>;
             readonly effects: VectorType<FloatType>;
         }>>;
+        /** Sign-prior check (when `config.expected_sign` is set): `some(true)` if a
+         *  material effect matches the expected direction, `some(false)` if it points the
+         *  other way (→ verdict `adjustment_insufficient`). `none` when no prior is given
+         *  or the effect is near-zero (its sign is undefined).
+         *  twin: e3-ui RefutationType.expected_sign_ok */
+        readonly expected_sign_ok: OptionType<BooleanType>;
     }>>;
     /** ALE dose-response of `dose_feature` (present when `config.dose_feature` is set). */
     readonly dose_response: OptionType<StructType<{
@@ -304,7 +400,10 @@ export declare const CausalExperimentResultType: StructType<{
         readonly size: VectorType<IntegerType>;
     }>>;
     readonly verdict: VariantType<{
-        /** A real, robust, material effect. */
+        /** A real, robust, material effect — robust to the **observed** backdoor set + the
+         *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+         *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+         *  (E-value) and `refutation.expected_sign_ok` alongside it. */
         readonly causal: NullType;
         /** A small but real effect, or no clear effect after adjustment. */
         readonly modest: NullType;
@@ -388,6 +487,23 @@ export declare const causal_experiment: import("@elaraai/east").GenericPlatformD
     }>>;
     /** Random seed. */
     readonly random_state: OptionType<IntegerType>;
+    /** Graded-overlap threshold — common support below this keeps `causal` from the
+     *  top tier (verdict `modest`, `overlap.support_strength = thin`); default 0.55. */
+    readonly strong_overlap: OptionType<FloatType>;
+    /** Robustness floor — when set, a `causal` verdict whose E-value
+     *  (`refutation.robustness_value`, risk-ratio scale) is below this is downgraded to
+     *  `modest`. Off by default. The E-value is a monotone transform of the standardized
+     *  effect, so this acts as a stricter materiality bar, not an independent check. */
+    readonly evalue_floor: OptionType<FloatType>;
+    /** Directional prior — when set, a material, CI-clear effect of the opposite sign is
+     *  flagged (`refutation.expected_sign_ok = some(false)`, verdict `adjustment_insufficient`).
+     *  Off by default. Catches reverse causation / reactive assignment the refuters can't. */
+    readonly expected_sign: OptionType<VariantType<{
+        /** The effect is expected to increase the outcome. */
+        readonly positive: NullType;
+        /** The effect is expected to decrease the outcome. */
+        readonly negative: NullType;
+    }>>;
 }>], StructType<{
     /** The raw (unadjusted) mean difference — always computable. */
     readonly naive: FloatType;
@@ -425,8 +541,21 @@ export declare const causal_experiment: import("@elaraai/east").GenericPlatformD
         readonly control_propensity: VectorType<FloatType>;
         /** Fraction of rows inside the treated/control common support. */
         readonly common_support_frac: FloatType;
-        /** Whether common support clears `min_overlap`. */
+        /** Whether common support clears the **refuse** gate `min_overlap` — i.e. an
+         *  adjusted estimate is attempted at all. NOT a quality signal: `true` at the
+         *  default gate (0.10) still means barely-overlapping. Read `support_strength`
+         *  for the graded tier. */
         readonly positivity_ok: BooleanType;
+        /** Graded common-support tier (`refused` / `thin` / `strong` vs `strong_overlap`).
+         *  twin: e3-ui OverlapDiagnosticType.support_strength */
+        readonly support_strength: VariantType<{
+            /** Below `min_overlap` — no like-for-like comparison (engine refuses). */
+            readonly refused: NullType;
+            /** Clears the refuse gate but below `strong_overlap` — fragile support. */
+            readonly thin: NullType;
+            /** Common support ≥ `strong_overlap` — solid. */
+            readonly strong: NullType;
+        }>;
     }>;
     readonly refutation: OptionType<StructType<{
         /** Effect under a permuted (placebo) treatment — should be ≈ 0. */
@@ -439,13 +568,22 @@ export declare const causal_experiment: import("@elaraai/east").GenericPlatformD
         readonly data_subset_effect: OptionType<FloatType>;
         /** Std of the effect across data subsamples. */
         readonly data_subset_std: OptionType<FloatType>;
-        /** Closed-form E-value — confounder strength needed to explain the effect away. */
+        /** Closed-form E-value (risk-ratio scale) — the confounder strength needed to
+         *  explain the effect away. A monotone transform of the standardized effect, so
+         *  it is NOT independent of the effect size; read it as "how easily overturned",
+         *  not as a separate confounding measure. */
         readonly robustness_value: OptionType<FloatType>;
         /** Unobserved-confounder sensitivity (tipping) curve: effect at each simulated strength. */
         readonly sensitivity: OptionType<StructType<{
             readonly strengths: VectorType<FloatType>;
             readonly effects: VectorType<FloatType>;
         }>>;
+        /** Sign-prior check (when `config.expected_sign` is set): `some(true)` if a
+         *  material effect matches the expected direction, `some(false)` if it points the
+         *  other way (→ verdict `adjustment_insufficient`). `none` when no prior is given
+         *  or the effect is near-zero (its sign is undefined).
+         *  twin: e3-ui RefutationType.expected_sign_ok */
+        readonly expected_sign_ok: OptionType<BooleanType>;
     }>>;
     /** ALE dose-response of `dose_feature` (present when `config.dose_feature` is set). */
     readonly dose_response: OptionType<StructType<{
@@ -458,7 +596,10 @@ export declare const causal_experiment: import("@elaraai/east").GenericPlatformD
         readonly size: VectorType<IntegerType>;
     }>>;
     readonly verdict: VariantType<{
-        /** A real, robust, material effect. */
+        /** A real, robust, material effect — robust to the **observed** backdoor set + the
+         *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+         *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+         *  (E-value) and `refutation.expected_sign_ok` alongside it. */
         readonly causal: NullType;
         /** A small but real effect, or no clear effect after adjustment. */
         readonly modest: NullType;
@@ -504,7 +645,10 @@ export declare const PowerCurveType: StructType<{
  */
 export declare const ExperimentDesignType: StructType<{
     readonly verdict: VariantType<{
-        /** A real, robust, material effect. */
+        /** A real, robust, material effect — robust to the **observed** backdoor set + the
+         *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+         *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+         *  (E-value) and `refutation.expected_sign_ok` alongside it. */
         readonly causal: NullType;
         /** A small but real effect, or no clear effect after adjustment. */
         readonly modest: NullType;
@@ -641,6 +785,23 @@ export declare const causal_design_validation: import("@elaraai/east").GenericPl
     }>>;
     /** Random seed. */
     readonly random_state: OptionType<IntegerType>;
+    /** Graded-overlap threshold — common support below this keeps `causal` from the
+     *  top tier (verdict `modest`, `overlap.support_strength = thin`); default 0.55. */
+    readonly strong_overlap: OptionType<FloatType>;
+    /** Robustness floor — when set, a `causal` verdict whose E-value
+     *  (`refutation.robustness_value`, risk-ratio scale) is below this is downgraded to
+     *  `modest`. Off by default. The E-value is a monotone transform of the standardized
+     *  effect, so this acts as a stricter materiality bar, not an independent check. */
+    readonly evalue_floor: OptionType<FloatType>;
+    /** Directional prior — when set, a material, CI-clear effect of the opposite sign is
+     *  flagged (`refutation.expected_sign_ok = some(false)`, verdict `adjustment_insufficient`).
+     *  Off by default. Catches reverse causation / reactive assignment the refuters can't. */
+    readonly expected_sign: OptionType<VariantType<{
+        /** The effect is expected to increase the outcome. */
+        readonly positive: NullType;
+        /** The effect is expected to decrease the outcome. */
+        readonly negative: NullType;
+    }>>;
 }>, StructType<{
     /** The raw (unadjusted) mean difference — always computable. */
     readonly naive: FloatType;
@@ -678,8 +839,21 @@ export declare const causal_design_validation: import("@elaraai/east").GenericPl
         readonly control_propensity: VectorType<FloatType>;
         /** Fraction of rows inside the treated/control common support. */
         readonly common_support_frac: FloatType;
-        /** Whether common support clears `min_overlap`. */
+        /** Whether common support clears the **refuse** gate `min_overlap` — i.e. an
+         *  adjusted estimate is attempted at all. NOT a quality signal: `true` at the
+         *  default gate (0.10) still means barely-overlapping. Read `support_strength`
+         *  for the graded tier. */
         readonly positivity_ok: BooleanType;
+        /** Graded common-support tier (`refused` / `thin` / `strong` vs `strong_overlap`).
+         *  twin: e3-ui OverlapDiagnosticType.support_strength */
+        readonly support_strength: VariantType<{
+            /** Below `min_overlap` — no like-for-like comparison (engine refuses). */
+            readonly refused: NullType;
+            /** Clears the refuse gate but below `strong_overlap` — fragile support. */
+            readonly thin: NullType;
+            /** Common support ≥ `strong_overlap` — solid. */
+            readonly strong: NullType;
+        }>;
     }>;
     readonly refutation: OptionType<StructType<{
         /** Effect under a permuted (placebo) treatment — should be ≈ 0. */
@@ -692,13 +866,22 @@ export declare const causal_design_validation: import("@elaraai/east").GenericPl
         readonly data_subset_effect: OptionType<FloatType>;
         /** Std of the effect across data subsamples. */
         readonly data_subset_std: OptionType<FloatType>;
-        /** Closed-form E-value — confounder strength needed to explain the effect away. */
+        /** Closed-form E-value (risk-ratio scale) — the confounder strength needed to
+         *  explain the effect away. A monotone transform of the standardized effect, so
+         *  it is NOT independent of the effect size; read it as "how easily overturned",
+         *  not as a separate confounding measure. */
         readonly robustness_value: OptionType<FloatType>;
         /** Unobserved-confounder sensitivity (tipping) curve: effect at each simulated strength. */
         readonly sensitivity: OptionType<StructType<{
             readonly strengths: VectorType<FloatType>;
             readonly effects: VectorType<FloatType>;
         }>>;
+        /** Sign-prior check (when `config.expected_sign` is set): `some(true)` if a
+         *  material effect matches the expected direction, `some(false)` if it points the
+         *  other way (→ verdict `adjustment_insufficient`). `none` when no prior is given
+         *  or the effect is near-zero (its sign is undefined).
+         *  twin: e3-ui RefutationType.expected_sign_ok */
+        readonly expected_sign_ok: OptionType<BooleanType>;
     }>>;
     /** ALE dose-response of `dose_feature` (present when `config.dose_feature` is set). */
     readonly dose_response: OptionType<StructType<{
@@ -711,7 +894,10 @@ export declare const causal_design_validation: import("@elaraai/east").GenericPl
         readonly size: VectorType<IntegerType>;
     }>>;
     readonly verdict: VariantType<{
-        /** A real, robust, material effect. */
+        /** A real, robust, material effect — robust to the **observed** backdoor set + the
+         *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+         *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+         *  (E-value) and `refutation.expected_sign_ok` alongside it. */
         readonly causal: NullType;
         /** A small but real effect, or no clear effect after adjustment. */
         readonly modest: NullType;
@@ -733,7 +919,10 @@ export declare const causal_design_validation: import("@elaraai/east").GenericPl
     readonly treated_shares: OptionType<ArrayType<FloatType>>;
 }>], StructType<{
     readonly verdict: VariantType<{
-        /** A real, robust, material effect. */
+        /** A real, robust, material effect — robust to the **observed** backdoor set + the
+         *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+         *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+         *  (E-value) and `refutation.expected_sign_ok` alongside it. */
         readonly causal: NullType;
         /** A small but real effect, or no clear effect after adjustment. */
         readonly modest: NullType;
@@ -817,6 +1006,12 @@ export declare const CausalTypes: {
         /** Average treatment effect on the controls */
         readonly atc: NullType;
     }>;
+    readonly CausalSignType: VariantType<{
+        /** The effect is expected to increase the outcome. */
+        readonly positive: NullType;
+        /** The effect is expected to decrease the outcome. */
+        readonly negative: NullType;
+    }>;
     readonly CausalBootstrapConfigType: StructType<{
         /** Number of bootstrap replicates (default 200) */
         readonly reps: IntegerType;
@@ -902,6 +1097,23 @@ export declare const CausalTypes: {
         }>>;
         /** Random seed. */
         readonly random_state: OptionType<IntegerType>;
+        /** Graded-overlap threshold — common support below this keeps `causal` from the
+         *  top tier (verdict `modest`, `overlap.support_strength = thin`); default 0.55. */
+        readonly strong_overlap: OptionType<FloatType>;
+        /** Robustness floor — when set, a `causal` verdict whose E-value
+         *  (`refutation.robustness_value`, risk-ratio scale) is below this is downgraded to
+         *  `modest`. Off by default. The E-value is a monotone transform of the standardized
+         *  effect, so this acts as a stricter materiality bar, not an independent check. */
+        readonly evalue_floor: OptionType<FloatType>;
+        /** Directional prior — when set, a material, CI-clear effect of the opposite sign is
+         *  flagged (`refutation.expected_sign_ok = some(false)`, verdict `adjustment_insufficient`).
+         *  Off by default. Catches reverse causation / reactive assignment the refuters can't. */
+        readonly expected_sign: OptionType<VariantType<{
+            /** The effect is expected to increase the outcome. */
+            readonly positive: NullType;
+            /** The effect is expected to decrease the outcome. */
+            readonly negative: NullType;
+        }>>;
     }>;
     readonly BalanceRowType: StructType<{
         readonly column: StringType;
@@ -913,6 +1125,14 @@ export declare const CausalTypes: {
         /** Standardized mean difference, (mt-mc)/sqrt((vt+vc)/2). */
         readonly std_diff: FloatType;
     }>;
+    readonly SupportStrengthType: VariantType<{
+        /** Below `min_overlap` — no like-for-like comparison (engine refuses). */
+        readonly refused: NullType;
+        /** Clears the refuse gate but below `strong_overlap` — fragile support. */
+        readonly thin: NullType;
+        /** Common support ≥ `strong_overlap` — solid. */
+        readonly strong: NullType;
+    }>;
     readonly OverlapDiagnosticType: StructType<{
         /** Propensity histogram (20 bins over [0,1]) for the treated arm. */
         readonly treated_propensity: VectorType<FloatType>;
@@ -920,8 +1140,21 @@ export declare const CausalTypes: {
         readonly control_propensity: VectorType<FloatType>;
         /** Fraction of rows inside the treated/control common support. */
         readonly common_support_frac: FloatType;
-        /** Whether common support clears `min_overlap`. */
+        /** Whether common support clears the **refuse** gate `min_overlap` — i.e. an
+         *  adjusted estimate is attempted at all. NOT a quality signal: `true` at the
+         *  default gate (0.10) still means barely-overlapping. Read `support_strength`
+         *  for the graded tier. */
         readonly positivity_ok: BooleanType;
+        /** Graded common-support tier (`refused` / `thin` / `strong` vs `strong_overlap`).
+         *  twin: e3-ui OverlapDiagnosticType.support_strength */
+        readonly support_strength: VariantType<{
+            /** Below `min_overlap` — no like-for-like comparison (engine refuses). */
+            readonly refused: NullType;
+            /** Clears the refuse gate but below `strong_overlap` — fragile support. */
+            readonly thin: NullType;
+            /** Common support ≥ `strong_overlap` — solid. */
+            readonly strong: NullType;
+        }>;
     }>;
     readonly RefutationType: StructType<{
         /** Effect under a permuted (placebo) treatment — should be ≈ 0. */
@@ -934,13 +1167,22 @@ export declare const CausalTypes: {
         readonly data_subset_effect: OptionType<FloatType>;
         /** Std of the effect across data subsamples. */
         readonly data_subset_std: OptionType<FloatType>;
-        /** Closed-form E-value — confounder strength needed to explain the effect away. */
+        /** Closed-form E-value (risk-ratio scale) — the confounder strength needed to
+         *  explain the effect away. A monotone transform of the standardized effect, so
+         *  it is NOT independent of the effect size; read it as "how easily overturned",
+         *  not as a separate confounding measure. */
         readonly robustness_value: OptionType<FloatType>;
         /** Unobserved-confounder sensitivity (tipping) curve: effect at each simulated strength. */
         readonly sensitivity: OptionType<StructType<{
             readonly strengths: VectorType<FloatType>;
             readonly effects: VectorType<FloatType>;
         }>>;
+        /** Sign-prior check (when `config.expected_sign` is set): `some(true)` if a
+         *  material effect matches the expected direction, `some(false)` if it points the
+         *  other way (→ verdict `adjustment_insufficient`). `none` when no prior is given
+         *  or the effect is near-zero (its sign is undefined).
+         *  twin: e3-ui RefutationType.expected_sign_ok */
+        readonly expected_sign_ok: OptionType<BooleanType>;
     }>;
     readonly DoseResponseType: StructType<{
         readonly feature: StringType;
@@ -952,7 +1194,10 @@ export declare const CausalTypes: {
         readonly size: VectorType<IntegerType>;
     }>;
     readonly ExperimentVerdictType: VariantType<{
-        /** A real, robust, material effect. */
+        /** A real, robust, material effect — robust to the **observed** backdoor set + the
+         *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+         *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+         *  (E-value) and `refutation.expected_sign_ok` alongside it. */
         readonly causal: NullType;
         /** A small but real effect, or no clear effect after adjustment. */
         readonly modest: NullType;
@@ -1000,8 +1245,21 @@ export declare const CausalTypes: {
             readonly control_propensity: VectorType<FloatType>;
             /** Fraction of rows inside the treated/control common support. */
             readonly common_support_frac: FloatType;
-            /** Whether common support clears `min_overlap`. */
+            /** Whether common support clears the **refuse** gate `min_overlap` — i.e. an
+             *  adjusted estimate is attempted at all. NOT a quality signal: `true` at the
+             *  default gate (0.10) still means barely-overlapping. Read `support_strength`
+             *  for the graded tier. */
             readonly positivity_ok: BooleanType;
+            /** Graded common-support tier (`refused` / `thin` / `strong` vs `strong_overlap`).
+             *  twin: e3-ui OverlapDiagnosticType.support_strength */
+            readonly support_strength: VariantType<{
+                /** Below `min_overlap` — no like-for-like comparison (engine refuses). */
+                readonly refused: NullType;
+                /** Clears the refuse gate but below `strong_overlap` — fragile support. */
+                readonly thin: NullType;
+                /** Common support ≥ `strong_overlap` — solid. */
+                readonly strong: NullType;
+            }>;
         }>;
         readonly refutation: OptionType<StructType<{
             /** Effect under a permuted (placebo) treatment — should be ≈ 0. */
@@ -1014,13 +1272,22 @@ export declare const CausalTypes: {
             readonly data_subset_effect: OptionType<FloatType>;
             /** Std of the effect across data subsamples. */
             readonly data_subset_std: OptionType<FloatType>;
-            /** Closed-form E-value — confounder strength needed to explain the effect away. */
+            /** Closed-form E-value (risk-ratio scale) — the confounder strength needed to
+             *  explain the effect away. A monotone transform of the standardized effect, so
+             *  it is NOT independent of the effect size; read it as "how easily overturned",
+             *  not as a separate confounding measure. */
             readonly robustness_value: OptionType<FloatType>;
             /** Unobserved-confounder sensitivity (tipping) curve: effect at each simulated strength. */
             readonly sensitivity: OptionType<StructType<{
                 readonly strengths: VectorType<FloatType>;
                 readonly effects: VectorType<FloatType>;
             }>>;
+            /** Sign-prior check (when `config.expected_sign` is set): `some(true)` if a
+             *  material effect matches the expected direction, `some(false)` if it points the
+             *  other way (→ verdict `adjustment_insufficient`). `none` when no prior is given
+             *  or the effect is near-zero (its sign is undefined).
+             *  twin: e3-ui RefutationType.expected_sign_ok */
+            readonly expected_sign_ok: OptionType<BooleanType>;
         }>>;
         /** ALE dose-response of `dose_feature` (present when `config.dose_feature` is set). */
         readonly dose_response: OptionType<StructType<{
@@ -1033,7 +1300,10 @@ export declare const CausalTypes: {
             readonly size: VectorType<IntegerType>;
         }>>;
         readonly verdict: VariantType<{
-            /** A real, robust, material effect. */
+            /** A real, robust, material effect — robust to the **observed** backdoor set + the
+             *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+             *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+             *  (E-value) and `refutation.expected_sign_ok` alongside it. */
             readonly causal: NullType;
             /** A small but real effect, or no clear effect after adjustment. */
             readonly modest: NullType;
@@ -1071,7 +1341,10 @@ export declare const CausalTypes: {
     }>;
     readonly ExperimentDesignType: StructType<{
         readonly verdict: VariantType<{
-            /** A real, robust, material effect. */
+            /** A real, robust, material effect — robust to the **observed** backdoor set + the
+             *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+             *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+             *  (E-value) and `refutation.expected_sign_ok` alongside it. */
             readonly causal: NullType;
             /** A small but real effect, or no clear effect after adjustment. */
             readonly modest: NullType;
@@ -1142,6 +1415,14 @@ export declare const CausalTypes: {
  * / `not_estimable`). It refuses (`adjusted = none`) when the data can't support
  * an estimate. DoWhy / EconML / PyALE are internal implementation it composes.
  *
+ * `causal` means robust to the **observed** backdoor set + the refuters that ran —
+ * NOT correctly-signed, free of reverse causation, or free of unobserved confounding.
+ * The graded `overlap.support_strength` (`refused`/`thin`/`strong`) tempers a thin-support
+ * result to `modest`; an opt-in `evalue_floor` folds a weak E-value into `modest`; an
+ * opt-in `expected_sign` prior flags an implausibly-signed effect (`adjustment_insufficient`,
+ * `refutation.expected_sign_ok = some(false)`). A reactively-assigned treatment needs a
+ * design-based strategy (IV / within-unit pre-period) — see `designValidation`.
+ *
  * @example
  * ```ts
  * import { East, ArrayType, StructType, FloatType, BooleanType, variant } from "@elaraai/east";
@@ -1225,6 +1506,23 @@ export declare const Causal: {
         }>>;
         /** Random seed. */
         readonly random_state: OptionType<IntegerType>;
+        /** Graded-overlap threshold — common support below this keeps `causal` from the
+         *  top tier (verdict `modest`, `overlap.support_strength = thin`); default 0.55. */
+        readonly strong_overlap: OptionType<FloatType>;
+        /** Robustness floor — when set, a `causal` verdict whose E-value
+         *  (`refutation.robustness_value`, risk-ratio scale) is below this is downgraded to
+         *  `modest`. Off by default. The E-value is a monotone transform of the standardized
+         *  effect, so this acts as a stricter materiality bar, not an independent check. */
+        readonly evalue_floor: OptionType<FloatType>;
+        /** Directional prior — when set, a material, CI-clear effect of the opposite sign is
+         *  flagged (`refutation.expected_sign_ok = some(false)`, verdict `adjustment_insufficient`).
+         *  Off by default. Catches reverse causation / reactive assignment the refuters can't. */
+        readonly expected_sign: OptionType<VariantType<{
+            /** The effect is expected to increase the outcome. */
+            readonly positive: NullType;
+            /** The effect is expected to decrease the outcome. */
+            readonly negative: NullType;
+        }>>;
     }>], StructType<{
         /** The raw (unadjusted) mean difference — always computable. */
         readonly naive: FloatType;
@@ -1262,8 +1560,21 @@ export declare const Causal: {
             readonly control_propensity: VectorType<FloatType>;
             /** Fraction of rows inside the treated/control common support. */
             readonly common_support_frac: FloatType;
-            /** Whether common support clears `min_overlap`. */
+            /** Whether common support clears the **refuse** gate `min_overlap` — i.e. an
+             *  adjusted estimate is attempted at all. NOT a quality signal: `true` at the
+             *  default gate (0.10) still means barely-overlapping. Read `support_strength`
+             *  for the graded tier. */
             readonly positivity_ok: BooleanType;
+            /** Graded common-support tier (`refused` / `thin` / `strong` vs `strong_overlap`).
+             *  twin: e3-ui OverlapDiagnosticType.support_strength */
+            readonly support_strength: VariantType<{
+                /** Below `min_overlap` — no like-for-like comparison (engine refuses). */
+                readonly refused: NullType;
+                /** Clears the refuse gate but below `strong_overlap` — fragile support. */
+                readonly thin: NullType;
+                /** Common support ≥ `strong_overlap` — solid. */
+                readonly strong: NullType;
+            }>;
         }>;
         readonly refutation: OptionType<StructType<{
             /** Effect under a permuted (placebo) treatment — should be ≈ 0. */
@@ -1276,13 +1587,22 @@ export declare const Causal: {
             readonly data_subset_effect: OptionType<FloatType>;
             /** Std of the effect across data subsamples. */
             readonly data_subset_std: OptionType<FloatType>;
-            /** Closed-form E-value — confounder strength needed to explain the effect away. */
+            /** Closed-form E-value (risk-ratio scale) — the confounder strength needed to
+             *  explain the effect away. A monotone transform of the standardized effect, so
+             *  it is NOT independent of the effect size; read it as "how easily overturned",
+             *  not as a separate confounding measure. */
             readonly robustness_value: OptionType<FloatType>;
             /** Unobserved-confounder sensitivity (tipping) curve: effect at each simulated strength. */
             readonly sensitivity: OptionType<StructType<{
                 readonly strengths: VectorType<FloatType>;
                 readonly effects: VectorType<FloatType>;
             }>>;
+            /** Sign-prior check (when `config.expected_sign` is set): `some(true)` if a
+             *  material effect matches the expected direction, `some(false)` if it points the
+             *  other way (→ verdict `adjustment_insufficient`). `none` when no prior is given
+             *  or the effect is near-zero (its sign is undefined).
+             *  twin: e3-ui RefutationType.expected_sign_ok */
+            readonly expected_sign_ok: OptionType<BooleanType>;
         }>>;
         /** ALE dose-response of `dose_feature` (present when `config.dose_feature` is set). */
         readonly dose_response: OptionType<StructType<{
@@ -1295,7 +1615,10 @@ export declare const Causal: {
             readonly size: VectorType<IntegerType>;
         }>>;
         readonly verdict: VariantType<{
-            /** A real, robust, material effect. */
+            /** A real, robust, material effect — robust to the **observed** backdoor set + the
+             *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+             *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+             *  (E-value) and `refutation.expected_sign_ok` alongside it. */
             readonly causal: NullType;
             /** A small but real effect, or no clear effect after adjustment. */
             readonly modest: NullType;
@@ -1371,6 +1694,23 @@ export declare const Causal: {
         }>>;
         /** Random seed. */
         readonly random_state: OptionType<IntegerType>;
+        /** Graded-overlap threshold — common support below this keeps `causal` from the
+         *  top tier (verdict `modest`, `overlap.support_strength = thin`); default 0.55. */
+        readonly strong_overlap: OptionType<FloatType>;
+        /** Robustness floor — when set, a `causal` verdict whose E-value
+         *  (`refutation.robustness_value`, risk-ratio scale) is below this is downgraded to
+         *  `modest`. Off by default. The E-value is a monotone transform of the standardized
+         *  effect, so this acts as a stricter materiality bar, not an independent check. */
+        readonly evalue_floor: OptionType<FloatType>;
+        /** Directional prior — when set, a material, CI-clear effect of the opposite sign is
+         *  flagged (`refutation.expected_sign_ok = some(false)`, verdict `adjustment_insufficient`).
+         *  Off by default. Catches reverse causation / reactive assignment the refuters can't. */
+        readonly expected_sign: OptionType<VariantType<{
+            /** The effect is expected to increase the outcome. */
+            readonly positive: NullType;
+            /** The effect is expected to decrease the outcome. */
+            readonly negative: NullType;
+        }>>;
     }>, StructType<{
         /** The raw (unadjusted) mean difference — always computable. */
         readonly naive: FloatType;
@@ -1408,8 +1748,21 @@ export declare const Causal: {
             readonly control_propensity: VectorType<FloatType>;
             /** Fraction of rows inside the treated/control common support. */
             readonly common_support_frac: FloatType;
-            /** Whether common support clears `min_overlap`. */
+            /** Whether common support clears the **refuse** gate `min_overlap` — i.e. an
+             *  adjusted estimate is attempted at all. NOT a quality signal: `true` at the
+             *  default gate (0.10) still means barely-overlapping. Read `support_strength`
+             *  for the graded tier. */
             readonly positivity_ok: BooleanType;
+            /** Graded common-support tier (`refused` / `thin` / `strong` vs `strong_overlap`).
+             *  twin: e3-ui OverlapDiagnosticType.support_strength */
+            readonly support_strength: VariantType<{
+                /** Below `min_overlap` — no like-for-like comparison (engine refuses). */
+                readonly refused: NullType;
+                /** Clears the refuse gate but below `strong_overlap` — fragile support. */
+                readonly thin: NullType;
+                /** Common support ≥ `strong_overlap` — solid. */
+                readonly strong: NullType;
+            }>;
         }>;
         readonly refutation: OptionType<StructType<{
             /** Effect under a permuted (placebo) treatment — should be ≈ 0. */
@@ -1422,13 +1775,22 @@ export declare const Causal: {
             readonly data_subset_effect: OptionType<FloatType>;
             /** Std of the effect across data subsamples. */
             readonly data_subset_std: OptionType<FloatType>;
-            /** Closed-form E-value — confounder strength needed to explain the effect away. */
+            /** Closed-form E-value (risk-ratio scale) — the confounder strength needed to
+             *  explain the effect away. A monotone transform of the standardized effect, so
+             *  it is NOT independent of the effect size; read it as "how easily overturned",
+             *  not as a separate confounding measure. */
             readonly robustness_value: OptionType<FloatType>;
             /** Unobserved-confounder sensitivity (tipping) curve: effect at each simulated strength. */
             readonly sensitivity: OptionType<StructType<{
                 readonly strengths: VectorType<FloatType>;
                 readonly effects: VectorType<FloatType>;
             }>>;
+            /** Sign-prior check (when `config.expected_sign` is set): `some(true)` if a
+             *  material effect matches the expected direction, `some(false)` if it points the
+             *  other way (→ verdict `adjustment_insufficient`). `none` when no prior is given
+             *  or the effect is near-zero (its sign is undefined).
+             *  twin: e3-ui RefutationType.expected_sign_ok */
+            readonly expected_sign_ok: OptionType<BooleanType>;
         }>>;
         /** ALE dose-response of `dose_feature` (present when `config.dose_feature` is set). */
         readonly dose_response: OptionType<StructType<{
@@ -1441,7 +1803,10 @@ export declare const Causal: {
             readonly size: VectorType<IntegerType>;
         }>>;
         readonly verdict: VariantType<{
-            /** A real, robust, material effect. */
+            /** A real, robust, material effect — robust to the **observed** backdoor set + the
+             *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+             *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+             *  (E-value) and `refutation.expected_sign_ok` alongside it. */
             readonly causal: NullType;
             /** A small but real effect, or no clear effect after adjustment. */
             readonly modest: NullType;
@@ -1463,7 +1828,10 @@ export declare const Causal: {
         readonly treated_shares: OptionType<ArrayType<FloatType>>;
     }>], StructType<{
         readonly verdict: VariantType<{
-            /** A real, robust, material effect. */
+            /** A real, robust, material effect — robust to the **observed** backdoor set + the
+             *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+             *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+             *  (E-value) and `refutation.expected_sign_ok` alongside it. */
             readonly causal: NullType;
             /** A small but real effect, or no clear effect after adjustment. */
             readonly modest: NullType;
@@ -1547,6 +1915,12 @@ export declare const Causal: {
             /** Average treatment effect on the controls */
             readonly atc: NullType;
         }>;
+        readonly CausalSignType: VariantType<{
+            /** The effect is expected to increase the outcome. */
+            readonly positive: NullType;
+            /** The effect is expected to decrease the outcome. */
+            readonly negative: NullType;
+        }>;
         readonly CausalBootstrapConfigType: StructType<{
             /** Number of bootstrap replicates (default 200) */
             readonly reps: IntegerType;
@@ -1632,6 +2006,23 @@ export declare const Causal: {
             }>>;
             /** Random seed. */
             readonly random_state: OptionType<IntegerType>;
+            /** Graded-overlap threshold — common support below this keeps `causal` from the
+             *  top tier (verdict `modest`, `overlap.support_strength = thin`); default 0.55. */
+            readonly strong_overlap: OptionType<FloatType>;
+            /** Robustness floor — when set, a `causal` verdict whose E-value
+             *  (`refutation.robustness_value`, risk-ratio scale) is below this is downgraded to
+             *  `modest`. Off by default. The E-value is a monotone transform of the standardized
+             *  effect, so this acts as a stricter materiality bar, not an independent check. */
+            readonly evalue_floor: OptionType<FloatType>;
+            /** Directional prior — when set, a material, CI-clear effect of the opposite sign is
+             *  flagged (`refutation.expected_sign_ok = some(false)`, verdict `adjustment_insufficient`).
+             *  Off by default. Catches reverse causation / reactive assignment the refuters can't. */
+            readonly expected_sign: OptionType<VariantType<{
+                /** The effect is expected to increase the outcome. */
+                readonly positive: NullType;
+                /** The effect is expected to decrease the outcome. */
+                readonly negative: NullType;
+            }>>;
         }>;
         readonly BalanceRowType: StructType<{
             readonly column: StringType;
@@ -1643,6 +2034,14 @@ export declare const Causal: {
             /** Standardized mean difference, (mt-mc)/sqrt((vt+vc)/2). */
             readonly std_diff: FloatType;
         }>;
+        readonly SupportStrengthType: VariantType<{
+            /** Below `min_overlap` — no like-for-like comparison (engine refuses). */
+            readonly refused: NullType;
+            /** Clears the refuse gate but below `strong_overlap` — fragile support. */
+            readonly thin: NullType;
+            /** Common support ≥ `strong_overlap` — solid. */
+            readonly strong: NullType;
+        }>;
         readonly OverlapDiagnosticType: StructType<{
             /** Propensity histogram (20 bins over [0,1]) for the treated arm. */
             readonly treated_propensity: VectorType<FloatType>;
@@ -1650,8 +2049,21 @@ export declare const Causal: {
             readonly control_propensity: VectorType<FloatType>;
             /** Fraction of rows inside the treated/control common support. */
             readonly common_support_frac: FloatType;
-            /** Whether common support clears `min_overlap`. */
+            /** Whether common support clears the **refuse** gate `min_overlap` — i.e. an
+             *  adjusted estimate is attempted at all. NOT a quality signal: `true` at the
+             *  default gate (0.10) still means barely-overlapping. Read `support_strength`
+             *  for the graded tier. */
             readonly positivity_ok: BooleanType;
+            /** Graded common-support tier (`refused` / `thin` / `strong` vs `strong_overlap`).
+             *  twin: e3-ui OverlapDiagnosticType.support_strength */
+            readonly support_strength: VariantType<{
+                /** Below `min_overlap` — no like-for-like comparison (engine refuses). */
+                readonly refused: NullType;
+                /** Clears the refuse gate but below `strong_overlap` — fragile support. */
+                readonly thin: NullType;
+                /** Common support ≥ `strong_overlap` — solid. */
+                readonly strong: NullType;
+            }>;
         }>;
         readonly RefutationType: StructType<{
             /** Effect under a permuted (placebo) treatment — should be ≈ 0. */
@@ -1664,13 +2076,22 @@ export declare const Causal: {
             readonly data_subset_effect: OptionType<FloatType>;
             /** Std of the effect across data subsamples. */
             readonly data_subset_std: OptionType<FloatType>;
-            /** Closed-form E-value — confounder strength needed to explain the effect away. */
+            /** Closed-form E-value (risk-ratio scale) — the confounder strength needed to
+             *  explain the effect away. A monotone transform of the standardized effect, so
+             *  it is NOT independent of the effect size; read it as "how easily overturned",
+             *  not as a separate confounding measure. */
             readonly robustness_value: OptionType<FloatType>;
             /** Unobserved-confounder sensitivity (tipping) curve: effect at each simulated strength. */
             readonly sensitivity: OptionType<StructType<{
                 readonly strengths: VectorType<FloatType>;
                 readonly effects: VectorType<FloatType>;
             }>>;
+            /** Sign-prior check (when `config.expected_sign` is set): `some(true)` if a
+             *  material effect matches the expected direction, `some(false)` if it points the
+             *  other way (→ verdict `adjustment_insufficient`). `none` when no prior is given
+             *  or the effect is near-zero (its sign is undefined).
+             *  twin: e3-ui RefutationType.expected_sign_ok */
+            readonly expected_sign_ok: OptionType<BooleanType>;
         }>;
         readonly DoseResponseType: StructType<{
             readonly feature: StringType;
@@ -1682,7 +2103,10 @@ export declare const Causal: {
             readonly size: VectorType<IntegerType>;
         }>;
         readonly ExperimentVerdictType: VariantType<{
-            /** A real, robust, material effect. */
+            /** A real, robust, material effect — robust to the **observed** backdoor set + the
+             *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+             *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+             *  (E-value) and `refutation.expected_sign_ok` alongside it. */
             readonly causal: NullType;
             /** A small but real effect, or no clear effect after adjustment. */
             readonly modest: NullType;
@@ -1730,8 +2154,21 @@ export declare const Causal: {
                 readonly control_propensity: VectorType<FloatType>;
                 /** Fraction of rows inside the treated/control common support. */
                 readonly common_support_frac: FloatType;
-                /** Whether common support clears `min_overlap`. */
+                /** Whether common support clears the **refuse** gate `min_overlap` — i.e. an
+                 *  adjusted estimate is attempted at all. NOT a quality signal: `true` at the
+                 *  default gate (0.10) still means barely-overlapping. Read `support_strength`
+                 *  for the graded tier. */
                 readonly positivity_ok: BooleanType;
+                /** Graded common-support tier (`refused` / `thin` / `strong` vs `strong_overlap`).
+                 *  twin: e3-ui OverlapDiagnosticType.support_strength */
+                readonly support_strength: VariantType<{
+                    /** Below `min_overlap` — no like-for-like comparison (engine refuses). */
+                    readonly refused: NullType;
+                    /** Clears the refuse gate but below `strong_overlap` — fragile support. */
+                    readonly thin: NullType;
+                    /** Common support ≥ `strong_overlap` — solid. */
+                    readonly strong: NullType;
+                }>;
             }>;
             readonly refutation: OptionType<StructType<{
                 /** Effect under a permuted (placebo) treatment — should be ≈ 0. */
@@ -1744,13 +2181,22 @@ export declare const Causal: {
                 readonly data_subset_effect: OptionType<FloatType>;
                 /** Std of the effect across data subsamples. */
                 readonly data_subset_std: OptionType<FloatType>;
-                /** Closed-form E-value — confounder strength needed to explain the effect away. */
+                /** Closed-form E-value (risk-ratio scale) — the confounder strength needed to
+                 *  explain the effect away. A monotone transform of the standardized effect, so
+                 *  it is NOT independent of the effect size; read it as "how easily overturned",
+                 *  not as a separate confounding measure. */
                 readonly robustness_value: OptionType<FloatType>;
                 /** Unobserved-confounder sensitivity (tipping) curve: effect at each simulated strength. */
                 readonly sensitivity: OptionType<StructType<{
                     readonly strengths: VectorType<FloatType>;
                     readonly effects: VectorType<FloatType>;
                 }>>;
+                /** Sign-prior check (when `config.expected_sign` is set): `some(true)` if a
+                 *  material effect matches the expected direction, `some(false)` if it points the
+                 *  other way (→ verdict `adjustment_insufficient`). `none` when no prior is given
+                 *  or the effect is near-zero (its sign is undefined).
+                 *  twin: e3-ui RefutationType.expected_sign_ok */
+                readonly expected_sign_ok: OptionType<BooleanType>;
             }>>;
             /** ALE dose-response of `dose_feature` (present when `config.dose_feature` is set). */
             readonly dose_response: OptionType<StructType<{
@@ -1763,7 +2209,10 @@ export declare const Causal: {
                 readonly size: VectorType<IntegerType>;
             }>>;
             readonly verdict: VariantType<{
-                /** A real, robust, material effect. */
+                /** A real, robust, material effect — robust to the **observed** backdoor set + the
+                 *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+                 *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+                 *  (E-value) and `refutation.expected_sign_ok` alongside it. */
                 readonly causal: NullType;
                 /** A small but real effect, or no clear effect after adjustment. */
                 readonly modest: NullType;
@@ -1801,7 +2250,10 @@ export declare const Causal: {
         }>;
         readonly ExperimentDesignType: StructType<{
             readonly verdict: VariantType<{
-                /** A real, robust, material effect. */
+                /** A real, robust, material effect — robust to the **observed** backdoor set + the
+                 *  refuters that were run. It does NOT mean correctly-signed, free of reverse
+                 *  causation, or free of unobserved confounding: read `refutation.robustness_value`
+                 *  (E-value) and `refutation.expected_sign_ok` alongside it. */
                 readonly causal: NullType;
                 /** A small but real effect, or no clear effect after adjustment. */
                 readonly modest: NullType;