diff --git a/README.md b/README.md
index 2713497..d4ac411 100644
--- a/README.md
+++ b/README.md
@@ -4,13 +4,13 @@
 
 # Maybe Spreadsheet
 
-Maybe is a React-based spreadsheet application with built-in support for uncertainty through Gaussian distributions and sampled distributions.
+Maybe is a React-based spreadsheet application with built-in support for uncertainty through explicit probability distributions and sampled distributions.
 
 ## Features
 
 - Full spreadsheet functionality powered by GaussFormula
 - Support for formulas and calculations
-- Built-in support for Gaussian distributions
+- Built-in support for explicit distributions such as `N(mean, variance)`, `LN(mu, sigma)`, `U(min, max)`, `N.CI(lower, upper, confidence)`, and `LN.CI(lower, upper, confidence)`
 - Interactive visualizations for distributions
 - Statistical analysis tools including:
   - Percentile calculations
@@ -46,12 +46,20 @@ pnpm dev
 
 ### Working with Distributions
 
-The spreadsheet supports Gaussian distributions that can be created and manipulated using the GaussFormula engine. 
+The spreadsheet supports explicit probability distributions that can be created and manipulated using the GaussFormula engine. 
 
 - Use the spreadsheet interface to input data and formulas
 - Visualize distributions with the interactive plotting tool
 - Analyze statistical properties of distributions
 
+### Distribution notation
+
+- `N(mean, variance)` uses normal-distribution parameters directly.
+- `LN(mu, sigma)` uses log-space parameters: if `X ~ LN(mu, sigma)`, then `ln(X) ~ N(mu, sigma^2)`. `mu` and `sigma` are not the mean and standard deviation of `X`.
+- Prefer `LN.CI(lower, upper, confidence)` for user-facing lognormal inputs because the bounds are in the original value scale.
+- `N.CI(lower, upper, confidence)` derives a normal distribution from a value-scale confidence interval.
+- `U(min, max)` represents a uniform range on the original value scale.
+
 ## Technical Details
 
 This project is built with:
diff --git a/package.json b/package.json
index 14ae5c6..3e71fec 100644
--- a/package.json
+++ b/package.json
@@ -21,7 +21,7 @@
     "ai": "^6.0.168",
     "echarts": "^6.0.0",
     "echarts-for-react": "^3.0.6",
-    "gaussformula": "^0.1.6",
+    "gaussformula": "file:../gaussformula/gaussformula-0.1.6.tgz",
     "react": "^19.2.5",
     "react-dom": "^19.2.5",
     "zod": "^4.3.6"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 7acc080..c40a7b9 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -27,8 +27,8 @@ importers:
         specifier: ^3.0.6
         version: 3.0.6(echarts@6.0.0)(react@19.2.5)
       gaussformula:
-        specifier: ^0.1.6
-        version: 0.1.6
+        specifier: file:../gaussformula/gaussformula-0.1.6.tgz
+        version: file:../gaussformula/gaussformula-0.1.6.tgz
       react:
         specifier: ^19.2.5
         version: 19.2.5
@@ -1002,8 +1002,9 @@ packages:
     engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
     os: [darwin]
 
-  gaussformula@0.1.6:
-    resolution: {integrity: sha512-cVx9S4UFr0w9z7NAlm5PkUH+aRMNH35hucVzg/NXkIh20lSVIAunPVbpDNLAr9BquYISfm+IRAw6YBC+adTh+A==}
+  gaussformula@file:../gaussformula/gaussformula-0.1.6.tgz:
+    resolution: {integrity: sha512-Py/KrGcDzMUj+Kn5TzlTJ0gIV8zcF3XwfPbi7f5jG5lUdtRZkkDdJDHnj+yO1Hai7wpQVPRSmLyUFKlMzIscgw==, tarball: file:../gaussformula/gaussformula-0.1.6.tgz}
+    version: 0.1.6
 
   gensync@1.0.0-beta.2:
     resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
@@ -2362,7 +2363,7 @@ snapshots:
   fsevents@2.3.3:
     optional: true
 
-  gaussformula@0.1.6:
+  gaussformula@file:../gaussformula/gaussformula-0.1.6.tgz:
     dependencies:
       chevrotain: 6.5.0
       tiny-emitter: 2.1.0
diff --git a/src/app/analysisState.ts b/src/app/analysisState.ts
index 12a19ad..5d776cc 100644
--- a/src/app/analysisState.ts
+++ b/src/app/analysisState.ts
@@ -1,11 +1,9 @@
 import {
   getSamplesFromDistribution,
-  isConfidenceIntervalValue,
+  isDistributionValue,
   isSampledDistributionValue,
-  parseConfidenceIntervalValue,
-  type ParsedConfidenceInterval,
+  parseDistributionValue,
 } from "../utils/distribution/distributionUtils";
-import type { DistributionViewType } from "../context/SpreadsheetContext";
 
 type DistributionType = "normal" | "lognormal" | "uniform" | "sampled";
 
@@ -18,7 +16,6 @@ interface AnalysisState {
   cellLabel: string;
   samples: number[] | null;
   distributionType: DistributionType;
-  confidenceInterval?: ParsedConfidenceInterval | null;
   message?: string;
 }
 
@@ -30,10 +27,6 @@ interface DeriveAnalysisStateInput {
   analysisMode: boolean;
   formulaEngine: FormulaValueReader | null;
   selectedCell: SelectedCell | null;
-  getDistributionView: (
-    row: number,
-    col: number,
-  ) => DistributionViewType | null;
 }
 
 export const getColumnName = (index: number): string => {
@@ -50,7 +43,6 @@ export const deriveAnalysisState = ({
   analysisMode,
   formulaEngine,
   selectedCell,
-  getDistributionView,
 }: DeriveAnalysisStateInput): AnalysisState | null => {
   if (!analysisMode || !formulaEngine || !selectedCell) {
     return null;
@@ -64,31 +56,26 @@ export const deriveAnalysisState = ({
   });
 
   const hasDistribution =
-    isConfidenceIntervalValue(value) || isSampledDistributionValue(value);
+    isDistributionValue(value) ||
+    isSampledDistributionValue(value);
 
   if (!hasDistribution) {
     return {
       cellLabel,
       samples: null,
       distributionType: "normal",
-      confidenceInterval: null,
       message:
-        "Select a cell containing uncertainty (CI[lower, upper] inputs or simulated outputs) to inspect its distribution.",
+        "Select a cell containing uncertainty (N, LN, U, N.CI, LN.CI, or simulated outputs) to inspect its distribution.",
     };
   }
 
-  const confidenceInterval = parseConfidenceIntervalValue(value);
+  const distribution = parseDistributionValue(value);
   const samples = getSamplesFromDistribution(value);
-  const viewOverride = getDistributionView(selectedCell.row, selectedCell.col);
 
   let distributionType: DistributionType = "normal";
-  if (viewOverride) {
-    distributionType = viewOverride;
-  } else if (confidenceInterval?.interpretation === "lognormal") {
-    distributionType = "lognormal";
-  } else if (confidenceInterval?.interpretation === "uniform") {
-    distributionType = "uniform";
-  } else if (!confidenceInterval && isSampledDistributionValue(value)) {
+  if (distribution) {
+    distributionType = distribution.kind;
+  } else if (isSampledDistributionValue(value)) {
     distributionType = "sampled";
   }
 
@@ -97,9 +84,8 @@ export const deriveAnalysisState = ({
       cellLabel,
       samples: null,
       distributionType,
-      confidenceInterval,
       message:
-        "Unable to generate samples for this cell. Ensure the value exposes samples or a confidence interval.",
+        "Unable to generate samples for this cell. Ensure the value exposes samples or an explicit distribution.",
     };
   }
 
@@ -107,6 +93,5 @@ export const deriveAnalysisState = ({
     cellLabel,
     samples,
     distributionType,
-    confidenceInterval,
   };
 };
diff --git a/src/assistant/formulaValidation.ts b/src/assistant/formulaValidation.ts
index f822494..7d8e19f 100644
--- a/src/assistant/formulaValidation.ts
+++ b/src/assistant/formulaValidation.ts
@@ -3,9 +3,148 @@ import { cellAddressFromA1 } from "./address";
 import { type ValidateFormulaInput } from "./toolSchemas";
 import {
   buildWorkbookSnapshot,
+  type WorkbookCellSnapshot,
+  type WorkbookDistributionSummary,
   type WorkbookSnapshot,
 } from "./workbookSnapshot";
 
+interface DistributionConstructor {
+  normal?: (
+    mean: number,
+    variance: number,
+    options?: Record<string, unknown>,
+  ) => unknown;
+  lognormal?: (
+    mu: number,
+    sigma: number,
+    options?: Record<string, unknown>,
+  ) => unknown;
+  uniform?: (
+    min: number,
+    max: number,
+    options?: Record<string, unknown>,
+  ) => unknown;
+  normalFromCI?: (
+    lower: number,
+    upper: number,
+    confidenceLevel: number,
+    options?: Record<string, unknown>,
+  ) => unknown;
+  lognormalFromCI?: (
+    lower: number,
+    upper: number,
+    confidenceLevel: number,
+    options?: Record<string, unknown>,
+  ) => unknown;
+}
+
+const getDistributionConstructor = (): DistributionConstructor | undefined =>
+  (GaussFormulaEngine as unknown as { DistributionNumber?: DistributionConstructor })
+    .DistributionNumber;
+
+const representativeDistributionValue = (
+  distribution: WorkbookDistributionSummary,
+): number | string => {
+  switch (distribution.kind) {
+    case "normal":
+      return distribution.mean ??
+        (distribution.lower !== undefined && distribution.upper !== undefined
+          ? (distribution.lower + distribution.upper) / 2
+          : "0");
+    case "lognormal":
+      if (distribution.mu !== undefined && distribution.sigma !== undefined) {
+        return Math.exp(distribution.mu + (distribution.sigma ** 2) / 2);
+      }
+      if (distribution.lower !== undefined && distribution.upper !== undefined) {
+        return Math.sqrt(distribution.lower * distribution.upper);
+      }
+      return "0";
+    case "uniform":
+      return distribution.min !== undefined && distribution.max !== undefined
+        ? (distribution.min + distribution.max) / 2
+        : "0";
+  }
+};
+
+const reconstructDistributionValue = (
+  distribution: WorkbookDistributionSummary,
+): unknown => {
+  const ctor = getDistributionConstructor();
+
+  if (ctor) {
+    if (
+      distribution.kind === "normal" &&
+      distribution.source === "ci" &&
+      distribution.lower !== undefined &&
+      distribution.upper !== undefined &&
+      distribution.confidenceLevel !== undefined &&
+      ctor.normalFromCI
+    ) {
+      return ctor.normalFromCI(
+        distribution.lower,
+        distribution.upper,
+        distribution.confidenceLevel,
+      );
+    }
+
+    if (
+      distribution.kind === "lognormal" &&
+      distribution.source === "ci" &&
+      distribution.lower !== undefined &&
+      distribution.upper !== undefined &&
+      distribution.confidenceLevel !== undefined &&
+      ctor.lognormalFromCI
+    ) {
+      return ctor.lognormalFromCI(
+        distribution.lower,
+        distribution.upper,
+        distribution.confidenceLevel,
+      );
+    }
+
+    if (
+      distribution.kind === "normal" &&
+      distribution.mean !== undefined &&
+      distribution.variance !== undefined &&
+      ctor.normal
+    ) {
+      return ctor.normal(distribution.mean, distribution.variance);
+    }
+
+    if (
+      distribution.kind === "lognormal" &&
+      distribution.mu !== undefined &&
+      distribution.sigma !== undefined &&
+      ctor.lognormal
+    ) {
+      return ctor.lognormal(distribution.mu, distribution.sigma);
+    }
+
+    if (
+      distribution.kind === "uniform" &&
+      distribution.min !== undefined &&
+      distribution.max !== undefined &&
+      ctor.uniform
+    ) {
+      return ctor.uniform(distribution.min, distribution.max);
+    }
+  }
+
+  return representativeDistributionValue(distribution);
+};
+
+const reconstructCellValue = (cell: WorkbookCellSnapshot): unknown => {
+  if (cell.formula) {
+    return cell.formula;
+  }
+
+  if (cell.distribution) {
+    return reconstructDistributionValue(cell.distribution);
+  }
+
+  return cell.displayValue;
+};
+
 const createFormulaEngineFromSnapshot = (snapshot: WorkbookSnapshot) => {
   const formulaEngine = GaussFormulaEngine.buildEmpty({
     licenseKey: "gpl-v3",
@@ -18,7 +157,7 @@ const createFormulaEngineFromSnapshot = (snapshot: WorkbookSnapshot) => {
 
   const rows = Math.max(1, snapshot.dimensions.height);
   const cols = Math.max(1, snapshot.dimensions.width);
-  const sheetData: Array<Array<string | null>> = Array.from(
+  const sheetData: unknown[][] = Array.from(
     { length: rows },
     () => Array.from({ length: cols }, () => null),
   );
@@ -28,7 +167,7 @@ const createFormulaEngineFromSnapshot = (snapshot: WorkbookSnapshot) => {
       continue;
     }
 
-    sheetData[cell.row][cell.col] = cell.formula ?? cell.displayValue;
+    sheetData[cell.row][cell.col] = reconstructCellValue(cell);
   }
 
   formulaEngine.setSheetContent(0, sheetData);
diff --git a/src/assistant/messages.ts b/src/assistant/messages.ts
index 84649d6..399cf6f 100644
--- a/src/assistant/messages.ts
+++ b/src/assistant/messages.ts
@@ -38,17 +38,24 @@ const workbookCellKindSchema = z.enum([
   "scalar",
   "text",
   "boolean",
-  "confidence_interval",
+  "distribution",
   "sampled_distribution",
   "error",
   "unknown_object",
 ]);
 
-const workbookConfidenceIntervalSchema = z.object({
-  lower: z.number(),
-  upper: z.number(),
-  confidenceLevel: z.number(),
-  interpretation: z.string(),
+const workbookDistributionSchema = z.object({
+  kind: z.enum(["normal", "lognormal", "uniform"]),
+  source: z.enum(["parameters", "ci"]),
+  mean: z.number().optional(),
+  variance: z.number().optional(),
+  mu: z.number().optional(),
+  sigma: z.number().optional(),
+  min: z.number().optional(),
+  max: z.number().optional(),
+  lower: z.number().optional(),
+  upper: z.number().optional(),
+  confidenceLevel: z.number().optional(),
 });
 
 const workbookSampleSummarySchema = z.object({
@@ -67,7 +74,7 @@ const workbookCellSnapshotSchema = z.object({
   formula: z.string().nullable(),
   displayValue: z.string(),
   kind: workbookCellKindSchema,
-  confidenceInterval: workbookConfidenceIntervalSchema.optional(),
+  distribution: workbookDistributionSchema.optional(),
   sampleSummary: workbookSampleSummarySchema.optional(),
 });
 
diff --git a/src/assistant/workbookSnapshot.ts b/src/assistant/workbookSnapshot.ts
index 802d3de..7c5083d 100644
--- a/src/assistant/workbookSnapshot.ts
+++ b/src/assistant/workbookSnapshot.ts
@@ -1,8 +1,9 @@
 import type { FormulaEngine } from "../lib/formulaEngine";
 import {
+  confidenceLevelToFormulaArgument,
   getSamplesFromDistribution,
   isSampledDistributionValue,
-  parseConfidenceIntervalValue,
+  parseDistributionValue,
   parseSampledDistributionValue,
 } from "../utils/distribution/distributionUtils";
 import { percentileFromSorted } from "../utils/distribution/distributionMath";
@@ -17,16 +18,23 @@ export type WorkbookCellKind =
   | "scalar"
   | "text"
   | "boolean"
-  | "confidence_interval"
+  | "distribution"
   | "sampled_distribution"
   | "error"
   | "unknown_object";
 
-export interface WorkbookConfidenceIntervalSummary {
-  lower: number;
-  upper: number;
-  confidenceLevel: number;
-  interpretation: string;
+export interface WorkbookDistributionSummary {
+  kind: "normal" | "lognormal" | "uniform";
+  source: "parameters" | "ci";
+  mean?: number;
+  variance?: number;
+  mu?: number;
+  sigma?: number;
+  min?: number;
+  max?: number;
+  lower?: number;
+  upper?: number;
+  confidenceLevel?: number;
 }
 
 export interface WorkbookSampleSummary {
@@ -45,7 +53,7 @@ export interface WorkbookCellSnapshot {
   formula: string | null;
   displayValue: string;
   kind: WorkbookCellKind;
-  confidenceInterval?: WorkbookConfidenceIntervalSummary;
+  distribution?: WorkbookDistributionSummary;
   sampleSummary?: WorkbookSampleSummary;
 }
 
@@ -109,15 +117,19 @@ const summarizeSamples = (value: unknown): WorkbookSampleSummary | undefined =>
 
   const sorted = [...samples].sort((a, b) => a - b);
   const mean =
+    parsed?.mean ??
     samples.reduce((sum, sample) => sum + sample, 0) / samples.length;
-  const variance =
-    samples.reduce((sum, sample) => sum + Math.pow(sample - mean, 2), 0) /
-    samples.length;
+  const standardDeviation =
+    parsed?.std ??
+    Math.sqrt(
+      samples.reduce((sum, sample) => sum + Math.pow(sample - mean, 2), 0) /
+        samples.length,
+    );
 
   return {
     sampleCount: samples.length,
     mean: round6(mean),
-    standardDeviation: round6(Math.sqrt(variance)),
+    standardDeviation: round6(standardDeviation),
     p10: round6(percentileFromSorted(sorted, 10)),
     p50: round6(percentileFromSorted(sorted, 50)),
     p90: round6(percentileFromSorted(sorted, 90)),
@@ -126,11 +138,11 @@ const summarizeSamples = (value: unknown): WorkbookSampleSummary | undefined =>
 
 const getCellKind = (
   value: unknown,
-  confidenceInterval: ReturnType<typeof parseConfidenceIntervalValue>,
+  distribution: ReturnType<typeof parseDistributionValue>,
   sampleSummary: WorkbookSampleSummary | undefined,
 ): WorkbookCellKind => {
-  if (confidenceInterval) {
-    return "confidence_interval";
+  if (distribution) {
+    return "distribution";
   }
   if (isSampledDistributionValue(value) || sampleSummary) {
     return "sampled_distribution";
@@ -161,7 +173,7 @@ const getCellKind = (
 
 const serializeCellValue = (
   value: unknown,
-  confidenceInterval: ReturnType<typeof parseConfidenceIntervalValue>,
+  distribution: ReturnType<typeof parseDistributionValue>,
   sampleSummary: WorkbookSampleSummary | undefined,
 ): string => {
   if (value === null || value === undefined) {
@@ -173,8 +185,19 @@ const serializeCellValue = (
   if (typeof value === "number" || typeof value === "boolean") {
     return String(value);
   }
-  if (confidenceInterval) {
-    return `CI[${confidenceInterval.lower}, ${confidenceInterval.upper}]`;
+  if (distribution) {
+    switch (distribution.kind) {
+      case "normal":
+        return distribution.source === "ci"
+          ? `N.CI(${distribution.lower}, ${distribution.upper}, ${confidenceLevelToFormulaArgument(distribution.confidenceLevel ?? 95)})`
+          : `N(${distribution.mean}, ${distribution.variance})`;
+      case "lognormal":
+        return distribution.source === "ci"
+          ? `LN.CI(${distribution.lower}, ${distribution.upper}, ${confidenceLevelToFormulaArgument(distribution.confidenceLevel ?? 95)})`
+          : `LN(${distribution.mu}, ${distribution.sigma})`;
+      case "uniform":
+        return `U(${distribution.min}, ${distribution.max})`;
+    }
   }
   if (sampleSummary) {
     return `samples(mean=${sampleSummary.mean}, p10=${sampleSummary.p10}, p90=${sampleSummary.p90})`;
@@ -219,7 +242,7 @@ export const buildWorkbookSnapshot = ({
         continue;
       }
 
-      const confidenceInterval = parseConfidenceIntervalValue(value);
+      const distribution = parseDistributionValue(value);
       const sampleSummary = summarizeSamples(value);
 
       cells.push({
@@ -227,14 +250,21 @@ export const buildWorkbookSnapshot = ({
         row,
         col,
         formula,
-        displayValue: serializeCellValue(value, confidenceInterval, sampleSummary),
-        kind: getCellKind(value, confidenceInterval, sampleSummary),
-        confidenceInterval: confidenceInterval
+        displayValue: serializeCellValue(value, distribution, sampleSummary),
+        kind: getCellKind(value, distribution, sampleSummary),
+        distribution: distribution
           ? {
-              lower: confidenceInterval.lower,
-              upper: confidenceInterval.upper,
-              confidenceLevel: confidenceInterval.confidenceLevel,
-              interpretation: confidenceInterval.interpretation ?? "normal",
+              kind: distribution.kind,
+              source: distribution.source,
+              mean: distribution.mean,
+              variance: distribution.variance,
+              mu: distribution.mu,
+              sigma: distribution.sigma,
+              min: distribution.min,
+              max: distribution.max,
+              lower: distribution.lower,
+              upper: distribution.upper,
+              confidenceLevel: distribution.confidenceLevel,
             }
           : undefined,
         sampleSummary,
diff --git a/src/components/charts/DistributionPlot.tsx b/src/components/charts/DistributionPlot.tsx
index 7ddd140..af3e705 100644
--- a/src/components/charts/DistributionPlot.tsx
+++ b/src/components/charts/DistributionPlot.tsx
@@ -4,6 +4,7 @@ import ReactEChartsCore, { echarts } from "../../lib/echarts";
 import {
   createDistributionChartData,
   createDistributionChartModelFromData,
+  type DistributionParams,
   type DistributionKind,
   type DistributionQueryState,
 } from "./distributionChartOptions";
@@ -15,6 +16,7 @@ interface DistributionPlotProps {
   position?: { top: number; left: number };
   inline?: boolean;
   distributionType?: DistributionKind;
+  distributionParams?: DistributionParams | null;
   confidenceInterval?: {
     lower: number;
     upper: number;
@@ -101,6 +103,7 @@ export const DistributionPlot: React.FC<DistributionPlotProps> = ({
   position,
   inline = false,
   distributionType,
+  distributionParams,
   confidenceInterval,
 }) => {
   const confidenceLower = confidenceInterval?.lower;
@@ -220,9 +223,10 @@ export const DistributionPlot: React.FC<DistributionPlotProps> = ({
       createDistributionChartData({
         samples,
         distributionKind,
+        distributionParams,
         confidenceInterval: normalizedConfidenceInterval,
       }),
-    [samples, distributionKind, normalizedConfidenceInterval],
+    [samples, distributionKind, distributionParams, normalizedConfidenceInterval],
   );
 
   const chartModel = useMemo(
diff --git a/src/components/charts/distributionChartOptions.ts b/src/components/charts/distributionChartOptions.ts
index ac4e603..95d108f 100644
--- a/src/components/charts/distributionChartOptions.ts
+++ b/src/components/charts/distributionChartOptions.ts
@@ -1,4 +1,3 @@
-import { zScoreForConfidence } from "../../utils/distribution/distributionUtils";
 import { formatNumber } from "../../utils/formatting/formatUtils";
 import {
   createLogNormalData,
@@ -57,6 +56,7 @@ export interface DistributionChartDataInput {
   samples: number[];
   distributionKind: DistributionKind;
   confidenceInterval?: ChartConfidenceInterval;
+  distributionParams?: DistributionParams | null;
 }
 
 export interface DistributionChartData {
@@ -112,11 +112,16 @@ const getDistributionTitle = (distributionKind: DistributionKind): string => {
 export const createDistributionChartData = (
   input: DistributionChartDataInput,
 ): DistributionChartData => {
-  const { samples, distributionKind, confidenceInterval } = input;
+  const {
+    samples,
+    distributionKind,
+    confidenceInterval,
+    distributionParams: providedDistributionParams,
+  } = input;
 
   const sortedSamples = [...samples].sort((a, b) => a - b);
 
-  const distributionParams = (() => {
+  const distributionParams = providedDistributionParams ?? (() => {
     switch (distributionKind) {
       case "uniform": {
         if (confidenceInterval) {
@@ -131,33 +136,10 @@ export const createDistributionChartData = (
         return params ? { type: "uniform" as const, ...params } : null;
       }
       case "lognormal": {
-        if (
-          confidenceInterval &&
-          confidenceInterval.lower > 0 &&
-          confidenceInterval.upper > 0
-        ) {
-          const z = zScoreForConfidence(confidenceInterval.confidenceLevel);
-          const lnLower = Math.log(confidenceInterval.lower);
-          const lnUpper = Math.log(confidenceInterval.upper);
-          const mu = (lnLower + lnUpper) / 2;
-          const sigma = (lnUpper - lnLower) / (2 * z);
-          if (Number.isFinite(mu) && Number.isFinite(sigma) && sigma > 0) {
-            return { type: "lognormal" as const, mu, sigma };
-          }
-        }
-
         const params = toLogNormalParams(samples);
         return params ? { type: "lognormal" as const, ...params } : null;
       }
       case "normal": {
-        if (confidenceInterval) {
-          const z = zScoreForConfidence(confidenceInterval.confidenceLevel);
-          const mean = (confidenceInterval.lower + confidenceInterval.upper) / 2;
-          const std =
-            (confidenceInterval.upper - confidenceInterval.lower) / (2 * z);
-          return { type: "normal" as const, mean, std };
-        }
-
         const { mean, std } = toMeanAndStd(samples);
         return std > 0 ? { type: "normal" as const, mean, std } : null;
       }
diff --git a/src/components/flow-diagram/FlowDiag.tsx b/src/components/flow-diagram/FlowDiag.tsx
index 2fa2790..69a965d 100644
--- a/src/components/flow-diagram/FlowDiag.tsx
+++ b/src/components/flow-diagram/FlowDiag.tsx
@@ -14,9 +14,8 @@ import type {
   VisualDependencyNodeValue,
 } from "../../types/visualDependencyGraph";
 import {
-  getAvailableDistributionViews,
-  isConfidenceIntervalValue,
   isSampledDistributionValue,
+  parseDistributionValue,
   parseSampledDistributionValue,
 } from "../../utils/distribution/distributionUtils";
 import {
@@ -53,9 +52,12 @@ interface FlowDiagramNodeData extends Record<string, unknown> {
   formula: string;
   row: number;
   col: number;
-  valueKind: "scalar" | "confidence_interval" | "sampled_distribution";
-  interpretation?: "normal" | "uniform" | "lognormal" | "auto";
-  confidenceIntervalBounds?: { lower: number; upper: number };
+  valueKind:
+    | "scalar"
+    | "distribution"
+    | "sampled_distribution";
+  distributionKind?: "normal" | "uniform" | "lognormal";
+  distributionSource?: "parameters" | "ci";
   isSelected: boolean;
   focusState: GraphFocusState;
   onSelect: () => void;
@@ -81,9 +83,12 @@ interface PlainNodeData extends Record<string, unknown> {
   formula: string;
   row: number;
   col: number;
-  valueKind: "scalar" | "confidence_interval" | "sampled_distribution";
-  interpretation?: "normal" | "uniform" | "lognormal" | "auto";
-  confidenceIntervalBounds?: { lower: number; upper: number };
+  valueKind:
+    | "scalar"
+    | "distribution"
+    | "sampled_distribution";
+  distributionKind?: "normal" | "uniform" | "lognormal";
+  distributionSource?: "parameters" | "ci";
 }
 
 interface PlainNode extends LayoutNode {
@@ -112,12 +117,9 @@ function buildPlainElements(graph: VisualDependencyGraph): {
       col: node.col,
       valueKind: node.value.kind,
     };
-    if (node.value.kind === "confidence_interval") {
-      data.interpretation = node.value.interpretation;
-      data.confidenceIntervalBounds = {
-        lower: node.value.lower,
-        upper: node.value.upper,
-      };
+    if (node.value.kind === "distribution") {
+      data.distributionKind = node.value.distribution;
+      data.distributionSource = node.value.source;
     }
     return {
       id: node.id,
@@ -152,21 +154,21 @@ function cellValueToNodeValue(raw: unknown): VisualDependencyNodeValue | null {
   }
 
   if (typeof raw === "object" && raw !== null) {
-    if (isConfidenceIntervalValue(raw)) {
-      const obj = raw as {
-        lower: number;
-        upper: number;
-        confidenceLevel: number;
-        interpretation?: string;
-      };
+    const distribution = parseDistributionValue(raw);
+    if (distribution) {
       return {
-        kind: "confidence_interval",
-        lower: obj.lower,
-        upper: obj.upper,
-        confidenceLevel: obj.confidenceLevel,
-        interpretation:
-          (obj.interpretation as "normal" | "lognormal" | "uniform" | "auto") ??
-          "normal",
+        kind: "distribution",
+        distribution: distribution.kind,
+        source: distribution.source,
+        mean: distribution.mean,
+        variance: distribution.variance,
+        mu: distribution.mu,
+        sigma: distribution.sigma,
+        min: distribution.min,
+        max: distribution.max,
+        lower: distribution.lower,
+        upper: distribution.upper,
+        confidenceLevel: distribution.confidenceLevel,
       };
     }
 
@@ -233,13 +235,10 @@ function collectOrphanNodes(
         valueKind: nodeValue.kind,
       };
 
-    if (nodeValue.kind === "confidence_interval") {
-      data.interpretation = nodeValue.interpretation;
-      data.confidenceIntervalBounds = {
-        lower: nodeValue.lower,
-        upper: nodeValue.upper,
-      };
-    }
+      if (nodeValue.kind === "distribution") {
+        data.distributionKind = nodeValue.distribution;
+        data.distributionSource = nodeValue.source;
+      }
 
       orphans.push({
         id: nodeId,
@@ -341,8 +340,8 @@ function getValueKindLabel(
   valueKind: FlowDiagramNodeData["valueKind"],
 ): string {
   switch (valueKind) {
-    case "confidence_interval":
-      return "confidence interval";
+    case "distribution":
+      return "distribution";
     case "sampled_distribution":
       return "sampled distribution";
     case "scalar":
@@ -392,18 +391,17 @@ function getSelectedNodeInspectorDetails(
 // ── CSS class helpers ───────────────────────────────────────────────────────
 
 function getDistributionClass(data: FlowDiagramNodeData): string {
-  if (data.valueKind === "confidence_interval" && data.interpretation) {
-    switch (data.interpretation) {
+  if (data.valueKind === "distribution" && data.distributionKind) {
+    switch (data.distributionKind) {
       case "normal":
         return styles.nodeDistNormal;
       case "lognormal":
         return styles.nodeDistLognormal;
       case "uniform":
         return styles.nodeDistUniform;
-      case "auto":
-        return styles.nodeDistNormal;
     }
   }
+
   if (data.valueKind === "sampled_distribution") return styles.nodeDistSampled;
   return "";
 }
@@ -426,11 +424,9 @@ function getSparklineProps(data: FlowDiagramNodeData): {
   type: "normal" | "lognormal" | "uniform" | "sampled";
   color: string;
 } | null {
-  if (data.valueKind === "confidence_interval") {
-    const interp = data.interpretation ?? "normal";
-    switch (interp) {
+  if (data.valueKind === "distribution" && data.distributionKind) {
+    switch (data.distributionKind) {
       case "normal":
-      case "auto":
         return { type: "normal", color: "var(--dist-normal-accent)" };
       case "lognormal":
         return { type: "lognormal", color: "var(--dist-lognormal-accent)" };
@@ -438,6 +434,7 @@ function getSparklineProps(data: FlowDiagramNodeData): {
         return { type: "uniform", color: "var(--dist-uniform-accent)" };
     }
   }
+
   if (data.valueKind === "sampled_distribution")
     return { type: "sampled", color: "var(--dist-sampled-accent)" };
   return null;
@@ -621,11 +618,6 @@ const SelectedNodeInspector: React.FC<{
 }> = ({ details }) => {
   const { node, role, directInputs, directOutputs } = details;
   const { data } = node;
-  const { setDistributionView } = useContext(SpreadsheetContext);
-  const distributionOptions =
-    data.valueKind === "confidence_interval" && data.confidenceIntervalBounds
-      ? getAvailableDistributionViews(data.confidenceIntervalBounds)
-      : [];
 
   return (
     <aside className={styles.nodeInspector} aria-label="Selected node inspector">
@@ -646,35 +638,8 @@ const SelectedNodeInspector: React.FC<{
         )}
         <div className={styles.inspectorMetaRow}>
           <span>{getValueKindLabel(data.valueKind)}</span>
-          {data.interpretation && <span>{data.interpretation}</span>}
+          {data.distributionKind && <span>{data.distributionKind}</span>}
         </div>
-        {data.valueKind === "confidence_interval" && data.interpretation && (
-          <div className={styles.inspectorDistributionRow}>
-            <span className={styles.inspectorLabel}>Distribution</span>
-            <div
-              className={styles.inspectorDistributionGroup}
-              aria-label="Cell distribution"
-            >
-              {distributionOptions.map((option) => (
-                <button
-                  key={option}
-                  type="button"
-                  className={`${styles.inspectorDistributionButton} ${
-                    data.interpretation === option
-                      ? styles.inspectorDistributionButtonActive
-                      : ""
-                  }`}
-                  aria-pressed={data.interpretation === option}
-                  onClick={() =>
-                    setDistributionView(data.row, data.col, option)
-                  }
-                >
-                  {option}
-                </button>
-              ))}
-            </div>
-          </div>
-        )}
       </div>
       <div className={styles.inspectorRelations}>
         <RelationshipList label="Direct inputs" nodes={directInputs} />
diff --git a/src/components/spreadsheet/CellRenderer.tsx b/src/components/spreadsheet/CellRenderer.tsx
index ae6d30b..803fa14 100644
--- a/src/components/spreadsheet/CellRenderer.tsx
+++ b/src/components/spreadsheet/CellRenderer.tsx
@@ -1,33 +1,26 @@
 import React, {
   useCallback,
-  useContext,
-  useEffect,
   useMemo,
   useRef,
   useState,
 } from "react";
 import {
-  getAvailableDistributionViews,
   getSamplesFromDistribution,
-  isConfidenceIntervalValue,
+  isDistributionValue,
   isSampledDistributionValue,
-  parseConfidenceIntervalValue,
-  parseSampledDistributionValue,
+  parseDistributionValue,
 } from "../../utils/distribution/distributionUtils";
 import {
   BooleanIcon,
   MicroSparkline,
+  formatCellEditValue,
   formatCellValue,
   type CellValue,
-  type DistributionViewOptions,
 } from "./cellFormatting";
 
 import { DistributionPlot } from "../charts/DistributionPlot";
-import {
-  SpreadsheetContext,
-  type DistributionViewType,
-} from "../../context/SpreadsheetContext";
-import { DistributionViewDropdown } from "./DistributionViewDropdown";
+import type { DistributionParams } from "../charts/distributionChartOptions";
+import { SpreadsheetContext } from "../../context/SpreadsheetContext";
 import styles from "./CellRenderer.module.css";
 
 interface CellRendererProps {
@@ -39,7 +32,9 @@ interface CellRendererProps {
   onContextMenu?: (e: React.MouseEvent) => void;
   isSelected?: boolean;
   isEditing?: boolean;
-  onRequestEdit?: (row: number, col: number) => void;
+  editValue?: string;
+  onEditValueChange?: (value: string) => void;
+  onRequestEdit?: (row: number, col: number, value: string) => void;
   onStopEdit?: () => void;
 }
 
@@ -52,77 +47,19 @@ export const CellRenderer: React.FC<CellRendererProps> = ({
   onContextMenu,
   isSelected = false,
   isEditing = false,
+  editValue = "",
+  onEditValueChange,
   onRequestEdit,
   onStopEdit,
 }) => {
-  const {
-    getCellFormula,
-    getDistributionView,
-    setDistributionView,
-    clearDistributionView,
-  } = useContext(SpreadsheetContext);
-  const [tempValue, setTempValue] = useState("");
+  const { getCellFormula } = React.useContext(SpreadsheetContext);
   const [showPlot, setShowPlot] = useState(false);
   const [plotPosition, setPlotPosition] = useState({ top: 0, left: 0 });
-  const [showViewDropdown, setShowViewDropdown] = useState(false);
-  const confidenceInterval = useMemo(
-    () =>
-      isConfidenceIntervalValue(value)
-        ? parseConfidenceIntervalValue(value)
-        : null,
+  const explicitDistribution = useMemo(
+    () => parseDistributionValue(value),
     [value],
   );
-  const availableDistributionViews = useMemo(
-    () =>
-      confidenceInterval
-        ? getAvailableDistributionViews(confidenceInterval)
-        : (["normal", "lognormal", "uniform"] satisfies DistributionViewType[]),
-    [confidenceInterval],
-  );
-  const inferViewFromValue = () => {
-    if (confidenceInterval) {
-      const override = getDistributionView(row, col);
-      if (override && availableDistributionViews.includes(override)) {
-        return override;
-      }
-      const interpretation = confidenceInterval.interpretation;
-      if (
-        interpretation === "lognormal" &&
-        availableDistributionViews.includes("lognormal")
-      ) {
-        return "lognormal";
-      }
-      if (interpretation === "uniform") {
-        return "uniform";
-      }
-    }
-    return "normal";
-  };
-  const [viewOptions, setViewOptions] = useState<DistributionViewOptions>(
-    () => ({
-      type: inferViewFromValue(),
-    }),
-  );
   const cellRef = useRef<HTMLDivElement>(null);
-  const dropdownRef = useRef<HTMLDivElement>(null);
-
-  // Close dropdown when clicking outside
-  useEffect(() => {
-    const handleClickOutside = (event: MouseEvent) => {
-      if (
-        dropdownRef.current &&
-        !dropdownRef.current.contains(event.target as Node)
-      ) {
-        setShowViewDropdown(false);
-      }
-    };
-
-    if (showViewDropdown) {
-      document.addEventListener("mousedown", handleClickOutside);
-      return () =>
-        document.removeEventListener("mousedown", handleClickOutside);
-    }
-  }, [showViewDropdown]);
 
   const getDistributionColors = useCallback(() => {
     if (isSampledDistributionValue(value)) {
@@ -133,8 +70,8 @@ export const CellRenderer: React.FC<CellRendererProps> = ({
         variant: "sampled" as const,
       };
     }
-    if (isConfidenceIntervalValue(value)) {
-      switch (viewOptions.type) {
+    if (explicitDistribution) {
+      switch (explicitDistribution.kind) {
         case "lognormal":
           return {
             bg: "var(--dist-lognormal-bg)",
@@ -160,89 +97,25 @@ export const CellRenderer: React.FC<CellRendererProps> = ({
       }
     }
     return null;
-  }, [value, viewOptions.type]);
+  }, [value, explicitDistribution]);
 
   const distColors = getDistributionColors();
 
-  useEffect(() => {
-    if (confidenceInterval) {
-      const override = getDistributionView(row, col);
-      let nextType: DistributionViewType = "normal";
-      if (override && availableDistributionViews.includes(override)) {
-        nextType = override;
-      } else if (
-        confidenceInterval.interpretation === "lognormal" &&
-        availableDistributionViews.includes("lognormal")
-      ) {
-        nextType = "lognormal";
-      } else if (confidenceInterval.interpretation === "uniform") {
-        nextType = "uniform";
-      }
-
-      setViewOptions((prev) =>
-        prev.type === nextType ? prev : { type: nextType },
-      );
-
-      if (!override) {
-        setDistributionView(row, col, nextType);
-      }
-    } else {
-      if (viewOptions.type !== "normal") {
-        setViewOptions({ type: "normal" });
-      }
-      clearDistributionView(row, col);
-    }
-  }, [
-    value,
-    confidenceInterval,
-    availableDistributionViews,
-    row,
-    col,
-    getDistributionView,
-    setDistributionView,
-    clearDistributionView,
-    viewOptions.type,
-  ]);
-
   const startEditing = () => {
     const formula = getCellFormula(row, col);
     if (formula) {
-      setTempValue(formula);
-      onRequestEdit?.(row, col);
+      onRequestEdit?.(row, col, formula);
       return;
     }
-    if (isConfidenceIntervalValue(value)) {
-      const ci = parseConfidenceIntervalValue(value);
-      if (ci) {
-        const ciDistRepresentation = `[${ci.lower.toFixed(2)}, ${ci.upper.toFixed(2)}]`;
-        setTempValue(ciDistRepresentation);
-      } else {
-        setTempValue("");
-      }
-    } else if (isSampledDistributionValue(value)) {
-      const sampled = parseSampledDistributionValue(value);
-      if (sampled) {
-        const sampledDistRepresentation = `S(μ=${sampled.mean.toFixed(2)}, σ=${sampled.std.toFixed(2)})`;
-        setTempValue(sampledDistRepresentation);
-      } else {
-        setTempValue("");
-      }
-    } else {
-      setTempValue(value ? String(value) : "");
-    }
-    onRequestEdit?.(row, col);
+    onRequestEdit?.(row, col, formatCellEditValue(value));
   };
 
-  const handleCellClick = (event: React.MouseEvent) => {
+  const handleCellClick = () => {
     onClick?.();
-
-    if (event.detail === 2) {
-      startEditing();
-    }
   };
 
   const handleBlur = () => {
-    onEdit(row, col, tempValue);
+    onEdit(row, col, editValue);
     onStopEdit?.();
   };
 
@@ -315,7 +188,7 @@ export const CellRenderer: React.FC<CellRendererProps> = ({
       });
 
       if (
-        isConfidenceIntervalValue(value) ||
+        isDistributionValue(value) ||
         isSampledDistributionValue(value)
       ) {
         setShowPlot(true);
@@ -323,18 +196,18 @@ export const CellRenderer: React.FC<CellRendererProps> = ({
     }
   };
 
-  // Update isDistribution to only include the two types we support in unified approach
   const isDistribution =
-    isConfidenceIntervalValue(value) || isSampledDistributionValue(value);
-
-  // Only show view options for confidence intervals, not sampled distributions
-  const showViewOptions = isConfidenceIntervalValue(value);
+    isDistributionValue(value) ||
+    isSampledDistributionValue(value);
 
   const leadingIcon = useMemo(() => {
-    if (isConfidenceIntervalValue(value) || isSampledDistributionValue(value)) {
+    if (
+      isDistributionValue(value) ||
+      isSampledDistributionValue(value)
+    ) {
       const sparkType = isSampledDistributionValue(value)
         ? ("sampled" as const)
-        : viewOptions.type;
+        : explicitDistribution?.kind ?? "normal";
       const sparkColor = distColors?.accent ?? "var(--text-muted)";
       return <MicroSparkline type={sparkType} color={sparkColor} />;
     }
@@ -344,17 +217,11 @@ export const CellRenderer: React.FC<CellRendererProps> = ({
     }
 
     return null;
-  }, [value, viewOptions.type, distColors]);
-
-  const handleViewOptionChange = (type: "normal" | "lognormal" | "uniform") => {
-    setViewOptions({ type });
-    setDistributionView(row, col, type);
-    setShowViewDropdown(false);
-  };
+  }, [value, explicitDistribution, distColors]);
 
   const displayValue = useMemo(
-    () => formatCellValue(value, viewOptions),
-    [value, viewOptions],
+    () => formatCellValue(value),
+    [value],
   );
 
   const cellClassName = [
@@ -377,22 +244,20 @@ export const CellRenderer: React.FC<CellRendererProps> = ({
         onDoubleClick={startEditing}
         className={cellClassName}
         style={{
-          gridTemplateColumns: showViewOptions
-            ? "auto 1fr auto auto"
-            : isDistribution
-              ? leadingIcon
-                ? "auto 1fr auto"
-                : "1fr auto"
-              : leadingIcon
-                ? "auto 1fr"
-                : "1fr",
+          gridTemplateColumns: isDistribution
+            ? leadingIcon
+              ? "auto 1fr auto"
+              : "1fr auto"
+            : leadingIcon
+              ? "auto 1fr"
+              : "1fr",
         }}
       >
         {isEditing ? (
           <input
             autoFocus
-            value={tempValue}
-            onChange={(e) => setTempValue(e.target.value)}
+            value={editValue}
+            onChange={(e) => onEditValueChange?.(e.target.value)}
             onBlur={handleBlur}
             onKeyDown={(e) => {
               if (e.key === "Enter") handleBlur();
@@ -407,16 +272,6 @@ export const CellRenderer: React.FC<CellRendererProps> = ({
             <span className={styles.cellText} title={displayValue}>
               {displayValue}
             </span>
-            {showViewOptions && !isEditing && (
-              <DistributionViewDropdown
-                availableViews={availableDistributionViews}
-                viewType={viewOptions.type}
-                showDropdown={showViewDropdown}
-                onToggleDropdown={() => setShowViewDropdown(!showViewDropdown)}
-                onSelectView={handleViewOptionChange}
-                dropdownRef={dropdownRef}
-              />
-            )}
             {isDistribution && !isEditing && (
               <button
                 type="button"
@@ -448,34 +303,65 @@ export const CellRenderer: React.FC<CellRendererProps> = ({
           const samples = getSamplesFromDistribution(value);
           if (!samples) return null;
 
-          // Get distribution type and confidence interval info
           let distributionType: "normal" | "lognormal" | "uniform" | "sampled" =
             "sampled";
+          let distributionParams: DistributionParams | null = null;
           let confidenceInterval:
             | { lower: number; upper: number; confidenceLevel: number }
             | undefined;
 
-          if (isConfidenceIntervalValue(value)) {
-            const ci = parseConfidenceIntervalValue(value);
-            if (ci) {
+          if (explicitDistribution) {
+            distributionType = explicitDistribution.kind;
+            switch (explicitDistribution.kind) {
+              case "normal":
+                if (
+                  explicitDistribution.mean !== undefined &&
+                  explicitDistribution.variance !== undefined
+                ) {
+                  distributionParams = {
+                    type: "normal",
+                    mean: explicitDistribution.mean,
+                    std: Math.sqrt(explicitDistribution.variance),
+                  };
+                }
+                break;
+              case "lognormal":
+                if (
+                  explicitDistribution.mu !== undefined &&
+                  explicitDistribution.sigma !== undefined
+                ) {
+                  distributionParams = {
+                    type: "lognormal",
+                    mu: explicitDistribution.mu,
+                    sigma: explicitDistribution.sigma,
+                  };
+                }
+                break;
+              case "uniform":
+                if (
+                  explicitDistribution.min !== undefined &&
+                  explicitDistribution.max !== undefined
+                ) {
+                  distributionParams = {
+                    type: "uniform",
+                    a: explicitDistribution.min,
+                    b: explicitDistribution.max,
+                  };
+                }
+                break;
+            }
+
+            if (
+              explicitDistribution.source === "ci" &&
+              explicitDistribution.lower !== undefined &&
+              explicitDistribution.upper !== undefined &&
+              explicitDistribution.confidenceLevel !== undefined
+            ) {
               confidenceInterval = {
-                lower: ci.lower,
-                upper: ci.upper,
-                confidenceLevel: ci.confidenceLevel,
+                lower: explicitDistribution.lower,
+                upper: explicitDistribution.upper,
+                confidenceLevel: explicitDistribution.confidenceLevel,
               };
-
-              // Map view options to distribution types
-              switch (viewOptions.type) {
-                case "normal":
-                  distributionType = "normal";
-                  break;
-                case "lognormal":
-                  distributionType = "lognormal";
-                  break;
-                case "uniform":
-                  distributionType = "uniform";
-                  break;
-              }
             }
           } else if (isSampledDistributionValue(value)) {
             distributionType = "sampled";
@@ -487,6 +373,7 @@ export const CellRenderer: React.FC<CellRendererProps> = ({
               samples={samples}
               onClose={() => setShowPlot(false)}
               distributionType={distributionType}
+              distributionParams={distributionParams}
               confidenceInterval={confidenceInterval}
             />
           );
diff --git a/src/components/spreadsheet/DistributionViewDropdown.tsx b/src/components/spreadsheet/DistributionViewDropdown.tsx
deleted file mode 100644
index c535621..0000000
--- a/src/components/spreadsheet/DistributionViewDropdown.tsx
+++ /dev/null
@@ -1,126 +0,0 @@
-import React from "react";
-import type { DistributionViewType } from "../../utils/distribution/distributionUtils";
-import styles from "./CellRenderer.module.css";
-
-const ChevronDownIcon: React.FC<{ size?: number; color?: string }> = ({
-  size = 14,
-  color = "currentColor",
-}) => (
-  <svg
-    width={size}
-    height={size}
-    viewBox="0 0 24 24"
-    fill="none"
-    xmlns="http://www.w3.org/2000/svg"
-    aria-hidden="true"
-  >
-    <path
-      d="M6 9L12 15L18 9"
-      stroke={color}
-      strokeWidth="1.5"
-      strokeLinecap="round"
-      strokeLinejoin="round"
-    />
-  </svg>
-);
-
-const DistributionIcon: React.FC = () => (
-  <svg
-    width={18}
-    height={18}
-    viewBox="0 0 24 24"
-    fill="none"
-    xmlns="http://www.w3.org/2000/svg"
-    aria-hidden="true"
-  >
-    <path
-      d="M4 18C6 14 8.5 9 12 9C15.5 9 16.5 14 20 6"
-      stroke="var(--resize-handle-active)"
-      strokeWidth="1.5"
-      strokeLinecap="round"
-      strokeLinejoin="round"
-    />
-    <line
-      x1="4"
-      y1="18"
-      x2="20"
-      y2="18"
-      stroke="var(--border-color)"
-      strokeWidth="1.25"
-      strokeLinecap="round"
-    />
-  </svg>
-);
-
-interface DistributionViewDropdownProps {
-  availableViews: DistributionViewType[];
-  viewType: DistributionViewType;
-  showDropdown: boolean;
-  onToggleDropdown: () => void;
-  onSelectView: (type: DistributionViewType) => void;
-  dropdownRef: React.RefObject<HTMLDivElement | null>;
-}
-
-const distributionOptions: Array<{
-  type: DistributionViewType;
-  label: string;
-}> = [
-  { type: "normal", label: "Normal Distribution" },
-  { type: "lognormal", label: "Log-Normal Distribution" },
-  { type: "uniform", label: "Uniform Distribution" },
-];
-
-export const DistributionViewDropdown: React.FC<
-  DistributionViewDropdownProps
-> = ({
-  availableViews,
-  viewType,
-  showDropdown,
-  onToggleDropdown,
-  onSelectView,
-  dropdownRef,
-}) => {
-  return (
-    <div
-      className={styles.dropdownWrapper}
-      ref={dropdownRef as React.RefObject<HTMLDivElement>}
-    >
-      <button
-        onClick={(e) => {
-          e.stopPropagation();
-          onToggleDropdown();
-        }}
-        className={[styles.dropdownBtn, showDropdown && styles.dropdownBtnOpen]
-          .filter(Boolean)
-          .join(" ")}
-        title="Change view"
-      >
-        <ChevronDownIcon size={14} />
-      </button>
-      {showDropdown && (
-        <div className={styles.dropdownPanel}>
-          <div className={styles.dropdownInner}>
-            <div className={styles.dropdownHeader}>View as:</div>
-            {distributionOptions
-              .filter((option) => availableViews.includes(option.type))
-              .map((option) => (
-                <button
-                  key={option.type}
-                  onClick={() => onSelectView(option.type)}
-                  className={[
-                    styles.dropdownOption,
-                    viewType === option.type && styles.dropdownOptionActive,
-                  ]
-                    .filter(Boolean)
-                    .join(" ")}
-                >
-                  <DistributionIcon />
-                  {option.label}
-                </button>
-              ))}
-          </div>
-        </div>
-      )}
-    </div>
-  );
-};
diff --git a/src/components/spreadsheet/Spreadsheet.tsx b/src/components/spreadsheet/Spreadsheet.tsx
index 4aff79a..05ff7e8 100644
--- a/src/components/spreadsheet/Spreadsheet.tsx
+++ b/src/components/spreadsheet/Spreadsheet.tsx
@@ -41,6 +41,7 @@ type SpreadsheetRow = {
 interface EditingCell {
   row: number;
   col: number;
+  value: string;
 }
 
 export const Spreadsheet: React.FC<SpreadsheetProps> = ({
@@ -158,7 +159,21 @@ export const Spreadsheet: React.FC<SpreadsheetProps> = ({
               isEditing={
                 editingCell?.row === rowIndex && editingCell?.col === colIndex
               }
-              onRequestEdit={(row, col) => setEditingCell({ row, col })}
+              editValue={
+                editingCell?.row === rowIndex && editingCell?.col === colIndex
+                  ? editingCell.value
+                  : ""
+              }
+              onEditValueChange={(value) => {
+                setEditingCell((current) =>
+                  current?.row === rowIndex && current?.col === colIndex
+                    ? { ...current, value }
+                    : current,
+                );
+              }}
+              onRequestEdit={(row, col, value) =>
+                setEditingCell({ row, col, value })
+              }
               onStopEdit={() => setEditingCell(null)}
             />
           );
@@ -259,7 +274,7 @@ export const Spreadsheet: React.FC<SpreadsheetProps> = ({
             </svg>
             <p className={styles.welcomeTitle}>Start building your model</p>
             <p className={styles.welcomeSubtitle}>
-              Type values, formulas, or ranges like <code>CI[10, 20]</code> to
+              Type values, formulas, or uncertainty like <code>N.CI(10, 20, 0.95)</code> to
               add uncertainty
             </p>
           </div>
diff --git a/src/components/spreadsheet/cellFormatting.tsx b/src/components/spreadsheet/cellFormatting.tsx
index dc1971f..6eb164d 100644
--- a/src/components/spreadsheet/cellFormatting.tsx
+++ b/src/components/spreadsheet/cellFormatting.tsx
@@ -3,18 +3,13 @@
 import React from "react";
 
 import {
-  getConfidenceIntervalMedian,
-  isConfidenceIntervalValue,
+  confidenceLevelToFormulaArgument,
+  isDistributionValue,
   isSampledDistributionValue,
-  parseConfidenceIntervalValue,
+  parseDistributionValue,
   parseSampledDistributionValue,
-  zScoreForConfidence,
 } from "../../utils/distribution/distributionUtils";
 
-export interface DistributionViewOptions {
-  type: "normal" | "lognormal" | "uniform";
-}
-
 export type CellValue =
   | string
   | number
@@ -24,7 +19,20 @@ export type CellValue =
   | undefined
   | { samples: number[] }
   | { mean: number; variance: number }
-  | { lower: number; upper: number; confidenceLevel: number };
+  | {
+      kind: "normal" | "lognormal" | "uniform";
+      source?: "parameters" | "ci";
+      mean?: number;
+      variance?: number;
+      mu?: number;
+      sigma?: number;
+      min?: number;
+      max?: number;
+      lower?: number;
+      upper?: number;
+      confidenceLevel?: number;
+      toSamples?: () => number[];
+    };
 
 export const BooleanIcon: React.FC<{ value: boolean }> = ({ value }) => (
   <svg
@@ -108,10 +116,72 @@ export const MicroSparkline: React.FC<{
   );
 };
 
-export const formatCellValue = (
-  val: CellValue,
-  options: DistributionViewOptions,
-): string => {
+const formatCompactNumber = (value: number): string => {
+  const abs = Math.abs(value);
+  const fractionDigits = abs > 0 && abs < 1 ? 4 : 2;
+  return value
+    .toFixed(fractionDigits)
+    .replace(/(\.\d*?)0+$/, "$1")
+    .replace(/\.$/, "");
+};
+
+const formatConfidencePercent = (confidenceLevel: number): string => {
+  const normalized = confidenceLevel > 1 ? confidenceLevel : confidenceLevel * 100;
+  return `${formatCompactNumber(normalized)}%`;
+};
+
+export const formatCellEditValue = (val: CellValue): string => {
+  if (val === null || val === undefined) return "";
+
+  if (typeof val === "boolean") {
+    return val ? "TRUE" : "FALSE";
+  }
+
+  if (typeof val === "string" || typeof val === "number") {
+    return String(val);
+  }
+
+  if (isDistributionValue(val)) {
+    const distribution = parseDistributionValue(val);
+    if (distribution) {
+      switch (distribution.kind) {
+        case "normal":
+          if (
+            distribution.source === "ci" &&
+            distribution.lower !== undefined &&
+            distribution.upper !== undefined &&
+            distribution.confidenceLevel !== undefined
+          ) {
+            return `N.CI(${distribution.lower.toFixed(2)}, ${distribution.upper.toFixed(2)}, ${confidenceLevelToFormulaArgument(distribution.confidenceLevel).toFixed(2)})`;
+          }
+          return `N(${(distribution.mean ?? 0).toFixed(2)}, ${(distribution.variance ?? 0).toFixed(2)})`;
+        case "lognormal":
+          if (
+            distribution.source === "ci" &&
+            distribution.lower !== undefined &&
+            distribution.upper !== undefined &&
+            distribution.confidenceLevel !== undefined
+          ) {
+            return `LN.CI(${distribution.lower.toFixed(2)}, ${distribution.upper.toFixed(2)}, ${confidenceLevelToFormulaArgument(distribution.confidenceLevel).toFixed(2)})`;
+          }
+          return `LN(${(distribution.mu ?? 0).toFixed(2)}, ${(distribution.sigma ?? 0).toFixed(2)})`;
+        case "uniform":
+          return `U(${(distribution.min ?? 0).toFixed(2)}, ${(distribution.max ?? 0).toFixed(2)})`;
+      }
+    }
+  }
+
+  if (isSampledDistributionValue(val)) {
+    const sampled = parseSampledDistributionValue(val);
+    if (sampled) {
+      return `S(μ=${sampled.mean.toFixed(2)}, σ=${sampled.std.toFixed(2)})`;
+    }
+  }
+
+  return String(val);
+};
+
+export const formatCellValue = (val: CellValue): string => {
   if (val === null || val === undefined) return "";
 
   if (typeof val === "boolean") {
@@ -122,31 +192,32 @@ export const formatCellValue = (
     return String(val);
   }
 
-  if (isConfidenceIntervalValue(val)) {
-    const ci = parseConfidenceIntervalValue(val);
-    if (ci) {
-      const median = getConfidenceIntervalMedian(ci);
-
-      switch (options.type) {
-        case "normal": {
-          const mean = (ci.lower + ci.upper) / 2;
-          const zScore = zScoreForConfidence(ci.confidenceLevel);
-          const std = (ci.upper - ci.lower) / (2 * zScore);
-          return `N(μ=${mean.toFixed(2)}, σ=${std.toFixed(2)})`;
-        }
+  if (isDistributionValue(val)) {
+    const distribution = parseDistributionValue(val);
+    if (distribution) {
+      switch (distribution.kind) {
+        case "normal":
+          if (
+            distribution.source === "ci" &&
+            distribution.lower !== undefined &&
+            distribution.upper !== undefined &&
+            distribution.confidenceLevel !== undefined
+          ) {
+            return `N ${formatConfidencePercent(distribution.confidenceLevel)} CI [${formatCompactNumber(distribution.lower)}, ${formatCompactNumber(distribution.upper)}]`;
+          }
+          return `N μ=${formatCompactNumber(distribution.mean ?? 0)} σ²=${formatCompactNumber(distribution.variance ?? 0)}`;
         case "lognormal":
-          if (ci.lower > 0 && ci.upper > 0) {
-            const lnLower = Math.log(ci.lower);
-            const lnUpper = Math.log(ci.upper);
-            const mu = (lnLower + lnUpper) / 2;
-            const sigma = (lnUpper - lnLower) / 3.29;
-            return `LN(μ=${mu.toFixed(2)}, σ=${sigma.toFixed(2)})`;
+          if (
+            distribution.source === "ci" &&
+            distribution.lower !== undefined &&
+            distribution.upper !== undefined &&
+            distribution.confidenceLevel !== undefined
+          ) {
+            return `LN ${formatConfidencePercent(distribution.confidenceLevel)} CI [${formatCompactNumber(distribution.lower)}, ${formatCompactNumber(distribution.upper)}]`;
           }
-          return `${median.toFixed(2)} [${ci.lower}-${ci.upper}]`;
+          return `LN μlog=${formatCompactNumber(distribution.mu ?? 0)} σlog=${formatCompactNumber(distribution.sigma ?? 0)}`;
         case "uniform":
-          return `U[${ci.lower.toFixed(2)}, ${ci.upper.toFixed(2)}]`;
-        default:
-          return `${median.toFixed(2)} [${ci.lower}-${ci.upper}]`;
+          return `U [${formatCompactNumber(distribution.min ?? 0)}, ${formatCompactNumber(distribution.max ?? 0)}]`;
       }
     }
   }
diff --git a/src/context/SpreadsheetContext.tsx b/src/context/SpreadsheetContext.tsx
index 0d4e523..e21f9f4 100644
--- a/src/context/SpreadsheetContext.tsx
+++ b/src/context/SpreadsheetContext.tsx
@@ -10,17 +10,10 @@ import {
   type WorkbookSnapshot,
 } from "../assistant/workbookSnapshot";
 import { GaussFormulaEngine, type FormulaEngine } from "../lib/formulaEngine";
-import {
-  canUseLognormalInterpretation,
-  parseConfidenceIntervalValue,
-  type DistributionViewType,
-} from "../utils/distribution/distributionUtils";
 
 type CellContent = string | number | null;
 type SheetData = CellContent[][];
 
-export type { DistributionViewType };
-
 const VISIBLE_SHEET_ROWS = 50;
 const VISIBLE_SHEET_COLUMNS = 26;
 
@@ -29,16 +22,6 @@ interface SpreadsheetContextValue {
   updateCell: (row: number, col: number, value: string) => void;
   getCellFormula: (row: number, col: number) => string | null;
   submitFormula: (row: number, col: number, formula: string) => void;
-  getDistributionView: (
-    row: number,
-    col: number,
-  ) => DistributionViewType | null;
-  setDistributionView: (
-    row: number,
-    col: number,
-    view: DistributionViewType,
-  ) => void;
-  clearDistributionView: (row: number, col: number) => void;
   getWorkbookSnapshot: (
     selectedCell: SelectedCell | null,
   ) => WorkbookSnapshot | null;
@@ -50,9 +33,6 @@ const SpreadsheetContext = createContext<SpreadsheetContextValue>({
   updateCell: () => {},
   getCellFormula: () => null,
   submitFormula: () => {},
-  getDistributionView: () => null,
-  setDistributionView: () => {},
-  clearDistributionView: () => {},
   getWorkbookSnapshot: () => null,
   applyAssistantChanges: () => {},
 });
@@ -63,10 +43,6 @@ export const SpreadsheetProvider: React.FC<{ children: React.ReactNode }> = ({
   const [formulaEngine, setFormulaEngine] = useState<FormulaEngine | null>(
     null,
   );
-  const [distributionViews, setDistributionViews] = useState<
-    Record<string, DistributionViewType>
-  >({});
-
   useEffect(() => {
     const config = {
       licenseKey: "gpl-v3",
@@ -140,65 +116,6 @@ export const SpreadsheetProvider: React.FC<{ children: React.ReactNode }> = ({
     [formulaEngine],
   );
 
-  const getDistributionView = useCallback(
-    (row: number, col: number) => {
-      const key = `${row}:${col}`;
-      return distributionViews[key] ?? null;
-    },
-    [distributionViews],
-  );
-
-  const setDistributionView = useCallback(
-    (row: number, col: number, view: DistributionViewType) => {
-      const key = `${row}:${col}`;
-      let appliedView = view;
-
-      if (formulaEngine) {
-        const address = { sheet: 0, row, col };
-        const formula = formulaEngine.getCellFormula(address);
-        const value = formulaEngine.getCellValue(address);
-        const confidenceInterval = parseConfidenceIntervalValue(value);
-
-        if (!formula && confidenceInterval) {
-          appliedView =
-            view === "lognormal" &&
-            !canUseLognormalInterpretation(confidenceInterval)
-              ? "normal"
-              : view;
-          formulaEngine.setCellContents(
-            address,
-            new GaussFormulaEngine.ConfidenceIntervalNumber(
-              confidenceInterval.lower,
-              confidenceInterval.upper,
-              confidenceInterval.confidenceLevel,
-              { interpretation: appliedView },
-            ),
-          );
-        }
-      }
-
-      setDistributionViews((prev) => {
-        if (prev[key] === appliedView) {
-          return prev;
-        }
-        return { ...prev, [key]: appliedView };
-      });
-    },
-    [formulaEngine],
-  );
-
-  const clearDistributionView = useCallback((row: number, col: number) => {
-    const key = `${row}:${col}`;
-    setDistributionViews((prev) => {
-      if (!(key in prev)) {
-        return prev;
-      }
-      const nextViews = { ...prev };
-      delete nextViews[key];
-      return nextViews;
-    });
-  }, []);
-
   const getWorkbookSnapshot = useCallback(
     (selectedCell: SelectedCell | null) => {
       if (!formulaEngine) return null;
@@ -242,9 +159,6 @@ export const SpreadsheetProvider: React.FC<{ children: React.ReactNode }> = ({
         updateCell,
         getCellFormula,
         submitFormula,
-        getDistributionView,
-        setDistributionView,
-        clearDistributionView,
         getWorkbookSnapshot,
         applyAssistantChanges,
       }}
diff --git a/src/examples/examples.ts b/src/examples/examples.ts
index 330162d..aa657ca 100644
--- a/src/examples/examples.ts
+++ b/src/examples/examples.ts
@@ -1,39 +1,94 @@
-export type ExampleCell = string | number | null
+export type ExampleCell = string | number | null;
 
 export interface ExampleDefinition {
-  id: string
-  name: string
-  description: string
-  data: ExampleCell[][]
+  id: string;
+  name: string;
+  description: string;
+  data: ExampleCell[][];
 }
 
 const llmPricingExample: ExampleDefinition = {
-  id: 'prompt-cost-ci',
-  name: 'Prompt Cost Forecast (CI)',
-  description: 'Mean-aligned prompt-cost forecast with CI bounds on variable inputs.',
+  id: "prompt-cost-uncertainty",
+  name: "Prompt Cost Forecast",
+  description:
+    "Mean-aligned prompt-cost forecast with explicit uncertainty inputs.",
   data: [
     [null, null, null, null, null],
     [null, null, null, null, null],
     [null, null, null, null, null],
-    ['Inputs', null, null, 'Calculated', 'Outputs update automatically as you adjust CI ranges.'],
-    ['Average Document Length (Pages)', 'CI[18, 22]', null, 'Input Tokens Per Doc', '=B5*B20'],
-    ['Number of Prompt Revisions', 0, null, 'Chunks Per Doc', '=CEILING(E5/B13,1)'],
-    ['Number of Documents To Label', 'CI[160, 240]', null, 'Field Batches Per Doc', '=CEILING(B8/B21,1)'],
-    ['Number of Fields', 20, null, 'Document Input Tokens', '=E5*E7'],
-    [null, null, null, 'Text-prompt Input Tokens', '=B14*E6*E7'],
-    ['Constants', null, null, 'Per-Field Input Tokens', '=E6*B8*B15'],
-    ['LLM Cost Per 1000 Tokens (Prompt)', 'CI[0.009, 0.011]', null, 'Total Input Tokens', '=E8+E9+E10'],
-    ['LLM Cost per 1000 Tokens (Completion)', 'CI[0.028, 0.032]', null, 'Response Tokens Per Doc', '=E6*B8*B19'],
-    ['Chunk Length (tokens)', 'CI[1948, 2148]', null, 'Total Cost Per Doc', '=(E11*B11+E12*B12)/1000'],
-    ['Prompt Length', 'CI[90, 110]', null, null, null],
-    ['Per Field Prompt Length', 'CI[22, 38]', null, 'Total Cost', '=B6*B16*E13 + B7*E13'],
-    ['Num Docs Shown in Prompt-studio', 'CI[4, 6]', null, null, null],
+    [
+      "Inputs",
+      null,
+      null,
+      "Calculated",
+      "Outputs update automatically as you adjust uncertainty inputs.",
+    ],
+    [
+      "Average Document Length (Pages)",
+      "N.CI(18, 22, 0.95)",
+      null,
+      "Input Tokens Per Doc",
+      "=B5*B20",
+    ],
+    [
+      "Number of Prompt Revisions",
+      0,
+      null,
+      "Chunks Per Doc",
+      "=CEILING(E5/B13,1)",
+    ],
+    [
+      "Number of Documents To Label",
+      "N.CI(160, 240, 0.95)",
+      null,
+      "Field Batches Per Doc",
+      "=CEILING(B8/B21,1)",
+    ],
+    ["Number of Fields", 20, null, "Document Input Tokens", "=E5*E7"],
+    [null, null, null, "Text-prompt Input Tokens", "=B14*E6*E7"],
+    ["Constants", null, null, "Per-Field Input Tokens", "=E6*B8*B15"],
+    [
+      "LLM Cost Per 1000 Tokens (Prompt)",
+      "N.CI(0.009, 0.011, 0.95)",
+      null,
+      "Total Input Tokens",
+      "=E8+E9+E10",
+    ],
+    [
+      "LLM Cost per 1000 Tokens (Completion)",
+      "N.CI(0.028, 0.032, 0.95)",
+      null,
+      "Response Tokens Per Doc",
+      "=E6*B8*B19",
+    ],
+    [
+      "Chunk Length (tokens)",
+      "N.CI(1948, 2148, 0.95)",
+      null,
+      "Total Cost Per Doc",
+      "=(E11*B11+E12*B12)/1000",
+    ],
+    ["Prompt Length", "N.CI(90, 110, 0.95)", null, null, null],
+    [
+      "Per Field Prompt Length",
+      "N.CI(22, 38, 0.95)",
+      null,
+      "Total Cost",
+      "=B6*B16*E13 + B7*E13",
+    ],
+    ["Num Docs Shown in Prompt-studio", "N.CI(4, 6, 0.95)", null, null, null],
     [null, null, null, null, null],
-    ['Assumptions', null, null, null, null],
-    ['Average Completion Length Per Field per chunk', 'CI[35, 45]', null, null, null],
-    ['Num Tokens per Page', 'CI[950, 1050]', null, null, null],
-    ['Field Batch Size', 10, null, null, null],
+    ["Assumptions", null, null, null, null],
+    [
+      "Average Completion Length Per Field per chunk",
+      "N.CI(35, 45, 0.95)",
+      null,
+      null,
+      null,
+    ],
+    ["Num Tokens per Page", "N.CI(950, 1050, 0.95)", null, null, null],
+    ["Field Batch Size", 10, null, null, null],
   ],
-}
+};
 
-export const spreadsheetExamples: ExampleDefinition[] = [llmPricingExample]
+export const spreadsheetExamples: ExampleDefinition[] = [llmPricingExample];
diff --git a/src/hooks/useFormulaBar.ts b/src/hooks/useFormulaBar.ts
index 72a5539..71c2de6 100644
--- a/src/hooks/useFormulaBar.ts
+++ b/src/hooks/useFormulaBar.ts
@@ -1,6 +1,10 @@
 import { useCallback, useContext, useEffect, useState } from "react";
 import { SpreadsheetContext } from "../context/SpreadsheetContext";
-import { parseSampledDistributionValue } from "../utils/distribution/distributionUtils";
+import {
+  confidenceLevelToFormulaArgument,
+  parseDistributionValue,
+  parseSampledDistributionValue,
+} from "../utils/distribution/distributionUtils";
 
 interface SelectedCell {
   row: number;
@@ -12,6 +16,34 @@ export const formatFormulaBarCellValue = (value: unknown): string => {
   if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
 
   if (typeof value === "object" && value !== null) {
+    const distribution = parseDistributionValue(value);
+    if (distribution) {
+      switch (distribution.kind) {
+        case "normal":
+          if (
+            distribution.source === "ci" &&
+            distribution.lower !== undefined &&
+            distribution.upper !== undefined &&
+            distribution.confidenceLevel !== undefined
+          ) {
+            return `N.CI(${distribution.lower.toFixed(2)}, ${distribution.upper.toFixed(2)}, ${confidenceLevelToFormulaArgument(distribution.confidenceLevel).toFixed(2)})`;
+          }
+          return `N(${(distribution.mean ?? 0).toFixed(2)}, ${(distribution.variance ?? 0).toFixed(2)})`;
+        case "lognormal":
+          if (
+            distribution.source === "ci" &&
+            distribution.lower !== undefined &&
+            distribution.upper !== undefined &&
+            distribution.confidenceLevel !== undefined
+          ) {
+            return `LN.CI(${distribution.lower.toFixed(2)}, ${distribution.upper.toFixed(2)}, ${confidenceLevelToFormulaArgument(distribution.confidenceLevel).toFixed(2)})`;
+          }
+          return `LN(${(distribution.mu ?? 0).toFixed(2)}, ${(distribution.sigma ?? 0).toFixed(2)})`;
+        case "uniform":
+          return `U(${(distribution.min ?? 0).toFixed(2)}, ${(distribution.max ?? 0).toFixed(2)})`;
+      }
+    }
+
     const sampled = parseSampledDistributionValue(value);
     if (sampled) {
       return `S(μ=${sampled.mean.toFixed(2)}, σ=${sampled.std.toFixed(2)})`;
@@ -22,10 +54,6 @@ export const formatFormulaBarCellValue = (value: unknown): string => {
       return `S(μ=${v.mean.toFixed(2)}, σ=${Math.sqrt(v.variance).toFixed(2)})`;
     if (typeof v.mu === "number" && typeof v.sigma2 === "number")
       return `LN(μ=${v.mu.toFixed(2)}, σ=${Math.sqrt(v.sigma2).toFixed(2)})`;
-    if (typeof v.a === "number" && typeof v.b === "number")
-      return `U[${v.a.toFixed(2)}, ${v.b.toFixed(2)}]`;
-    if (typeof v.lower === "number" && typeof v.upper === "number" && typeof v.confidenceLevel === "number")
-      return `CI[${v.lower.toFixed(2)}, ${v.upper.toFixed(2)}]`;
   }
 
   return String(value);
diff --git a/src/server/assistantRoute.ts b/src/server/assistantRoute.ts
index b400c19..de2f3c6 100644
--- a/src/server/assistantRoute.ts
+++ b/src/server/assistantRoute.ts
@@ -36,8 +36,8 @@ const buildSystemPrompt = (
   [
     "You are Sage, the assistant inside Maybe, a spreadsheet for probabilistic modeling powered by GaussFormula.",
     "Help users understand and edit the current workbook while preserving uncertainty instead of collapsing it to false precision.",
-    "The workbook can contain confidence intervals such as CI[10, 20], sampled distributions, formulas, scalar values, text, booleans, and errors.",
-    "Do not use LaTeX. Use Maybe spreadsheet formulas such as =A1*B1, CI[10, 20], P10(A1), P50(A1), and P90(A1).",
+    "The workbook can contain explicit uncertainty inputs such as N(mean, variance), LN(mu, sigma), U(min, max), N.CI(lower, upper, confidence), LN.CI(lower, upper, confidence), sampled distributions, formulas, scalar values, text, booleans, and errors.",
+    "Do not use LaTeX. Use Maybe spreadsheet formulas such as =A1*B1, N.CI(10, 20, 0.95), U(10, 20), P10(A1), P50(A1), and P90(A1).",
     "Keep visible responses concise and readable: a short summary, the key formulas, and any caveats. Do not expose raw JSON to the user.",
     "Use getWorkbookContext when you need to inspect the workbook state, selected cell, formulas, or distribution summaries.",
     "Use validateFormula before proposing or applying any formula you invent or revise.",
diff --git a/src/types/gaussformula.d.ts b/src/types/gaussformula.d.ts
index ef82154..7e5285e 100644
--- a/src/types/gaussformula.d.ts
+++ b/src/types/gaussformula.d.ts
@@ -1,25 +1,54 @@
 declare module "gaussformula" {
-  export type CIInterpretation = "normal" | "uniform" | "lognormal" | "auto";
-
-  export interface ConfidenceIntervalOptions {
-    interpretation?: CIInterpretation;
-    sourceFormat?: "ci" | "range" | "bracket";
+  export interface DistributionNumberOptions {
+    source?: "parameters" | "ci";
+    lower?: number;
+    upper?: number;
+    confidenceLevel?: number;
     samplingIdentity?: string;
-    format?: unknown;
   }
 
-  export class ConfidenceIntervalNumber {
-    readonly lower: number;
-    readonly upper: number;
-    readonly confidenceLevel: number;
-    readonly interpretation: CIInterpretation;
+  export class DistributionNumber {
+    readonly kind: "normal" | "lognormal" | "uniform";
+    readonly source: "parameters" | "ci";
+    readonly mean?: number;
+    readonly variance?: number;
+    readonly mu?: number;
+    readonly sigma?: number;
+    readonly min?: number;
+    readonly max?: number;
+    readonly lower?: number;
+    readonly upper?: number;
+    readonly confidenceLevel?: number;
 
-    constructor(
+    static normal(
+      mean: number,
+      variance: number,
+      options?: DistributionNumberOptions
+    ): DistributionNumber;
+    static lognormal(
+      mu: number,
+      sigma: number,
+      options?: DistributionNumberOptions
+    ): DistributionNumber;
+    static uniform(
+      min: number,
+      max: number,
+      options?: DistributionNumberOptions
+    ): DistributionNumber;
+    static normalFromCI(
+      lower: number,
+      upper: number,
+      confidenceLevel: number,
+      options?: DistributionNumberOptions
+    ): DistributionNumber;
+    static lognormalFromCI(
       lower: number,
       upper: number,
-      confidenceLevel?: number,
-      options?: ConfidenceIntervalOptions
-    );
+      confidenceLevel: number,
+      options?: DistributionNumberOptions
+    ): DistributionNumber;
+
+    toSamples(sampleSize?: number): number[];
   }
 
   export type RawCellContent =
@@ -29,11 +58,11 @@ declare module "gaussformula" {
     | Date
     | null
     | undefined
-    | ConfidenceIntervalNumber;
+    | DistributionNumber;
 
   export class GaussFormula {
     static buildEmpty(config?: Record<string, unknown>): GaussFormula;
-    static ConfidenceIntervalNumber: typeof ConfidenceIntervalNumber;
+    static DistributionNumber: typeof DistributionNumber;
     static version: string;
     static buildDate: string;
     static releaseDate: string;
diff --git a/src/types/visualDependencyGraph.ts b/src/types/visualDependencyGraph.ts
index dce0857..60aaeed 100644
--- a/src/types/visualDependencyGraph.ts
+++ b/src/types/visualDependencyGraph.ts
@@ -1,11 +1,18 @@
 export type VisualDependencyNodeValue =
   | { kind: 'scalar'; value: number }
   | {
-      kind: 'confidence_interval'
-      lower: number
-      upper: number
-      confidenceLevel: number
-      interpretation: 'normal' | 'uniform' | 'lognormal' | 'auto'
+      kind: 'distribution'
+      distribution: 'normal' | 'uniform' | 'lognormal'
+      source: 'parameters' | 'ci'
+      mean?: number
+      variance?: number
+      mu?: number
+      sigma?: number
+      min?: number
+      max?: number
+      lower?: number
+      upper?: number
+      confidenceLevel?: number
     }
   | {
       kind: 'sampled_distribution'
diff --git a/src/utils/distribution/distributionUtils.ts b/src/utils/distribution/distributionUtils.ts
index 93dbb22..75e543c 100644
--- a/src/utils/distribution/distributionUtils.ts
+++ b/src/utils/distribution/distributionUtils.ts
@@ -1,125 +1,133 @@
-export type CIInterpretation = 'normal' | 'uniform' | 'lognormal' | 'auto'
-export type DistributionViewType = 'normal' | 'lognormal' | 'uniform'
-
-export interface ParsedConfidenceInterval {
-  lower: number
-  upper: number
-  confidenceLevel: number
-  interpretation?: CIInterpretation
+export type DistributionKind = 'normal' | 'lognormal' | 'uniform'
+
+export interface ParsedDistribution {
+  kind: DistributionKind
+  source: 'parameters' | 'ci'
+  mean?: number
+  variance?: number
+  mu?: number
+  sigma?: number
+  min?: number
+  max?: number
+  lower?: number
+  upper?: number
+  confidenceLevel?: number
 }
 
-export const isConfidenceIntervalValue = (val: unknown): boolean => {
-  if (val && typeof val === 'object' && 'lower' in (val as Record<string, unknown>) && 'upper' in (val as Record<string, unknown>) && 'confidenceLevel' in (val as Record<string, unknown>)) {
-    return true
-  }
+const isDistributionKind = (value: unknown): value is DistributionKind =>
+  value === 'normal' || value === 'lognormal' || value === 'uniform'
 
-  if (typeof val === 'string') {
-    return /^\d+\.?\d*\s+to\s+\d+\.?\d*$/.test(val) || (val.startsWith('CI[') && val.endsWith(']'))
+export const parseDistributionValue = (val: unknown): ParsedDistribution | null => {
+  if (!val || typeof val !== 'object') {
+    return null
   }
 
-  return false
-}
+  const obj = val as Record<string, unknown>
 
-export const parseConfidenceIntervalValue = (val: unknown): ParsedConfidenceInterval | null => {
-  if (val && typeof val === 'object' && 'lower' in val && 'upper' in val && 'confidenceLevel' in val) {
-    const ciVal = val as { lower: number; upper: number; confidenceLevel: number; interpretation?: CIInterpretation }
+  if (isDistributionKind(obj.kind)) {
     return {
-      lower: ciVal.lower,
-      upper: ciVal.upper,
-      confidenceLevel: ciVal.confidenceLevel,
-      interpretation: ciVal.interpretation ?? 'normal',
+      kind: obj.kind,
+      source: obj.source === 'ci' ? 'ci' : 'parameters',
+      mean: typeof obj.mean === 'number' ? obj.mean : undefined,
+      variance: typeof obj.variance === 'number' ? obj.variance : undefined,
+      mu: typeof obj.mu === 'number' ? obj.mu : undefined,
+      sigma: typeof obj.sigma === 'number' ? obj.sigma : undefined,
+      min: typeof obj.min === 'number' ? obj.min : undefined,
+      max: typeof obj.max === 'number' ? obj.max : undefined,
+      lower: typeof obj.lower === 'number' ? obj.lower : undefined,
+      upper: typeof obj.upper === 'number' ? obj.upper : undefined,
+      confidenceLevel: typeof obj.confidenceLevel === 'number'
+        ? obj.confidenceLevel
+        : undefined,
     }
   }
 
-  if (typeof val === 'string') {
-    let match = val.match(/^(\d+\.?\d*)\s+to\s+(\d+\.?\d*)$/)
-    if (match) {
-      return {
-        lower: parseFloat(match[1]),
-        upper: parseFloat(match[2]),
-        confidenceLevel: 95,
-        interpretation: 'normal',
-      }
-    }
-
-    match = val.match(/^CI\[(-?\d+\.?\d*),\s*(-?\d+\.?\d*)\]$/)
-    if (match) {
-      return {
-        lower: parseFloat(match[1]),
-        upper: parseFloat(match[2]),
-        confidenceLevel: 95,
-        interpretation: 'normal',
-      }
+  if (obj.kind === 'distribution' && isDistributionKind(obj.distribution)) {
+    return {
+      kind: obj.distribution,
+      source: obj.source === 'ci' ? 'ci' : 'parameters',
+      mean: typeof obj.mean === 'number' ? obj.mean : undefined,
+      variance: typeof obj.variance === 'number' ? obj.variance : undefined,
+      mu: typeof obj.mu === 'number' ? obj.mu : undefined,
+      sigma: typeof obj.sigma === 'number' ? obj.sigma : undefined,
+      min: typeof obj.min === 'number' ? obj.min : undefined,
+      max: typeof obj.max === 'number' ? obj.max : undefined,
+      lower: typeof obj.lower === 'number' ? obj.lower : undefined,
+      upper: typeof obj.upper === 'number' ? obj.upper : undefined,
+      confidenceLevel: typeof obj.confidenceLevel === 'number'
+        ? obj.confidenceLevel
+        : undefined,
     }
   }
 
   return null
 }
 
+export const isDistributionValue = (val: unknown): boolean =>
+  parseDistributionValue(val) !== null
+
+export const confidenceLevelToFormulaArgument = (
+  confidenceLevel: number,
+): number => confidenceLevel > 1 ? confidenceLevel / 100 : confidenceLevel
+
+type SampledDistributionLike = {
+  samples?: unknown
+  getSamples?: () => number[]
+  getMean?: () => number
+  getVariance?: () => number
+}
+
+const getSampleArray = (val: unknown): number[] | null => {
+  if (!val || typeof val !== 'object') {
+    return null
+  }
+
+  const sampled = val as SampledDistributionLike
+  if (typeof sampled.getSamples === 'function') {
+    return sampled.getSamples()
+  }
+
+  return Array.isArray(sampled.samples) ? sampled.samples as number[] : null
+}
+
 export const isSampledDistributionValue = (val: unknown): boolean => {
-  return Boolean(val && typeof val === 'object' && 'samples' in (val as Record<string, unknown>) && Array.isArray((val as { samples?: unknown }).samples))
+  return getSampleArray(val) !== null
 }
 
 export const parseSampledDistributionValue = (val: unknown): { samples: number[]; mean: number; std: number } | null => {
-  if (val && typeof val === 'object' && 'samples' in (val as Record<string, unknown>) && Array.isArray((val as { samples: unknown[] }).samples)) {
-    const samples = (val as { samples: number[] }).samples
-    if (!samples.length) {
-      return { samples, mean: 0, std: 0 }
-    }
+  const samples = getSampleArray(val)
+  if (!samples) {
+    return null
+  }
 
-    const mean = samples.reduce((a, b) => a + b, 0) / samples.length
-    const variance = samples.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / samples.length
-    const std = Math.sqrt(variance)
-    return { samples, mean, std }
+  if (!samples.length) {
+    return { samples, mean: 0, std: 0 }
   }
-  return null
+
+  const sampled = val as SampledDistributionLike
+  const mean = typeof sampled.getMean === 'function'
+    ? sampled.getMean()
+    : samples.reduce((a, b) => a + b, 0) / samples.length
+  const variance = typeof sampled.getVariance === 'function'
+    ? sampled.getVariance()
+    : samples.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / samples.length
+  const std = Math.sqrt(variance)
+  return { samples, mean, std }
 }
 
 export const getSamplesFromDistribution = (val: unknown): number[] | null => {
-  if (isSampledDistributionValue(val)) {
-    return ((val as { samples: number[] }).samples)
+  const sampledSamples = getSampleArray(val)
+  if (sampledSamples) {
+    return sampledSamples
   }
 
-  if (val && typeof val === 'object' && 'toSamples' in (val as Record<string, unknown>) && typeof (val as { toSamples: () => number[] }).toSamples === 'function') {
+  if (isDistributionValue(val) && val && typeof val === 'object' && 'toSamples' in (val as Record<string, unknown>) && typeof (val as { toSamples: () => number[] }).toSamples === 'function') {
     try {
       return (val as { toSamples: () => number[] }).toSamples()
     } catch (error) {
-      console.error('Error calling toSamples:', error)
+      console.error('Error calling distribution toSamples:', error)
     }
   }
 
   return null
 }
-
-export const getConfidenceIntervalMedian = (ci: Pick<ParsedConfidenceInterval, 'lower' | 'upper' | 'interpretation'>): number => {
-  switch (ci.interpretation) {
-    case 'lognormal':
-      return Math.sqrt(ci.lower * ci.upper)
-    case 'uniform':
-    case 'normal':
-    default:
-      return (ci.lower + ci.upper) / 2
-  }
-}
-
-export const canUseLognormalInterpretation = (
-  ci: Pick<ParsedConfidenceInterval, 'lower' | 'upper'>,
-): boolean => ci.lower > 0 && ci.upper > 0
-
-export const getAvailableDistributionViews = (
-  ci: Pick<ParsedConfidenceInterval, 'lower' | 'upper'>,
-): DistributionViewType[] =>
-  canUseLognormalInterpretation(ci)
-    ? ['normal', 'lognormal', 'uniform']
-    : ['normal', 'uniform']
-
-export const zScoreForConfidence = (confidenceLevel: number): number => {
-  if (confidenceLevel >= 99.9) return 3.29;
-  if (confidenceLevel >= 99) return 2.576;
-  if (confidenceLevel >= 98) return 2.326;
-  if (confidenceLevel >= 95) return 1.96;
-  if (confidenceLevel >= 90) return 1.645;
-  if (confidenceLevel >= 80) return 1.282;
-  if (confidenceLevel >= 70) return 1.036;
-  return 1.0;
-}
diff --git a/src/utils/visual-dependency-graph/visualDependencyGraphFormatter.ts b/src/utils/visual-dependency-graph/visualDependencyGraphFormatter.ts
index 28b1269..fdcd605 100644
--- a/src/utils/visual-dependency-graph/visualDependencyGraphFormatter.ts
+++ b/src/utils/visual-dependency-graph/visualDependencyGraphFormatter.ts
@@ -1,13 +1,28 @@
 import type { VisualDependencyNodeValue } from '../../types/visualDependencyGraph'
+import { confidenceLevelToFormulaArgument } from '../distribution/distributionUtils'
 
 const formatNumber = (value: number): string => value.toFixed(2)
+const formatConfidence = (value: number | undefined): string =>
+  confidenceLevelToFormulaArgument(value ?? 95).toFixed(2)
 
 export const formatVisualDependencyValue = (value: VisualDependencyNodeValue): string => {
   switch (value.kind) {
     case 'scalar':
       return Number.isInteger(value.value) ? `${value.value}` : formatNumber(value.value)
-    case 'confidence_interval':
-      return `CI[${formatNumber(value.lower)}, ${formatNumber(value.upper)}]`
+    case 'distribution':
+      switch (value.distribution) {
+        case 'normal':
+          return value.source === 'ci'
+            ? `N.CI(${formatNumber(value.lower ?? 0)}, ${formatNumber(value.upper ?? 0)}, ${formatConfidence(value.confidenceLevel)})`
+            : `N(μ=${formatNumber(value.mean ?? 0)}, σ²=${formatNumber(value.variance ?? 0)})`
+        case 'lognormal':
+          return value.source === 'ci'
+            ? `LN.CI(${formatNumber(value.lower ?? 0)}, ${formatNumber(value.upper ?? 0)}, ${formatConfidence(value.confidenceLevel)})`
+            : `LN(μ=${formatNumber(value.mu ?? 0)}, σ=${formatNumber(value.sigma ?? 0)})`
+        case 'uniform':
+          return `U(${formatNumber(value.min ?? 0)}, ${formatNumber(value.max ?? 0)})`
+      }
+      return ''
     case 'sampled_distribution':
       return `S(μ=${formatNumber(value.mean)}, σ=${formatNumber(Math.sqrt(value.variance))})`
   }
diff --git a/tests/e2e/spreadsheet-edit.spec.ts b/tests/e2e/spreadsheet-edit.spec.ts
index 0181f2b..7b93508 100644
--- a/tests/e2e/spreadsheet-edit.spec.ts
+++ b/tests/e2e/spreadsheet-edit.spec.ts
@@ -18,7 +18,30 @@ test("edits a spreadsheet cell directly", async ({ page }) => {
   );
 });
 
-test("opens a confidence interval distribution chart", async ({ page }) => {
+test("double-clicking an existing cell preserves the editor and formula bar values", async ({
+  page,
+}) => {
+  await page.goto("/");
+
+  const firstCell = page.locator("tbody tr:first-child td:nth-child(2) > div");
+  const formulaBar = page.getByPlaceholder("Enter value or formula…");
+
+  await firstCell.dblclick();
+
+  const editor = page.getByLabel("Cell A1");
+  await editor.fill("456");
+  await editor.press("Enter");
+
+  await expect(firstCell).toHaveText("456");
+  await expect(formulaBar).toHaveValue("456");
+
+  await firstCell.dblclick();
+
+  await expect(page.getByLabel("Cell A1")).toHaveValue("456");
+  await expect(formulaBar).toHaveValue("456");
+});
+
+test("opens an explicit distribution chart", async ({ page }) => {
   const pageErrors: string[] = [];
   page.on("pageerror", (error) => pageErrors.push(error.message));
 
@@ -28,10 +51,10 @@ test("opens a confidence interval distribution chart", async ({ page }) => {
   await firstCell.dblclick();
 
   const editor = page.getByLabel("Cell A1");
-  await editor.fill("CI[10, 20]");
+  await editor.fill("N.CI(10, 20, 0.95)");
   await editor.press("Enter");
 
-  await expect(firstCell).toHaveText("N(μ=15.00, σ=2.55)");
+  await expect(firstCell).toHaveText("N 95% CI [10, 20]");
 
   await firstCell.click({ button: "right" });
 
@@ -83,7 +106,7 @@ test("opens Sage, receives a proposal, and applies it", async ({ page }) => {
       expect.arrayContaining([
         expect.objectContaining({
           address: "A1",
-          kind: "confidence_interval",
+          kind: "distribution",
         }),
       ]),
     );
@@ -124,7 +147,7 @@ test("opens Sage, receives a proposal, and applies it", async ({ page }) => {
   await firstCell.dblclick();
 
   let editor = page.getByLabel("Cell A1");
-  await editor.fill("CI[10, 20]");
+  await editor.fill("N.CI(10, 20, 0.95)");
   await editor.press("Enter");
 
   // GaussFormula trims empty rightmost columns, so C1 keeps empty B1 in bounds.
@@ -237,12 +260,12 @@ test("renders Sage prose readably and applies proposals from json fences", async
     "```json",
     JSON.stringify({
       title: "Add uncertain input",
-      summary: "Adds a starter confidence interval.",
+      summary: "Adds a starter uncertainty input.",
       changes: [
         {
           cell: "A1",
           before: "",
-          after: "CI[100, 200]",
+          after: "N.CI(100, 200, 0.95)",
           reason: "Capture the uncertain source estimate as a distribution.",
           kind: "add",
         },
@@ -286,12 +309,12 @@ test("renders Sage prose readably and applies proposals from json fences", async
 test("renders and applies proposals produced by Sage tools", async ({ page }) => {
   const proposal = {
     title: "Add tool proposal output",
-    summary: "Adds a starter confidence interval through the proposal tool.",
+    summary: "Adds a starter uncertainty input through the proposal tool.",
     changes: [
       {
         cell: "A1",
         before: "",
-        after: "CI[100, 200]",
+        after: "N.CI(100, 200, 0.95)",
         reason: "Capture the uncertain source estimate as a distribution.",
         kind: "add",
       },
@@ -341,13 +364,13 @@ test("renders and applies proposals produced by Sage tools", async ({ page }) =>
   await expect(
     page.getByText("I prepared one workbook change for review."),
   ).toBeVisible();
-  await expect(page.getByText("CI[100, 200]")).toBeVisible();
+  await expect(page.getByText("N.CI(100, 200, 0.95)")).toBeVisible();
   await page.getByRole("button", { name: "Apply 1 change" }).click();
   await expect(page.getByText("Applied", { exact: true })).toBeVisible();
 
   await page.locator("tbody tr:first-child td:nth-child(2) > div").click();
   await expect(page.getByPlaceholder("Enter value or formula…")).toHaveValue(
-    "CI[100.00, 200.00]",
+    "N.CI(100.00, 200.00, 0.95)",
   );
 });
 
@@ -356,12 +379,12 @@ test("keeps proposal cards with the assistant messages that produced them", asyn
 }) => {
   const firstProposal = {
     title: "Add uncertain input",
-    summary: "Adds a starter confidence interval.",
+    summary: "Adds a starter uncertainty input.",
     changes: [
       {
         cell: "A1",
         before: "",
-        after: "CI[100, 200]",
+        after: "N.CI(100, 200, 0.95)",
         reason: "Capture the uncertain source estimate as a distribution.",
         kind: "add",
       },
@@ -429,14 +452,14 @@ test("keeps proposal cards with the assistant messages that produced them", asyn
     .fill("Prepare the first change");
   await page.getByRole("button", { name: "Send" }).click();
 
-  await expect(page.getByText("CI[100, 200]")).toBeVisible();
+  await expect(page.getByText("N.CI(100, 200, 0.95)")).toBeVisible();
 
   await page.getByLabel("Message Sage")
     .fill("Prepare a second change");
   await page.getByRole("button", { name: "Send" }).click();
 
   const sagePanel = page.getByRole("complementary", { name: "Sage" });
-  await expect(page.getByText("CI[100, 200]")).toBeVisible();
+  await expect(page.getByText("N.CI(100, 200, 0.95)")).toBeVisible();
   await expect(sagePanel.getByText("42", { exact: true })).toBeVisible();
   await expect(
     sagePanel.getByRole("button", { name: "Apply 1 change" }),
@@ -448,12 +471,12 @@ test("auto-applies direct apply tool results in Write mode", async ({
 }) => {
   const proposal = {
     title: "Apply tool output",
-    summary: "Applies a starter confidence interval through the apply tool.",
+    summary: "Applies a starter uncertainty input through the apply tool.",
     changes: [
       {
         cell: "A1",
         before: "",
-        after: "CI[100, 200]",
+        after: "N.CI(100, 200, 0.95)",
         reason: "Capture the uncertain source estimate as a distribution.",
         kind: "add",
       },
@@ -513,7 +536,7 @@ test("auto-applies direct apply tool results in Write mode", async ({
   await expect(page.getByText("Applied", { exact: true })).toBeVisible();
   await page.locator("tbody tr:first-child td:nth-child(2) > div").click();
   await expect(page.getByPlaceholder("Enter value or formula…")).toHaveValue(
-    "CI[100.00, 200.00]",
+    "N.CI(100.00, 200.00, 0.95)",
   );
 });
 
@@ -522,12 +545,12 @@ test("auto-applies proposal tool results in Write mode", async ({
 }) => {
   const proposal = {
     title: "Proposal tool output",
-    summary: "Adds a starter confidence interval through the proposal tool.",
+    summary: "Adds a starter uncertainty input through the proposal tool.",
     changes: [
       {
         cell: "A1",
         before: "",
-        after: "CI[100, 200]",
+        after: "N.CI(100, 200, 0.95)",
         reason: "Capture the uncertain source estimate as a distribution.",
         kind: "add",
       },
@@ -589,7 +612,7 @@ test("auto-applies proposal tool results in Write mode", async ({
   ).toHaveCount(0);
   await page.locator("tbody tr:first-child td:nth-child(2) > div").click();
   await expect(page.getByPlaceholder("Enter value or formula…")).toHaveValue(
-    "CI[100.00, 200.00]",
+    "N.CI(100.00, 200.00, 0.95)",
   );
 });
 
@@ -603,7 +626,7 @@ test("does not show proposal action buttons in Write mode", async ({
       {
         cell: "A1",
         before: "stale",
-        after: "CI[100, 200]",
+        after: "N.CI(100, 200, 0.95)",
         reason: "Capture the uncertain source estimate as a distribution.",
         kind: "add",
       },
@@ -814,7 +837,7 @@ test("editing the sheet preserves the current flow graph viewport", async ({
     .toBe(transformAfterPan);
 });
 
-test("changing a CI node distribution persists in the flow inspector", async ({
+test("shows explicit distribution nodes in the flow inspector", async ({
   page,
 }) => {
   await page.goto("/");
@@ -831,7 +854,7 @@ test("changing a CI node distribution persists in the flow inspector", async ({
   await firstCell.dblclick();
 
   editor = page.getByLabel("Cell A1");
-  await editor.fill("CI[10, 20]");
+  await editor.fill("N.CI(10, 20, 0.95)");
   await editor.press("Enter");
 
   await page.getByTitle("Show dependency graph").click();
@@ -843,15 +866,13 @@ test("changing a CI node distribution persists in the flow inspector", async ({
   await canvasInner.getByText("A1").first().click();
 
   const inspector = flowPane.getByLabel("Selected node inspector");
-  await expect(inspector).toContainText("confidence interval");
+  await expect(inspector).toContainText("distribution");
   await expect(inspector).toContainText("normal");
-
-  await inspector.getByRole("button", { name: "uniform" }).click();
-
-  await expect(inspector).toContainText("uniform");
+  await expect(inspector.getByRole("button", { name: "uniform" }))
+    .toHaveCount(0);
 });
 
-test("hides lognormal distribution for CI cells with non-positive bounds", async ({
+test("does not show reinterpretation controls for explicit distributions", async ({
   page,
 }) => {
   await page.goto("/");
@@ -868,22 +889,10 @@ test("hides lognormal distribution for CI cells with non-positive bounds", async
   await firstCell.dblclick();
 
   editor = page.getByLabel("Cell A1");
-  await editor.fill("CI[0, 1]");
+  await editor.fill("N.CI(0, 1, 0.95)");
   await editor.press("Enter");
 
-  await firstCell.getByRole("button", { name: "Change view" }).click();
-
-  await expect(
-    page.getByRole("button", { name: "Normal Distribution", exact: true }),
-  )
-    .toBeVisible();
-  await expect(
-    page.getByRole("button", { name: "Uniform Distribution", exact: true }),
-  )
-    .toBeVisible();
-  await expect(
-    page.getByRole("button", { name: "Log-Normal Distribution", exact: true }),
-  )
+  await expect(firstCell.getByRole("button", { name: "Change view" }))
     .toHaveCount(0);
 
   await page.getByTitle("Show dependency graph").click();
@@ -896,9 +905,9 @@ test("hides lognormal distribution for CI cells with non-positive bounds", async
 
   const inspector = flowPane.getByLabel("Selected node inspector");
   await expect(inspector.getByRole("button", { name: "normal" }))
-    .toBeVisible();
+    .toHaveCount(0);
   await expect(inspector.getByRole("button", { name: "uniform" }))
-    .toBeVisible();
+    .toHaveCount(0);
   await expect(inspector.getByRole("button", { name: "lognormal" }))
     .toHaveCount(0);
 });
diff --git a/tests/unit/app/analysisState.test.ts b/tests/unit/app/analysisState.test.ts
index dfeeb04..7fb8563 100644
--- a/tests/unit/app/analysisState.test.ts
+++ b/tests/unit/app/analysisState.test.ts
@@ -16,7 +16,6 @@ describe('analysisState', () => {
         analysisMode: false,
         formulaEngine: null,
         selectedCell: { row: 0, col: 0 },
-        getDistributionView: () => null,
       }),
     ).toBeNull()
   })
@@ -31,23 +30,22 @@ describe('analysisState', () => {
         analysisMode: true,
         formulaEngine,
         selectedCell: { row: 0, col: 0 },
-        getDistributionView: () => null,
       }),
     ).toMatchObject({
       cellLabel: 'A1',
       samples: null,
       distributionType: 'normal',
-      confidenceInterval: null,
     })
   })
 
-  it('respects distribution view overrides for confidence interval cells', () => {
+  it('uses explicit distribution kind when present', () => {
     const formulaEngine = {
       getCellValue: () => ({
-        lower: 10,
-        upper: 20,
-        confidenceLevel: 95,
-        samples: [10, 15, 20],
+        kind: 'lognormal',
+        source: 'parameters',
+        mu: 0,
+        sigma: 0.2,
+        toSamples: () => [1, 1.1, 1.2],
       }),
     }
 
@@ -55,13 +53,12 @@ describe('analysisState', () => {
       deriveAnalysisState({
         analysisMode: true,
         formulaEngine,
-        selectedCell: { row: 1, col: 1 },
-        getDistributionView: () => 'uniform',
+        selectedCell: { row: 2, col: 0 },
       }),
     ).toMatchObject({
-      cellLabel: 'B2',
-      samples: [10, 15, 20],
-      distributionType: 'uniform',
+      cellLabel: 'A3',
+      samples: [1, 1.1, 1.2],
+      distributionType: 'lognormal',
     })
   })
 })
diff --git a/tests/unit/assistant/proposals.test.ts b/tests/unit/assistant/proposals.test.ts
index 43bbd45..c831928 100644
--- a/tests/unit/assistant/proposals.test.ts
+++ b/tests/unit/assistant/proposals.test.ts
@@ -23,8 +23,15 @@ const snapshot: WorkbookSnapshot = {
       row: 0,
       col: 0,
       formula: null,
-      displayValue: "CI[10, 20]",
-      kind: "confidence_interval",
+      displayValue: "N.CI(10, 20, 0.95)",
+      kind: "distribution",
+      distribution: {
+        kind: "normal",
+        source: "ci",
+        lower: 10,
+        upper: 20,
+        confidenceLevel: 95,
+      },
     },
     {
       address: "B1",
@@ -61,8 +68,8 @@ const text = [
       {
         cell: "A1",
         before: "stale value",
-        after: "CI[10, 20]",
-        reason: "Document the confidence interval for reviewers.",
+        after: "N.CI(10, 20, 0.95)",
+        reason: "Document the uncertainty for reviewers.",
         kind: "review",
       },
     ],
@@ -337,7 +344,7 @@ describe("assistant proposal parsing", () => {
 
     try {
       engine.addSheet("Sheet1");
-      engine.setSheetContent(0, [["CI[10, 20]", "=A1*2", null]]);
+      engine.setSheetContent(0, [[10, "=A1*2", null]]);
 
       applyAssistantChangesToEngine(
         engine,
@@ -359,8 +366,8 @@ describe("assistant proposal parsing", () => {
           },
           {
             cell: "A1",
-            before: "CI[10, 20]",
-            after: "CI[15, 25]",
+            before: "10",
+            after: "N.CI(15, 25, 0.95)",
             reason: "Flag for manual review.",
             kind: "review",
           },
@@ -390,7 +397,7 @@ describe("assistant proposal parsing", () => {
 
     try {
       engine.addSheet("Sheet1");
-      engine.setSheetContent(0, [["CI[10, 20]", "=A1*2"]]);
+      engine.setSheetContent(0, [[10, "=A1*2"]]);
 
       let error: unknown;
       try {
@@ -432,7 +439,7 @@ describe("assistant proposal parsing", () => {
 
     try {
       engine.addSheet("Sheet1");
-      engine.setSheetContent(0, [["CI[10, 20]", "=A1*2", null]]);
+      engine.setSheetContent(0, [[10, "=A1*2", null]]);
 
       let error: unknown;
       try {
diff --git a/tests/unit/assistant/workbookSnapshot.test.ts b/tests/unit/assistant/workbookSnapshot.test.ts
index 278d547..47e6b14 100644
--- a/tests/unit/assistant/workbookSnapshot.test.ts
+++ b/tests/unit/assistant/workbookSnapshot.test.ts
@@ -6,6 +6,7 @@ import {
 } from "../../../src/assistant/address";
 import { buildWorkbookSnapshot } from "../../../src/assistant/workbookSnapshot";
 import { GaussFormulaEngine } from "../../../src/lib/formulaEngine";
+import type { FormulaEngine } from "../../../src/lib/formulaEngine";
 
 describe("assistant workbook snapshot", () => {
   it("converts between zero-based coordinates and A1 addresses", () => {
@@ -24,55 +25,102 @@ describe("assistant workbook snapshot", () => {
   });
 
   it("captures formulas, evaluated values, selected cell, and uncertainty metadata", () => {
-    const engine = GaussFormulaEngine.buildEmpty({
-      licenseKey: "gpl-v3",
-      language: "enGB",
-      useColumnIndex: true,
-      sampleSize: 1000,
-    });
-
-    try {
-      engine.addSheet("Sheet1");
-      engine.setSheetContent(0, [
-        ["Label", "CI[10, 20]", "=B1*2"],
-        ["Plain", 42, null],
-      ]);
-
-      const snapshot = buildWorkbookSnapshot({
-        formulaEngine: engine,
-        selectedCell: { row: 0, col: 2 },
-        maxCells: 20,
-      });
-
-      expect(snapshot.sheetName).toBe("Sheet1");
-      expect(snapshot.selectedCell).toBe("C1");
-      expect(snapshot.truncated).toBe(false);
-      expect(snapshot.cells.map((cell) => cell.address)).toEqual([
-        "A1",
-        "B1",
-        "C1",
-        "A2",
-        "B2",
-      ]);
-      expect(snapshot.cells.find((cell) => cell.address === "B1")).toMatchObject({
-        address: "B1",
-        formula: null,
-        kind: "confidence_interval",
-        confidenceInterval: {
+    const values = [
+      [
+        "Label",
+        {
+          kind: "normal",
+          source: "ci",
           lower: 10,
           upper: 20,
           confidenceLevel: 95,
-          interpretation: "normal",
+          mean: 15,
+          variance: 6.508682,
+          toSamples: () => [10, 15, 20],
         },
-      });
-      expect(snapshot.cells.find((cell) => cell.address === "C1")).toMatchObject({
-        address: "C1",
-        formula: "=B1*2",
-        kind: "sampled_distribution",
-      });
-    } finally {
-      engine.destroy();
-    }
+        {
+          samples: [20, 30, 40],
+        },
+      ],
+      ["Plain", 42, null],
+    ];
+    const formulas = [
+      [null, null, "=B1*2"],
+      [null, null, null],
+    ];
+    const engine = {
+      getSheetName: () => "Sheet1",
+      getSheetDimensions: () => ({ width: 3, height: 2 }),
+      getCellFormula: ({ row, col }: { row: number; col: number }) =>
+        formulas[row]?.[col] ?? null,
+      getCellValue: ({ row, col }: { row: number; col: number }) =>
+        values[row]?.[col] ?? null,
+    };
+
+    const snapshot = buildWorkbookSnapshot({
+      formulaEngine: engine as unknown as FormulaEngine,
+      selectedCell: { row: 0, col: 2 },
+      maxCells: 20,
+    });
+
+    expect(snapshot.sheetName).toBe("Sheet1");
+    expect(snapshot.selectedCell).toBe("C1");
+    expect(snapshot.truncated).toBe(false);
+    expect(snapshot.cells.map((cell) => cell.address)).toEqual([
+      "A1",
+      "B1",
+      "C1",
+      "A2",
+      "B2",
+    ]);
+    expect(snapshot.cells.find((cell) => cell.address === "B1")).toMatchObject({
+      address: "B1",
+      formula: null,
+      displayValue: "N.CI(10, 20, 0.95)",
+      kind: "distribution",
+      distribution: {
+        kind: "normal",
+        source: "ci",
+        lower: 10,
+        upper: 20,
+        confidenceLevel: 95,
+      },
+    });
+    expect(snapshot.cells.find((cell) => cell.address === "C1")).toMatchObject({
+      address: "C1",
+      formula: "=B1*2",
+      kind: "sampled_distribution",
+    });
+  });
+
+  it("uses sampled distribution summary methods in cell snapshots", () => {
+    const engine = {
+      getSheetName: () => "Sheet1",
+      getSheetDimensions: () => ({ width: 1, height: 1 }),
+      getCellFormula: () => null,
+      getCellValue: () => ({
+        samples: [1, 2, 100],
+        getSamples: () => [1, 2, 100],
+        getMean: () => 42,
+        getVariance: () => 9,
+      }),
+    };
+
+    const snapshot = buildWorkbookSnapshot({
+      formulaEngine: engine as unknown as FormulaEngine,
+      selectedCell: null,
+      maxCells: 20,
+    });
+
+    expect(snapshot.cells[0]).toMatchObject({
+      address: "A1",
+      kind: "sampled_distribution",
+      sampleSummary: {
+        sampleCount: 3,
+        mean: 42,
+        standardDeviation: 3,
+      },
+    });
   });
 
   it("returns null for an out-of-bounds selected cell and uses the engine sheet name", () => {
diff --git a/tests/unit/components/charts/distributionChartOptions.test.ts b/tests/unit/components/charts/distributionChartOptions.test.ts
index 94b2184..46c997d 100644
--- a/tests/unit/components/charts/distributionChartOptions.test.ts
+++ b/tests/unit/components/charts/distributionChartOptions.test.ts
@@ -106,4 +106,29 @@ describe('distributionChartOptions', () => {
       }),
     )
   })
+
+  it('uses engine-derived chart parameters when provided', () => {
+    const chartData = createDistributionChartData({
+      samples: [18, 19, 20, 21, 22],
+      distributionKind: 'normal',
+      distributionParams: {
+        type: 'normal',
+        mean: 20,
+        std: 1.103807174302308,
+      },
+      confidenceInterval: {
+        lower: 18,
+        upper: 22,
+        confidenceLevel: 93,
+      },
+    })
+
+    expect(chartData.distributionParams).toEqual(
+      expect.objectContaining({
+        type: 'normal',
+        mean: 20,
+        std: 1.103807174302308,
+      }),
+    )
+  })
 })
diff --git a/tests/unit/components/spreadsheet/cellFormatting.test.ts b/tests/unit/components/spreadsheet/cellFormatting.test.ts
index 59a575a..51f2af6 100644
--- a/tests/unit/components/spreadsheet/cellFormatting.test.ts
+++ b/tests/unit/components/spreadsheet/cellFormatting.test.ts
@@ -1,6 +1,9 @@
 import { describe, expect, it } from 'vitest'
 
-import { formatCellValue } from '../../../../src/components/spreadsheet/cellFormatting'
+import {
+  formatCellEditValue,
+  formatCellValue,
+} from '../../../../src/components/spreadsheet/cellFormatting'
 
 const sampledValue = {
   samples: [1, 2, 3],
@@ -14,34 +17,78 @@ const sampledValue = {
 
 describe('formatCellValue', () => {
   it('formats primitive values', () => {
-    expect(formatCellValue(null, { type: 'normal' })).toBe('')
-    expect(formatCellValue(true, { type: 'normal' })).toBe('TRUE')
-    expect(formatCellValue(false, { type: 'normal' })).toBe('FALSE')
-    expect(formatCellValue(123, { type: 'normal' })).toBe('123')
-    expect(formatCellValue('abc', { type: 'normal' })).toBe('abc')
+    expect(formatCellValue(null)).toBe('')
+    expect(formatCellValue(true)).toBe('TRUE')
+    expect(formatCellValue(false)).toBe('FALSE')
+    expect(formatCellValue(123)).toBe('123')
+    expect(formatCellValue('abc')).toBe('abc')
   })
 
-  it('formats normal confidence intervals', () => {
+  it('formats explicit distributions', () => {
     expect(
       formatCellValue(
-        { lower: 10, upper: 20, confidenceLevel: 95 },
-        { type: 'normal' },
+        {
+          kind: 'normal',
+          source: 'parameters',
+          mean: 10,
+          variance: 4,
+        },
       ),
-    ).toBe('N(μ=15.00, σ=2.55)')
-  })
+    ).toBe('N μ=10 σ²=4')
 
-  it('formats uniform confidence intervals', () => {
     expect(
       formatCellValue(
-        { lower: 10, upper: 20, confidenceLevel: 95 },
-        { type: 'uniform' },
+        {
+          kind: 'normal',
+          source: 'ci',
+          lower: 10,
+          upper: 20,
+          confidenceLevel: 95,
+        },
+      ),
+    ).toBe('N 95% CI [10, 20]')
+
+    expect(
+      formatCellValue(
+        {
+          kind: 'lognormal',
+          source: 'ci',
+          lower: 1,
+          upper: 2,
+          confidenceLevel: 95,
+        },
+      ),
+    ).toBe('LN 95% CI [1, 2]')
+
+    expect(
+      formatCellValue(
+        {
+          kind: 'uniform',
+          source: 'parameters',
+          min: 1,
+          max: 2,
+        },
+      ),
+    ).toBe('U [1, 2]')
+  })
+
+  it('formats explicit distributions as editable formulas', () => {
+    expect(
+      formatCellEditValue(
+        {
+          kind: 'lognormal',
+          source: 'ci',
+          lower: 1,
+          upper: 2,
+          confidenceLevel: 95,
+        },
       ),
-    ).toBe('U[10.00, 20.00]')
+    ).toBe('LN.CI(1.00, 2.00, 0.95)')
   })
 
   it('formats sampled distributions', () => {
     expect(
-      formatCellValue(sampledValue, { type: 'normal' }),
+      formatCellValue(sampledValue),
     ).toBe('S(μ=2.00, σ=0.82)')
   })
 })
diff --git a/tests/unit/examples/examples.test.ts b/tests/unit/examples/examples.test.ts
index 734956d..04547f0 100644
--- a/tests/unit/examples/examples.test.ts
+++ b/tests/unit/examples/examples.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, it } from "vitest";
 
 import { spreadsheetExamples } from "../../../src/examples/examples";
 import { GaussFormulaEngine } from "../../../src/lib/formulaEngine";
+import { parseSampledDistributionValue } from "../../../src/utils/distribution/distributionUtils";
 
 const a1ToAddress = (address: string) => {
   const match = address.match(/^([A-Z]+)(\d+)$/);
@@ -18,23 +19,26 @@ const a1ToAddress = (address: string) => {
 };
 
 const meanOfSampledValue = (value: unknown): number => {
-  if (
-    !value ||
-    typeof value !== "object" ||
-    !("samples" in value) ||
-    !Array.isArray((value as { samples?: unknown }).samples)
-  ) {
+  const sampled = parseSampledDistributionValue(value);
+
+  if (!sampled) {
     throw new Error("Expected a sampled distribution value.");
   }
 
-  const samples = (value as { samples: number[] }).samples;
-  return samples.reduce((sum, sample) => sum + sample, 0) / samples.length;
+  return sampled.mean;
 };
 
 describe("spreadsheet examples", () => {
-  it("keeps the prompt-cost example mean aligned with the deterministic workbook total", () => {
+  const supportsExplicitDistributions = Boolean(
+    (GaussFormulaEngine as unknown as { DistributionNumber?: unknown })
+      .DistributionNumber,
+  );
+
+  it.skipIf(!supportsExplicitDistributions)(
+    "keeps the prompt-cost example mean aligned with the deterministic workbook total",
+    () => {
     const promptCostExample = spreadsheetExamples.find(
-      (example) => example.id === "prompt-cost-ci",
+      (example) => example.id === "prompt-cost-uncertainty",
     );
     expect(promptCostExample).toBeDefined();
 
@@ -56,5 +60,6 @@ describe("spreadsheet examples", () => {
     } finally {
       engine.destroy();
     }
-  });
+    },
+  );
 });
diff --git a/tests/unit/hooks/useFormulaBar.test.ts b/tests/unit/hooks/useFormulaBar.test.ts
index c16a54b..d51bebf 100644
--- a/tests/unit/hooks/useFormulaBar.test.ts
+++ b/tests/unit/hooks/useFormulaBar.test.ts
@@ -3,6 +3,34 @@ import { describe, expect, it } from "vitest";
 import { formatFormulaBarCellValue } from "../../../src/hooks/useFormulaBar";
 
 describe("formatFormulaBarCellValue", () => {
+  it("formats explicit distributions as formulas", () => {
+    expect(
+      formatFormulaBarCellValue({
+        kind: "normal",
+        source: "parameters",
+        mean: 1,
+        variance: 2,
+      }),
+    ).toBe("N(1.00, 2.00)");
+    expect(
+      formatFormulaBarCellValue({
+        kind: "lognormal",
+        source: "ci",
+        lower: 1,
+        upper: 2,
+        confidenceLevel: 95,
+      }),
+    ).toBe("LN.CI(1.00, 2.00, 0.95)");
+    expect(
+      formatFormulaBarCellValue({
+        kind: "uniform",
+        source: "parameters",
+        min: 1,
+        max: 2,
+      }),
+    ).toBe("U(1.00, 2.00)");
+  });
+
   it("formats variance-backed summaries as standard deviation", () => {
     expect(formatFormulaBarCellValue({ mean: 5, variance: 4 }))
       .toBe("S(μ=5.00, σ=2.00)");
diff --git a/tests/unit/server/assistantRoute.test.ts b/tests/unit/server/assistantRoute.test.ts
index 8cfc255..51a1a0b 100644
--- a/tests/unit/server/assistantRoute.test.ts
+++ b/tests/unit/server/assistantRoute.test.ts
@@ -35,13 +35,14 @@ const requestBodyWithWorkbookContext = {
         row: 0,
         col: 0,
         formula: null,
-        displayValue: "CI[10, 20]",
-        kind: "confidence_interval",
-        confidenceInterval: {
+        displayValue: "N.CI(10, 20, 0.95)",
+        kind: "distribution",
+        distribution: {
+          kind: "normal",
+          source: "ci",
           lower: 10,
           upper: 20,
           confidenceLevel: 95,
-          interpretation: "normal",
         },
       },
     ],
@@ -271,7 +272,7 @@ describe("assistant route", () => {
       modelId: DEFAULT_ASSISTANT_MODEL_ID,
     });
     expect(options.system).toContain("Current workbook snapshot");
-    expect(options.system).toContain("CI[10, 20]");
+    expect(options.system).toContain("N.CI(10, 20, 0.95)");
     expect(options.system).toContain("Do not use LaTeX");
     expect(options.system).toContain("Use getWorkbookContext");
     expect(options.system).toContain("Use validateFormula");
@@ -330,7 +331,7 @@ describe("assistant route", () => {
       cells: [
         expect.objectContaining({
           address: "A1",
-          kind: "confidence_interval",
+          kind: "distribution",
         }),
       ],
     });
@@ -340,7 +341,6 @@ describe("assistant route", () => {
       cell: "B1",
       valid: true,
       formula: "=A1*2",
-      kind: "sampled_distribution",
     });
     await expect(
       tools.proposeCellChanges.execute({
diff --git a/tests/unit/utils/distribution/distributionUtils.test.ts b/tests/unit/utils/distribution/distributionUtils.test.ts
new file mode 100644
index 0000000..d5ae1da
--- /dev/null
+++ b/tests/unit/utils/distribution/distributionUtils.test.ts
@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  getSamplesFromDistribution,
+  isSampledDistributionValue,
+  parseSampledDistributionValue,
+} from '../../../../src/utils/distribution/distributionUtils'
+
+describe('distributionUtils', () => {
+  it('uses sampled distribution summary methods when available', () => {
+    const sampled = {
+      samples: [1, 2, 100],
+      getMean: () => 42,
+      getVariance: () => 9,
+    }
+
+    expect(parseSampledDistributionValue(sampled)).toEqual({
+      samples: [1, 2, 100],
+      mean: 42,
+      std: 3,
+    })
+  })
+
+  it('uses sampled distribution getSamples when available', () => {
+    const sampled = {
+      samples: [100],
+      getSamples: () => [1, 2, 3],
+    }
+
+    expect(isSampledDistributionValue(sampled)).toBe(true)
+    expect(getSamplesFromDistribution(sampled)).toEqual([1, 2, 3])
+    expect(parseSampledDistributionValue(sampled)).toEqual({
+      samples: [1, 2, 3],
+      mean: 2,
+      std: Math.sqrt(2 / 3),
+    })
+  })
+
+  it('falls back to computing summaries for plain sampled objects', () => {
+    const sampled = {
+      samples: [1, 2, 3],
+    }
+
+    expect(parseSampledDistributionValue(sampled)).toEqual({
+      samples: [1, 2, 3],
+      mean: 2,
+      std: Math.sqrt(2 / 3),
+    })
+  })
+})
diff --git a/tests/unit/utils/visual-dependency-graph/visualDependencyGraphFormatter.test.ts b/tests/unit/utils/visual-dependency-graph/visualDependencyGraphFormatter.test.ts
index e50cb48..cada930 100644
--- a/tests/unit/utils/visual-dependency-graph/visualDependencyGraphFormatter.test.ts
+++ b/tests/unit/utils/visual-dependency-graph/visualDependencyGraphFormatter.test.ts
@@ -7,25 +7,36 @@ describe('formatVisualDependencyValue', () => {
     expect(formatVisualDependencyValue({ kind: 'scalar', value: 42 })).toBe('42')
   })
 
-  it('formats confidence intervals', () => {
+  it('formats sampled distributions from summary stats', () => {
+    expect(
+      formatVisualDependencyValue({
+        kind: 'sampled_distribution',
+        mean: 5,
+        variance: 4,
+      }),
+    ).toBe('S(μ=5.00, σ=2.00)')
+  })
+
+  it('formats explicit distributions', () => {
     expect(
       formatVisualDependencyValue({
-        kind: 'confidence_interval',
+        kind: 'distribution',
+        distribution: 'normal',
+        source: 'ci',
         lower: 10,
         upper: 20,
         confidenceLevel: 95,
-        interpretation: 'normal',
       }),
-    ).toBe('CI[10.00, 20.00]')
-  })
+    ).toBe('N.CI(10.00, 20.00, 0.95)')
 
-  it('formats sampled distributions from summary stats', () => {
     expect(
       formatVisualDependencyValue({
-        kind: 'sampled_distribution',
-        mean: 5,
-        variance: 4,
+        kind: 'distribution',
+        distribution: 'uniform',
+        source: 'parameters',
+        min: 10,
+        max: 20,
       }),
-    ).toBe('S(μ=5.00, σ=2.00)')
+    ).toBe('U(10.00, 20.00)')
   })
 })