abtestresult-mcp 1.0.8 → 1.3.0

package/README.md

@@ -2,7 +2,7 @@
 
 Statistical tools for A/B testing, available as a [Model Context Protocol](https://modelcontextprotocol.io) (MCP) server. Powered by [abtestresult.com](https://abtestresult.com).
 
-Give any AI assistant (Claude, Cursor, VS Code, etc.) the ability to analyze A/B tests, calculate sample sizes, run Bayesian analysis, and more. All calculations run locally on your machine — no API keys, your test data never leaves your device.
+Give any AI assistant (Claude, Codex, Cursor, VS Code, etc.) the ability to analyze A/B tests, calculate sample sizes, run Bayesian analysis, and more. All calculations run locally on your machine — no API keys, your test data never leaves your device.
 
 This package ships readable source. It is source-available for local personal use only and is not licensed for commercial use.
 
@@ -23,7 +23,8 @@ Add to your MCP configuration:
 
 **Where to add this:**
 
-- **Claude Desktop:** `~/.claude/claude_desktop_config.json`
+- **Claude Desktop:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Codex:** `~/.codex/config.toml`
 - **Claude Code:** `.mcp.json` in your project root
 - **Cursor:** `.cursor/mcp.json`
 - **VS Code:** `.vscode/settings.json` (use `mcp.servers` instead of `mcpServers`)
@@ -35,7 +36,7 @@ That's it. No API keys, no authentication. The server starts automatically when
 | Tool | Description |
 |------|-------------|
 | `analyze_ab_test` | Z-test for rate metrics (conversion rate, CTR, etc.) |
-| `analyze_ab_test_average` | T-test for continuous metrics (revenue, time on page, etc.) |
+| `analyze_ab_test_average` | Welch's T-test for continuous metrics (revenue, time on page, etc.); no equal-variance assumption |
 | `calculate_sample_size` | Required sample size for rate or average metrics |
 | `calculate_mde` | Minimum detectable effect given a fixed sample size |
 | `bayesian_ab_test` | Bayesian analysis with probability to be best & expected loss |
@@ -43,6 +44,14 @@ That's it. No API keys, no authentication. The server starts automatically when
 | `paired_test` | Paired T-test or Wilcoxon signed-rank for before/after data |
 | `survey_sample_size` | Cochran's formula with finite population correction |
 
+## Shareable result links
+
+Every analysis tool (except `paired_test`) returns a `view_url` in its response — a
+deeplink to [abtestresult.com](https://abtestresult.com) that pre-fills the matching
+calculator with your inputs and auto-runs it. Open it to inspect the result visually
+(charts, confidence intervals, recommendations) or share it with your team. No data is
+stored server-side: the inputs are encoded directly into the URL.
+
 ## Usage Examples
 
 Once connected, just ask your AI assistant in natural language:

package/dist/index.js

@@ -33997,10 +33997,24 @@ function normalInterval(confidence, mean, std) {
   const z2 = normalPpf(1 - alpha / 2);
   return [mean - z2 * std, mean + z2 * std];
 }
+var LARGE_DF = 1e4;
 function tCdf(x, df) {
+  if (df > LARGE_DF) {
+    const z2 = x * (1 - 1 / (4 * df)) / Math.sqrt(1 + x * x / (2 * df));
+    return normalCdf(z2);
+  }
   return import_jstat.default.studentt.cdf(x, df);
 }
 function tPpf(p, df) {
+  if (df > LARGE_DF) {
+    const z2 = normalPpf(p);
+    const z22 = z2 * z2;
+    const g1 = (z22 + 1) * z2 / 4;
+    const g2 = ((5 * z22 + 16) * z22 + 3) * z2 / 96;
+    const g3 = (((3 * z22 + 19) * z22 + 17) * z22 - 15) * z2 / 384;
+    const g4 = ((((79 * z22 + 776) * z22 + 1482) * z22 - 1920) * z22 - 945) * z2 / 92160;
+    return z2 + g1 / df + g2 / df ** 2 + g3 / df ** 3 + g4 / df ** 4;
+  }
   return import_jstat.default.studentt.inv(p, df);
 }
 function chiSquareCdf(x, df) {
@@ -34064,12 +34078,23 @@ function zTestForProportions(controlUsers, controlConversions, variantUsers, var
   };
 }
 function tTestForAverages(controlUsers, controlMean, controlStdDev, variantUsers, variantMean, variantStdDev, confidenceLevelAdj, sided, niMarginPercent = 0) {
+  if (!(controlUsers >= 2) || !(variantUsers >= 2)) {
+    throw new RangeError("Welch T-test needs at least 2 users in each group");
+  }
+  if (!(controlStdDev >= 0) || !(variantStdDev >= 0) || !Number.isFinite(controlStdDev) || !Number.isFinite(variantStdDev)) {
+    throw new RangeError("Standard deviations must be finite and non-negative");
+  }
+  if (controlStdDev === 0 && variantStdDev === 0) {
+    throw new RangeError("At least one group must have a standard deviation above 0");
+  }
   const niMarginDecimal = niMarginPercent / 100;
+  const controlVarMean = controlStdDev ** 2 / controlUsers;
+  const variantVarMean = variantStdDev ** 2 / variantUsers;
+  const sem = Math.sqrt(controlVarMean + variantVarMean);
+  const df = (controlVarMean + variantVarMean) ** 2 / (controlVarMean ** 2 / (controlUsers - 1) + variantVarMean ** 2 / (variantUsers - 1));
   const pooledStd = Math.sqrt(
     ((controlUsers - 1) * controlStdDev ** 2 + (variantUsers - 1) * variantStdDev ** 2) / (controlUsers + variantUsers - 2)
   );
-  const sem = pooledStd * Math.sqrt(1 / controlUsers + 1 / variantUsers);
-  const df = controlUsers + variantUsers - 2;
   let tScore = (variantMean - controlMean + niMarginDecimal * controlMean) / sem;
   if (sided === 2) {
     tScore = Math.abs(tScore);
@@ -34081,7 +34106,8 @@ function tTestForAverages(controlUsers, controlMean, controlStdDev, variantUsers
     pValue = 1 - tCdf(tScore, df);
   }
   const alphaT = 1 - confidenceLevelAdj;
-  const tCritical = sided === 1 ? tPpf(1 - alphaT, df) : tPpf(1 - alphaT / 2, df);
+  const criticalT = (dof) => sided === 1 ? tPpf(1 - alphaT, dof) : tPpf(1 - alphaT / 2, dof);
+  const tCritical = criticalT(df);
   const isSignificant = tScore > tCritical;
   const delta = variantMean - controlMean;
   const deltaRelative = controlMean !== 0 ? delta / controlMean : 0;
@@ -34089,18 +34115,21 @@ function tTestForAverages(controlUsers, controlMean, controlStdDev, variantUsers
   const meanCriticalLess = controlMean - tCritical * sem;
   const deltaCritical = tCritical * sem;
   const deltaCriticalLess = -tCritical * sem;
+  const controlSe = controlStdDev / Math.sqrt(controlUsers);
+  const variantSe = variantStdDev / Math.sqrt(variantUsers);
+  const controlT = criticalT(controlUsers - 1);
+  const variantT = criticalT(variantUsers - 1);
   const controlCi = [
-    controlMean - tCritical * (controlStdDev / Math.sqrt(controlUsers)),
-    controlMean + tCritical * (controlStdDev / Math.sqrt(controlUsers))
+    controlMean - controlT * controlSe,
+    controlMean + controlT * controlSe
   ];
   const variationCi = [
-    variantMean - tCritical * (variantStdDev / Math.sqrt(variantUsers)),
-    variantMean + tCritical * (variantStdDev / Math.sqrt(variantUsers))
+    variantMean - variantT * variantSe,
+    variantMean + variantT * variantSe
   ];
-  const diffSe = Math.sqrt(controlStdDev ** 2 / controlUsers + variantStdDev ** 2 / variantUsers);
   const diffCi = [
-    variantMean - controlMean - tCritical * diffSe,
-    variantMean - controlMean + tCritical * diffSe
+    delta - tCritical * sem,
+    delta + tCritical * sem
   ];
   return {
     tScore,
@@ -34112,6 +34141,8 @@ function tTestForAverages(controlUsers, controlMean, controlStdDev, variantUsers
     pooledStd,
     sem,
     df,
+    controlSe,
+    variantSe,
     controlCi,
     variationCi,
     diffCi,
@@ -34123,16 +34154,18 @@ function tTestForAverages(controlUsers, controlMean, controlStdDev, variantUsers
     variantMean
   };
 }
-function checkSRM(controlUsers, variantUsers) {
+function checkSRM(controlUsers, variantUsers, expectedControlShare = 0.5) {
   const total = controlUsers + variantUsers;
-  const expected = total / 2;
-  const chiSquare = Math.pow(controlUsers - expected, 2) / expected + Math.pow(variantUsers - expected, 2) / expected;
+  const expectedControl = total * expectedControlShare;
+  const expectedVariant = total - expectedControl;
+  const chiSquare = Math.pow(controlUsers - expectedControl, 2) / expectedControl + Math.pow(variantUsers - expectedVariant, 2) / expectedVariant;
   const pValue = 1 - chiSquareCdf(chiSquare, 1);
   const hasMismatch = pValue < 0.01;
   return {
     chiSquare,
     pValue,
-    hasMismatch
+    hasMismatch,
+    expectedControlShare
   };
 }
 function calculateSampleSizeRate(baseline, mde, confidenceLevel, power, sided, numVariants = 1, successMetrics = 1, guardrailMetrics = 0, niMarginPercent = 0, dailyTraffic = null) {
@@ -34201,15 +34234,30 @@ function calculateSampleSizeAverage(baseline, mde, stdDev, confidenceLevel, powe
     mdeAbsolute: p2 - baseline
   };
 }
+function allocateSampleSize(samplesEachBalanced, numVariants, controlShare) {
+  const variantShare = (1 - controlShare) / numVariants;
+  const total = samplesEachBalanced / 2 * (1 / controlShare + 1 / variantShare);
+  const control = Math.ceil(total * controlShare - 1e-9);
+  const perVariant = Math.ceil(total * variantShare - 1e-9);
+  const allocatedTotal = control + perVariant * numVariants;
+  return {
+    control,
+    perVariant,
+    total: allocatedTotal,
+    multiplier: allocatedTotal / (samplesEachBalanced * (numVariants + 1))
+  };
+}
 function calculateSurveySampleSize(population, marginOfError, confidenceLevel) {
   const estimatedProportion = 0.5;
   const zScore = Math.abs(normalPpf((1 - confidenceLevel) / 2));
   const sampleSize = population * Math.pow(zScore, 2) * estimatedProportion * (1 - estimatedProportion) / (Math.pow(marginOfError, 2) * (population - 1) + Math.pow(zScore, 2) * estimatedProportion * (1 - estimatedProportion));
   return Math.ceil(sampleSize);
 }
-function estimateMDE(traffic, stdDev, power, confidenceLevel, numVariants = 1, successMetrics = 1, guardrailMetrics = 0) {
+function estimateMDE(traffic, stdDev, power, confidenceLevel, numVariants = 1, successMetrics = 1, guardrailMetrics = 0, controlShare) {
   const nGroups = numVariants + 1;
-  const n = traffic / nGroups;
+  const cShare = controlShare ?? 1 / nGroups;
+  const nControl = traffic * cShare;
+  const nVariant = traffic * (1 - cShare) / numVariants;
   let alpha = 1 - confidenceLevel;
   const comparisons = numVariants + (successMetrics - 1);
   if (comparisons > 0) {
@@ -34222,9 +34270,68 @@ function estimateMDE(traffic, stdDev, power, confidenceLevel, numVariants = 1, s
   }
   const zAlpha = normalPpf(1 - alpha / 2);
   const zPower = normalPpf(adjustedPower);
-  const mde = (zPower + zAlpha) * Math.sqrt(2) * stdDev / Math.sqrt(n);
+  const mde = (zPower + zAlpha) * stdDev * Math.sqrt(1 / nControl + 1 / nVariant);
   return mde;
 }
+function twoProportionPower(nControl, nVariant, baselineRate, lift, alpha, sided = 2) {
+  const p1 = baselineRate;
+  const p2 = baselineRate + lift;
+  const pooled = (nControl * p1 + nVariant * p2) / (nControl + nVariant);
+  const se0 = Math.sqrt(pooled * (1 - pooled) * (1 / nControl + 1 / nVariant));
+  const se1 = Math.sqrt(p1 * (1 - p1) / nControl + p2 * (1 - p2) / nVariant);
+  if (sided === 1) {
+    return normalCdf((lift - normalPpf(1 - alpha) * se0) / se1);
+  }
+  const z2 = normalPpf(1 - alpha / 2);
+  return normalCdf((lift - z2 * se0) / se1) + normalCdf((-lift - z2 * se0) / se1);
+}
+function estimateMDERate({
+  traffic,
+  baselineRate,
+  power,
+  confidenceLevel,
+  numVariants = 1,
+  successMetrics = 1,
+  guardrailMetrics = 0,
+  controlShare,
+  sided = 2
+}) {
+  const p = baselineRate;
+  if (!(traffic > 0) || !(p > 0 && p < 1)) return NaN;
+  const cShare = controlShare ?? 1 / (numVariants + 1);
+  const nControl = traffic * cShare;
+  const nVariant = traffic * (1 - cShare) / numVariants;
+  let alpha = 1 - confidenceLevel;
+  const comparisons = numVariants + (successMetrics - 1);
+  if (comparisons > 0) {
+    alpha = sidakCorrection(alpha, comparisons);
+  }
+  let adjustedPower = power;
+  if (guardrailMetrics > 0) {
+    adjustedPower = 1 - (1 - power) / (guardrailMetrics + 1);
+  }
+  const powerAt = (d) => twoProportionPower(nControl, nVariant, p, d, alpha, sided);
+  const maxLift = 1 - p - 1e-12;
+  const steps = 200;
+  const minLift = maxLift * 1e-6;
+  let lo = 0;
+  let hi = NaN;
+  for (let i = 0; i <= steps; i++) {
+    const d = minLift * Math.pow(maxLift / minLift, i / steps);
+    if (powerAt(d) >= adjustedPower) {
+      hi = d;
+      break;
+    }
+    lo = d;
+  }
+  if (Number.isNaN(hi)) return Infinity;
+  for (let i = 0; i < 100; i++) {
+    const mid = (lo + hi) / 2;
+    if (powerAt(mid) >= adjustedPower) hi = mid;
+    else lo = mid;
+  }
+  return hi;
+}
 function pairedTTest(sample1, sample2, confidenceLevel) {
   if (sample1.length !== sample2.length) {
     throw new Error("Samples must have the same length");
@@ -34420,6 +34527,31 @@ function betaPosterior(priorAlpha, priorBeta, successes, trials) {
     beta: priorBeta + (trials - successes)
   };
 }
+function computeVariantLifts(samples, tail) {
+  const EPSILON = 1e-10;
+  const control = samples[0];
+  const percentileCi = (sorted) => sorted.length > 0 ? [sorted[Math.floor(tail * sorted.length)], sorted[Math.floor((1 - tail) * sorted.length)]] : [0, 0];
+  const mean = (arr) => arr.length > 0 ? arr.reduce((s, v) => s + v, 0) / arr.length : 0;
+  const lifts = [];
+  for (let v = 1; v < samples.length; v++) {
+    const abs = [];
+    const rel = [];
+    for (let i = 0; i < control.length; i++) {
+      abs.push(samples[v][i] - control[i]);
+      if (Math.abs(control[i]) > EPSILON) rel.push((samples[v][i] - control[i]) / control[i]);
+    }
+    abs.sort((a, b) => a - b);
+    rel.sort((a, b) => a - b);
+    lifts.push({
+      variantIndex: v,
+      mean: mean(abs),
+      ci: percentileCi(abs),
+      relativeMean: mean(rel),
+      relativeCi: percentileCi(rel)
+    });
+  }
+  return lifts;
+}
 function bayesianMonteCarlo(variants, simulations = 1e5, credibility = 0.95) {
   const n = variants.length;
   const samples = [];
@@ -34531,7 +34663,8 @@ function bayesianMonteCarlo(variants, simulations = 1e5, credibility = 0.95) {
     credibleIntervals,
     posteriorMeans,
     liftDistribution: { mean: liftMean, ci: liftCi, histogram },
-    relativeLiftDistribution: { mean: relLiftMean, ci: relLiftCi, histogram: relHistogram }
+    relativeLiftDistribution: { mean: relLiftMean, ci: relLiftCi, histogram: relHistogram },
+    variantLifts: computeVariantLifts(samples, tail)
   };
 }
 function normalPosterior(sampleMean, sampleStdDev, sampleSize) {
@@ -34651,7 +34784,8 @@ function bayesianMonteCarloNormal(variants, simulations = 1e5, credibility = 0.9
     credibleIntervals,
     posteriorMeans,
     liftDistribution: { mean: liftMean, ci: liftCi, histogram },
-    relativeLiftDistribution: { mean: relLiftMean, ci: relLiftCi, histogram: relHistogram }
+    relativeLiftDistribution: { mean: relLiftMean, ci: relLiftCi, histogram: relHistogram },
+    variantLifts: computeVariantLifts(samples, tail)
   };
 }
 
@@ -34719,9 +34853,29 @@ function trackToolUsage(toolName) {
 }
 var server = new McpServer({
   name: "ABTestResult",
-  version: "1.0.0",
+  version: "1.3.0",
   description: "Statistical tools for A/B testing \u2014 significance testing, sample size calculation, Bayesian analysis, and more. Powered by abtestresult.com"
 });
+var SITE_URL = (process.env.ABTESTRESULT_BASE_URL || "https://abtestresult.com").replace(/\/+$/, "");
+function toBase64Url(str) {
+  return Buffer.from(str, "utf-8").toString("base64url");
+}
+function buildDeeplink(path, compact) {
+  const clean = {};
+  for (const [k, v] of Object.entries(compact)) {
+    if (v !== void 0 && v !== null && v !== "") clean[k] = v;
+  }
+  return `${SITE_URL}${path}?d=${toBase64Url(JSON.stringify(clean))}`;
+}
+function pipeJoin(parts) {
+  const arr = parts.map((p) => p === void 0 || p === null ? "" : String(p));
+  while (arr.length > 0 && arr[arr.length - 1] === "") arr.pop();
+  return arr.join("|");
+}
+function tailCode(testType, niMargin) {
+  if (niMargin > 0) return "n";
+  return testType === "one-sided" ? "1" : "2";
+}
 server.tool(
   "analyze_ab_test",
   `Analyze an A/B test with rate/proportion metrics (e.g. conversion rate, click-through rate).
@@ -34735,13 +34889,15 @@ Example: "Control had 5000 visitors with 250 conversions, variant had 5000 visit
     variant_conversions: external_exports3.number().int().min(0).describe("Number of conversions in the variant group"),
     confidence_level: external_exports3.number().min(0.5).max(0.999).default(0.95).describe("Confidence level (e.g. 0.95 for 95%). Default: 0.95"),
     test_type: external_exports3.enum(["two-sided", "one-sided"]).default("two-sided").describe("Two-sided tests for any difference, one-sided for improvement only. Default: two-sided"),
-    non_inferiority_margin: external_exports3.number().min(0).default(0).describe("Non-inferiority margin as percentage (e.g. 5 for 5%). Default: 0 (superiority test)")
+    non_inferiority_margin: external_exports3.number().min(0).default(0).describe("Non-inferiority margin as a RELATIVE percentage of the control rate (e.g. 2 means the variant may be up to 2% of the control rate worse: at an 80% control rate that is 1.6 percentage points, not 2 points). When > 0, a one-sided non-inferiority test is run and test_type is ignored. Default: 0 (superiority test)"),
+    expected_control_share: external_exports3.number().gt(0).lt(1).optional().describe("Optional planned share of users in control, as a decimal, for intentionally unequal splits (e.g. 0.05 for a 5% holdout). When set, the response includes a sample ratio mismatch check against this planned split. Analyse the real user counts; never rescale a group to equal size.")
   },
   async (params) => {
     const rl = checkRateLimit();
     if (rl) return { content: rl, isError: true };
     trackToolUsage("analyze_ab_test");
-    const sided = params.test_type === "one-sided" ? 1 : 2;
+    const isNonInferiority = params.non_inferiority_margin > 0;
+    const sided = isNonInferiority || params.test_type === "one-sided" ? 1 : 2;
     const result = zTestForProportions(
       params.control_users,
       params.control_conversions,
@@ -34751,14 +34907,29 @@ Example: "Control had 5000 visitors with 250 conversions, variant had 5000 visit
       sided,
       params.non_inferiority_margin
     );
-    const summary = result.isSignificant ? `\u2705 SIGNIFICANT \u2014 The variant ${result.delta > 0 ? "outperforms" : "underperforms"} the control.` : `\u23F3 NOT SIGNIFICANT \u2014 No statistically significant difference detected.`;
+    const marginAbsolute = params.non_inferiority_margin / 100 * result.controlRate;
+    const marginText = `${params.non_inferiority_margin}% of the control rate (${round(marginAbsolute * 100, 4)} percentage points; variant must stay above ${toPercent(result.controlRate - marginAbsolute)})`;
+    const summary = isNonInferiority ? nonInferioritySummary(result.isSignificant, marginText) : superioritySummary(result.isSignificant, result.delta);
+    const ctrlRate = (params.control_conversions / params.control_users * 100).toFixed(2);
+    const varRate = (params.variant_conversions / params.variant_users * 100).toFixed(2);
+    const viewUrl = buildDeeplink("/statistical-significance-calculator", {
+      c: pipeJoin([params.control_users, params.control_conversions, ctrlRate]),
+      v: pipeJoin([params.variant_users, params.variant_conversions, varRate]),
+      m: "r",
+      t: tailCode(params.test_type, params.non_inferiority_margin),
+      l: String(Math.round(params.confidence_level * 100)),
+      n: params.non_inferiority_margin > 0 ? String(params.non_inferiority_margin) : "",
+      r: params.expected_control_share !== void 0 ? String(round(params.expected_control_share * 100, 4)) : ""
+    });
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
           summary,
+          view_url: viewUrl,
           significant: result.isSignificant,
-          p_value: round(result.pValue, 6),
+          p_value: roundPValue(result.pValue),
+          p_value_display: formatPValue(result.pValue),
           z_score: round(result.zScore, 4),
           control_rate: toPercent(result.controlRate),
           variant_rate: toPercent(result.variantRate),
@@ -34777,7 +34948,15 @@ Example: "Control had 5000 visitors with 250 conversions, variant had 5000 visit
             upper: toPercent(result.ciVariation[1])
           },
           confidence_level: toPercent(params.confidence_level),
-          test_type: params.test_type
+          test_type: isNonInferiority ? "non-inferiority (one-sided)" : params.test_type,
+          ...isNonInferiority && {
+            non_inferiority_margin: {
+              relative_to_control: `${params.non_inferiority_margin}%`,
+              absolute_percentage_points: round(marginAbsolute * 100, 4),
+              threshold_rate: toPercent(result.controlRate - marginAbsolute)
+            }
+          },
+          ...plannedSplitSRM(params.control_users, params.variant_users, params.expected_control_share)
         }, null, 2)
       }]
     };
@@ -34786,25 +34965,27 @@ Example: "Control had 5000 visitors with 250 conversions, variant had 5000 visit
 server.tool(
   "analyze_ab_test_average",
   `Analyze an A/B test with continuous/average metrics (e.g. revenue per user, time on page, order value).
-Uses a pooled T-test. Returns significance, p-value, confidence intervals, and lift.
+Uses Welch's T-test (unequal variances), which stays accurate when groups differ in size or spread (e.g. 95/5 holdouts). Returns significance, p-value, confidence intervals, and lift.
 
 Example: "Control had 1000 users with mean $45.20 (std $12.50), variant had 1000 users with mean $48.80 (std $13.10)"`,
   {
-    control_users: external_exports3.number().int().positive().describe("Number of users in the control group"),
+    control_users: external_exports3.number().int().min(2).describe("Number of users in the control group (at least 2)"),
     control_mean: external_exports3.number().describe("Mean value for the control group"),
     control_std_dev: external_exports3.number().positive().describe("Standard deviation for the control group"),
-    variant_users: external_exports3.number().int().positive().describe("Number of users in the variant group"),
+    variant_users: external_exports3.number().int().min(2).describe("Number of users in the variant group (at least 2)"),
     variant_mean: external_exports3.number().describe("Mean value for the variant group"),
     variant_std_dev: external_exports3.number().positive().describe("Standard deviation for the variant group"),
     confidence_level: external_exports3.number().min(0.5).max(0.999).default(0.95).describe("Confidence level (e.g. 0.95 for 95%). Default: 0.95"),
     test_type: external_exports3.enum(["two-sided", "one-sided"]).default("two-sided").describe("Two-sided or one-sided test. Default: two-sided"),
-    non_inferiority_margin: external_exports3.number().min(0).default(0).describe("Non-inferiority margin as percentage. Default: 0")
+    non_inferiority_margin: external_exports3.number().min(0).default(0).describe("Non-inferiority margin as a RELATIVE percentage of the control mean (e.g. 2 means the variant mean may be up to 2% of the control mean lower). When > 0, a one-sided non-inferiority test is run and test_type is ignored. Default: 0 (superiority test)"),
+    expected_control_share: external_exports3.number().gt(0).lt(1).optional().describe("Optional planned share of users in control, as a decimal, for intentionally unequal splits (e.g. 0.05 for a 5% holdout). When set, the response includes a sample ratio mismatch check against this planned split. Analyse the real user counts; never rescale a group to equal size.")
   },
   async (params) => {
     const rl = checkRateLimit();
     if (rl) return { content: rl, isError: true };
     trackToolUsage("analyze_ab_test_average");
-    const sided = params.test_type === "one-sided" ? 1 : 2;
+    const isNonInferiority = params.non_inferiority_margin > 0;
+    const sided = isNonInferiority || params.test_type === "one-sided" ? 1 : 2;
     const result = tTestForAverages(
       params.control_users,
       params.control_mean,
@@ -34816,16 +34997,29 @@ Example: "Control had 1000 users with mean $45.20 (std $12.50), variant had 1000
       sided,
       params.non_inferiority_margin
     );
-    const summary = result.isSignificant ? `\u2705 SIGNIFICANT \u2014 The variant ${result.delta > 0 ? "outperforms" : "underperforms"} the control.` : `\u23F3 NOT SIGNIFICANT \u2014 No statistically significant difference detected.`;
+    const marginAbsolute = params.non_inferiority_margin / 100 * result.controlMean;
+    const marginText = `${params.non_inferiority_margin}% of the control mean (${round(marginAbsolute, 4)} in metric units; variant mean must stay above ${round(result.controlMean - marginAbsolute, 4)})`;
+    const summary = isNonInferiority ? nonInferioritySummary(result.isSignificant, marginText) : superioritySummary(result.isSignificant, result.delta);
+    const viewUrl = buildDeeplink("/statistical-significance-calculator", {
+      c: pipeJoin([params.control_users, params.control_mean, "", params.control_std_dev]),
+      v: pipeJoin([params.variant_users, params.variant_mean, "", params.variant_std_dev]),
+      m: "a",
+      t: tailCode(params.test_type, params.non_inferiority_margin),
+      l: String(Math.round(params.confidence_level * 100)),
+      n: params.non_inferiority_margin > 0 ? String(params.non_inferiority_margin) : "",
+      r: params.expected_control_share !== void 0 ? String(round(params.expected_control_share * 100, 4)) : ""
+    });
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
           summary,
+          view_url: viewUrl,
           significant: result.isSignificant,
-          p_value: round(result.pValue, 6),
+          p_value: roundPValue(result.pValue),
+          p_value_display: formatPValue(result.pValue),
           t_score: round(result.tScore, 4),
-          degrees_of_freedom: result.df,
+          degrees_of_freedom: round(result.df, 2),
           control_mean: round(result.controlMean, 4),
           variant_mean: round(result.variantMean, 4),
           absolute_lift: round(result.delta, 4),
@@ -34843,7 +35037,15 @@ Example: "Control had 1000 users with mean $45.20 (std $12.50), variant had 1000
             upper: round(result.variationCi[1], 4)
           },
           confidence_level: toPercent(params.confidence_level),
-          test_type: params.test_type
+          test_type: isNonInferiority ? "non-inferiority (one-sided)" : params.test_type,
+          ...isNonInferiority && {
+            non_inferiority_margin: {
+              relative_to_control: `${params.non_inferiority_margin}%`,
+              absolute: round(marginAbsolute, 4),
+              threshold_mean: round(result.controlMean - marginAbsolute, 4)
+            }
+          },
+          ...plannedSplitSRM(params.control_users, params.variant_users, params.expected_control_share)
         }, null, 2)
       }]
     };
@@ -34865,7 +35067,8 @@ Example: "How many users do I need to detect a 10% relative lift on a 5% baselin
     power: external_exports3.number().min(0.5).max(0.999).default(0.8).describe("Statistical power. Default: 0.80"),
     test_type: external_exports3.enum(["two-sided", "one-sided"]).default("two-sided").describe("Test sidedness. Default: two-sided"),
     num_variants: external_exports3.number().int().min(1).default(1).describe("Number of variant groups (not counting control). Default: 1"),
-    daily_traffic: external_exports3.number().int().positive().optional().describe("Daily traffic to estimate test duration in days")
+    daily_traffic: external_exports3.number().int().positive().optional().describe("Daily traffic to estimate test duration in days"),
+    control_share: external_exports3.number().gt(0).lt(1).optional().describe("Planned share of traffic in control, as a decimal, for unequal splits (e.g. 0.05 for a 5% holdout, 0.95 for a 5% canary variant). Omit for an equal split.")
   },
   async (params) => {
     const rl = checkRateLimit();
@@ -34910,14 +35113,35 @@ Example: "How many users do I need to detect a 10% relative lift on a 5% baselin
         params.daily_traffic ?? null
       );
     }
+    const viewUrl = buildDeeplink("/sample-size-calculator", {
+      m: params.metric_type === "rate" ? "r" : "a",
+      t: params.test_type === "one-sided" ? "1" : "2",
+      b: String(params.baseline),
+      d: String(params.mde),
+      s: params.metric_type === "average" && params.std_dev ? String(params.std_dev) : "",
+      c: String(Math.round(params.confidence_level * 100)),
+      p: String(Math.round(params.power * 100)),
+      v: params.num_variants !== 1 ? String(params.num_variants) : "",
+      r: params.control_share !== void 0 ? String(round(params.control_share * 100, 4)) : ""
+    });
+    const equalShare = 1 / (params.num_variants + 1);
+    const allocation = params.control_share !== void 0 && Math.abs(params.control_share - equalShare) > 1e-9 ? allocateSampleSize(result.samplesEach, params.num_variants, params.control_share) : null;
+    const totalSamples = allocation ? allocation.total : result.samplesTotal;
+    const estimatedDays = params.daily_traffic ? Math.ceil(totalSamples / params.daily_traffic) : null;
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
-          samples_per_group: result.samplesEach,
-          total_samples: result.samplesTotal,
+          view_url: viewUrl,
+          ...allocation ? {
+            control_samples: allocation.control,
+            samples_per_variant: allocation.perVariant,
+            equal_split_samples_per_group: result.samplesEach,
+            traffic_multiplier_vs_equal_split: round(allocation.multiplier, 3)
+          } : { samples_per_group: result.samplesEach },
+          total_samples: totalSamples,
           number_of_groups: params.num_variants + 1,
-          estimated_days: result.days,
+          estimated_days: estimatedDays,
           effect_size: round(result.effectSize, 4),
           absolute_mde: round(result.mdeAbsolute, 6),
           settings: {
@@ -34946,7 +35170,8 @@ Example: "I have 50,000 total users and a 5% conversion rate. What's my MDE?"`,
     std_dev: external_exports3.number().positive().optional().describe("Standard deviation. Required for average metrics. For rate metrics, auto-calculated from baseline if omitted."),
     confidence_level: external_exports3.number().min(0.5).max(0.999).default(0.95).describe("Confidence level. Default: 0.95"),
     power: external_exports3.number().min(0.5).max(0.999).default(0.8).describe("Statistical power. Default: 0.80"),
-    num_variants: external_exports3.number().int().min(1).default(1).describe("Number of variant groups. Default: 1")
+    num_variants: external_exports3.number().int().min(1).default(1).describe("Number of variant groups. Default: 1"),
+    control_share: external_exports3.number().gt(0).lt(1).optional().describe("Share of total traffic in control, as a decimal, for unequal splits (e.g. 0.05 for a 5% holdout). Omit for an equal split.")
   },
   async (params) => {
     const rl = checkRateLimit();
@@ -34968,25 +35193,59 @@ Example: "I have 50,000 total users and a 5% conversion rate. What's my MDE?"`,
       }
       stdDev = params.std_dev;
     }
-    const mdeAbsolute = estimateMDE(
+    const mdeAbsolute = params.metric_type === "rate" ? estimateMDERate({
+      traffic: params.total_traffic,
+      baselineRate: params.baseline / 100,
+      power: params.power,
+      confidenceLevel: params.confidence_level,
+      numVariants: params.num_variants,
+      controlShare: params.control_share
+    }) : estimateMDE(
       params.total_traffic,
       stdDev,
       params.power,
       params.confidence_level,
-      params.num_variants
+      params.num_variants,
+      1,
+      0,
+      params.control_share
     );
+    if (!Number.isFinite(mdeAbsolute)) {
+      return {
+        content: [{
+          type: "text",
+          text: params.metric_type === "rate" && !(params.baseline > 0 && params.baseline < 100) ? "Error: baseline must be between 0 and 100 (percent) for rate metrics." : "No detectable effect: with this traffic, even a lift to a 100% conversion rate would not reach the target power. Increase traffic or lower the power or confidence level."
+        }],
+        isError: true
+      };
+    }
+    const controlShare = params.control_share ?? 1 / (params.num_variants + 1);
     const baselineValue = params.metric_type === "rate" ? params.baseline / 100 : params.baseline;
     const mdeRelative = baselineValue !== 0 ? mdeAbsolute / baselineValue : 0;
+    const viewUrl = buildDeeplink("/mde-calculator", {
+      t: String(params.total_traffic),
+      s: params.std_dev ? String(params.std_dev) : "",
+      r: String(params.baseline),
+      p: String(params.power),
+      c: String(params.confidence_level),
+      m: params.metric_type === "average" ? "c" : "r",
+      k: params.control_share !== void 0 ? String(round(params.control_share * 100, 4)) : "",
+      v: params.num_variants !== 1 ? String(params.num_variants) : ""
+    });
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
+          view_url: viewUrl,
           mde_absolute: round(mdeAbsolute, 6),
           mde_relative_percent: toPercent(mdeRelative),
           interpretation: params.metric_type === "rate" ? `You can detect an absolute change of ${toPercent(mdeAbsolute)} (${toPercent(mdeRelative)} relative lift) from the ${params.baseline}% baseline.` : `You can detect an absolute change of ${round(mdeAbsolute, 4)} (${toPercent(mdeRelative)} relative lift) from the ${params.baseline} baseline.`,
           settings: {
             total_traffic: params.total_traffic,
-            traffic_per_group: Math.floor(params.total_traffic / (params.num_variants + 1)),
+            ...params.control_share === void 0 ? { traffic_per_group: Math.floor(params.total_traffic / (params.num_variants + 1)) } : {
+              control_traffic: Math.round(params.total_traffic * controlShare),
+              traffic_per_variant: Math.round(params.total_traffic * (1 - controlShare) / params.num_variants)
+            },
             baseline: params.baseline,
             confidence_level: toPercent(params.confidence_level),
             power: toPercent(params.power)
@@ -34998,10 +35257,17 @@ Example: "I have 50,000 total users and a 5% conversion rate. What's my MDE?"`,
 );
 server.tool(
   "bayesian_ab_test",
-  `Run Bayesian A/B test analysis. Returns probability to be best, expected loss, and credible intervals.
+  `Run Bayesian A/B test analysis. Returns probability to be best, expected loss, credible intervals,
+and the lift of every variant vs the control (first variant).
 Supports both rate metrics (Beta-Binomial model) and average metrics (Normal model).
 Supports multiple variants.
 
+Units: for rate metrics, raw values (posterior_mean, credible_interval, expected_loss, absolute lift) are
+proportions (0.05 = 5%), so a difference of 0.0006 is 0.06 percentage points. For average metrics they are
+in the metric's own units. Each variant also includes expected_loss_display in plain terms.
+Expected loss = the average amount you give up by shipping that variant if it is not actually the best.
+A common stopping rule: ship when the leader's expected loss is below the smallest difference you care about.
+
 Example: "Control: 5000 visitors, 250 conversions. Variant: 5000 visitors, 300 conversions."`,
   {
     metric_type: external_exports3.enum(["rate", "average"]).describe('Metric type: "rate" for proportions, "average" for continuous'),
@@ -35029,18 +35295,32 @@ Example: "Control: 5000 visitors, 250 conversions. Variant: 5000 visitors, 300 c
       });
       result = bayesianMonteCarlo(posteriors, params.simulations, params.credibility);
     } else {
-      const posteriors = params.variants.map((v) => {
-        if (v.mean === void 0 || v.std_dev === void 0) {
-          throw new Error(`Mean and std_dev are required for average metrics (variant: ${v.name})`);
-        }
-        return normalPosterior(v.mean, v.std_dev, v.users);
-      });
+      const missing = params.variants.find((v) => v.mean === void 0 || v.std_dev === void 0);
+      if (missing) {
+        return {
+          content: [{
+            type: "text",
+            text: `Error: mean and std_dev are required for average metrics (variant: ${missing.name}).`
+          }],
+          isError: true
+        };
+      }
+      const posteriors = params.variants.map((v) => normalPosterior(v.mean, v.std_dev, v.users));
       result = bayesianMonteCarloNormal(posteriors, params.simulations, params.credibility);
     }
+    const isRate = params.metric_type === "rate";
+    const controlMean = result.posteriorMeans[0];
+    const lossDisplay = (loss) => {
+      const relPct = controlMean !== 0 ? loss / Math.abs(controlMean) * 100 : null;
+      const relText = relPct === null ? "" : relPct > 0 && relPct < 0.01 ? "< 0.01%" : `\u2248 ${round(relPct, 2)}%`;
+      const relative = relPct === null ? "" : ` (${relText} of the control ${isRate ? "rate" : "mean"})`;
+      return isRate ? `\u2248 ${round(loss * 100, 3)} percentage points${relative}` : `\u2248 ${round(loss, 4)}${relative}`;
+    };
     const variantResults = params.variants.map((v, i) => ({
       name: v.name,
       probability_to_be_best: toPercent(result.probabilityToBeBest[i]),
       expected_loss: round(result.expectedLoss[i], 6),
+      expected_loss_display: lossDisplay(result.expectedLoss[i]),
       credible_interval: {
         lower: round(result.credibleIntervals[i].lower, 6),
         upper: round(result.credibleIntervals[i].upper, 6)
@@ -35048,27 +35328,43 @@ Example: "Control: 5000 visitors, 250 conversions. Variant: 5000 visitors, 300 c
       posterior_mean: round(result.posteriorMeans[i], 6)
     }));
     const bestIdx = result.probabilityToBeBest.indexOf(Math.max(...result.probabilityToBeBest));
-    const summary = result.probabilityToBeBest[bestIdx] > 0.95 ? `\u{1F3C6} ${params.variants[bestIdx].name} is the winner with ${toPercent(result.probabilityToBeBest[bestIdx])} probability of being best.` : result.probabilityToBeBest[bestIdx] > 0.8 ? `\u{1F4CA} ${params.variants[bestIdx].name} is leading with ${toPercent(result.probabilityToBeBest[bestIdx])} probability, but more data may be needed.` : `\u23F3 No clear winner yet. The leading variant has only ${toPercent(result.probabilityToBeBest[bestIdx])} probability of being best.`;
+    const summary = result.probabilityToBeBest[bestIdx] > 0.95 ? `\u{1F3C6} ${params.variants[bestIdx].name} is the winner with ${toPercent(result.probabilityToBeBest[bestIdx])} probability of being best.` : result.probabilityToBeBest[bestIdx] > 0.8 ? `\u{1F4CA} ${params.variants[bestIdx].name} is leading with ${toPercent(result.probabilityToBeBest[bestIdx])} probability, but more data may be needed.` : `\u23F3 No clear winner yet. The leading variant (${params.variants[bestIdx].name}) has only ${toPercent(result.probabilityToBeBest[bestIdx])} probability of being best.`;
+    const summaryWithLoss = `${summary} Expected loss if you ship ${params.variants[bestIdx].name}: ${lossDisplay(result.expectedLoss[bestIdx])}.`;
+    const liftVsControl = result.variantLifts.map((l) => ({
+      variant: params.variants[l.variantIndex].name,
+      vs: params.variants[0].name,
+      absolute_lift: isRate ? {
+        mean: toPercentagePoints(l.mean),
+        credible_interval: { lower: toPercentagePoints(l.ci[0]), upper: toPercentagePoints(l.ci[1]) }
+      } : {
+        mean: round(l.mean, 6),
+        credible_interval: { lower: round(l.ci[0], 6), upper: round(l.ci[1], 6) }
+      },
+      relative_lift: {
+        mean: toPercent(l.relativeMean),
+        credible_interval: { lower: toPercent(l.relativeCi[0]), upper: toPercent(l.relativeCi[1]) }
+      }
+    }));
+    const bayesPart = (v, withName) => {
+      const rate = isRate && v.conversions !== void 0 && v.users ? (v.conversions / v.users * 100).toFixed(2) : "";
+      return pipeJoin(isRate ? [v.users, v.conversions, rate, "", withName ? v.name : ""] : [v.users, v.mean, "", v.std_dev, withName ? v.name : ""]);
+    };
+    const viewUrl = buildDeeplink("/bayesian-calculator", {
+      c: bayesPart(params.variants[0], false),
+      v: params.variants.slice(1).map((v) => bayesPart(v, true)).join(";"),
+      m: isRate ? "r" : "a",
+      // alpha=beta=1 is the uninformative prior; anything else maps to "weak".
+      p: params.prior_alpha === 1 && params.prior_beta === 1 ? "u" : "w",
+      l: String(Math.round(params.credibility * 100))
+    });
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
-          summary,
+          summary: summaryWithLoss,
+          view_url: viewUrl,
           variants: variantResults,
-          lift_distribution: {
-            mean: round(result.liftDistribution.mean, 6),
-            credible_interval: {
-              lower: round(result.liftDistribution.ci[0], 6),
-              upper: round(result.liftDistribution.ci[1], 6)
-            }
-          },
-          relative_lift_distribution: {
-            mean: toPercent(result.relativeLiftDistribution.mean),
-            credible_interval: {
-              lower: toPercent(result.relativeLiftDistribution.ci[0]),
-              upper: toPercent(result.relativeLiftDistribution.ci[1])
-            }
-          },
+          lift_vs_control: liftVsControl,
           simulations: params.simulations,
           credibility: toPercent(params.credibility)
         }, null, 2)
@@ -35079,34 +35375,48 @@ Example: "Control: 5000 visitors, 250 conversions. Variant: 5000 visitors, 300 c
 server.tool(
   "check_srm",
   `Check for Sample Ratio Mismatch (SRM) in an A/B test.
-SRM occurs when the traffic split between control and variant doesn't match the expected ratio (usually 50/50).
+SRM occurs when the traffic split between control and variant doesn't match the planned ratio (50/50 unless you say otherwise).
 SRM is a sign of a bug in the experiment setup and invalidates results.
+For intentionally unequal splits (holdouts, canary tests) pass the planned control share, e.g. 0.05 for a 5% holdout.
 
 Example: "Control has 10,234 users, variant has 9,766 users"`,
   {
     control_users: external_exports3.number().int().positive().describe("Number of users in the control group"),
-    variant_users: external_exports3.number().int().positive().describe("Number of users in the variant group")
+    variant_users: external_exports3.number().int().positive().describe("Number of users in the variant group"),
+    expected_control_share: external_exports3.number().gt(0).lt(1).default(0.5).describe("Planned share of users in control, as a decimal. 0.5 for 50/50, 0.1 for a 10% holdout, 0.95 for a 5% canary variant. Default: 0.5")
   },
   async (params) => {
     const rl = checkRateLimit();
     if (rl) return { content: rl, isError: true };
     trackToolUsage("check_srm");
-    const result = checkSRM(params.control_users, params.variant_users);
+    const result = checkSRM(params.control_users, params.variant_users, params.expected_control_share);
     const total = params.control_users + params.variant_users;
     const actualRatio = params.control_users / total;
-    const summary = result.hasMismatch ? `\u{1F6A8} SRM DETECTED (p=${round(result.pValue, 6)}) \u2014 The traffic split is ${toPercent(actualRatio)}/${toPercent(1 - actualRatio)} instead of the expected 50/50. Your experiment may have a bug. DO NOT trust the results.` : `\u2705 No SRM detected (p=${round(result.pValue, 4)}) \u2014 The traffic split of ${toPercent(actualRatio)}/${toPercent(1 - actualRatio)} is consistent with a 50/50 split.`;
+    const expectedSplit = `${toPercent(params.expected_control_share)}/${toPercent(1 - params.expected_control_share)}`;
+    const summary = result.hasMismatch ? `\u{1F6A8} SRM DETECTED (${formatPValueEq(result.pValue)}) \u2014 The traffic split is ${toPercent(actualRatio)}/${toPercent(1 - actualRatio)} instead of the expected ${expectedSplit}. Your experiment may have a bug. DO NOT trust the results.` : `\u2705 No SRM detected (${formatPValueEq(result.pValue)}) \u2014 The traffic split of ${toPercent(actualRatio)}/${toPercent(1 - actualRatio)} is consistent with the expected ${expectedSplit} split.`;
+    const viewUrl = buildDeeplink("/sample-ratio-mismatch", {
+      c: String(params.control_users),
+      v: String(params.variant_users),
+      e: params.expected_control_share !== 0.5 ? String(round(params.expected_control_share * 100, 4)) : ""
+    });
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
           summary,
+          view_url: viewUrl,
           has_mismatch: result.hasMismatch,
-          p_value: round(result.pValue, 6),
+          p_value: roundPValue(result.pValue),
+          p_value_display: formatPValue(result.pValue),
           chi_square: round(result.chiSquare, 4),
           actual_split: {
             control: toPercent(actualRatio),
             variant: toPercent(1 - actualRatio)
           },
+          expected_split: {
+            control: toPercent(params.expected_control_share),
+            variant: toPercent(1 - params.expected_control_share)
+          },
           total_users: total
         }, null, 2)
       }]
@@ -35143,7 +35453,7 @@ Example: "Before: [10, 12, 8, 15, 11], After: [12, 14, 9, 18, 13]"`,
       params.sample_after,
       params.confidence_level
     );
-    const summary = result.isSignificant ? `\u2705 SIGNIFICANT (${result.testUsed}) \u2014 There is a statistically significant difference (p=${round(result.pValue, 6)}).` : `\u23F3 NOT SIGNIFICANT (${result.testUsed}) \u2014 No statistically significant difference detected (p=${round(result.pValue, 6)}).`;
+    const summary = result.isSignificant ? `\u2705 SIGNIFICANT (${result.testUsed}) \u2014 There is a statistically significant difference (${formatPValueEq(result.pValue)}).` : `\u23F3 NOT SIGNIFICANT (${result.testUsed}) \u2014 No statistically significant difference detected (${formatPValueEq(result.pValue)}).`;
     return {
       content: [{
         type: "text",
@@ -35152,7 +35462,8 @@ Example: "Before: [10, 12, 8, 15, 11], After: [12, 14, 9, 18, 13]"`,
           test_used: result.testUsed,
           test_statistic_name: result.testStatisticName,
           test_statistic: round(result.testStatistic, 4),
-          p_value: round(result.pValue, 6),
+          p_value: roundPValue(result.pValue),
+          p_value_display: formatPValue(result.pValue),
           significant: result.isSignificant,
           mean_before: round(result.mean1, 4),
           mean_after: round(result.mean2, 4),
@@ -35174,13 +35485,15 @@ Example: "Before: [10, 12, 8, 15, 11], After: [12, 14, 9, 18, 13]"`,
 );
 server.tool(
   "survey_sample_size",
-  `Calculate the required sample size for a survey using Cochran's formula with finite population correction.
+  `Calculate the required number of completed survey responses using Cochran's formula with finite population correction.
+Optionally pass expected_response_rate to get how many people to invite.
 
 Example: "How many responses do I need from a population of 10,000 with 5% margin of error at 95% confidence?"`,
   {
     population: external_exports3.number().int().positive().describe("Total population size"),
     margin_of_error: external_exports3.number().positive().max(50).describe("Desired margin of error as percentage (e.g. 5 for \xB15%)"),
-    confidence_level: external_exports3.number().min(0.5).max(0.999).default(0.95).describe("Confidence level. Default: 0.95")
+    confidence_level: external_exports3.number().min(0.5).max(0.999).default(0.95).describe("Confidence level. Default: 0.95"),
+    expected_response_rate: external_exports3.number().positive().max(100).optional().describe("Optional: expected survey response rate as percentage (e.g. 20 for 20%). When given, returns how many people to invite to get the required completed responses.")
   },
   async (params) => {
     const rl = checkRateLimit();
@@ -35191,15 +35504,26 @@ Example: "How many responses do I need from a population of 10,000 with 5% margi
       params.margin_of_error / 100,
       params.confidence_level
     );
+    const viewUrl = buildDeeplink("/sample-size-calculator", {
+      m: "r",
+      t: "s",
+      // survey mode
+      e: String(params.margin_of_error),
+      c: String(Math.round(params.confidence_level * 100)),
+      z: String(params.population)
+    });
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
+          view_url: viewUrl,
           required_sample_size: sampleSize,
           population: params.population,
           margin_of_error: `\xB1${params.margin_of_error}%`,
           confidence_level: toPercent(params.confidence_level),
-          response_rate_needed: toPercent(sampleSize / params.population)
+          // Share of the population that must complete the survey — not a response rate.
+          share_of_population_needed: toPercent(sampleSize / params.population),
+          ...invitationEstimate(sampleSize, params.population, params.expected_response_rate)
         }, null, 2)
       }]
     };
@@ -35210,6 +35534,53 @@ function round(value, decimals) {
   const factor = Math.pow(10, decimals);
   return Math.round(value * factor) / factor;
 }
+function superioritySummary(isSignificant, delta) {
+  return isSignificant ? `\u2705 SIGNIFICANT \u2014 The variant ${delta > 0 ? "outperforms" : "underperforms"} the control.` : `\u23F3 NOT SIGNIFICANT \u2014 No statistically significant difference detected.`;
+}
+function nonInferioritySummary(isSignificant, marginText) {
+  return isSignificant ? `\u2705 NON-INFERIORITY CONFIRMED \u2014 The variant is not worse than the control by more than ${marginText}.` : `\u23F3 NON-INFERIORITY NOT SHOWN \u2014 We cannot rule out that the variant is worse than the control by more than ${marginText}.`;
+}
+function toPercentagePoints(value) {
+  if (!isFinite(value)) return "0 pp";
+  const pts = round(value * 100, 3);
+  return `${pts > 0 ? "+" : ""}${pts} pp`;
+}
+function invitationEstimate(sampleSize, population, responseRatePercent) {
+  if (responseRatePercent === void 0) return {};
+  const invitations = Math.ceil(sampleSize / (responseRatePercent / 100));
+  const exceedsPopulation = invitations > population;
+  return {
+    expected_response_rate: `${responseRatePercent}%`,
+    invitations_needed: Math.min(invitations, population),
+    ...exceedsPopulation && {
+      warning: `At a ${responseRatePercent}% response rate you would need to invite ${invitations.toLocaleString("en-US")} people, more than the population of ${population.toLocaleString("en-US")}. Even inviting everyone, expect about ${Math.floor(population * responseRatePercent / 100).toLocaleString("en-US")} responses, short of the ${sampleSize.toLocaleString("en-US")} needed. Accept a wider margin of error or improve the response rate.`
+    }
+  };
+}
+function formatPValue(p) {
+  if (!isFinite(p)) return "n/a";
+  return p < 1e-4 ? "< 0.0001" : String(round(p, 4));
+}
+function formatPValueEq(p) {
+  const display = formatPValue(p);
+  return display.startsWith("<") ? `p ${display}` : `p = ${display}`;
+}
+function roundPValue(p) {
+  if (!isFinite(p)) return 0;
+  return p > 0 && p < 1e-6 ? Number(p.toPrecision(3)) : round(p, 6);
+}
+function plannedSplitSRM(controlUsers, variantUsers, expectedControlShare) {
+  if (expectedControlShare === void 0) return {};
+  const srm = checkSRM(controlUsers, variantUsers, expectedControlShare);
+  return {
+    sample_ratio_mismatch: {
+      has_mismatch: srm.hasMismatch,
+      p_value: roundPValue(srm.pValue),
+      expected_split: { control: toPercent(expectedControlShare), variant: toPercent(1 - expectedControlShare) },
+      actual_split: { control: toPercent(controlUsers / (controlUsers + variantUsers)), variant: toPercent(variantUsers / (controlUsers + variantUsers)) }
+    }
+  };
+}
 function toPercent(value) {
   if (!isFinite(value)) return "0%";
   return `${round(value * 100, 2)}%`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abtestresult-mcp",
-  "version": "1.0.8",
+  "version": "1.3.0",
   "description": "MCP server for A/B test statistical analysis — significance testing, sample size calculation, Bayesian analysis, and more",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",